Reconhecimento de fala

Use o reconhecimento de fala para fornecer entrada, especificar uma ação ou comando e realizar tarefas.

APIs importantes: Windows.Media.SpeechRecognition

O reconhecimento de fala é composto por um runtime de fala, APIs de reconhecimento para programar o runtime, gramáticas prontas para uso para ditado e pesquisa na Web e uma interface do usuário do sistema padrão que ajuda os usuários a descobrir e usar recursos de reconhecimento de fala.

Configurar o reconhecimento de fala

Para dar suporte ao reconhecimento de fala com seu aplicativo, o usuário deve se conectar e habilitar um microfone em seu dispositivo e aceitar a Política de Privacidade da Microsoft que concede permissão para seu aplicativo usá-lo.

Para solicitar automaticamente ao usuário uma caixa de diálogo do sistema solicitando permissão para acessar e usar o feed de áudio do microfone (exemplo do exemplo de reconhecimento de fala e síntese de fala mostrado abaixo), basta definir a funcionalidade do dispositivo de microfone no manifesto do pacote do aplicativo. Para obter mais detalhes, consulte Declarações de funcionalidade do aplicativo.

Se o usuário clicar em Sim para conceder acesso ao microfone, seu aplicativo será adicionado à lista de aplicativos aprovados na página Configurações -> Privacidade -> Microfone. No entanto, como o usuário pode optar por desativar essa configuração a qualquer momento, você deve confirmar se o aplicativo tem acesso ao microfone antes de tentar usá-lo.

Se você também quiser dar suporte ao ditado, à Cortana ou a outros serviços de reconhecimento de fala (como uma gramática predefinida definida em uma restrição de tópico), também deverá confirmar se o reconhecimento de fala online (Configurações -> Privacidade -> Fala) está habilitado.

Este snippet mostra como seu aplicativo pode verificar se um microfone está presente e se ele tem permissão para usá-lo.

public class AudioCapturePermissions
{
    // If no microphone is present, an exception is thrown with the following HResult value.
    private static int NoCaptureDevicesHResult = -1072845856;

    /// <summary>
    /// Note that this method only checks the Settings->Privacy->Microphone setting, it does not handle
    /// the Cortana/Dictation privacy check.
    ///
    /// You should perform this check every time the app gets focus, in case the user has changed
    /// the setting while the app was suspended or not in focus.
    /// </summary>
    /// <returns>True, if the microphone is available.</returns>
    public async static Task<bool> RequestMicrophonePermission()
    {
        try
        {
            // Request access to the audio capture device.
            MediaCaptureInitializationSettings settings = new MediaCaptureInitializationSettings();
            settings.StreamingCaptureMode = StreamingCaptureMode.Audio;
            settings.MediaCategory = MediaCategory.Speech;
            MediaCapture capture = new MediaCapture();

            await capture.InitializeAsync(settings);
        }
        catch (TypeLoadException)
        {
            // Thrown when a media player is not available.
            var messageDialog = new Windows.UI.Popups.MessageDialog("Media player components are unavailable.");
            await messageDialog.ShowAsync();
            return false;
        }
        catch (UnauthorizedAccessException)
        {
            // Thrown when permission to use the audio capture device is denied.
            // If this occurs, show an error or disable recognition functionality.
            return false;
        }
        catch (Exception exception)
        {
            // Thrown when an audio capture device is not present.
            if (exception.HResult == NoCaptureDevicesHResult)
            {
                var messageDialog = new Windows.UI.Popups.MessageDialog("No Audio Capture devices are present on this system.");
                await messageDialog.ShowAsync();
                return false;
            }
            else
            {
                throw;
            }
        }
        return true;
    }
}

/// <summary>
/// Note that this method only checks the Settings->Privacy->Microphone setting, it does not handle
/// the Cortana/Dictation privacy check.
///
/// You should perform this check every time the app gets focus, in case the user has changed
/// the setting while the app was suspended or not in focus.
/// </summary>
/// <returns>True, if the microphone is available.</returns>
IAsyncOperation<bool>^  AudioCapturePermissions::RequestMicrophonePermissionAsync()
{
    return create_async([]() 
    {
        try
        {
            // Request access to the audio capture device.
            MediaCaptureInitializationSettings^ settings = ref new MediaCaptureInitializationSettings();
            settings->StreamingCaptureMode = StreamingCaptureMode::Audio;
            settings->MediaCategory = MediaCategory::Speech;
            MediaCapture^ capture = ref new MediaCapture();

            return create_task(capture->InitializeAsync(settings))
                .then([](task<void> previousTask) -> bool
            {
                try
                {
                    previousTask.get();
                }
                catch (AccessDeniedException^)
                {
                    // Thrown when permission to use the audio capture device is denied.
                    // If this occurs, show an error or disable recognition functionality.
                    return false;
                }
                catch (Exception^ exception)
                {
                    // Thrown when an audio capture device is not present.
                    if (exception->HResult == AudioCapturePermissions::NoCaptureDevicesHResult)
                    {
                        auto messageDialog = ref new Windows::UI::Popups::MessageDialog("No Audio Capture devices are present on this system.");
                        create_task(messageDialog->ShowAsync());
                        return false;
                    }

                    throw;
                }
                return true;
            });
        }
        catch (Platform::ClassNotRegisteredException^ ex)
        {
            // Thrown when a media player is not available. 
            auto messageDialog = ref new Windows::UI::Popups::MessageDialog("Media Player Components unavailable.");
            create_task(messageDialog->ShowAsync());
            return create_task([] {return false; });
        }
    });
}

var AudioCapturePermissions = WinJS.Class.define(
    function () { }, {},
    {
        requestMicrophonePermission: function () {
            /// <summary>
            /// Note that this method only checks the Settings->Privacy->Microphone setting, it does not handle
            /// the Cortana/Dictation privacy check.
            ///
            /// You should perform this check every time the app gets focus, in case the user has changed
            /// the setting while the app was suspended or not in focus.
            /// </summary>
            /// <returns>True, if the microphone is available.</returns>
            return new WinJS.Promise(function (completed, error) {

                try {
                    // Request access to the audio capture device.
                    var captureSettings = new Windows.Media.Capture.MediaCaptureInitializationSettings();
                    captureSettings.streamingCaptureMode = Windows.Media.Capture.StreamingCaptureMode.audio;
                    captureSettings.mediaCategory = Windows.Media.Capture.MediaCategory.speech;

                    var capture = new Windows.Media.Capture.MediaCapture();
                    capture.initializeAsync(captureSettings).then(function () {
                        completed(true);
                    },
                    function (error) {
                        // Audio Capture can fail to initialize if there's no audio devices on the system, or if
                        // the user has disabled permission to access the microphone in the Privacy settings.
                        if (error.number == -2147024891) { // Access denied (microphone disabled in settings)
                            completed(false);
                        } else if (error.number == -1072845856) { // No recording device present.
                            var messageDialog = new Windows.UI.Popups.MessageDialog("No Audio Capture devices are present on this system.");
                            messageDialog.showAsync();
                            completed(false);
                        } else {
                            error(error);
                        }
                    });
                } catch (exception) {
                    if (exception.number == -2147221164) { // REGDB_E_CLASSNOTREG
                        var messageDialog = new Windows.UI.Popups.MessageDialog("Media Player components not available on this system.");
                        messageDialog.showAsync();
                        return false;
                    }
                }
            });
        }
    })

Reconhecer entrada de fala

Uma restrição define as palavras e frases (vocabulário) que um aplicativo reconhece na entrada de fala. As restrições estão no centro do reconhecimento de fala e dão ao seu aplicativo maior controle sobre a precisão do reconhecimento de fala.

Você pode usar os seguintes tipos de restrições para reconhecer a entrada de fala.

Gramáticas predefinidas

Ditado predefinido e gramáticas de pesquisa na Web fornecem reconhecimento de fala para seu aplicativo sem exigir que você crie uma gramática. Ao usar essas gramáticas, o reconhecimento de fala é executado por um serviço Web remoto e os resultados são retornados ao dispositivo.

A gramática de ditado de texto livre padrão pode reconhecer a maioria das palavras e frases que um usuário pode dizer em um idioma específico e é otimizada para reconhecer frases curtas. A gramática de ditado predefinida será usada se você não especificar nenhuma restrição para o objeto SpeechRecognizer. O ditado de texto livre é útil quando você não deseja limitar os tipos de coisas que um usuário pode dizer. Os usos típicos incluem criar notas ou ditar o conteúdo de uma mensagem.

A gramática de pesquisa na web, como uma gramática de ditado, contém um grande número de palavras e frases que um usuário pode dizer. No entanto, ele é otimizado para reconhecer termos que as pessoas normalmente usam ao pesquisar na web.

Essas gramáticas predefinidas podem ser usadas para reconhecer até 10 segundos de entrada de fala e não exigem nenhum esforço de criação de sua parte. No entanto, eles exigem uma conexão com uma rede.

Para usar restrições de serviço da Web, a entrada de fala e o suporte ao ditado devem ser ativados em Configurações, ativando a opção "Conheça-me" em Configurações -> Privacidade -> Fala, escrita à tinta e digitação.

Aqui, mostramos como testar se a entrada de fala está habilitada e abrir a página Configurações -> Privacidade -> Fala, escrita à tinta e digitação, caso contrário.

Primeiro, inicializamos uma variável global (HResultPrivacyStatementDeclined) para o valor HResult de 0x80045509. Consulte Tratamento de exceções em C# ou Visual Basic.

private static uint HResultPrivacyStatementDeclined = 0x80045509;

Em seguida, capturamos todas as exceções padrão durante o reconhecimento e testamos se o valor HResult é igual ao valor da variável HResultPrivacyStatementDeclined. Nesse caso, exibimos um aviso e chamamos await Windows.System.Launcher.LaunchUriAsync(new Uri("ms-settings:privacy-accounts")); para abrir a página Configurações.

catch (Exception exception)
{
  // Handle the speech privacy policy error.
  if ((uint)exception.HResult == HResultPrivacyStatementDeclined)
  {
    resultTextBlock.Visibility = Visibility.Visible;
    resultTextBlock.Text = "The privacy statement was declined." + 
      "Go to Settings -> Privacy -> Speech, inking and typing, and ensure you" +
      "have viewed the privacy policy, and 'Get To Know You' is enabled.";
    // Open the privacy/speech, inking, and typing settings page.
    await Windows.System.Launcher.LaunchUriAsync(new Uri("ms-settings:privacy-accounts")); 
  }
  else
  {
    var messageDialog = new Windows.UI.Popups.MessageDialog(exception.Message, "Exception");
    await messageDialog.ShowAsync();
  }
}

Consulte SpeechRecognitionTopicConstraint.

Restrições de lista programática

As restrições de lista programática fornecem uma abordagem leve para criar gramáticas simples usando uma lista de palavras ou frases. Uma restrição de lista funciona bem para reconhecer frases curtas e distintas. Especificar explicitamente todas as palavras em uma gramática também melhora a precisão do reconhecimento, pois o mecanismo de reconhecimento de fala só deve processar a fala para confirmar uma correspondência. A lista também pode ser atualizada programaticamente.

Uma restrição de lista consiste em uma matriz de cadeias de caracteres que representa a entrada de fala que seu aplicativo aceitará para uma operação de reconhecimento. Você pode criar uma restrição de lista em seu aplicativo criando um objeto de restrição de lista de reconhecimento de fala e passando uma matriz de cadeias de caracteres. Em seguida, adicione esse objeto à coleção constraints do reconhecedor. O reconhecimento é bem-sucedido quando o reconhecedor de fala reconhece qualquer uma das cadeias de caracteres na matriz.

Consulte SpeechRecognitionListConstraint.

Gramáticas SRGS

Uma gramática SRGS (Especificação de Gramática de Reconhecimento de Fala) é um documento estático que, ao contrário de uma restrição de lista programática, usa o formato XML definido pelo SRGS Versão 1.0. Uma gramática SRGS fornece o maior controle sobre a experiência de reconhecimento de fala, permitindo que você capture vários significados semânticos em um único reconhecimento.

Consulte SpeechRecognitionGrammarFileConstraint.

Restrições de comando de voz

Use um arquivo XML de definição de comando de voz (VCD) para definir os comandos que o usuário pode dizer para iniciar ações ao ativar seu aplicativo. Para obter mais detalhes, consulte Ativar um aplicativo em primeiro plano com comandos de voz por meio da Cortana.

Consulte SpeechRecognitionVoiceCommandDefinitionConstraint/

Observação O tipo de restrição que você usa depende da complexidade da experiência de reconhecimento que você deseja criar. Qualquer um pode ser a melhor opção para uma tarefa de reconhecimento específica e você pode encontrar usos para todos os tipos de restrições em seu aplicativo. Para começar a usar restrições, consulte Definir restrições de reconhecimento personalizadas.

A gramática de ditado predefinida do aplicativo Universal do Windows reconhece a maioria das palavras e frases curtas em um idioma. Ele é ativado por padrão quando um objeto reconhecedor de fala é instanciado sem restrições personalizadas.

Neste exemplo, mostramos como:

• Crie um reconhecedor de fala.
• Compile as restrições padrão do aplicativo Universal do Windows (nenhuma gramática foi adicionada ao conjunto de gramáticas do reconhecedor de fala).
• Comece a ouvir a fala usando a interface do usuário de reconhecimento básico e os comentários TTS fornecidos pelo método RecognizeWithUIAsync. Use o método RecognizeAsync se a interface do usuário padrão não for necessária.

private async void StartRecognizing_Click(object sender, RoutedEventArgs e)
{
    // Create an instance of SpeechRecognizer.
    var speechRecognizer = new Windows.Media.SpeechRecognition.SpeechRecognizer();

    // Compile the dictation grammar by default.
    await speechRecognizer.CompileConstraintsAsync();

    // Start recognition.
    Windows.Media.SpeechRecognition.SpeechRecognitionResult speechRecognitionResult = await speechRecognizer.RecognizeWithUIAsync();

    // Do something with the recognition result.
    var messageDialog = new Windows.UI.Popups.MessageDialog(speechRecognitionResult.Text, "Text spoken");
    await messageDialog.ShowAsync();
}

Personalizar a interface do usuário de reconhecimento

Quando seu aplicativo tenta o reconhecimento de fala chamando SpeechRecognizer.RecognizeWithUIAsync, várias telas são mostradas na ordem a seguir.

Se você estiver usando uma restrição com base em uma gramática predefinida (ditado ou pesquisa na Web):

• A tela de escuta .
• A tela Thinking .
• A tela Ouvi você dizer ou a tela de erro.

Se você estiver usando uma restrição baseada em uma lista de palavras ou frases, ou uma restrição baseada em um arquivo de gramática SRGS:

• A tela de escuta .
• A tela Você disse , se o que o usuário disse pode ser interpretado como mais de um resultado potencial.
• A tela Ouvi você dizer ou a tela de erro.

A imagem a seguir mostra um exemplo do fluxo entre telas para um reconhecedor de fala que usa uma restrição baseada em um arquivo de gramática SRGS. Neste exemplo, o reconhecimento de fala foi bem-sucedido.

A tela Listening pode fornecer exemplos de palavras ou frases que o aplicativo pode reconhecer. Aqui, mostramos como usar as propriedades da classe SpeechRecognizerUIOptions (obtida chamando a propriedade SpeechRecognizer.UIOptions) para personalizar o conteúdo na tela de escuta.

private async void WeatherSearch_Click(object sender, RoutedEventArgs e)
{
    // Create an instance of SpeechRecognizer.
    var speechRecognizer = new Windows.Media.SpeechRecognition.SpeechRecognizer();

    // Listen for audio input issues.
    speechRecognizer.RecognitionQualityDegrading += speechRecognizer_RecognitionQualityDegrading;

    // Add a web search grammar to the recognizer.
    var webSearchGrammar = new Windows.Media.SpeechRecognition.SpeechRecognitionTopicConstraint(Windows.Media.SpeechRecognition.SpeechRecognitionScenario.WebSearch, "webSearch");


    speechRecognizer.UIOptions.AudiblePrompt = "Say what you want to search for...";
    speechRecognizer.UIOptions.ExampleText = @"Ex. 'weather for London'";
    speechRecognizer.Constraints.Add(webSearchGrammar);

    // Compile the constraint.
    await speechRecognizer.CompileConstraintsAsync();

    // Start recognition.
    Windows.Media.SpeechRecognition.SpeechRecognitionResult speechRecognitionResult = await speechRecognizer.RecognizeWithUIAsync();
    //await speechRecognizer.RecognizeWithUIAsync();

    // Do something with the recognition result.
    var messageDialog = new Windows.UI.Popups.MessageDialog(speechRecognitionResult.Text, "Text spoken");
    await messageDialog.ShowAsync();
}

Artigos relacionados

• Interações de controle por voz

Amostras

• Exemplo de reconhecimento de fala e sintetização de controle por voz