Freigeben über

Aktivieren einer Hintergrund-App in Cortana mithilfe von Sprachbefehlen

  • Artikel

Warnung

Diese Funktion wird seit dem Windows 10 Mai 2020 Update (Version 2004, Codename „20H1“) nicht mehr unterstützt.

Zusätzlich zur Verwendung von Sprachbefehlen in Cortana für den Zugriff auf Systemfeatures können Sie Cortana auch mit Features und Funktionen aus Ihrer App (als Hintergrundaufgabe) erweitern, indem Sie Sprachbefehle verwenden, die eine auszuführende Aktion oder einen Befehl angeben. Wenn eine App einen Sprachbefehl im Hintergrund behandelt, nimmt sie nicht den Fokus. Stattdessen werden alle Feedback und Ergebnisse über die Cortana-Canvas und die Cortana-Stimme zurückgegeben.

Hinweis

Wichtige APIs

Apps können im Vordergrund aktiviert werden (die App nimmt den Fokus) oder im Hintergrund aktiviert werden (Cortana behält den Fokus), abhängig von der Komplexität der Interaktion. Sprachbefehle, die zusätzlichen Kontext oder Benutzereingaben erfordern (z. B. das Senden einer Nachricht an einen bestimmten Kontakt), werden in einer Vordergrund-App am besten behandelt, während grundlegende Befehle (z. B. das Auflisten anstehender Reisen) in Cortana über eine Hintergrund-App behandelt werden können.

Wenn Sie eine App mithilfe von Sprachbefehlen im Vordergrund aktivieren möchten, lesen Sie " Aktivieren einer Vordergrund-App mit Sprachbefehlen über Cortana".

Hinweis

Ein Sprachbefehl ist eine einzelne Äußerung mit einer bestimmten Absicht, die in einer VCD-Datei (Voice Command Definition) definiert ist, die an eine installierte App über Cortana gerichtet ist.

Eine VCD-Datei definiert einen oder mehrere Sprachbefehle, jeweils mit einer eindeutigen Absicht.

Sprachbefehlsdefinitionen können in der Komplexität variieren. Sie können alles von einer einzigen, eingeschränkten Äußerung bis zu einer Sammlung flexiblerer, natürlicher Sprache Ausdrücke unterstützen, die denselben Zweck bezeichnen.

Wir verwenden eine Reiseplanungs- und Verwaltungs-App namens Adventure Works , die in die Cortana-Benutzeroberfläche integriert ist, die hier gezeigt wird, um viele der konzepte und Features zu veranschaulichen, die wir diskutieren. Weitere Informationen finden Sie im Cortana-Sprachbefehlsbeispiel.

Screenshot der Cortana-Start-Vordergrund-App

Um eine Adventure Works-Reise ohne Cortana anzuzeigen, startet ein Benutzer die App und navigiert zur Seite "Bevorstehende Reisen" .

Die Verwendung von Sprachbefehlen über Cortana zum Starten Ihrer App im Hintergrund kann der Benutzer stattdessen einfach sagen. Adventure Works, when is my trip to Las Vegas? Ihre App behandelt den Befehl und Cortana zeigt ergebnisse zusammen mit Dem App-Symbol und anderen App-Informationen an, sofern angegeben.

Screenshot von Cortana mit einer einfachen Abfrage und einem Ergebnisbildschirm mithilfe der AdventureWorks-App im Hintergrund

Die folgenden grundlegenden Schritte fügen Sprachbefehlsfunktionen hinzu und erweitern Cortana mit Hintergrundfunktionen aus Ihrer App mithilfe von Sprach- oder Tastatureingaben.

  1. Erstellen Sie einen App-Dienst (siehe Windows.ApplicationModel.AppService), den Cortana im Hintergrund aufruft.
  2. Erstellen Sie eine VCD-Datei. Die VCD-Datei ist ein XML-Dokument, das alle gesprochenen Befehle definiert, die der Benutzer sagen kann, um Aktionen zu initiieren oder Befehle aufzurufen, wenn Sie Ihre App aktivieren. Siehe VCD-Elemente und Attribute v1.2.
  3. Registrieren Sie die Befehlssätze in der VCD-Datei, wenn die App gestartet wird.
  4. Behandeln Sie die Hintergrundaktivierung des App-Diensts und die Ausführung des Sprachbefehls.
  5. Zeigen Sie das entsprechende Feedback an den Sprachbefehl in Cortana an, und sprechen Sie es.

Tipp

Voraussetzungen

Wenn Sie noch nicht mit der Entwicklung von Universelle Windows-Plattform(UWP)-Apps vertraut sind, schauen Sie sich diese Themen an, um sich mit den hier erläuterten Technologien vertraut zu machen.

Richtlinien für die Benutzeroberfläche

Informationen zum Integrieren Ihrer App in Cortana- und Sprachinteraktionen finden Sie in den Entwurfsrichtlinien für Cortana und Spracherkennung.

Erstellen einer neuen Projektmappe mit einem primären Projekt in Visual Studio

  1. Starten Sie Microsoft Visual Studio 2015.
    Die Visual Studio 2015-Startseite wird angezeigt.

  2. Wählen Sie im Menü Datei die Option Neu>Projekt.
    Das Dialogfeld Neues Projekt wird geöffnet. Im linken Bereich des Dialogfelds können Sie den Typ der anzuzeigenden Vorlagen auswählen.

  3. Erweitern Sie im linken Bereich installierte > Vorlagen > Visual C# > Windows, und wählen Sie dann die Gruppe " Universelle Vorlagen" aus. Im mittleren Bereich des Dialogfelds wird eine Liste der Projektvorlagen für Universelle Windows-Plattform-Apps (UWP) angezeigt.

  4. Wählen Sie im mittleren Bereich die Vorlage "Leere App" (Universelle Windows-App) aus.
    Die Vorlage "Leere App " erstellt eine minimale UWP-App, die kompiliert und ausgeführt wird. Die Vorlage "Leere App " enthält keine Steuerelemente oder Daten der Benutzeroberfläche. Sie fügen der App Steuerelemente hinzu, indem Sie diese Seite als Leitfaden verwenden.

  5. Geben Sie im Textfeld "Name " den Projektnamen ein. Beispiel: Verwenden Sie AdventureWorks.

  6. Klicken Sie auf die Schaltfläche "OK ", um das Projekt zu erstellen.
    Microsoft Visual Studio erstellt Ihr Projekt und zeigt es im Projektmappen-Explorer an.

Hinzufügen von Bildressourcen zum primären Projekt und Angeben im App-Manifest

UWP-Apps sollten automatisch die am besten geeigneten Bilder auswählen. Die Auswahl basiert auf bestimmten Einstellungen und Gerätefunktionen (hoher Kontrast, effektive Pixel, Gebietsschema usw.). Sie müssen die Bilder bereitstellen und sicherstellen, dass Sie die entsprechende Benennungskonvention und Ordnerorganisation innerhalb Ihres App-Projekts für die verschiedenen Ressourcenversionen verwenden.
Wenn Sie die empfohlenen Ressourcenversionen nicht bereitstellen, kann die Benutzererfahrung auf folgende Weise leiden.

  • Zugriff
  • Lokalisierung
  • Bildqualität
    Die Ressourcenversionen werden verwendet, um die folgenden Änderungen an der Benutzeroberfläche anzupassen.
  • Benutzereinstellungen
  • Fähigkeiten
  • Gerätetyp
  • Location

Weitere Details zu Bildressourcen für hohe Kontrast- und Skalierungsfaktoren finden Sie auf der Seite "Richtlinien für Kachel- und Symbolressourcen" auf msdn.microsoft.com/windows/uwp/controls-and-patterns/tiles-and-notifications-app-assets.

Sie müssen Ressourcen mithilfe von Qualifizierern benennen. Ressourcenqualifizierer sind Ordner- und Dateinamenmodifizierer, die den Kontext identifizieren, in dem eine bestimmte Version einer Ressource verwendet werden soll.

Die Standardbenennungskonvention lautet foldername/qualifiername-value[_qualifiername-value]/filename.qualifiername-value[_qualifiername-value].ext.
Beispiel: images/logo.scale-100_contrast-white.png, der auf Code mit nur dem Stammordner und dem Dateinamen verweisen kann: images/logo.png.
Weitere Informationen finden Sie auf der Seite zum Benennen von Ressourcen mithilfe der Qualifiziererseite unter msdn.microsoft.com/library/windows/apps/xaml/hh965324.aspx.

Microsoft empfiehlt, die Standardsprache für Zeichenfolgenressourcendateien (z en-US\resources.resw. B. ) und den Standardskalierungsfaktor für Bilder (z logo.scale-100.png. B. ) zu markieren, auch wenn Sie derzeit keine lokalisierten oder mehrere Auflösungsressourcen bereitstellen möchten. Microsoft empfiehlt jedoch mindestens, Ressourcen für 100, 200 und 400 Skalierungsfaktoren bereitzustellen.

Wichtig

Das app-Symbol, das im Titelbereich der Cortana-Canvas verwendet wird, ist das in der Package.appxmanifest Datei angegebene Square44x44Logo-Symbol.
Sie können auch ein Symbol für jeden Eintrag im Inhaltsbereich der Cortana-Canvas angeben. Gültige Bildgrößen für die Ergebnissymbole sind:

  • 68w x 68h
  • 68w x 92h
  • 280w x 140h

Die Inhaltskachel wird erst überprüft, wenn ein VoiceCommandResponse-Objekt an die VoiceCommandServiceConnection-Klasse übergeben wird. Wenn Sie ein VoiceCommandResponse-Objekt an Cortana übergeben, das eine Inhaltskachel mit einem Bild enthält, das diesen Größenverhältnissen nicht entspricht, kann eine Ausnahme auftreten. 

Beispiel: Die Adventure Works-App (VoiceCommandService\\AdventureWorksVoiceCommandService.cs) gibt ein einfaches, graues Quadrat (GreyTile.png) für die VoiceCommandContentTile-Klasse mithilfe der Kachelvorlage TitleWith68x68IconAndText an. Die Logovarianten befinden sich in VoiceCommandService\\Imagesund werden mithilfe der GetFileFromApplicationUriAsync-Methode abgerufen.

var destinationTile = new VoiceCommandContentTile();  

destinationTile.ContentTileType = VoiceCommandContentTileType.TitleWith68x68IconAndText;
destinationTile.Image = await StorageFile.GetFileFromApplicationUriAsync(
    new Uri("ms-appx:///AdventureWorks.VoiceCommands/Images/GreyTile.png")
);

Erstellen eines App Service-Projekts

  1. Klicken Sie mit der rechten Maustaste auf ihren Projektmappennamen, wählen Sie "Neues Projekt" > aus.

  2. Wählen Sie unter installierten > Vorlagen > Visual C# > Windows > Universal Windows-Runtime Komponente aus. Die Windows-Runtime Komponente ist die Komponente, die den App-Dienst (Windows.ApplicationModel.AppService) implementiert.

  3. Geben Sie einen Namen für das Projekt ein, und klicken Sie auf die Schaltfläche "OK ".
    Beispiel: VoiceCommandService.

  4. Wählen Sie in Projektmappen-Explorer das VoiceCommandService Projekt aus, und benennen Sie die Class1.cs von Visual Studio generierte Datei um. Beispiel: Die Adventure Works verwendet AdventureWorksVoiceCommandService.cs.

  5. Klicken Sie auf die Schaltfläche "Ja ". Wenn Sie gefragt werden, ob Sie alle Vorkommen Class1.csumbenennen möchten.

  6. In der AdventureWorksVoiceCommandService.cs-Datei:

    1. Fügen Sie die folgende using-Direktive hinzu.
      using Windows.ApplicationModel.Background;
    2. Wenn Sie ein neues Projekt erstellen, wird der Projektname in allen Dateien als Standardstammnamespace verwendet. Benennen Sie den Namespace um, um den App-Dienstcode unter dem primären Projekt zu verschachteln. Beispiel: namespace AdventureWorks.VoiceCommands.
    3. Klicken Sie in Projektmappen-Explorer mit der rechten Maustaste auf den Namen des App-Dienstprojekts, und wählen Sie "Eigenschaften" aus.
    4. Aktualisieren Sie auf der Registerkarte "Bibliothek " das Standardnamespacefeld mit diesem Wert.
      Beispiel: AdventureWorks.VoiceCommands).
    5. Erstellen Sie eine neue Klasse, die die IBackgroundTask-Schnittstelle implementiert. Diese Klasse erfordert eine Run-Methode , die den Einstiegspunkt darstellt, wenn Cortana den Sprachbefehl erkennt.

    Beispiel: Eine einfache Hintergrundaufgabenklasse aus der Adventure Works-App .

    Hinweis

    Die Hintergrundaufgabenklasse selbst sowie alle Klassen im Hintergrundaufgabenprojekt müssen versiegelte öffentliche Klassen sein.

    namespace AdventureWorks.VoiceCommands
{
    ...

    /// <summary>
    /// The VoiceCommandService implements the entry point for all voice commands.
    /// The individual commands supported are described in the VCD xml file. 
    /// The service entry point is defined in the appxmanifest.
    /// </summary>
    public sealed class AdventureWorksVoiceCommandService : IBackgroundTask
    {
        ...

        /// <summary>
        /// The background task entrypoint. 
        /// 
        /// Background tasks must respond to activation by Cortana within 0.5 second, and must 
        /// report progress to Cortana every 5 seconds (unless Cortana is waiting for user
        /// input). There is no running time limit on the background task managed by Cortana,
        /// but developers should use plmdebug (https://msdn.microsoft.com/library/windows/hardware/jj680085%28v=vs.85%29.aspx)
        /// on the Cortana app package in order to prevent Cortana timing out the task during
        /// debugging.
        /// 
        /// The Cortana UI is dismissed if Cortana loses focus. 
        /// The background task is also dismissed even if being debugged. 
        /// Use of Remote Debugging is recommended in order to debug background task behaviors. 
        /// Open the project properties for the app package (not the background task project), 
        /// and enable Debug -> "Do not launch, but debug my code when it starts". 
        /// Alternatively, add a long initial progress screen, and attach to the background task process while it runs.
        /// </summary>
        /// <param name="taskInstance">Connection to the hosting background service process.</param>
        public void Run(IBackgroundTaskInstance taskInstance)
        {
          //
          // TODO: Insert code 
          //
          //
    }
  }
}

  7. Deklarieren Sie Ihre Hintergrundaufgabe als AppService im App-Manifest.

    1. Klicken Sie in Projektmappen-Explorer mit der rechten Maustaste auf die Package.appxmanifest Datei, und wählen Sie "Code anzeigen" aus.
    2. Suchen Sie das Application-Element.
    3. Fügen Sie dem Application Element ein Extensions Element hinzu.
    4. Fügen Sie dem uap:Extension-Element ein Extensions-Element hinzu.
    5. Fügen Sie dem Element ein Category Attribut hinzu, und legen Sie den Wert des Category Attributs auf windows.appService.uap:Extension
    6. Fügen Sie dem Element ein EntryPoint Attribut hinzu, und legen Sie den Wert des EntryPoint Attributs auf den Namen der Klasse fest, die implementiert wirdIBackgroundTask.uap: Extension
      Beispiel: AdventureWorks.VoiceCommands.AdventureWorksVoiceCommandService.
    7. Fügen Sie dem uap:AppService-Element ein uap:Extension-Element hinzu.
    8. Fügen Sie dem Element ein Name Attribut hinzu, und legen Sie in diesem Fall AdventureWorksVoiceCommandServiceden Wert des Name Attributs auf einen Namen für den App-Dienst uap:AppService fest.
    9. Fügen Sie dem Extensions Element ein zweites uap:Extension Element hinzu.
    10. Fügen Sie diesem Element ein Category Attribut hinzu, und legen Sie den Wert des Category Attributs auf windows.personalAssistantLaunch.uap:Extension

    Beispiel: Ein Manifest aus der Adventure Works-App.

    <Package>
    <Applications>
        <Application>

            <Extensions>
                <uap:Extension Category="windows.appService" EntryPoint="CortanaBack1.VoiceCommands.AdventureWorksVoiceCommandService">
                    <uap:AppService Name="AdventureWorksVoiceCommandService"/>
                </uap:Extension>
                <uap:Extension Category="windows.personalAssistantLaunch"/>
            </Extensions>

        <Application>
    <Applications>
</Package>

  8. Fügen Sie dieses App-Dienstprojekt als Verweis im primären Projekt hinzu.

    1. Klicken Sie mit der rechten Maustaste auf die Verweise.
    2. Wählen Sie " Verweis hinzufügen..." aus.
    3. Erweitern Sie im Dialogfeld "Verweis-Manager" Projekte, und wählen Sie das App-Dienstprojekt aus.
    4. Klicken Sie auf die Schaltfläche "OK ".

Erstellen einer VCD-Datei

  1. Klicken Sie in Visual Studio mit der rechten Maustaste auf ihren primären Projektnamen, und wählen Sie "Neues Element hinzufügen" > aus. Fügen Sie eine XML-Datei hinzu.
  2. Geben Sie einen Namen für die VCD-Datei ein.
    Beispiel: AdventureWorksCommands.xml.
  3. Klicken Sie auf die Schaltfläche "Hinzufügen" .
  4. Wählen Sie in Projektmappen-Explorer die VCD-Datei aus.
  5. Legen Sie im Fenster "Eigenschaften" die Buildaktion auf "Inhalt" fest, und legen Sie dann "Kopieren" auf "Ausgabeverzeichnis" auf "Kopieren" fest, wenn neuer.

Bearbeiten der VCD-Datei

  1. Fügen Sie ein VoiceCommands Element mit einem xmlns Attribut hinzu, das auf https://schemas.microsoft.com/voicecommands/1.2.

  2. Erstellen Sie für jede sprache, die von Ihrer App unterstützt wird, ein CommandSet Element, das die sprachbefehle enthält, die von Ihrer App unterstützt werden.
    Sie können mehrere CommandSet Elemente deklarieren, jeweils mit einem anderen xml:lang Attribut, damit Ihre App in verschiedenen Märkten verwendet werden kann. Eine App für die USA kann beispielsweise englisch CommandSet und spanisch seinCommandSet.

    Wichtig

    Um eine App zu aktivieren und eine Aktion mithilfe eines Sprachbefehls zu initiieren, muss die App eine VCD-Datei registrieren, die ein CommandSet Element mit einer Sprache enthält, die mit der sprache übereinstimmt, die auf dem Gerät des Benutzers angegeben ist. Die Sprache befindet sich in der Spracherkennungssprache "Einstellungen>">>.

  3. Fügen Sie ein Command Element für jeden Befehl hinzu, den Sie unterstützen möchten.
    Jede Command in einer VCD-Datei deklarierte Datei muss diese Informationen enthalten:

    • Ein Name Attribut, das Ihre Anwendung zum Identifizieren des Sprachbefehls zur Laufzeit verwendet.

    • Ein Example Element, das einen Ausdruck enthält, der beschreibt, wie ein Benutzer den Befehl aufruft. Cortana zeigt das Beispiel an, wenn der Benutzer sagt What can I say?, Helpoder tippt auf "Mehr anzeigen".

    • Ein ListenFor Element, das die Wörter oder Ausdrücke enthält, die ihre App als Befehl erkennt. Jedes ListenFor Element kann Verweise auf ein oder PhraseList mehrere Elemente enthalten, die bestimmte für den Befehl relevante Wörter enthalten.

      Hinweis

      ListenFor Elemente dürfen nicht programmgesteuert geändert werden. Elemente, die Elementen ListenFor zugeordnet sind, PhraseList können jedoch programmgesteuert geändert werden. Anwendungen sollten den Inhalt des PhraseList Elements zur Laufzeit basierend auf dem von dem Benutzer generierten Datensatz ändern, der die App verwendet.

      Weitere Informationen finden Sie unter Dynamisches Ändern von Cortana VCD-Begriffslisten.

    • Ein Feedback Element, das den Text enthält, der Cortana anzeigt und spricht, während die Anwendung gestartet wird.

Ein Navigate Element gibt an, dass der Sprachbefehl die App im Vordergrund aktiviert. In diesem Beispiel ist der showTripToDestination Befehl eine Vordergrundaufgabe.

Ein VoiceCommandService Element gibt an, dass der Sprachbefehl die App im Hintergrund aktiviert. Der Wert des Attributs Target dieses Elements sollte mit dem Wert des Name Attributs des uap:AppService Elements in der Datei "package.appxmanifest" übereinstimmen. In diesem Beispiel sind die whenIsTripToDestination Und cancelTripToDestination Befehle Hintergrundaufgaben, die den Namen des App-Diensts als AdventureWorksVoiceCommandServiceangeben.

Weitere Details finden Sie in der VCD-Element- und Attributreferenz v1.2.

Beispiel: Ein Teil der VCD-Datei, der die en-us Sprachbefehle für die Adventure Works-App definiert.

<?xml version="1.0" encoding="utf-8" ?>
<VoiceCommands xmlns="https://schemas.microsoft.com/voicecommands/1.2">
<CommandSet xml:lang="en-us" Name="AdventureWorksCommandSet_en-us">
    <AppName> Adventure Works </AppName>
    <Example> Show trip to London </Example>
    
    <Command Name="showTripToDestination">
        <Example> Show trip to London </Example>
        <ListenFor RequireAppName="BeforeOrAfterPhrase"> show [my] trip to {destination} </ListenFor>
        <ListenFor RequireAppName="ExplicitlySpecified"> show [my] {builtin:AppName} trip to {destination} </ListenFor>
        <Feedback> Showing trip to {destination} </Feedback>
        <Navigate />
    </Command>
      
    <Command Name="whenIsTripToDestination">
        <Example> When is my trip to Las Vegas?</Example>
        <ListenFor RequireAppName="BeforeOrAfterPhrase"> when is [my] trip to {destination}</ListenFor>
        <ListenFor RequireAppName="ExplicitlySpecified"> when is [my] {builtin:AppName} trip to {destination} </ListenFor>
        <Feedback> Looking for trip to {destination}</Feedback>
        <VoiceCommandService Target="AdventureWorksVoiceCommandService"/>
    </Command>
    
    <Command Name="cancelTripToDestination">
        <Example> Cancel my trip to Las Vegas </Example>
        <ListenFor RequireAppName="BeforeOrAfterPhrase"> cancel [my] trip to {destination}</ListenFor>
        <ListenFor RequireAppName="ExplicitlySpecified"> cancel [my] {builtin:AppName} trip to {destination} </ListenFor>
        <Feedback> Cancelling trip to {destination}</Feedback>
        <VoiceCommandService Target="AdventureWorksVoiceCommandService"/>
    </Command>

    <PhraseList Label="destination">
        <Item>London</Item>
        <Item>Las Vegas</Item>
        <Item>Melbourne</Item>
        <Item>Yosemite National Park</Item>
    </PhraseList>
</CommandSet>

Installieren der VCD-Befehle

Ihre App muss einmal ausgeführt werden, um die VCD zu installieren.

Hinweis

Sprachbefehlsdaten werden nicht für App-Installationen beibehalten. Um sicherzustellen, dass die Sprachbefehlsdaten für Ihre App intakt bleiben, sollten Sie die VCD-Datei jedes Mal initialisieren, wenn die App gestartet oder aktiviert wird, oder eine Einstellung beibehalten, die angibt, ob die VCD derzeit installiert ist.

In der app.xaml.cs-Datei:

  1. Fügen Sie die folgende Using-Direktive hinzu:

    using Windows.Storage;

  2. Markieren Sie die OnLaunched Methode mit dem asynchronen Modifizierer.

    protected async override void OnLaunched(LaunchActivatedEventArgs e)

  3. Rufen Sie die InstallCommandDefinitionsFromStorageFileAsync Methode im OnLaunched Handler auf, um die Sprachbefehle zu registrieren, die erkannt werden sollen.
    Beispiel: Die Adventure Works-App definiert ein StorageFile Objekt.
    Beispiel: Rufen Sie die GetFileAsync Methode auf, um das StorageFile Objekt mit der AdventureWorksCommands.xml Datei zu initialisieren.
    Das StorageFile Objekt wird dann an InstallCommandDefinitionsFromStorageFileAsync die Methode übergeben.

    try {
   // Install the main VCD. 
   StorageFile vcdStorageFile = await Package.Current.InstalledLocation.GetFileAsync(
         @"AdventureWorksCommands.xml"
   );

   await Windows.ApplicationModel.VoiceCommands.VoiceCommandDefinitionManager.InstallCommandDefinitionsFromStorageFileAsync(vcdStorageFile);

   // Update phrase list.
   ViewModel.ViewModelLocator locator = App.Current.Resources["ViewModelLocator"] as ViewModel.ViewModelLocator;
   if(locator != null) {
         await locator.TripViewModel.UpdateDestinationPhraseList();
     }
 }
 catch (Exception ex) {
     System.Diagnostics.Debug.WriteLine("Installing Voice Commands Failed: " + ex.ToString());
 }

Behandeln der Aktivierung

Geben Sie an, wie Ihre App auf nachfolgende Sprachbefehlsaktivierungen reagiert.

Hinweis

Sie müssen Ihre App mindestens einmal starten, nachdem die Sprachbefehlssätze installiert wurden.

  1. Vergewissern Sie sich, dass Ihre App durch einen Sprachbefehl aktiviert wurde.

    Überschreiben Sie das Application.OnActivated Ereignis, und überprüfen Sie, ob IActivatedEventArgs.Kind ist VoiceCommand.

  2. Bestimmen Sie den Namen des Befehls und was gesprochen wurde.

    Rufen Sie einen Verweis auf ein VoiceCommandActivatedEventArgs Objekt aus dem IActivatedEventArgs ab, und fragen Sie die Result Eigenschaft für ein SpeechRecognitionResult Objekt ab.

    Um zu bestimmen, was der Benutzer gesagt hat, überprüfen Sie den Wert von Text oder die semantischen Eigenschaften des erkannten Ausdrucks im SpeechRecognitionSemanticInterpretation Wörterbuch.

  3. Ergreifen Sie die entsprechende Aktion in Ihrer App, z. B. das Navigieren zur gewünschten Seite.

    Hinweis

    Wenn Sie auf Ihre VCD verweisen müssen, besuchen Sie den Abschnitt "VCD-Datei bearbeiten".

    Nachdem Sie das Spracherkennungsergebnis für den Sprachbefehl erhalten haben, erhalten Sie den Befehlsnamen aus dem ersten Wert im RulePath Array. Da die VCD-Datei mehr als einen möglichen Sprachbefehl definiert, müssen Sie überprüfen, ob der Wert den Befehlsnamen in der VCD entspricht und die entsprechende Aktion durchführt.

    Die häufigste Aktion für eine Anwendung besteht darin, zu einer Seite zu navigieren, deren Inhalt für den Kontext des Sprachbefehls relevant ist.
    Beispiel: Öffnen Sie die TripPage-Seite , und übergeben Sie den Wert des Sprachbefehls, die Eingabe des Befehls und den erkannten Zielausdruck (falls zutreffend). Alternativ kann die App beim Navigieren zur TripPage-Seite einen Navigationsparameter an das SpeechRecognitionResult senden.

    Sie können herausfinden, ob der Sprachbefehl, der Ihre App gestartet hat, tatsächlich gesprochen wurde oder ob sie als Text eingegeben wurde, aus dem SpeechRecognitionSemanticInterpretation.Properties Wörterbuch mithilfe der CommandMode-Taste . Der Wert dieses Schlüssels ist entweder voice oder text. Wenn der Wert des Schlüssels lautet voice, sollten Sie die Verwendung der Sprachsynthese (Windows.Media.SpeechSynthesis) in Ihrer App in Betracht ziehen, um dem Benutzer gesprochenes Feedback zu geben.

    Verwenden Sie die SpeechRecognitionSemanticInterpretation.Properties , um den inhalt zu ermitteln, der in den PhraseList Oder PhraseTopic Einschränkungen eines ListenFor Elements gesprochen wird. Der Wörterbuchschlüssel ist der Wert des Label Attributs oder PhraseList PhraseTopic Elements. Beispiel: Der folgende Code für den Zugriff auf den Wert des {destination}-Ausdrucks.

    /// <summary>
/// Entry point for an application activated by some means other than normal launching. 
/// This includes voice commands, URI, share target from another app, and so on. 
/// 
/// NOTE:
/// A previous version of the VCD file might remain in place 
/// if you modify it and update the app through the store. 
/// Activations might include commands from older versions of your VCD. 
/// Try to handle these commands gracefully.
/// </summary>
/// <param name="args">Details about the activation method.</param>
protected override void OnActivated(IActivatedEventArgs args) {
    base.OnActivated(args);

    Type navigationToPageType;
    ViewModel.TripVoiceCommand? navigationCommand = null;

    // Voice command activation.
    if (args.Kind == ActivationKind.VoiceCommand) {
        // Event args may represent many different activation types. 
        // Cast the args so that you only get useful parameters out.
        var commandArgs = args as VoiceCommandActivatedEventArgs;

        Windows.Media.SpeechRecognition.SpeechRecognitionResult speechRecognitionResult = commandArgs.Result;

        // Get the name of the voice command and the text spoken.
        // See VoiceCommands.xml for supported voice commands.
        string voiceCommandName = speechRecognitionResult.RulePath[0];
        string textSpoken = speechRecognitionResult.Text;

        // commandMode indicates whether the command was entered using speech or text.
        // Apps should respect text mode by providing silent (text) feedback.
        string commandMode = this.SemanticInterpretation("commandMode", speechRecognitionResult);

        switch (voiceCommandName) {
            case "showTripToDestination":
                // Access the value of {destination} in the voice command.
                string destination = this.SemanticInterpretation("destination", speechRecognitionResult);

                // Create a navigation command object to pass to the page.
                navigationCommand = new ViewModel.TripVoiceCommand(
                    voiceCommandName,
                    commandMode,
                    textSpoken,
                    destination
                );

                // Set the page to navigate to for this voice command.
                navigationToPageType = typeof(View.TripDetails);
                break;
            default:
                // If not able to determine what page to launch, then go to the default entry point.
                navigationToPageType = typeof(View.TripListView);
                break;
        }
    }
    // Protocol activation occurs when a card is selected within Cortana (using a background task).
    else if (args.Kind == ActivationKind.Protocol) {
        // Extract the launch context. In this case, use the destination from the phrase set (passed
        // along in the background task inside Cortana), which makes no attempt to be unique. A unique id or 
        // identifier is ideal for more complex scenarios. The destination page is left to check if the 
        // destination trip still exists, and navigate back to the trip list if it does not.
        var commandArgs = args as ProtocolActivatedEventArgs;
        Windows.Foundation.WwwFormUrlDecoder decoder = new Windows.Foundation.WwwFormUrlDecoder(commandArgs.Uri.Query);
        var destination = decoder.GetFirstValueByName("LaunchContext");

        navigationCommand = new ViewModel.TripVoiceCommand(
            "protocolLaunch",
            "text",
            "destination",
            destination
        );

        navigationToPageType = typeof(View.TripDetails);
    }
    else {
        // If launched using any other mechanism, fall back to the main page view.
        // Otherwise, the app will freeze at a splash screen.
        navigationToPageType = typeof(View.TripListView);
    }

    // Repeat the same basic initialization as OnLaunched() above, taking into account whether
    // or not the app is already active.
    Frame rootFrame = Window.Current.Content as Frame;

    // Do not repeat app initialization when the Window already has content,
    // just ensure that the window is active.
    if (rootFrame == null) {
        // Create a frame to act as the navigation context and navigate to the first page.
        rootFrame = new Frame();
        App.NavigationService = new NavigationService(rootFrame);

        rootFrame.NavigationFailed += OnNavigationFailed;

        // Place the frame in the current window.
        Window.Current.Content = rootFrame;
    }

    // Since the expectation is to always show a details page, navigate even if 
    // a content frame is in place (unlike OnLaunched).
    // Navigate to either the main trip list page, or if a valid voice command
    // was provided, to the details page for that trip.
    rootFrame.Navigate(navigationToPageType, navigationCommand);

    // Ensure the current window is active
    Window.Current.Activate();
}

/// <summary>
/// Returns the semantic interpretation of a speech result. 
/// Returns null if there is no interpretation for that key.
/// </summary>
/// <param name="interpretationKey">The interpretation key.</param>
/// <param name="speechRecognitionResult">The speech recognition result to get the semantic interpretation from.</param>
/// <returns></returns>
private string SemanticInterpretation(string interpretationKey, SpeechRecognitionResult speechRecognitionResult) {
    return speechRecognitionResult.SemanticInterpretation.Properties[interpretationKey].FirstOrDefault();
}

Behandeln des Sprachbefehls im App-Dienst

Verarbeiten sie den Sprachbefehl im App-Dienst.

  1. Fügen Sie der Sprachbefehlsdienstdatei die folgenden Direktiven hinzu.
    Beispiel: AdventureWorksVoiceCommandService.cs.

        using Windows.ApplicationModel.VoiceCommands;
    using Windows.ApplicationModel.Resources.Core;
    using Windows.ApplicationModel.AppService;

  2. Verwenden Sie eine Dienstverzögerung, sodass Der App-Dienst beim Behandeln des Sprachbefehls nicht beendet wird.

  3. Vergewissern Sie sich, dass Ihre Hintergrundaufgabe als App-Dienst ausgeführt wird, der von einem Sprachbefehl aktiviert wird.

    1. Wandeln Sie "IBackgroundTaskInstance.TriggerDetails" in "Windows.ApplicationModel.AppService.AppServiceTriggerDetails" um.
    2. Überprüfen Sie, ob IBackgroundTaskInstance.TriggerDetails.Name der Name des App-Diensts in der Package.appxmanifest Datei ist.

  4. Verwenden Sie "IBackgroundTaskInstance.TriggerDetails ", um eine VoiceCommandServiceConnection zu Cortana zu erstellen, um den Sprachbefehl abzurufen.

  5. Registrieren Sie einen Ereignishandler für VoiceCommandServiceConnection. VoiceCommandCompleted zum Empfangen von Benachrichtigungen, wenn der App-Dienst aufgrund einer Benutzerabsage geschlossen wird.

  6. Registrieren Sie einen Ereignishandler für den IBackgroundTaskInstance.Canceled to receive notification when the app service is closed due an unexpected failure.

  7. Bestimmen Sie den Namen des Befehls und was gesprochen wurde.

    1. Verwenden Sie VoiceCommand. CommandName-Eigenschaft, um den Namen des Sprachbefehls zu bestimmen.
    2. Um zu bestimmen, was der Benutzer gesagt hat, überprüfen Sie den Wert von Text oder die semantischen Eigenschaften des erkannten Ausdrucks im SpeechRecognitionSemanticInterpretation Wörterbuch.

  8. Ergreifen Sie die entsprechende Aktion in Ihrem App-Dienst.

  9. Zeigen Sie das Feedback mithilfe von Cortana an den Sprachbefehl an, und sprechen Sie es.

    1. Bestimmen Sie die Zeichenfolgen, die Cortana als Reaktion auf den Sprachbefehl anzeigen und mit dem Benutzer sprechen soll, und erstellen Sie ein VoiceCommandResponse Objekt. Anleitungen zum Auswählen der Feedbackzeichenfolgen, die Cortana anzeigt und spricht, finden Sie in den Cortana-Entwurfsrichtlinien.
    2. Verwenden Sie die VoiceCommandServiceConnection-Instanz, um den Fortschritt oder abschluss von Cortana durch Aufrufen von ReportProgressAsync oder ReportSuccessAsync mit dem VoiceCommandServiceConnection Objekt zu melden.

    Hinweis

    Wenn Sie auf Ihre VCD verweisen müssen, besuchen Sie den Abschnitt "VCD-Datei bearbeiten".

    public sealed class VoiceCommandService : IBackgroundTask {
    private BackgroundTaskDeferral serviceDeferral;
    VoiceCommandServiceConnection voiceServiceConnection;

    public async void Run(IBackgroundTaskInstance taskInstance) {
        //Take a service deferral so the service isn&#39;t terminated.
        this.serviceDeferral = taskInstance.GetDeferral();

        taskInstance.Canceled += OnTaskCanceled;

        var triggerDetails = taskInstance.TriggerDetails as AppServiceTriggerDetails;

        if (triggerDetails != null &amp;&amp; 
            triggerDetails.Name == "AdventureWorksVoiceServiceEndpoint") {
            try {
                voiceServiceConnection = 
                VoiceCommandServiceConnection.FromAppServiceTriggerDetails(
                    triggerDetails);
                voiceServiceConnection.VoiceCommandCompleted += 
                VoiceCommandCompleted;

                VoiceCommand voiceCommand = await 
                voiceServiceConnection.GetVoiceCommandAsync();

                switch (voiceCommand.CommandName) {
                    case "whenIsTripToDestination":
                        {
                            var destination = 
                            voiceCommand.Properties["destination"][0];
                            SendCompletionMessageForDestination(destination);
                            break;
                        }

                        // As a last resort, launch the app in the foreground.
                    default:
                        LaunchAppInForeground();
                        break;
                }
            }
            finally {
                if (this.serviceDeferral != null) {
                    // Complete the service deferral.
                    this.serviceDeferral.Complete();
                }
            }
        }
    }

    private void VoiceCommandCompleted(VoiceCommandServiceConnection sender,
        VoiceCommandCompletedEventArgs args) {
        if (this.serviceDeferral != null) {
            // Insert your code here.
            // Complete the service deferral.
            this.serviceDeferral.Complete();
        }
    }

    private async void SendCompletionMessageForDestination(
        string destination) {
        // Take action and determine when the next trip to destination
        // Insert code here.

        // Replace the hardcoded strings used here with strings 
        // appropriate for your application.

        // First, create the VoiceCommandUserMessage with the strings 
        // that Cortana will show and speak.
        var userMessage = new VoiceCommandUserMessage();
        userMessage.DisplayMessage = "Here's your trip.";
        userMessage.SpokenMessage = "Your trip to Vegas is on August 3rd.";

        // Optionally, present visual information about the answer.
        // For this example, create a VoiceCommandContentTile with an 
        // icon and a string.
        var destinationsContentTiles = new List<VoiceCommandContentTile>();

        var destinationTile = new VoiceCommandContentTile();
        destinationTile.ContentTileType = 
            VoiceCommandContentTileType.TitleWith68x68IconAndText;
        // The user taps on the visual content to launch the app. 
        // Pass in a launch argument to enable the app to deep link to a 
        // page relevant to the item displayed on the content tile.
        destinationTile.AppLaunchArgument = 
            string.Format("destination={0}", "Las Vegas");
        destinationTile.Title = "Las Vegas";
        destinationTile.TextLine1 = "August 3rd 2015";
        destinationsContentTiles.Add(destinationTile);

        // Create the VoiceCommandResponse from the userMessage and list    
        // of content tiles.
        var response = VoiceCommandResponse.CreateResponse(
            userMessage, destinationsContentTiles);

        // Cortana displays a "Go to app_name" link that the user 
        // taps to launch the app. 
        // Pass in a launch to enable the app to deep link to a page 
        // relevant to the voice command.
        response.AppLaunchArgument = string.Format(
            "destination={0}", "Las Vegas");

        // Ask Cortana to display the user message and content tile and 
        // also speak the user message.
        await voiceServiceConnection.ReportSuccessAsync(response);
    }

    private async void LaunchAppInForeground() {
        var userMessage = new VoiceCommandUserMessage();
        userMessage.SpokenMessage = "Launching Adventure Works";

        var response = VoiceCommandResponse.CreateResponse(userMessage);

        // When launching the app in the foreground, pass an app 
        // specific launch parameter to indicate what page to show.
        response.AppLaunchArgument = "showAllTrips=true";

        await voiceServiceConnection.RequestAppLaunchAsync(response);
    }
}

Nach der Aktivierung hat der App-Dienst 0,5 Sekunden, um ReportSuccessAsync aufzurufen. Cortana zeigt eine Feedbackzeichenfolge an und sagt sie.

Hinweis

Sie können eine Feedbackzeichenfolge in der VCD-Datei deklarieren. Die Zeichenfolge wirkt sich nicht auf den ui-Text aus, der auf der Cortana-Canvas angezeigt wird, und wirkt sich nur auf den von Cortana gesprochenen Text aus.

Wenn die App länger als 0,5 Sekunden dauert, um den Anruf zu tätigen, fügt Cortana wie hier gezeigt einen Handzettelbildschirm ein. Cortana zeigt den Übergabebildschirm an, bis die Anwendung ReportSuccessAsync aufruft oder bis zu 5 Sekunden lang. Wenn der App-Dienst "ReportSuccessAsync" oder eine der VoiceCommandServiceConnection Methoden, die Cortana Informationen bereitstellen, nicht aufruft, erhält der Benutzer eine Fehlermeldung, und der App-Dienst wird abgebrochen.

Screenshot von Cortana und einer einfachen Abfrage mit Status- und Ergebnisbildschirmen mithilfe der AdventureWorks-App im Hintergrund