Spracherkennung

Verwenden Sie die Spracherkennung, um Eingaben bereitzustellen, eine Aktion oder einen Befehl anzugeben und Aufgaben auszuführen.

Wichtige APIs: Windows.Media.SpeechRecognition

Die Spracherkennung besteht aus einer Sprachlaufzeit, Erkennungs-APIs für die Programmierung der Laufzeit, einsatzbereiten Grammatiken für diktieren und Websuche und einer Standardsystembenutzeroberfläche, die Benutzern hilft, Spracherkennungsfeatures zu erkennen und zu verwenden.

Konfigurieren der Spracherkennung

Um die Spracherkennung mit Ihrer App zu unterstützen, muss der Benutzer ein Mikrofon auf dem Gerät verbinden und aktivieren und die Microsoft-Datenschutzrichtlinie akzeptieren, die die Berechtigung für die Verwendung Ihrer App erteilt.

Um den Benutzer automatisch mit einem Systemdialogfeld aufzufordern, das die Berechtigung für den Zugriff auf und die Verwendung des Audiofeeds des Mikrofons anfordert (Beispiel aus dem unten gezeigten Beispiel zur Spracherkennung und Sprachsynthese), legen Sie einfach die Mikrofongerätefunktion im App-Paketmanifest fest. Weitere Details finden Sie unter App-Funktionsdeklarationen.

Wenn der Benutzer auf "Ja" klickt, um zugriff auf das Mikrofon zu gewähren, wird Ihre App zur Liste der genehmigten Anwendungen auf der Seite "Einstellungen – Datenschutz ->> Mikrofon" hinzugefügt. Da der Benutzer diese Einstellung jedoch jederzeit deaktivieren kann, sollten Sie bestätigen, dass Ihre App Zugriff auf das Mikrofon hat, bevor Sie versuchen, sie zu verwenden.

Wenn Sie auch Diktier-, Cortana- oder andere Spracherkennungsdienste (z. B. eine vordefinierte Grammatik, die in einer Themeneinschränkung definiert ist) unterstützen möchten, müssen Sie auch bestätigen, dass die Online-Spracherkennung (Einstellungen – Datenschutz –>> Spracherkennung) aktiviert ist.

Dieser Codeausschnitt zeigt, wie Ihre App überprüfen kann, ob ein Mikrofon vorhanden ist und ob sie über die Berechtigung zum Verwenden verfügt.

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

Erkennen der Spracheingabe

Eine Einschränkung definiert die Wörter und Ausdrücke (Vokabular), die eine App in der Spracheingabe erkennt. Einschränkungen sind der Kern der Spracherkennung und ermöglichen Ihrer App eine bessere Kontrolle über die Genauigkeit der Spracherkennung.

Sie können die folgenden Arten von Einschränkungen für die Erkennung von Spracheingaben verwenden.

Vordefinierte Grammatiken

Vordefinierte Diktier- und Websuchgrammatiken bieten spracherkennung für Ihre App, ohne dass Sie eine Grammatik erstellen müssen. Wenn Sie diese Grammatiken verwenden, wird die Spracherkennung von einem Remotewebdienst ausgeführt, und die Ergebnisse werden an das Gerät zurückgegeben.

Die Standardmäßige Freitext-Diktiergrammatik kann die meisten Wörter und Ausdrücke erkennen, die ein Benutzer in einer bestimmten Sprache sagen kann, und ist für die Erkennung kurzer Ausdrücke optimiert. Die vordefinierte Diktiergrammatik wird verwendet, wenn Sie keine Einschränkungen für Ihr SpeechRecognizer-Objekt angeben. Die Freitext-Diktierfunktion ist nützlich, wenn Sie die Arten von Dingen, die ein Benutzer sagen kann, nicht einschränken möchten. Typische Verwendungsmöglichkeiten sind das Erstellen von Notizen oder das Diktieren des Inhalts für eine Nachricht.

Die Grammatik der Websuche, z. B. eine Diktiergrammatik, enthält eine große Anzahl von Wörtern und Ausdrücken, die ein Benutzer sagen könnte. Es ist jedoch optimiert, Ausdrücke zu erkennen, die personen in der Regel beim Durchsuchen des Webs verwenden.

Diese vordefinierten Grammatiken können verwendet werden, um bis zu 10 Sekunden Spracheingaben zu erkennen und erfordern keinen Aufwand für die Dokumenterstellung. Sie erfordern jedoch eine Verbindung mit einem Netzwerk.

Um Webdiensteinschränkungen zu verwenden, muss die Spracheingabe- und Diktierunterstützung in den Einstellungen aktiviert sein, indem sie die Option "Get to know me" in "Einstellungen – Datenschutz –>> Sprache, Freihandeingabe und Eingabe" aktivieren.

Hier erfahren Sie, wie Sie testen, ob die Spracheingabe aktiviert ist, und öffnen Sie die Einstellungen – Datenschutz –>> Sprache, Freihandeingabe und Eingabeseite, wenn nicht.

Zunächst initialisieren wir eine globale Variable (HResultPrivacyStatementDeclined) auf den HResult-Wert von 0x80045509. Siehe Ausnahmebehandlung für C# oder Visual Basic.

private static uint HResultPrivacyStatementDeclined = 0x80045509;

Anschließend erfassen wir alle Standard exceptions während der Erkennung und testen, ob der HResult-Wert dem Wert der HResultPrivacyStatementDeclined-Variablen entspricht. Wenn ja, wird eine Warnung und ein Aufruf await Windows.System.Launcher.LaunchUriAsync(new Uri("ms-settings:privacy-accounts")); angezeigt, um die Seite "Einstellungen" zu öffnen.

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

Siehe SpeechRecognitionTopicConstraint.

Programmgesteuerte Listeneinschränkungen

Programmgesteuerte Listeneinschränkungen bieten einen einfachen Ansatz zum Erstellen einfacher Grammatiken mithilfe einer Liste von Wörtern oder Ausdrücken. Eine Listeneinschränkung eignet sich gut zum Erkennen kurzer, eindeutiger Ausdrücke. Durch die explizite Angabe aller Wörter in einer Grammatik wird auch die Erkennungsgenauigkeit verbessert, da das Spracherkennungsmodul nur die Spracherkennung verarbeiten darf, um eine Übereinstimmung zu bestätigen. Die Liste kann auch programmgesteuert aktualisiert werden.

Eine Listeneinschränkung besteht aus einem Array von Zeichenfolgen, die Die Spracheingabe darstellt, die Ihre App für einen Erkennungsvorgang akzeptiert. Sie können eine Listeneinschränkung in Ihrer App erstellen, indem Sie ein Listeneinschränkungsobjekt für die Spracherkennung erstellen und ein Array von Zeichenfolgen übergeben. Fügen Sie dieses Objekt dann der Einschränkungsauflistung der Erkennung hinzu. Die Erkennung ist erfolgreich, wenn die Spracherkennung eine der Zeichenfolgen im Array erkennt.

Siehe SpeechRecognitionListConstraint.

SRGS-Grammatiken

Eine Grammatik der Spracherkennung (Speech Recognition Grammar Specification, SRGS) ist ein statisches Dokument, das im Gegensatz zu einer programmgesteuerten Listeneinschränkung das xml-Format verwendet, das von SRGS Version 1.0 definiert ist. Eine SRGS-Grammatik bietet die größte Kontrolle über die Spracherkennung, indem Sie mehrere semantische Bedeutungen in einer einzigen Erkennung erfassen können.

Siehe SpeechRecognitionGrammarFileConstraint.

Einschränkungen für Sprachbefehle

Verwenden Sie eine VCD-XML-Datei (Voice Command Definition), um die Befehle zu definieren, die der Benutzer sagen kann, um Aktionen beim Aktivieren der App zu initiieren. Weitere Details finden Sie unter Aktivieren einer Vordergrund-App mit Sprachbefehlen über Cortana.

Siehe SpeechRecognitionVoiceCommandDefinitionConstraint/

Beachten Sie , welche Art von Einschränkungstyp Sie verwenden, hängt von der Komplexität der Erkennungserfahrung ab, die Sie erstellen möchten. Dies kann die beste Wahl für einen bestimmten Erkennungsvorgang sein, und Sie finden möglicherweise Verwendungsmöglichkeiten für alle Arten von Einschränkungen in Ihrer App. Informationen zu den ersten Schritten mit Einschränkungen finden Sie unter Definieren von benutzerdefinierten Erkennungseinschränkungen.

Die vordefinierte Diktiergrammatik der universellen Windows-App erkennt die meisten Wörter und kurzen Ausdrücke in einer Sprache. Sie wird standardmäßig aktiviert, wenn ein Spracherkennungsobjekt ohne benutzerdefinierte Einschränkungen instanziiert wird.

In diesem Beispiel wird gezeigt, wie Sie:

• Erstellen Sie eine Spracherkennung.
• Kompilieren Sie die standardmäßigen Einschränkungen für universelle Windows-Apps (dem Grammatiksatz der Spracherkennung wurden keine Grammatiken hinzugefügt).
• Beginnen Sie mit der Spracherkennung, indem Sie die grundlegende Erkennungsbenutzeroberfläche und das TTS-Feedback verwenden, das von der RecognizeWithUIAsync-Methode bereitgestellt wird. Verwenden Sie die RecognizeAsync-Methode , wenn die Standard-UI nicht erforderlich ist.

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

Anpassen der Erkennungs-UI

Wenn Ihre App die Spracherkennung durch Aufrufen von SpeechRecognizer.RecognizeWithUIAsync versucht, werden mehrere Bildschirme in der folgenden Reihenfolge angezeigt.

Wenn Sie eine Einschränkung basierend auf einer vordefinierten Grammatik (Diktieren oder Websuche) verwenden:

• Der Bildschirm "Überwachung ".
• Der Bildschirm "Denken ".
• Der "Gehört" -Bildschirm oder der Fehlerbildschirm.

Wenn Sie eine Einschränkung basierend auf einer Liste von Wörtern oder Ausdrücken oder einer Einschränkung basierend auf einer SRGS-Grammatikdatei verwenden:

• Der Bildschirm "Überwachung ".
• Der Bildschirm hat Sie gesagt , wenn das, was der Benutzer sagte, als mehr als ein potenzielles Ergebnis interpretiert werden könnte.
• Der "Gehört" -Bildschirm oder der Fehlerbildschirm.

Die folgende Abbildung zeigt ein Beispiel für den Fluss zwischen Bildschirmen für eine Spracherkennung, die eine Einschränkung basierend auf einer SRGS-Grammatikdatei verwendet. In diesem Beispiel war die Spracherkennung erfolgreich.

Der Bildschirm "Überwachung " kann Beispiele für Wörter oder Ausdrücke bereitstellen, die von der App erkannt werden können. Hier zeigen wir, wie Sie die Eigenschaften der SpeechRecognizerUIOptions-Klasse (abgerufen durch Aufrufen der SpeechRecognizer.UIOptions-Eigenschaft ) verwenden, um Inhalte auf dem Bildschirm " Überwachung " anzupassen.

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

Verwandte Artikel

• Sprachinteraktionen

Beispiele

• Beispiel für Spracherkennung und Sprachsynthese