Reconnaissance vocaleSpeech recognition

La reconnaissance vocale permet de fournir une saisie vocale, de spécifier une action ou une commande et d’accomplir différentes tâches.Use speech recognition to provide input, specify an action or command, and accomplish tasks.

API importantes: Windows. Media. SpeechRecognitionImportant APIs: Windows.Media.SpeechRecognition

La reconnaissance vocale se compose d’un runtime de fonctions vocales, d’API de reconnaissance vocale pour programmer le runtime, de grammaires prêtes à l’emploi pour la dictée et la recherche web, ainsi que d’une interface utilisateur système par défaut permettant aux utilisateurs de découvrir et d’utiliser les fonctionnalités de reconnaissance vocale.Speech recognition is made up of a speech runtime, recognition APIs for programming the runtime, ready-to-use grammars for dictation and web search, and a default system UI that helps users discover and use speech recognition features.

Configurer la reconnaissance vocaleConfigure speech recognition

Pour prendre en charge la reconnaissance vocale avec votre application, l’utilisateur doit se connecter et activer un microphone sur son appareil, et accepter la politique de confidentialité Microsoft accordant à votre application l’autorisation de l’utiliser.To support speech recognition with your app, the user must connect and enable a microphone on their device, and accept the Microsoft Privacy Policy granting permission for your app to use it.

Pour demander automatiquement à l’utilisateur une boîte de dialogue système qui demande l’autorisation d’accéder et d’utiliser le flux audio du microphone (à partir de l’exemple de reconnaissance vocale et de synthèse vocale illustrée ci-dessous), il vous suffit de définir la fonctionnalité de périphérique du microphone dans le manifeste du package d’application.To automatically prompt the user with a system dialog requesting permission to access and use the microphone's audio feed (example from the Speech recognition and speech synthesis sample shown below), just set the Microphone device capability in the App package manifest. Pour plus d’informations, consultez déclarations de fonctionnalités d’application.For more detail, see App capability declarations.

Politique de confidentialité pour l’accès au microphone

Si l’utilisateur clique sur Oui pour accorder l’accès au microphone, votre application est ajoutée à la liste des applications approuvées dans la page Paramètres-> confidentialité-> microphone.If the user clicks Yes to grant access to the microphone, your app is added to the list of approved applications on the Settings -> Privacy -> Microphone page. Toutefois, étant donné que l’utilisateur peut choisir de désactiver ce paramètre à tout moment, vous devez vérifier que votre application a accès au microphone avant de tenter de l’utiliser.However, as the user can choose to turn this setting off at any time, you should confirm that your app has access to the microphone before attempting to use it.

Si vous souhaitez également prendre en charge la dictée, Cortana ou d’autres services de reconnaissance vocale (par exemple, une grammaire prédéfinie définie dans une contrainte de rubrique), vous devez également vérifier que la reconnaissance vocale en ligne (paramètres-> confidentialité-> Speech) est activée.If you also want to support dictation, Cortana, or other speech recognition services (such as a predefined grammar defined in a topic constraint), you must also confirm that Online speech recognition (Settings -> Privacy -> Speech) is enabled.

Cet extrait de code montre comment votre application peut vérifier si un microphone est présent et s’il a l’autorisation de l’utiliser.This snippet shows how your app can check if a microphone is present and if it has permission to use it.

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;
                    }
                }
            });
        }
    })

Reconnaître la saisie vocaleRecognize speech input

Une contrainte définit les mots et expressions (vocabulaire) qu’une application reconnaît dans la saisie vocale.A constraint defines the words and phrases (vocabulary) that an app recognizes in speech input. Les contraintes sont au cœur de la reconnaissance vocale et offrent à votre application un meilleur contrôle de la précision de la reconnaissance vocale.Constraints are at the core of speech recognition and give your app greater control over the accuracy of speech recognition.

Vous pouvez utiliser les types de contraintes suivants pour la reconnaissance de l’entrée vocale.You can use the following types of constraints for recognizing speech input.

Grammaires prédéfiniesPredefined grammars

Les grammaires de dictée et de recherche web prédéfinies vous permettent d’activer la reconnaissance vocale dans votre application sans créer votre propre grammaire.Predefined dictation and web-search grammars provide speech recognition for your app without requiring you to author a grammar. Si vous optez pour ces grammaires, la reconnaissance vocale est effectuée par un service web distant qui renvoie les résultats à l’appareil.When using these grammars, speech recognition is performed by a remote web service and the results are returned to the device.

La grammaire de dictée de texte libre par défaut peut reconnaître la plupart des mots et expressions prononcés par un utilisateur dans une langue spécifique. Elle est optimisée pour reconnaître les expressions courtes.The default free-text dictation grammar can recognize most words and phrases that a user can say in a particular language, and is optimized to recognize short phrases. La syntaxe de dictée prédéfinie est utilisée si vous ne spécifiez aucune contrainte pour votre objet SpeechRecognizer .The predefined dictation grammar is used if you don't specify any constraints for your SpeechRecognizer object. La dictée de texte libre est utile si vous ne souhaitez pas limiter ce qu’un utilisateur peut dire.Free-text dictation is useful when you don't want to limit the kinds of things a user can say. Elle est généralement utilisée pour créer des notes ou dicter le contenu d’un message.Typical uses include creating notes or dictating the content for a message.

La grammaire de recherche web, comme une grammaire de dictée, contient un grand nombre de mots et expressions qu’un utilisateur peut dire.The web-search grammar, like a dictation grammar, contains a large number of words and phrases that a user might say. Toutefois, elle est optimisée pour reconnaître les termes que les personnes utilisent généralement lors des recherches sur le web.However, it is optimized to recognize terms that people typically use when searching the web.

Notes

 Étant donné que les grammaires de dictée et de recherche web prédéfinies peuvent être volumineuses et qu’elles sont hébergées en ligne (elles ne se trouvent pas sur l’appareil), les performances obtenues peuvent ne pas être aussi bonnes qu’avec des grammaires personnalisées qui sont installées sur l’appareil. Because predefined dictation and web-search grammars can be large, and because they are online (not on the device), performance might not be as fast as with a custom grammar installed on the device.  

Ces grammaires prédéfinies peuvent être utilisées pour reconnaître jusqu’à 10 secondes de saisie vocale et ne nécessitent aucun effort de création de votre part.These predefined grammars can be used to recognize up to 10 seconds of speech input and require no authoring effort on your part. Toutefois, elles requièrent une connexion à un réseau.However, they do require a connection to a network.

Pour utiliser les contraintes de service Web, l’entrée vocale et la prise en charge de la dictée doivent être activées dans les paramètres en activant l’option « obtenir un savoir-faire » dans paramètres-> la confidentialité > la reconnaissance vocale, l’entrée manuscrite et la saisie.To use web-service constraints, speech input and dictation support must be enabled in Settings by turning on the "Get to know me" option in Settings -> Privacy -> Speech, inking, and typing.

Ici, nous montrons comment tester si les entrées vocales sont activées et ouvrir la page Paramètres-> confidentialité-> la parole, l’entrée manuscrite et la frappe, si ce n’est pas le cas.Here, we show how to test whether speech input is enabled and open the Settings -> Privacy -> Speech, inking, and typing page, if not.

Nous commençons par initialiser une variable globale (HResultPrivacyStatementDeclined) sur la valeur HResult de 0x80045509.First, we initialize a global variable (HResultPrivacyStatementDeclined) to the HResult value of 0x80045509. Consultez gestion des exceptions pour dans C # ou Visual Basic.See Exception handling for in C# or Visual Basic.

private static uint HResultPrivacyStatementDeclined = 0x80045509;

Nous interceptons ensuite toutes les exceptions standard pendant recogntion et testons si la valeur HRESULT est égale à la valeur de la variable HResultPrivacyStatementDeclined.We then catch any standard exceptions during recogntion and test if the HResult value is equal to the value of the HResultPrivacyStatementDeclined variable. Si c’est le cas, nous affichons un avertissement et appelons await Windows.System.Launcher.LaunchUriAsync(new Uri("ms-settings:privacy-accounts")); pour ouvrir la page des paramètres.If so, we display a warning and call await Windows.System.Launcher.LaunchUriAsync(new Uri("ms-settings:privacy-accounts")); to open the Settings page.

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();
  }
}

Consultez SpeechRecognitionTopicConstraint.See SpeechRecognitionTopicConstraint.

Contraintes de liste de programmationProgrammatic list constraints

Les contraintes de liste de programmation permettent de créer facilement une grammaire simple sous la forme d’une liste de mots ou d’expressions.Programmatic list constraints provide a lightweight approach to creating simple grammars using a list of words or phrases. Une contrainte de liste fonctionne correctement pour la reconnaissance d’expressions distinctes courtes.A list constraint works well for recognizing short, distinct phrases. En indiquant explicitement des mots dans une grammaire, vous améliorez également la précision de la reconnaissance, car le traitement de la parole par le moteur de reconnaissance se limite à la confirmation d’une correspondance.Explicitly specifying all words in a grammar also improves recognition accuracy, as the speech recognition engine must only process speech to confirm a match. La liste peut également être mise à jour par programme.The list can also be programmatically updated.

Une contrainte de liste se compose d’un tableau de chaînes qui correspondent à la saisie vocale acceptée par votre application en vue d’une opération de reconnaissance vocale.A list constraint consists of an array of strings that represents speech input that your app will accept for a recognition operation. Pour créer une contrainte de liste dans votre application, vous devez créer un objet de contrainte de liste de reconnaissance vocale et lui passer un tableau de chaînes.You can create a list constraint in your app by creating a speech-recognition list-constraint object and passing an array of strings. Vous devez ensuite ajouter cet objet à la collection de contraintes du moteur de reconnaissance vocale.Then, add that object to the constraints collection of the recognizer. La reconnaissance vocale fonctionne quand le moteur de reconnaissance vocale reconnaît l’une des chaînes du tableau.Recognition is successful when the speech recognizer recognizes any one of the strings in the array.

Consultez SpeechRecognitionListConstraint.See SpeechRecognitionListConstraint.

Grammaires SRGSSRGS grammars

Contrairement à une contrainte de liste de programmation, une grammaire SRGS (Speech Recognition Grammar Specification) est un document statique au format XML défini par la norme SRGS version 1.0.An Speech Recognition Grammar Specification (SRGS) grammar is a static document that, unlike a programmatic list constraint, uses the XML format defined by the SRGS Version 1.0. Une grammaire SRGS permet de contrôler au maximum l’expérience de la reconnaissance vocale en capturant plusieurs significations sémantiques dans une même reconnaissance.An SRGS grammar provides the greatest control over the speech recognition experience by letting you capture multiple semantic meanings in a single recognition.

Consultez SpeechRecognitionGrammarFileConstraint.See SpeechRecognitionGrammarFileConstraint.

Contraintes de commande vocaleVoice command constraints

Utilisez un fichier XML VCD (Voice Command Definition) pour définir les commandes que l’utilisateur peut prononcer pour lancer des actions au moment de l’activation de votre application.Use a Voice Command Definition (VCD) XML file to define the commands that the user can say to initiate actions when activating your app. Pour plus d’informations, consultez activer une application de premier plan avec des commandes vocales via Cortana.For more detail, see Activate a foreground app with voice commands through Cortana.

Voir SpeechRecognitionVoiceCommandDefinitionConstraint/See SpeechRecognitionVoiceCommandDefinitionConstraint/

Remarque    Le type de contrainte que vous utilisez dépend de la complexité de l’expérience de reconnaissance que vous souhaitez créer.Note  The type of constraint type you use depends on the complexity of the recognition experience you want to create. Un type de contrainte peut être mieux adapté à une tâche de reconnaissance vocale particulière, mais vous pouvez aussi combiner tous les types de contrainte dans votre application.Any could be the best choice for a specific recognition task, and you might find uses for all types of constraints in your app. Pour apprendre à utiliser des contraintes, voir Définir des contraintes de reconnaissance vocale personnalisées.To get started with constraints, see Define custom recognition constraints.

La grammaire de dictée prédéfinie d’une application Windows universelle reconnaît la plupart des mots et des expressions courtes dans une langue donnée.The predefined Universal Windows app dictation grammar recognizes most words and short phrases in a language. Elle est activée par défaut lorsqu’un objet du moteur de reconnaissance vocale est instancié sans contraintes personnalisées.It is activated by default when a speech recognizer object is instantiated without custom constraints.

Dans cet exemple, nous montrons comment effectuer les opérations suivantes :In this example, we show how to:

  • créer un moteur de reconnaissance vocale ;Create a speech recognizer.
  • compiler les contraintes de l’application Windows universelle par défaut (aucune grammaire n’a été ajoutée à l’ensemble de grammaires du moteur de reconnaissance vocale) ;Compile the default Universal Windows app constraints (no grammars have been added to the speech recognizer's grammar set).
  • Commencez à écouter la parole à l’aide de l’interface utilisateur de reconnaissance de base et des commentaires TTS fournis par la méthode RecognizeWithUIAsync .Start listening for speech by using the basic recognition UI and TTS feedback provided by the RecognizeWithUIAsync method. Utilisez la méthode RecognizeAsync si l’interface utilisateur par défaut n’est pas requise.Use the RecognizeAsync method if the default UI is not required.
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();
}

Personnaliser l’interface utilisateur de reconnaissance vocaleCustomize the recognition UI

Lorsque votre application tente de reconnaître la reconnaissance vocale en appelant SpeechRecognizer. RecognizeWithUIAsync, plusieurs écrans sont affichés dans l’ordre suivant.When your app attempts speech recognition by calling SpeechRecognizer.RecognizeWithUIAsync, several screens are shown in the following order.

Si vous utilisez une contrainte basée sur une grammaire prédéfinie (dictée ou recherche web) :If you're using a constraint based on a predefined grammar (dictation or web search):

  • Écran ÉcouteThe Listening screen.
  • Écran RéflexionThe Thinking screen.
  • Écran Nous vous avons entendu dire ou écran de notification d’erreurThe Heard you say screen or the error screen.

Si vous utilisez une contrainte basée sur une liste de mots ou d’expressions ou une contrainte basée sur un fichier de grammaire SRGS :If you're using a constraint based on a list of words or phrases, or a constraint based on a SRGS grammar file:

  • Écran ÉcouteThe Listening screen.
  • Écran Nous vous avons entendu dire, si l’interprétation de ce que l’utilisateur a prononcé pourrait avoir plusieurs résultats éventuelsThe Did you say screen, if what the user said could be interpreted as more than one potential result.
  • Écran Nous vous avons entendu dire ou écran de notification d’erreurThe Heard you say screen or the error screen.

L’image suivante présente un exemple du flux entre des écrans d’un moteur de reconnaissance vocale qui utilise une contrainte basée sur un fichier de grammaire SGRS.The following image shows an example of the flow between screens for a speech recognizer that uses a constraint based on a SRGS grammar file. Dans cet exemple, la reconnaissance vocale a réussi.In this example, speech recognition was successful.

Écran initial de la reconnaissance vocale correspondant à une contrainte basée sur un fichier de grammaire SGRS

Écran intermédiaire de la reconnaissance vocale correspondant à une contrainte basée sur un fichier de grammaire SGRS

Écran final de la reconnaissance vocale correspondant à une contrainte basée sur un fichier de grammaire SGRS

L’écran Listening peut fournir des exemples de mot ou d’expression que l’application peut reconnaître.The Listening screen can provide examples of words or phrases that the app can recognize. Nous montrons ici comment utiliser les propriétés de la classe SpeechRecognizerUIOptions (obtenue en appelant la propriété SpeechRecognizer.UIOptions) pour personnaliser le contenu de l’écran Listening.Here, we show how to use the properties of the SpeechRecognizerUIOptions class (obtained by calling the SpeechRecognizer.UIOptions property) to customize content on the Listening screen.

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();
}

ExemplesSamples