问颤振/飞镖:任何语言对文本的演讲(离线和连续)

EN

import 'package:bloc/bloc.dart';
import 'package:meta/meta.dart';
import 'package:template_mobile/core/sevices/speech_recognition_service.dart';
import 'package:template_mobile/core/state/event/speech_recognition_event.dart';
import 'package:template_mobile/core/state/state/speech_recognition_state.dart';

class SpeechRecognitionBloc
    extends Bloc<SpeechRecognitionEvent, SpeechRecognitionState> {
  final SpeechRecognitionService speechRecognitionService;

  SpeechRecognitionBloc({
    @required this.speechRecognitionService,
  }) : assert(speechRecognitionService != null) {
    speechRecognitionService.errors.stream.listen((errorResult) {
      add(SpeechRecognitionErrorEvent(
        error: "${errorResult.errorMsg} - ${errorResult.permanent}",
      ));
    });

    speechRecognitionService.statuses.stream.listen((status) {
      if (state is SpeechRecognitionRecognizedState) {
        var currentState = state as SpeechRecognitionRecognizedState;
        if (currentState.finalResult) {
          add(SpeechRecognitionStatusChangedEvent());
        }
      }
    });

    speechRecognitionService.words.stream.listen((speechResult) {
      add(SpeechRecognitionRecognizedEvent(
        words: speechResult.recognizedWords,
        finalResult: speechResult.finalResult,
      ));
    });
  }

  @override
  SpeechRecognitionState get initialState =>
      SpeechRecognitionUninitializedState();

  @override
  Stream<SpeechRecognitionState> mapEventToState(
      SpeechRecognitionEvent event) async* {
    if (event is SpeechRecognitionInitEvent) {
      var hasSpeech = await speechRecognitionService.initSpeech();
      if (hasSpeech) {
        yield SpeechRecognitionAvailableState();
      } else {
        yield SpeechRecognitionUnavailableState();
      }
    }

    if (event is SpeechRecognitionStartPressEvent) {
      yield SpeechRecognitionStartPressedState();
      add(SpeechRecognitionStartEvent());
    }

    if (event is SpeechRecognitionStartEvent) {
      speechRecognitionService.startListening();
      yield SpeechRecognitionStartedState();
    }

    if (event is SpeechRecognitionStopPressEvent) {
      yield SpeechRecognitionStopPressedState();
      add(SpeechRecognitionStopEvent());
    }

    if (event is SpeechRecognitionStopEvent) {
      speechRecognitionService.stopListening();
      yield SpeechRecognitionStopedState();
    }

    if (event is SpeechRecognitionCancelEvent) {
      speechRecognitionService.cancelListening();
      yield SpeechRecognitionCanceledState();
    }

    if (event is SpeechRecognitionRecognizedEvent) {
      yield SpeechRecognitionRecognizedState(
          words: event.words, finalResult: event.finalResult);
      if (event.finalResult == true &&
          speechRecognitionService.statuses.value == 'notListening') {
        await Future.delayed(Duration(milliseconds: 50));
        add(SpeechRecognitionStatusChangedEvent());
      }
    }

    if (event is SpeechRecognitionErrorEvent) {
      yield SpeechRecognitionErrorState(error: event.error);
      // Just for UI updates for the state to propagates
      await Future.delayed(Duration(milliseconds: 50));
      add(SpeechRecognitionInitEvent());
      await Future.delayed(Duration(milliseconds: 50));
      add(SpeechRecognitionStartPressEvent());
    }

    if (event is SpeechRecognitionStatusChangedEvent) {
      yield SpeechRecognitionStatusState();
      add(SpeechRecognitionStartPressEvent());
    }
  }
}

import 'dart:async';

import 'package:rxdart/rxdart.dart';
import 'package:speech_to_text/speech_recognition_error.dart';
import 'package:speech_to_text/speech_recognition_result.dart';
import 'package:speech_to_text/speech_to_text.dart';

class SpeechRecognitionService {
  final SpeechToText speech = SpeechToText();

  var errors = StreamController<SpeechRecognitionError>();
  var statuses = BehaviorSubject<String>();
  var words = StreamController<SpeechRecognitionResult>();

  var _localeId = '';

  Future<bool> initSpeech() async {
    bool hasSpeech = await speech.initialize(
      onError: errorListener,
      onStatus: statusListener,
    );

    if (hasSpeech) {
      var systemLocale = await speech.systemLocale();
      _localeId = systemLocale.localeId;
    }

    return hasSpeech;
  }

  void startListening() {
    speech.stop();
    speech.listen(
        onResult: resultListener,
        listenFor: Duration(minutes: 1),
        localeId: _localeId,
        onSoundLevelChange: null,
        cancelOnError: true,
        partialResults: true);
  }

  void errorListener(SpeechRecognitionError error) {
    errors.add(error);
  }

  void statusListener(String status) {
    statuses.add(status);
  }

  void resultListener(SpeechRecognitionResult result) {
    words.add(result);
  }

  void stopListening() {
    speech.stop();
  }

  void cancelListening() {
    speech.cancel();
  }
}

import 'package:flutter/material.dart';
import 'package:speech_to_text/speech_recognition_error.dart';
import 'package:speech_to_text/speech_recognition_result.dart';
import 'package:speech_to_text/speech_to_text.dart';

void main() {
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({Key? key}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return const MaterialApp(
      title: 'Flutter Demo',
      home: MyHomePage(),
    );
  }
}

class MyHomePage extends StatefulWidget {
  const MyHomePage({Key? key}) : super(key: key);

  @override
  MyHomePageState createState() => MyHomePageState();
}

class MyHomePageState extends State<MyHomePage> {
  final SpeechToText _speechToText = SpeechToText();
  bool _speechEnabled = false;
  bool _speechAvailable = false;
  String _lastWords = '';
  String _currentWords = '';
  final String _selectedLocaleId = 'es_MX';

  printLocales() async {
    var locales = await _speechToText.locales();
    for (var local in locales) {
      debugPrint(local.name);
      debugPrint(local.localeId);
    }
  }

  @override
  void initState() {
    super.initState();
    _initSpeech();
  }

  void errorListener(SpeechRecognitionError error) {
    debugPrint(error.errorMsg.toString());
  }

  void statusListener(String status) async {
    debugPrint("status $status");
    if (status == "done" && _speechEnabled) {
      setState(() {
        _lastWords += " $_currentWords";
        _currentWords = "";
        _speechEnabled = false;
      });
      await _startListening();
    }
  }

  /// This has to happen only once per app
  void _initSpeech() async {
    _speechAvailable = await _speechToText.initialize(
        onError: errorListener,
        onStatus: statusListener
    );
    setState(() {});
  }

  /// Each time to start a speech recognition session
  Future _startListening() async {
    debugPrint("=================================================");
    await _stopListening();
    await Future.delayed(const Duration(milliseconds: 50));
    await _speechToText.listen(
        onResult: _onSpeechResult,
        localeId: _selectedLocaleId,
        cancelOnError: false,
        partialResults: true,
        listenMode: ListenMode.dictation
    );
    setState(() {
      _speechEnabled = true;
    });
  }

  /// Manually stop the active speech recognition session
  /// Note that there are also timeouts that each platform enforces
  /// and the SpeechToText plugin supports setting timeouts on the
  /// listen method.
  Future _stopListening() async {
    setState(() {
      _speechEnabled = false;
    });
    await _speechToText.stop();
  }

  /// This is the callback that the SpeechToText plugin calls when
  /// the platform returns recognized words.
  void _onSpeechResult(SpeechRecognitionResult result) {
    setState(() {
      _currentWords = result.recognizedWords;
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('Speech Demo'),
      ),
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: <Widget>[
            Container(
              padding: const EdgeInsets.all(16),
              child: const Text(
                'Recognized words:',
                style: TextStyle(fontSize: 20.0),
              ),
            ),
            Expanded(
              child: Container(
                padding: const EdgeInsets.all(16),
                child: Text(
                  _lastWords.isNotEmpty
                      ? '$_lastWords $_currentWords'
                      : _speechAvailable
                      ? 'Tap the microphone to start listening...'
                      : 'Speech not available',
                ),
              ),
            ),
          ],
        ),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed:
        _speechToText.isNotListening ? _startListening : _stopListening,
        tooltip: 'Listen',
        child: Icon(_speechToText.isNotListening ? Icons.mic_off : Icons.mic),
      ),
    );
  }
}