Ditado contínuoContinuous dictation

Saiba como capturar e reconhecer entrada de fala de ditado contínuo de formato longo.Learn how to capture and recognize long-form, continuous dictation speech input.

APIs importantes: SpeechContinuousRecognitionSession, ContinuousRecognitionSessionImportant APIs: SpeechContinuousRecognitionSession, ContinuousRecognitionSession

Em Reconhecimento de fala, você aprendeu como capturar e reconhecer entradas de fala relativamente curtas usando o método RecognizeAsync ou o método RecognizeWithUIAsync de um objeto SpeechRecognizer, por exemplo, ao compor uma mensagem SMS curta ou fazer uma pergunta.In Speech recognition, you learned how to capture and recognize relatively short speech input using the RecognizeAsync or RecognizeWithUIAsync methods of a SpeechRecognizer object, for example, when composing a short message service (SMS) message or when asking a question.

Para sessões de reconhecimento de fala contínuas mais longas, como ditado ou email, use a propriedade ContinuousRecognitionSession de um SpeechRecognizer para obter um objeto SpeechContinuousRecognitionSession.For longer, continuous speech recognition sessions, such as dictation or email, use the ContinuousRecognitionSession property of a SpeechRecognizer to obtain a SpeechContinuousRecognitionSession object.

Observação

O suporte ao idioma do ditado depende do dispositivo em que seu aplicativo está sendo executado.Dictation language support depends on the device where your app is running. Para PCs e laptops, apenas en-US é reconhecido, enquanto o Xbox e os telefones podem reconhecer todos os idiomas com suporte no reconhecimento de fala.For PCs and laptops, only en-US is recognized, while Xbox and phones can recognize all languages supported by speech recognition. Para obter mais informações, consulte especificar o idioma do reconhecedor de fala.For more info, see Specify the speech recognizer language.

ConfiguraçãoSet up

Seu aplicativo precisa de alguns objetos para gerenciar uma sessão de ditado contínuo:Your app needs a few objects to manage a continuous dictation session:

  • Uma instância de um objeto SpeechRecognizer.An instance of a SpeechRecognizer object.
  • Uma referência a um dispatcher de interface do usuário para atualizar a interface do usuário durante o ditado.A reference to a UI dispatcher to update the UI during dictation.
  • Uma maneira de acompanhar as palavras acumuladas faladas pelo usuário.A way to track the accumulated words spoken by the user.

Aqui, declaramos uma instância SpeechRecognizer como um campo particular da classe code-behind.Here, we declare a SpeechRecognizer instance as a private field of the code-behind class. Seu aplicativo precisa armazenar uma referência em outro lugar se você quiser que o ditado contínuo persista além de uma única página XAML.Your app needs to store a reference elsewhere if you want continuous dictation to persist beyond a single Extensible Application Markup Language (XAML) page.

private SpeechRecognizer speechRecognizer;

Durante o ditado, o reconhecedor aciona eventos de um thread em segundo plano.During dictation, the recognizer raises events from a background thread. Como um thread em segundo plano não pode atualizar diretamente a interface do usuário em XAML, seu aplicativo deve usar um dispatcher para atualizar a interface do usuário em resposta a eventos de reconhecimento.Because a background thread cannot directly update the UI in XAML, your app must use a dispatcher to update the UI in response to recognition events.

Aqui, nós declaramos um campo particular que será inicializado posteriormente com o dispatcher de interface do usuário.Here, we declare a private field that will be initialized later with the UI dispatcher.

// Speech events may originate from a thread other than the UI thread.
// Keep track of the UI thread dispatcher so that we can update the
// UI in a thread-safe manner.
private CoreDispatcher dispatcher;

Para acompanhar o que o usuário está dizendo, você precisa tratar eventos de reconhecimento acionados pelo reconhecedor de fala.To track what the user is saying, you need to handle recognition events raised by the speech recognizer. Esses eventos fornecem os resultados do reconhecimento de blocos de expressões do usuário.These events provide the recognition results for chunks of user utterances.

Aqui, usamos um objeto StringBuilder para reter todos os resultados do reconhecimento obtidos durante a sessão.Here, we use a StringBuilder object to hold all the recognition results obtained during the session. Novos resultados são acrescentados ao StringBuilder conforme eles são processados.New results are appended to the StringBuilder as they are processed.

private StringBuilder dictatedTextBuilder;

InicializaçãoInitialization

Durante a inicialização do reconhecimento de fala contínua, você deve:During the initialization of continuous speech recognition, you must:

  • Buscar o dispatcher do thread de interface do usuário se você atualizar a interface do usuário do aplicativo nos manipuladores de eventos de reconhecimento contínuo.Fetch the dispatcher for the UI thread if you update the UI of your app in the continuous recognition event handlers.
  • Inicializar o reconhecedor de fala.Initialize the speech recognizer.
  • Compilar a gramática de ditado interna.Compile the built-in dictation grammar. Observação    O reconhecimento de fala requer pelo menos uma restrição para definir um vocabulário reconhecível.Note   Speech recognition requires at least one constraint to define a recognizable vocabulary. Se nenhuma restrição for especificada, uma gramática de ditado predefinida será usada.If no constraint is specified, a predefined dictation grammar is used. Consulte Reconhecimento de fala.See Speech recognition.
  • Configure os ouvintes de eventos para eventos de reconhecimento.Set up the event listeners for recognition events.

Nesse exemplo, inicializamos o reconhecimento de fala no evento de página OnNavigatedTo.In this example, we initialize speech recognition in the OnNavigatedTo page event.

  1. Como os eventos acionados pelo reconhecedor de fala ocorrem em um thread em segundo plano, crie uma referência ao dispatcher para atualizações no thread de interface do usuário.Because events raised by the speech recognizer occur on a background thread, create a reference to the dispatcher for updates to the UI thread. OnNavigatedTo é sempre invocado no thread de interface do usuário.OnNavigatedTo is always invoked on the UI thread.
this.dispatcher = CoreWindow.GetForCurrentThread().Dispatcher;
  1. Em seguida, inicializamos a instância SpeechRecognizer.We then initialize the SpeechRecognizer instance.
this.speechRecognizer = new SpeechRecognizer();
  1. Depois, adicionamos e compilamos a gramática que define todas as palavras e frases que podem ser reconhecidas pelo SpeechRecognizer.We then add and compile the grammar that defines all of the words and phrases that can be recognized by the SpeechRecognizer.

    Se você não especificar explicitamente uma gramática, uma gramática de ditado predefinida será usada por padrão.If you don't specify a grammar explicitly, a predefined dictation grammar is used by default. Normalmente, a gramática padrão é melhor para ditado geral.Typically, the default grammar is best for general dictation.

    Aqui, chamamos CompileConstraintsAsync imediatamente, sem adicionar uma gramática.Here, we call CompileConstraintsAsync immediately without adding a grammar.

SpeechRecognitionCompilationResult result =
      await speechRecognizer.CompileConstraintsAsync();

Tratar eventos de reconhecimentoHandle recognition events

Você pode capturar uma única expressão ou frase curta chamando RecognizeAsync ou RecognizeWithUIAsync.You can capture a single, brief utterance or phrase by calling RecognizeAsync or RecognizeWithUIAsync.

No entanto, para capturar uma sessão de reconhecimento contínua mais longa, especificamos ouvintes de eventos a serem executados em segundo plano conforme o usuário fala e definimos manipuladores para criar a cadeia de caracteres de ditado.However, to capture a longer, continuous recognition session, we specify event listeners to run in the background as the user speaks and define handlers to build the dictation string.

Em seguida, usamos a propriedade ContinuousRecognitionSession do nosso reconhecedor para obter um objeto SpeechContinuousRecognitionSession que fornece métodos e eventos para gerenciar uma sessão de reconhecimento contínua.We then use the ContinuousRecognitionSession property of our recognizer to obtain a SpeechContinuousRecognitionSession object that provides methods and events for managing a continuous recognition session.

Dois eventos em particular são essenciais:Two events in particular are critical:

  • ResultGenerated, que ocorre quando o reconhecedor gerou alguns resultados.ResultGenerated, which occurs when the recognizer has generated some results.
  • Completed, que ocorre quando a sessão de reconhecimento contínua termina.Completed, which occurs when the continuous recognition session has ended.

O evento ResultGenerated é acionado conforme o usuário fala.The ResultGenerated event is raised as the user speaks. O reconhecedor escuta o usuário de forma contínua e periodicamente aciona um evento que passa um bloco de entrada de fala.The recognizer continuously listens to the user and periodically raises an event that passes a chunk of speech input. Você deve examinar a entrada de fala usando a propriedade Result do argumento do evento e executar a ação apropriada no manipulador de eventos, por exemplo, acrescentando o texto a um objeto StringBuilder.You must examine the speech input, using the Result property of the event argument, and take appropriate action in the event handler, such as appending the text to a StringBuilder object.

Como uma instância de SpeechRecognitionResult, a propriedade Result é útil para determinar se você deseja aceitar a entrada de falaAs an instance of SpeechRecognitionResult, the Result property is useful for determining whether you want to accept the speech input. Um SpeechRecognitionResult fornece duas propriedades para isso:A SpeechRecognitionResult provides two properties for this:

  • Status indica se o reconhecimento foi executado com êxito.Status indicates whether the recognition was successful. Pode haver falha no reconhecimento por vários motivos.Recognition can fail for a variety of reasons.
  • Confidence indica a confiança relativa com que o reconhecedor compreendeu as palavras corretas.Confidence indicates the relative confidence that the recognizer understood the correct words.

Aqui estão as etapas básicas para dar suporte contínuo reconhecimento:Here are the basic steps for supporting continuous recognition:

  1. Aqui, registramos o manipulador do evento de reconhecimento contínuo ResultGenerated no evento de página OnNavigatedTo.Here, we register the handler for the ResultGenerated continuous recognition event in the OnNavigatedTo page event.
speechRecognizer.ContinuousRecognitionSession.ResultGenerated +=
        ContinuousRecognitionSession_ResultGenerated;
  1. Em seguida, verificamos a propriedade Confidence.We then check the Confidence property. Se o valor de Confiança for Medium ou melhor, acrescentamos o texto ao StringBuilder.If the value of Confidence is Medium or better, we append the text to the StringBuilder. Também atualizamos a interface do usuário conforme coletamos entradas.We also update the UI as we collect input.

    Observação    o evento ResultGenerated é gerado em um thread em segundo plano que não pode atualizar a interface do usuário diretamente.Note  the ResultGenerated event is raised on a background thread that cannot update the UI directly. Se um manipulador precisar atualizar a interface do usuário (como o [ exemplo de voz e TTS ] ), você deverá expedir as atualizações para o thread da interface do usuário por meio do método RunAsync do Dispatcher.If a handler needs to update the UI (as the [Speech and TTS sample] does), you must dispatch the updates to the UI thread through the RunAsync method of the dispatcher.

private async void ContinuousRecognitionSession_ResultGenerated(
      SpeechContinuousRecognitionSession sender,
      SpeechContinuousRecognitionResultGeneratedEventArgs args)
      {

        if (args.Result.Confidence == SpeechRecognitionConfidence.Medium ||
          args.Result.Confidence == SpeechRecognitionConfidence.High)
          {
            dictatedTextBuilder.Append(args.Result.Text + " ");

            await dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
            {
              dictationTextBox.Text = dictatedTextBuilder.ToString();
              btnClearText.IsEnabled = true;
            });
          }
        else
        {
          await dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
            {
              dictationTextBox.Text = dictatedTextBuilder.ToString();
            });
        }
      }
  1. Em seguida, tratamos o evento Completed, que indica o final do ditado contínuo.We then handle the Completed event, which indicates the end of continuous dictation.

    A sessão termina quando você chama os métodos StopAsync ou CancelAsync (descritos na próxima seção).The session ends when you call the StopAsync or CancelAsync methods (described the next section). A sessão também pode terminar quando ocorre um erro, ou quando o usuário para de falar.The session can also end when an error occurs, or when the user has stopped speaking. Verifique a propriedade Status do argumento do evento para determinar por que a sessão terminou (SpeechRecognitionResultStatus).Check the Status property of the event argument to determine why the session ended (SpeechRecognitionResultStatus).

    Aqui, registramos o manipulador do evento de reconhecimento contínuo Completed no evento de página OnNavigatedTo.Here, we register the handler for the Completed continuous recognition event in the OnNavigatedTo page event.

speechRecognizer.ContinuousRecognitionSession.Completed +=
      ContinuousRecognitionSession_Completed;
  1. O manipulador de eventos verifica a propriedade Status para determinar se o reconhecimento foi executado com êxito.The event handler checks the Status property to determine whether the recognition was successful. Ele também trata o caso em que o usuário parou de falar.It also handles the case where the user has stopped speaking. Frequentemente, TimeoutExceeded é considerado um reconhecimento bem-sucedido porque significa que o usuário terminou de falar.Often, a TimeoutExceeded is considered successful recognition as it means the user has finished speaking. Você deve tratar esse caso no seu código para obter uma boa experiência.You should handle this case in your code for a good experience.

    Observação    o evento ResultGenerated é gerado em um thread em segundo plano que não pode atualizar a interface do usuário diretamente.Note  the ResultGenerated event is raised on a background thread that cannot update the UI directly. Se um manipulador precisar atualizar a interface do usuário (como o [ exemplo de voz e TTS ] ), você deverá expedir as atualizações para o thread da interface do usuário por meio do método RunAsync do Dispatcher.If a handler needs to update the UI (as the [Speech and TTS sample] does), you must dispatch the updates to the UI thread through the RunAsync method of the dispatcher.

private async void ContinuousRecognitionSession_Completed(
      SpeechContinuousRecognitionSession sender,
      SpeechContinuousRecognitionCompletedEventArgs args)
      {
        if (args.Status != SpeechRecognitionResultStatus.Success)
        {
          if (args.Status == SpeechRecognitionResultStatus.TimeoutExceeded)
          {
            await dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
            {
              rootPage.NotifyUser(
                "Automatic Time Out of Dictation",
                NotifyType.StatusMessage);

              DictationButtonText.Text = " Continuous Recognition";
              dictationTextBox.Text = dictatedTextBuilder.ToString();
            });
          }
          else
          {
            await dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
            {
              rootPage.NotifyUser(
                "Continuous Recognition Completed: " + args.Status.ToString(),
                NotifyType.StatusMessage);

              DictationButtonText.Text = " Continuous Recognition";
            });
          }
        }
      }

Fornecer feedback de reconhecimento contínuoProvide ongoing recognition feedback

Quando as pessoas conversam, elas frequentemente dependem do contexto para entender completamente o que está sendo dito.When people converse, they often rely on context to fully understand what is being said. Da mesma forma, o reconhecedor de fala precisa de contexto para fornecer resultados de reconhecimento de alta confiabilidade.Similarly, the speech recognizer often needs context to provide high-confidence recognition results. Por exemplo, sozinhas, as palavras "acento" e "assento" não podem ser diferenciadas até que mais contexto seja coletado das palavras adjacentes.For example, by themselves, the words "weight" and "wait" are indistinguishable until more context can be gleaned from surrounding words. Até que o reconhecedor tenha alguma confiança de que uma ou mais palavras foram reconhecidas corretamente, ele não acionará um evento ResultGenerated.Until the recognizer has some confidence that a word, or words, have been recognized correctly, it will not raise the ResultGenerated event.

Isso pode resultar em uma experiência longe da ideal para o usuário, pois ele continua falando e nenhum resultado é fornecido até que o reconhecedor tenha confiança suficiente para acionar um evento ResultGenerated.This can result in a less than ideal experience for the user as they continue speaking and no results are provided until the recognizer has high enough confidence to raise the ResultGenerated event.

Trate o evento HypothesisGenerated para melhorar essa aparente falta de capacidade de resposta.Handle the HypothesisGenerated event to improve this apparent lack of responsiveness. Esse evento é acionado sempre que o reconhecedor gera um novo conjunto de possíveis correspondências para a palavra que está sendo processada.This event is raised whenever the recognizer generates a new set of potential matches for the word being processed. O argumento do evento fornece uma propriedade Hypothesis que contém as correspondências atuais.The event argument provides an Hypothesis property that contains the current matches. Mostre as correspondências ao usuário conforme ele continua falando e assegure que o processamento ainda está ativo.Show these to the user as they continue speaking and reassure them that processing is still active. Assim que a confiança for alta e um resultado de reconhecimento tiver sido determinado, substitua os resultados Hypothesis temporários pelo Result final fornecido no evento ResultGenerated.Once confidence is high and a recognition result has been determined, replace the interim Hypothesis results with the final Result provided in the ResultGenerated event.

Aqui, acrescentamos o texto hipotético e reticências ("…") ao valor atual da caixa de texto de saída TextBox.Here, we append the hypothetical text and an ellipsis ("…") to the current value of the output TextBox. O conteúdo da caixa de texto é atualizado conforme novas hipóteses são geradas e até que os resultados finais sejam obtidos do evento ResultGenerated.The contents of the text box are updated as new hypotheses are generated and until the final results are obtained from the ResultGenerated event.

private async void SpeechRecognizer_HypothesisGenerated(
  SpeechRecognizer sender,
  SpeechRecognitionHypothesisGeneratedEventArgs args)
  {

    string hypothesis = args.Hypothesis.Text;
    string textboxContent = dictatedTextBuilder.ToString() + " " + hypothesis + " ...";

    await dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
    {
      dictationTextBox.Text = textboxContent;
      btnClearText.IsEnabled = true;
    });
  }

Iniciar e parar o reconhecimentoStart and stop recognition

Antes de iniciar uma sessão de reconhecimento, verifique o valor da propriedade State do reconhecedor de fala.Before starting a recognition session, check the value of the speech recognizer State property. O reconhecedor de fala deve estar em um estado Idle.The speech recognizer must be in an Idle state.

Depois de verificar o estado do reconhecedor de fala, começamos a sessão chamando o método StartAsync da propriedade ContinuousRecognitionSession do reconhecedor de fala.After checking the state of the speech recognizer, we start the session by calling the StartAsync method of the speech recognizer's ContinuousRecognitionSession property.

if (speechRecognizer.State == SpeechRecognizerState.Idle)
{
  await speechRecognizer.ContinuousRecognitionSession.StartAsync();
}

O reconhecimento pode ser interrompido de duas maneiras:Recognition can be stopped in two ways:

  • StopAsync permite que qualquer evento de reconhecimento pendente seja concluído (ResultGenerated continua sendo acionado até que todas as operações de reconhecimento pendentes sejam concluídas).StopAsync lets any pending recognition events complete (ResultGenerated continues to be raised until all pending recognition operations are complete).
  • CancelAsync finaliza a sessão de reconhecimento imediatamente e descarta qualquer resultado pendente.CancelAsync terminates the recognition session immediately and discards any pending results.

Depois de verificar o estado do reconhecedor de fala, interrompemos a sessão chamando o método CancelAsync da propriedade ContinuousRecognitionSession do reconhecedor de fala.After checking the state of the speech recognizer, we stop the session by calling the CancelAsync method of the speech recognizer's ContinuousRecognitionSession property.

if (speechRecognizer.State != SpeechRecognizerState.Idle)
{
  await speechRecognizer.ContinuousRecognitionSession.CancelAsync();
}

Observação

Um evento ResultGenerated pode ocorrer após uma chamada para CancelAsync.A ResultGenerated event can occur after a call to CancelAsync.
Por causa do multithreading, um evento ResultGenerated ainda pode permanecer na pilha quando CancelAsync é chamado.Because of multithreading, a ResultGenerated event might still remain on the stack when CancelAsync is called. Nesse caso, o evento ResultGenerated ainda é acionado.If so, the ResultGenerated event still fires.
Se você definir qualquer campo particular ao cancelar a sessão de reconhecimento, sempre confirme seus valores no manipulador ResultGenerated.If you set any private fields when canceling the recognition session, always confirm their values in the ResultGenerated handler. Por exemplo, não suponha que um campo será inicializado em seu manipulador se você defini-lo como nulo ao cancelar a sessão.For example, don't assume a field is initialized in your handler if you set them to null when you cancel the session.

 

AmostrasSamples