HoloLens (1:a gen) Input 212: Voice

Viktigt

Självstudierna Mixed Reality Academy har utformats med HoloLens (1:a gen), Unity 2017 och Mixed Reality Immersive Headsets i åtanke. Därför anser vi att det är viktigt att lämna de här självstudierna på plats för utvecklare som fortfarande letar efter vägledning i utvecklingen för dessa enheter. De här självstudierna uppdateras inte med de senaste verktygen eller interaktionerna som används för HoloLens 2 och kanske inte är kompatibla med nyare versioner av Unity. De kommer att finnas kvar för att fortsätta arbeta med de enheter som stöds. En ny serie självstudier har publicerats för HoloLens 2.

Röstinmatning ger oss ett annat sätt att interagera med våra hologram. Röstkommandon fungerar på ett mycket naturligt och enkelt sätt. Utforma dina röstkommandon så att de är:

  • Naturliga
  • Lätt att komma ihåg
  • Kontext som är lämplig
  • Tillräckligt distinkt från andra alternativ inom samma kontext

I MR Basics 101 använde vi KeywordRecognizer för att skapa två enkla röstkommandon. I MR Input 212 går vi djupare och lär oss att:

  • Utforma röstkommandon som är optimerade för HoloLens talmotor.
  • Gör användaren medveten om vilka röstkommandon som är tillgängliga.
  • Bekräfta att vi har hört användarens röstkommando.
  • Förstå vad användaren säger med hjälp av en dikteringstolkning.
  • Använd grammatikigenkänning för att lyssna efter kommandon baserat på en SRGS-fil eller en grammatikspecifikation för taligenkänning.

I den här kursen går vi tillbaka till Model Explorer, som vi skapade i MR Input 210och MR Input 211.

Viktigt

Videorna som bäddades in i vart och ett av kapitlen nedan registrerades med en äldre version av Unity och Mixed Reality Toolkit. De stegvisa anvisningarna är korrekta och aktuella, men du kan se skript och visuella objekt i motsvarande videor som är in datera. Videorna finns kvar för eftervärlden och eftersom de begrepp som tas upp fortfarande gäller.

Stöd för enheter

Kurs HoloLens Integrerande headset
MR Input 212: Voice ✔️ ✔️

Innan du börjar

Förutsättningar

Project filer

  • Ladda ned de filer som krävs av projektet. Kräver Unity 2017.2 eller senare.
  • Ta bort arkivering av filerna till skrivbordet eller någon annan plats som är lätt att nå.

Anteckning

Om du vill titta igenom källkoden innan du laddar ned den finns den på GitHub.

Errata och anteckningar

  • "Aktivera Just My Code" måste inaktiveras (avmarkerat) i Visual Studio under Verktyg-Alternativ-Felsökning>> för att komma till brytpunkter i koden.

Unity-konfiguration

Instruktioner

  1. Starta Unity.
  2. Välj Öppna.
  3. Gå till mappen HolographicAcademy-Hologram-212-Voice som du tidigare avarkiverade.
  4. Leta upp och välj mappenStartingModel/ Explorer.
  5. Klicka på knappen Välj mapp.
  6. I Project panelen expanderar du mappen Scenes.
  7. Dubbelklicka på ModelExplorer-scenen för att läsa in den i Unity.

Byggnad

  1. I Unity väljer du Filbygge > Inställningar.
  2. Om Scenes/ModelExplorer inte visas i Scenes In Build klickar du på Lägg till öppna scener för att lägga till scenen.
  3. Om du utvecklar specifikt för HoloLens anger du Målenhet tillHoloLens. Annars lämnar du den på Valfri enhet.
  4. Kontrollera att Versionstyp är inställt på D3D och ATT SDK är inställt på Senaste installerade (som ska vara SDK 16299 eller nyare).
  5. Klicka på Skapa.
  6. Skapa en ny mapp med namnet "App".
  7. Klicka på mappen App.
  8. Tryck på Välj mapp så börjar Unity skapa projektet för Visual Studio.

När Unity är klart Utforskaren ett fönster.

  1. Öppna mappen App.
  2. Öppna modelExplorer-Visual Studio lösningen.

Om du distribuerar till HoloLens:

  1. Använd det översta verktygsfältet i Visual Studio ändra målet från Felsök till Version och från ARM till x86.
  2. Klicka på listrpilen bredvid knappen Lokal dator och välj Fjärrdator.
  3. Ange din HoloLens IP-adress och ange Autentiseringsläge till Universal (Okrypterat protokoll). Klicka på Välj. Om du inte känner till enhetens IP-adress kan du titta i Inställningar > Avancerade & alternativ för Nätverkets > Internet.
  4. Klicka på Felsök – Starta utan felsökning på> den översta menyraden eller tryckCtrl + F5. Om det här är första gången du distribuerar till din enhet måste du koppla det till Visual Studio.
  5. När appen har distribuerats stänger du Fitbox med en select-gest.

Om du distribuerar till ett integrerande headset:

  1. Använd det översta verktygsfältet i Visual Studio ändra målet från Felsök till Version och från ARM till x64.
  2. Kontrollera att distributionsmålet är inställt på Lokal dator.
  3. Klicka på Felsök – Starta utan felsökning på> den översta menyraden eller tryckCtrl + F5.
  4. När appen har distribuerats stänger du Fitbox genom att hämta utlösaren på en rörelsekontroll.

Anteckning

Du kanske ser några röda fel Visual Studio panelen Fel. Det är säkert att ignorera dem. Växla till panelen Utdata för att visa faktiska byggförloppet. Fel i panelen Utdata kräver att du gör en korrigering (oftast orsakas de av ett misstag i ett skript).

Kapitel 1 – Medvetenhet

Mål

  • Lär dig mer om design av dos och don'ts för röstkommandon.
  • Använd KeywordRecognizer för att lägga till blickbaserade röstkommandon.
  • Gör användarna medvetna om röstkommandon med hjälp av markörfeedback.

Design av röstkommando

I det här kapitlet lär du dig att utforma röstkommandon. När du skapar röstkommandon:

DO

  • Skapa koncisa kommandon. Du vill inte använda "Spela upp den valda videon ", eftersom det kommandot inte är koncis och lätt skulle glömmas bort av användaren. I stället bör du använda: "Spela upp video", eftersom den är koncis och har flera stavelser.
  • Använd en enkel vokabulär. Försök alltid att använda vanliga ord och fraser som är enkla för användaren att upptäcka och komma ihåg. Om ditt program till exempel har ett anteckningsobjekt som kan visas eller döljas från vyn, skulle du inte använda kommandot "Visa Placard", eftersom "placard" är en term som sällan används. I stället använder du kommandot : "Visa anteckning" för att visa anteckningen i ditt program.
  • Var konsekvent. Röstkommandon bör vara konsekventa i hela programmet. Imagine att du har två scener i programmet och båda platserna innehåller en knapp för att stänga programmet. Om den första scenen använde kommandot "Avsluta" för att utlösa knappen, men den andra scenen använde kommandot "Stäng app", kommer användaren att bli mycket förvirrad. Om samma funktion finns kvar i flera scener ska samma röstkommando användas för att utlösa den.

GÖR INTE

  • Använd enkla syllable-kommandon. Om du till exempel skapar ett röstkommando för att spela upp en video bör du undvika att använda det enkla kommandot "Play", eftersom det bara är en enda stavelse och enkelt kan missas av systemet. I stället bör du använda: "Spela upp video", eftersom den är koncis och har flera stavelser.
  • Använd systemkommandon. Kommandot "Select" är reserverat av systemet för att utlösa en tryckhändelse för det aktuella objektet. Använd inte kommandot "Select" igen i ett nyckelord eller en fras, eftersom det kanske inte fungerar som förväntat. Om röstkommandot för att välja en kub i programmet till exempel var "Select cube", men användaren tittade på en sfär när de tog emot kommandot, skulle sfären väljas i stället. På samma sätt är kommandon i appfältet röstaktiverade. Använd inte följande talkommandon i Din CoreWindow-vy:
    1. Gå tillbaka
    2. Rullningsverktyget
    3. Zoomverktyg
    4. Dra verktyg
    5. Justera
    6. Ta bort
  • Använd liknande ljud. Försök att undvika att använda röstkommandon som fungerar. Om du hade ett shoppingprogram som hade stöd för "Visa butik" och "Visa mer" som röstkommandon skulle du vilja inaktivera ett av kommandona medan det andra används. Du kan till exempel använda knappen "Visa butik" för att öppna butiken och sedan inaktivera det kommandot när butiken visades så att kommandot "Visa mer" kan användas för surfning.

Instruktioner

  • På panelen Hierarki i Unity använder du sökverktyget för att hitta holoComm_screen_mesh objekt.
  • Dubbelklicka på objektet holoComm_screen_mesh att visa det i scenen. Det här är astronautens klocka som svarar på våra röstkommandon.
  • Leta upp komponenten Speech Input Source (Script) på panelen Kontroll.
  • Expandera avsnittet Nyckelord för att se det röstkommando som stöds: Öppna Communicator.
  • Klicka på kuggen till höger och välj sedan Redigera skript.
  • Utforska SpeechInputSource.cs för att förstå hur det använder KeywordRecognizer för att lägga till röstkommandon.

Skapa och distribuera

  • I Unity använder du File > Build Inställningar för att återskapa programmet.
  • Öppna mappen App.
  • Öppna modelExplorer-Visual Studio lösningen.

(Om du redan har skapat/distribuerat det här projektet i Visual Studio under set-up, kan du öppna den instansen av VS och klicka på Läs in alla på nytt när du uppmanas till det).

  • I Visual Studio klickar du på Felsök –> Starta utan felsökning eller trycker på Ctrl + F5.
  • När programmet har distribuerats till HoloLens du anpassa rutan med hjälp av lufttrycksgesten.
  • Titta på astronautens klocka.
  • När klockan har fokus kontrollerar du att markören ändras till en mikrofon. Detta ger feedback om att programmet lyssnar efter röstkommandon.
  • Kontrollera att en knappbeskrivning visas på klockan. Detta hjälper användarna att identifiera kommandot "Öppna Communicator".
  • När du tittar på klockan säger du "Öppna Communicator" för att öppna kommunikationspanelen.

Kapitel 2 – Bekräftelse

Mål

  • Spela in ett meddelande med mikrofonindata.
  • Ge feedback till användaren om att programmet lyssnar på användarens röst.

Anteckning

Funktionen Mikrofon måste deklareras för att en app ska kunna spela in från mikrofonen. Detta görs för dig redan i MR Input 212, men ha detta i åtanke för dina egna projekt.

  1. I Unity-redigeraren går du till spelarinställningarna genom att gå till "Redigera > Project Inställningar > Player"
  2. Klicka på fliken "Universell Windows-plattform"
  3. I avsnittet "Inställningar > funktioner" kontrollerar du funktionen Mikrofon

Instruktioner

  • På panelen Hierarki i Unity kontrollerar du att holoComm_screen_mesh har valts.
  • I panelen Inspector (Kontroll) hittar du komponenten Astronaut Watch ( Script).
  • Klicka på den lilla blå kuben som anges som värdet för Communicator Prefab.
  • I Project bör nu Communicator prefab ha fokus.
  • Klicka på Communicator prefab i Project för att visa dess komponenter i Kontroll.
  • Titta på komponenten Microphone Manager (Script) så att vi kan spela in användarens röst.
  • Observera att Communicator har en komponent för talinmatningshanterare (skript) som svarar på kommandot Skicka meddelande.
  • Titta på Communicator (skript) och dubbelklicka på skriptet för att öppna det i Visual Studio.

Communicator.cs ansvarar för att ange rätt knapp tillstånd på kommunikationsenheten. Detta gör att våra användare kan spela in ett meddelande, spela upp det och skicka meddelandet till astronauten. Den startar och stoppar också ett animerat vågformulär för att bekräfta för användaren att deras röst har hörts.

  • I Communicator.cs tar du bort följande rader (81 och 82) från startmetoden. Då aktiveras knappen "Post" i kommuniceraren.
// TODO: 2.a Delete the following two lines:
RecordButton.SetActive(false);
MessageUIRenderer.gameObject.SetActive(false);

Skapa och distribuera

  • I Visual Studio återskapar du programmet och distribuerar det till enheten.
  • Titta på astronautens klocka och säg "Öppna Communicator" för att visa kommuniceraren.
  • Tryck på knappen Spela in (mikrofon) för att börja spela in ett verbalt meddelande för astronauten.
  • Börja tala och kontrollera att våganimeringen spelas upp på kommuniceraren, som ger feedback till användaren om att deras röst hörs.
  • Tryck på stoppknappen (vänster ruta) och kontrollera att våganimeringen slutar köras.
  • Tryck på knappen Spela upp (höger triangel) för att spela upp det inspelade meddelandet och höra det på enheten.
  • Tryck på stoppknappen (höger ruta) för att stoppa uppspelningen av det inspelade meddelandet.
  • Säg "Skicka meddelande" för att stänga kommuniceraren och ta emot ett meddelande mottaget-svar från astronauten.

Kapitel 3 – Förstå och dikteringstolkning

Mål

  • Använd Dikteringsigenkänning för att konvertera användarens tal till text.
  • Visa dikteringstolkningens hypotes och slutliga resultat i kommuniceraren.

I det här kapitlet använder vi Dictation Recognizer för att skapa ett meddelande för astronauten. Tänk på följande när du använder Dictation Recognizer:

  • Du måste vara ansluten till WiFi för att dikteringstolkningen ska fungera.
  • Tidsgränser inträffar efter en viss tidsperiod. Det finns två tidsgränser att känna till:
    • Om identifieraren startar och inte hör något ljud under de första fem sekunderna går tidsgränsen ut.
    • Om identifieraren har gett ett resultat men sedan hör tystnad i 20 sekunder går tidsgränsen ut.
  • Endast en typ av identifierare (nyckelord eller diktering) kan köras i taget.

Anteckning

Funktionen Mikrofon måste deklareras för att en app ska kunna spela in från mikrofonen. Detta görs för dig redan i MR Input 212, men ha detta i åtanke för dina egna projekt.

  1. I Unity-redigeraren går du till spelarinställningarna genom att gå till "Redigera > Project Inställningar > Player"
  2. Klicka på fliken "Universell Windows-plattform"
  3. I avsnittet "Inställningar > funktioner" kontrollerar du funktionen Mikrofon

Instruktioner

Vi ska redigera MicrophoneManager.cs för att använda dikteringstolkning. Det här är vad vi ska lägga till:

  1. När du trycker på knappen Spela in startar vi DictationRecognizer.
  2. Visa hypotesen om vad DictationRecognizer förstår.
  3. Lås resultatet av det som DictationRecognizer förstår.
  4. Sök efter tidsgränser från DictationRecognizer.
  5. Stoppa DictationRecognizer när du trycker på stoppknappen, eller när mic-sessionen får en sluttid.
  6. Starta om KeywordRecognizer, som lyssnar efter kommandot Skicka meddelande.

Nu sätter vi igång. Slutför alla kodningsövningar för 3.a i MicrophoneManager.cs, eller kopiera och klistra in den färdiga koden nedan:

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See LICENSE in the project root for license information.

using System.Collections;
using System.Text;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.Windows.Speech;

namespace Academy
{
    public class MicrophoneManager : MonoBehaviour
    {
        [Tooltip("A text area for the recognizer to display the recognized strings.")]
        [SerializeField]
        private Text dictationDisplay;

        private DictationRecognizer dictationRecognizer;

        // Use this string to cache the text currently displayed in the text box.
        private StringBuilder textSoFar;

        // Using an empty string specifies the default microphone.
        private static string deviceName = string.Empty;
        private int samplingRate;
        private const int messageLength = 10;

        // Use this to reset the UI once the Microphone is done recording after it was started.
        private bool hasRecordingStarted;

        void Awake()
        {
            /* TODO: DEVELOPER CODING EXERCISE 3.a */

            // 3.a: Create a new DictationRecognizer and assign it to dictationRecognizer variable.
            dictationRecognizer = new DictationRecognizer();

            // 3.a: Register for dictationRecognizer.DictationHypothesis and implement DictationHypothesis below
            // This event is fired while the user is talking. As the recognizer listens, it provides text of what it's heard so far.
            dictationRecognizer.DictationHypothesis += DictationRecognizer_DictationHypothesis;

            // 3.a: Register for dictationRecognizer.DictationResult and implement DictationResult below
            // This event is fired after the user pauses, typically at the end of a sentence. The full recognized string is returned here.
            dictationRecognizer.DictationResult += DictationRecognizer_DictationResult;

            // 3.a: Register for dictationRecognizer.DictationComplete and implement DictationComplete below
            // This event is fired when the recognizer stops, whether from Stop() being called, a timeout occurring, or some other error.
            dictationRecognizer.DictationComplete += DictationRecognizer_DictationComplete;

            // 3.a: Register for dictationRecognizer.DictationError and implement DictationError below
            // This event is fired when an error occurs.
            dictationRecognizer.DictationError += DictationRecognizer_DictationError;

            // Query the maximum frequency of the default microphone. Use 'unused' to ignore the minimum frequency.
            int unused;
            Microphone.GetDeviceCaps(deviceName, out unused, out samplingRate);

            // Use this string to cache the text currently displayed in the text box.
            textSoFar = new StringBuilder();

            // Use this to reset the UI once the Microphone is done recording after it was started.
            hasRecordingStarted = false;
        }

        void Update()
        {
            // 3.a: Add condition to check if dictationRecognizer.Status is Running
            if (hasRecordingStarted && !Microphone.IsRecording(deviceName) && dictationRecognizer.Status == SpeechSystemStatus.Running)
            {
                // Reset the flag now that we're cleaning up the UI.
                hasRecordingStarted = false;

                // This acts like pressing the Stop button and sends the message to the Communicator.
                // If the microphone stops as a result of timing out, make sure to manually stop the dictation recognizer.
                // Look at the StopRecording function.
                SendMessage("RecordStop");
            }
        }

        /// <summary>
        /// Turns on the dictation recognizer and begins recording audio from the default microphone.
        /// </summary>
        /// <returns>The audio clip recorded from the microphone.</returns>
        public AudioClip StartRecording()
        {
            // 3.a Shutdown the PhraseRecognitionSystem. This controls the KeywordRecognizers
            PhraseRecognitionSystem.Shutdown();

            // 3.a: Start dictationRecognizer
            dictationRecognizer.Start();

            // 3.a Uncomment this line
            dictationDisplay.text = "Dictation is starting. It may take time to display your text the first time, but begin speaking now...";

            // Set the flag that we've started recording.
            hasRecordingStarted = true;

            // Start recording from the microphone for 10 seconds.
            return Microphone.Start(deviceName, false, messageLength, samplingRate);
        }

        /// <summary>
        /// Ends the recording session.
        /// </summary>
        public void StopRecording()
        {
            // 3.a: Check if dictationRecognizer.Status is Running and stop it if so
            if (dictationRecognizer.Status == SpeechSystemStatus.Running)
            {
                dictationRecognizer.Stop();
            }

            Microphone.End(deviceName);
        }

        /// <summary>
        /// This event is fired while the user is talking. As the recognizer listens, it provides text of what it's heard so far.
        /// </summary>
        /// <param name="text">The currently hypothesized recognition.</param>
        private void DictationRecognizer_DictationHypothesis(string text)
        {
            // 3.a: Set DictationDisplay text to be textSoFar and new hypothesized text
            // We don't want to append to textSoFar yet, because the hypothesis may have changed on the next event
            dictationDisplay.text = textSoFar.ToString() + " " + text + "...";
        }

        /// <summary>
        /// This event is fired after the user pauses, typically at the end of a sentence. The full recognized string is returned here.
        /// </summary>
        /// <param name="text">The text that was heard by the recognizer.</param>
        /// <param name="confidence">A representation of how confident (rejected, low, medium, high) the recognizer is of this recognition.</param>
        private void DictationRecognizer_DictationResult(string text, ConfidenceLevel confidence)
        {
            // 3.a: Append textSoFar with latest text
            textSoFar.Append(text + ". ");

            // 3.a: Set DictationDisplay text to be textSoFar
            dictationDisplay.text = textSoFar.ToString();
        }

        /// <summary>
        /// This event is fired when the recognizer stops, whether from Stop() being called, a timeout occurring, or some other error.
        /// Typically, this will simply return "Complete". In this case, we check to see if the recognizer timed out.
        /// </summary>
        /// <param name="cause">An enumerated reason for the session completing.</param>
        private void DictationRecognizer_DictationComplete(DictationCompletionCause cause)
        {
            // If Timeout occurs, the user has been silent for too long.
            // With dictation, the default timeout after a recognition is 20 seconds.
            // The default timeout with initial silence is 5 seconds.
            if (cause == DictationCompletionCause.TimeoutExceeded)
            {
                Microphone.End(deviceName);

                dictationDisplay.text = "Dictation has timed out. Please press the record button again.";
                SendMessage("ResetAfterTimeout");
            }
        }

        /// <summary>
        /// This event is fired when an error occurs.
        /// </summary>
        /// <param name="error">The string representation of the error reason.</param>
        /// <param name="hresult">The int representation of the hresult.</param>
        private void DictationRecognizer_DictationError(string error, int hresult)
        {
            // 3.a: Set DictationDisplay text to be the error string
            dictationDisplay.text = error + "\nHRESULT: " + hresult;
        }

        /// <summary>
        /// The dictation recognizer may not turn off immediately, so this call blocks on
        /// the recognizer reporting that it has actually stopped.
        /// </summary>
        public IEnumerator WaitForDictationToStop()
        {
            while (dictationRecognizer != null && dictationRecognizer.Status == SpeechSystemStatus.Running)
            {
                yield return null;
            }
        }
    }
}

Skapa och distribuera

  • Återskapa i Visual Studio och distribuera till din enhet.
  • Stäng anpassa-rutan med en lufttrycksgest.
  • Titta på astronautens klocka och säg "Open Communicator".
  • Välj knappen Spela in (mikrofon) för att spela in meddelandet.
  • Börja tala. Dikteringsigenkänning tolkar ditt tal och visar den hypoteserade texten i kommuniceraren.
  • Försök att säga "Skicka meddelande" medan du spelar in ett meddelande. Observera att nyckelords recognizer inte svarar eftersom dikteringstolkningen fortfarande är aktiv.
  • Sluta tala i några sekunder. Se när dikteringstolkaren slutför sin hypotes och visar slutresultatet.
  • Börja tala och pausa sedan i 20 sekunder. Detta gör att tidsgränsen för Dictation Recognizer går ut.
  • Observera att Keyword Recognizer återaktiveras efter ovanstående tidsgräns. Nu svarar kommuniceraren på röstkommandon.
  • Säg "Skicka meddelande" för att skicka meddelandet till astronauten.

Kapitel 4 – Grammatik recognizer

Mål

  • Använd Grammatikigenkänning för att identifiera användarens tal enligt en SRGS-fil eller en fil med grammatikspecifikation för taligenkänning.

Anteckning

Funktionen Mikrofon måste deklareras för att en app ska kunna spela in från mikrofonen. Detta görs för dig redan i MR Input 212, men ha detta i åtanke för dina egna projekt.

  1. I Unity-redigeraren går du till spelarinställningarna genom att gå till "Redigera > Project Inställningar > Player"
  2. Klicka på fliken "Universell Windows-plattform"
  3. I avsnittet "Inställningar > funktioner" kontrollerar du funktionen Mikrofon

Instruktioner

  1. I panelen Hierarki söker du efter Jetpack_Center och markerar den.
  2. Leta efter Tagalong-åtgärdsskriptet i kontrollpanelen .
  3. Klicka på den lilla cirkeln till höger om fältet Objekt att tagga längs.
  4. I fönstret som öppnas söker du efter SRGSToolbox och väljer den i listan.
  5. Ta en titt på SRGSColor.xml i mappen StreamingAssets .
    1. SRGS-designspecifikationen finns på W3C-webbplatsen här.

I vår SRGS-fil har vi tre typer av regler:

  • En regel som låter dig säga en färg från en lista med tolv färger.
  • Tre regler som lyssnar efter en kombination av färgregeln och en av de tre figurerna.
  • Rotregeln colorChooser, som lyssnar efter valfri kombination av de tre reglerna för "färg + form". Formerna kan sägas i valfri ordning och i valfri mängd från bara en till alla tre. Det här är den enda regeln som lyssnar efter, eftersom den anges som rotregel överst i filen i den första grammatiktaggen<>.

Skapa och distribuera

  • Återskapa programmet i Unity och skapa och distribuera sedan från Visual Studio för att uppleva appen på HoloLens.
  • Stäng anpassa-rutan med en lufttrycksgest.
  • Titta på astronautens jetpack och utför en lufttrycksgest.
  • Börja tala. Grammatikigenkänning tolkar ditt tal och ändrar färgerna på formerna baserat på igenkänningen. Ett exempelkommando är "blå cirkel, gul fyrkant".
  • Utför en till tryckgest för att stänga verktygslådan.

Slutet

Grattis! Nu har du slutfört MR Input 212: Voice.

  • Du känner till Dos och Don'ts för röstkommandon.
  • Du såg hur knappbeskrivningar användes för att göra användarna medvetna om röstkommandon.
  • Du såg flera typer av feedback som användes för att bekräfta att användarens röst har hörts.
  • Du vet hur du växlar mellan Nyckelordsigenkänning och Dikteringsigenkänning och hur dessa två funktioner förstår och tolkar din röst.
  • Du har lärt dig hur du använder en SRGS-fil och grammatikigenkänning för taligenkänning i ditt program.