Activer la dictée continue

Découvrez comment capturer et reconnaître l’entrée vocale de dictée longue et continue dans votre application SDK d'application Windows.

Important

La reconnaissance vocale nécessite l’identité du package MSIX. Les Windows.Media.SpeechRecognition API sont disponibles uniquement lorsque votre application s’exécute avec une identité de package (empaquetée ou empaquetée avec un emplacement externe). Les applications non empaquetées ne peuvent pas utiliser ces API.

API clés

Aperçu

En reconnaissance vocale, vous allez apprendre à capturer et à reconnaître des entrées vocales courtes à l’aide RecognizeAsync ou RecognizeWithUIAsync. Pour des sessions plus longues et continues de reconnaissance vocale — comme la dictée ou les e-mails — utilisez la propriété ContinuousRecognitionSession d’un objet SpeechRecognizer pour obtenir un objet SpeechContinuousRecognitionSession.

Note

La prise en charge de la langue de dictée dépend de l’appareil sur lequel votre application s’exécute. Pour les PC et les ordinateurs portables, seuls les en-US sont reconnus pour la dictée, tandis que Xbox peuvent reconnaître toutes les langues prises en charge par la reconnaissance vocale. Pour plus d’informations, consultez Spécifier la langue du module de reconnaissance vocale.

Configurer

Votre application a besoin des objets suivants pour gérer une session de dictée continue :

  • Une instance d’un objet SpeechRecognizer.
  • Référence au répartiteur d’interface utilisateur pour mettre à jour l’interface utilisateur pendant la dictée.
  • Un moyen de suivre les mots accumulés prononcés par l’utilisateur.

Déclarez une instance SpeechRecognizer et un StringBuilder pour accumuler les résultats de la reconnaissance en tant que champs de votre classe de page :

private SpeechRecognizer speechRecognizer;
private StringBuilder dictatedTextBuilder;

Dans WinUI 3, vous utilisez DispatcherQueue pour distribuer les mises à jour de l’interface utilisateur à partir de threads d’arrière-plan (et non CoreDispatcher) :

// Get the DispatcherQueue for the current thread (UI thread).
private Microsoft.UI.Dispatching.DispatcherQueue dispatcherQueue =
    Microsoft.UI.Dispatching.DispatcherQueue.GetForCurrentThread();

Initialiser

Lors de l’initialisation, vous :

  1. Initialisez le module de reconnaissance vocale.
  2. Compilez la grammaire de dictée intégrée (ou ajoutez des contraintes personnalisées).
  3. Configurez les écouteurs d’événements pour les événements de reconnaissance.
// Initialize the speech recognizer.
speechRecognizer = new SpeechRecognizer();

// Compile the default dictation grammar.
SpeechRecognitionCompilationResult result =
    await speechRecognizer.CompileConstraintsAsync();

// Subscribe to continuous recognition events.
speechRecognizer.ContinuousRecognitionSession.ResultGenerated +=
    ContinuousRecognitionSession_ResultGenerated;
speechRecognizer.ContinuousRecognitionSession.Completed +=
    ContinuousRecognitionSession_Completed;
speechRecognizer.HypothesisGenerated +=
    SpeechRecognizer_HypothesisGenerated;

dictatedTextBuilder = new StringBuilder();

Gérer les événements de reconnaissance

Résultat généré

L’événement ResultGenerated se déclenche lorsque l’utilisateur parle. Le module de reconnaissance transmet régulièrement un bloc d’entrée vocale. Vérifiez la Confidence propriété pour déterminer s’il faut accepter le résultat.

Étant donné que cet événement se déclenche sur un thread d’arrière-plan, utilisez DispatcherQueue.TryEnqueue pour mettre à jour l’interface utilisateur :

private void ContinuousRecognitionSession_ResultGenerated(
    SpeechContinuousRecognitionSession sender,
    SpeechContinuousRecognitionResultGeneratedEventArgs args)
{
    if (args.Result.Confidence == SpeechRecognitionConfidence.Medium ||
        args.Result.Confidence == SpeechRecognitionConfidence.High)
    {
        dictatedTextBuilder.Append(args.Result.Text + " ");

        dispatcherQueue.TryEnqueue(() =>
        {
            dictationTextBox.Text = dictatedTextBuilder.ToString();
            btnClearText.IsEnabled = true;
        });
    }
}

Terminé

L’événement Completed indique que la session de reconnaissance continue s’est terminée. La session se termine lorsque vous appelez StopAsync ou CancelAsync, ou lorsqu’une erreur se produit, ou quand l’utilisateur a cessé de parler.

private void ContinuousRecognitionSession_Completed(
    SpeechContinuousRecognitionSession sender,
    SpeechContinuousRecognitionCompletedEventArgs args)
{
    if (args.Status != SpeechRecognitionResultStatus.Success)
    {
        dispatcherQueue.TryEnqueue(() =>
        {
            if (args.Status == SpeechRecognitionResultStatus.TimeoutExceeded)
            {
                dictationTextBox.Text = dictatedTextBuilder.ToString();
            }
        });
    }
}

Hypothèse générée

Gérez l’événement HypothesisGenerated pour afficher les résultats intermédiaires pendant que le module de reconnaissance est toujours en cours de traitement. Cela améliore la réactivité en donnant aux utilisateurs des commentaires avant qu’un résultat final soit disponible :

private void SpeechRecognizer_HypothesisGenerated(
    SpeechRecognizer sender,
    SpeechRecognitionHypothesisGeneratedEventArgs args)
{
    string hypothesis = args.Hypothesis.Text;
    string textboxContent = dictatedTextBuilder.ToString() + " " + hypothesis + " ...";

    dispatcherQueue.TryEnqueue(() =>
    {
        dictationTextBox.Text = textboxContent;
        btnClearText.IsEnabled = true;
    });
}

Démarrer et arrêter la reconnaissance

Vérifiez l’état du module de reconnaissance avant de démarrer ou d’arrêter une session :

// Start continuous recognition.
if (speechRecognizer.State == SpeechRecognizerState.Idle)
{
    await speechRecognizer.ContinuousRecognitionSession.StartAsync();
}

// Stop continuous recognition (lets pending events complete).
if (speechRecognizer.State != SpeechRecognizerState.Idle)
{
    await speechRecognizer.ContinuousRecognitionSession.StopAsync();
}

Pour annuler immédiatement et ignorer les résultats en attente, appelez CancelAsync au lieu de StopAsync.

Note

Il est possible qu’un événement ResultGenerated se déclenche après avoir appelé CancelAsync, en raison du multithreading. Si vous définissez des champs privés lors de l’annulation de la session de reconnaissance, validez toujours leurs valeurs dans le ResultGenerated gestionnaire.

  • Last updated on