Activer une application en arrière-plan dans Cortana à l’aide de commandes vocales

Article
07/05/2024

Avertissement

Cette fonctionnalité n’est plus prise en charge à partir de la mise à jour Windows 10 Update de mai 2020 (version 2004, nom de code « 20H1 »).

Outre l’utilisation de commandes vocales dans Cortana pour accéder aux fonctionnalités système, vous pouvez également étendre Cortana avec des fonctionnalités et fonctionnalités de votre application (en tant que tâche en arrière-plan) à l’aide de commandes vocales qui spécifient une action ou une commande à exécuter. Lorsqu’une application gère une commande vocale en arrière-plan, elle ne prend pas le focus. Au lieu de cela, elle retourne tous les commentaires et résultats via le canevas Cortana et la voix Cortana .

Remarque

API importantes

Les applications peuvent être activées au premier plan (l’application prend le focus) ou activées en arrière-plan (Cortana conserve le focus), en fonction de la complexité de l’interaction. Par exemple, les commandes vocales qui nécessitent un contexte supplémentaire ou une entrée utilisateur (par exemple, l’envoi d’un message à un contact spécifique) sont mieux gérées dans une application de premier plan, tandis que les commandes de base (telles que la liste des voyages à venir) peuvent être gérées dans Cortana via une application en arrière-plan.

Si vous souhaitez activer une application au premier plan à l’aide de commandes vocales, consultez Activer une application de premier plan avec des commandes vocales via Cortana.

Remarque

Une commande vocale est un énoncé unique avec une intention spécifique, définie dans un fichier VCD (Voice Command Definition), dirigé vers une application installée via Cortana.

Un fichier VCD définit une ou plusieurs commandes vocales, chacune avec une intention unique.

Les définitions de commande vocale peuvent varier en complexité. Ils peuvent prendre en charge n’importe quoi d’un énoncé unique et limité à une collection d’énoncés de langage naturel plus flexibles, tout en indiquant la même intention.

Nous utilisons une application de planification et de gestion de voyage nommée Adventure Works intégrée à l’interface utilisateur Cortana , présentée ici, pour illustrer la plupart des concepts et fonctionnalités que nous abordons. Pour plus d’informations, consultez l’exemple de commande vocale Cortana.

Capture d’écran de l’application de premier plan de Cortana

Pour afficher un voyage Adventure Works sans Cortana, un utilisateur lance l’application et accède à la page Des voyages à venir.

À l’aide de commandes vocales via Cortana pour lancer votre application en arrière-plan, l’utilisateur peut simplement dire. Adventure Works, when is my trip to Las Vegas? Votre application gère la commande et Cortana affiche les résultats avec l’icône de votre application et d’autres informations sur l’application, le cas échéant.

Capture d’écran de Cortana avec une requête de base et un écran de résultat à l’aide de l’application AdventureWorks en arrière-plan

Les étapes de base suivantes ajoutent des fonctionnalités de commande vocale et étendent Cortana avec des fonctionnalités en arrière-plan de votre application à l’aide de la reconnaissance vocale ou de l’entrée clavier.

Créez un service d’application (voir Windows.ApplicationModel.AppService) appelé par Cortana en arrière-plan.
Créez un fichier VCD. Le fichier VCD est un document XML qui définit toutes les commandes parlées que l’utilisateur peut dire pour lancer des actions ou appeler des commandes lors de l’activation de votre application. Consultez les éléments et attributs VCD v1.2.
Inscrivez les jeux de commandes dans le fichier VCD lorsque l’application est lancée.
Gérez l’activation en arrière-plan du service d’application et l’exécution de la commande vocale.
Affichez et parlez les commentaires appropriés à la commande vocale dans Cortana.

Conseil

Conditions préalables

Si vous débutez avec le développement d’applications plateforme Windows universelle (UWP), consultez ces rubriques pour vous familiariser avec les technologies présentées ici.

Créez votre première application
Pour en savoir plus sur les événements, consultez Vue d’ensemble des événements et des événements routés

Instructions relatives à l’expérience utilisateur

Consultez les instructions de conception de Cortana pour obtenir des informations sur l’intégration de votre application à Cortana et aux interactions vocales pour obtenir des conseils utiles sur la conception d’une application prenant en charge la reconnaissance vocale utile et attrayante.

Créer une solution avec un projet principal dans Visual Studio

Lancez Microsoft Visual Studio 2015.
La page de démarrage de Visual Studio 2015 s’affiche.
Dans le menu Fichier, sélectionnez Nouveau>Projet.
La boîte de dialogue Nouveau projet s’affiche. Le volet gauche de la boîte de dialogue vous permet de sélectionner le type de modèles à afficher.
Dans le volet gauche, développez Modèles installés > Visual C# > Windows, puis sélectionnez le groupe de modèles universels.> Le volet central de la boîte de dialogue affiche une liste de modèles de projet pour les applications plateforme Windows universelle (UWP).
Dans le volet central, sélectionnez le modèle Application vide (Windows universel).
Le modèle d’application vide crée une application UWP minimale qui compile et s’exécute. Le modèle d’application vide n’inclut aucun contrôle ou données d’interface utilisateur. Vous ajoutez des contrôles à l’application à l’aide de cette page comme guide.
Dans la zone de texte Nom , tapez le nom de votre projet. Exemple : Utiliser AdventureWorks.
Cliquez sur le bouton OK pour créer le projet.
Microsoft Visual Studio crée votre projet et l’affiche dans le Explorateur de solutions.

Ajouter des ressources d’image au projet principal et les spécifier dans le manifeste de l’application

Les applications UWP doivent sélectionner automatiquement les images les plus appropriées. La sélection est basée sur des paramètres spécifiques et des fonctionnalités d’appareil (contraste élevé, pixels effectifs, paramètres régionaux, etc.). Vous devez fournir les images et vous assurer que vous utilisez la convention d’affectation de noms et l’organisation de dossiers appropriées au sein de votre projet d’application pour les différentes versions de ressources.
Si vous ne fournissez pas les versions de ressources recommandées, l’expérience utilisateur peut souffrir de la manière suivante.

Accessibilité
Localisation
Qualité de l’image
Les versions de ressources sont utilisées pour adapter les modifications suivantes dans l’expérience utilisateur.
Préférences utilisateur
Capacités
Type d’appareil
Emplacement

Pour plus d’informations sur les ressources d’image pour les facteurs de contraste élevé et d’échelle, consultez la page Recommandations pour les ressources de vignette et d’icône située à msdn.microsoft.com/windows/uwp/controls-and-patterns/tiles-and-notifications-app-assets.

Vous devez nommer des ressources à l’aide de qualificateurs. Les qualificateurs de ressources sont des modificateurs de dossier et de nom de fichier qui identifient le contexte dans lequel une version particulière d’une ressource doit être utilisée.

La convention d’affectation de noms standard est foldername/qualifiername-value[_qualifiername-value]/filename.qualifiername-value[_qualifiername-value].ext.
Exemple : images/logo.scale-100_contrast-white.png, qui peut faire référence au code à l’aide du dossier racine et du nom de fichier : images/logo.png.
Pour plus d’informations, consultez la page How to name resources using qualifiers page located at msdn.microsoft.com/library/windows/apps/xaml/hh965324.aspx.

Microsoft vous recommande de marquer la langue par défaut sur les fichiers de ressources de chaîne (par en-US\resources.reswexemple) et le facteur d’échelle par défaut sur les images (par logo.scale-100.pngexemple), même si vous ne prévoyez pas actuellement de fournir des ressources localisées ou plusieurs ressources de résolution. Toutefois, Au minimum, Microsoft recommande de fournir des ressources pour 100, 200 et 400 facteurs d’échelle.

Important

L’icône d’application utilisée dans la zone de titre du canevas Cortana est l’icône Square44x44Logo spécifiée dans le Package.appxmanifest fichier.
Vous pouvez également spécifier une icône pour chaque entrée dans la zone de contenu du canevas Cortana . Les tailles d’image valides pour les icônes de résultats sont les suivantes :

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

La vignette de contenu n’est pas validée tant qu’un objet VoiceCommandResponse n’est pas passé à la classe VoiceCommandServiceConnection. Si vous passez un objet VoiceCommandResponse à Cortana qui inclut une vignette de contenu avec une image qui ne respecte pas ces ratios de taille, une exception peut se produire.

Exemple : l’application Adventure Works () spécifie un carré gris simpleVoiceCommandService\\AdventureWorksVoiceCommandService.cs (GreyTile.png) sur la classe VoiceCommandContentTile à l’aide du modèle de vignette TitleWith68x68IconAndText. Les variantes de logo se trouvent dans et sont récupérées à VoiceCommandService\\Imagesl’aide de la méthode GetFileFromApplicationUriAsync .

var destinationTile = new VoiceCommandContentTile();  

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

Créer un projet App Service

Cliquez avec le bouton droit sur le nom de votre solution, sélectionnez Nouveau > projet.
Sous Modèles installés > > Visual C# > > Windows Universel, sélectionnez Composant Windows Runtime. Le composant Windows Runtime est le composant qui implémente le service d’application (Windows.ApplicationModel.AppService).
Tapez un nom pour le projet, puis cliquez sur le bouton OK .
Exemple : VoiceCommandService.
Dans Explorateur de solutions, sélectionnez le VoiceCommandService projet et renommez le Class1.cs fichier généré par Visual Studio. Exemple : Adventure Works utilise AdventureWorksVoiceCommandService.cs.
Cliquez sur le bouton Oui ; lorsque vous êtes invité à renommer toutes les occurrences de Class1.cs.

Dans le fichier AdventureWorksVoiceCommandService.cs :

Ajoutez la directive using suivante.
using Windows.ApplicationModel.Background;
Lorsque vous créez un projet, le nom du projet est utilisé comme espace de noms racine par défaut dans tous les fichiers. Renommez l’espace de noms pour imbriquer le code App Service sous le projet principal. Exemple : namespace AdventureWorks.VoiceCommands.
Cliquez avec le bouton droit sur le nom du projet App Service dans Explorateur de solutions, puis sélectionnez Propriétés.
Sous l’onglet Bibliothèque , mettez à jour le champ d’espace de noms par défaut avec cette même valeur.
Exemple : AdventureWorks.VoiceCommands.
Créez une classe qui implémente l’interface IBackgroundTask . Cette classe nécessite une méthode Run , qui est le point d’entrée lorsque Cortana reconnaît la commande vocale.

Exemple : classe de tâche en arrière-plan de base de l’application Adventure Works .

Remarque

La classe de tâche en arrière-plan elle-même, ainsi que toutes les classes du projet de tâche en arrière-plan, doivent être scellées des classes publiques.

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 
          //
          //
    }
  }
}

Déclarez votre tâche en arrière-plan en tant qu’AppService dans le manifeste de l’application.
1. Dans Explorateur de solutions, cliquez avec le bouton droit sur le fichier, puis sélectionnez Afficher le Package.appxmanifest code.
2. Recherchez l’élément Application.
3. Ajoutez un Extensions élément à l’élément Application .
4. Ajoutez un élément uap:Extension à l'élément Extensions.
5. Ajoutez un Category attribut à l’élément uap:Extension et définissez la valeur de l’attribut Category sur windows.appService.
6. Ajoutez un EntryPoint attribut à l’élément uap: Extension et définissez la valeur de l’attribut EntryPoint sur le nom de la classe qui implémente IBackgroundTask.
  Exemple : AdventureWorks.VoiceCommands.AdventureWorksVoiceCommandService.
7. Ajoutez un élément uap:AppService à l'élément uap:Extension.
8. Ajoutez un Name attribut à l’élément uap:AppService et définissez la valeur de l’attribut Name sur un nom pour le service d’application, dans ce cas AdventureWorksVoiceCommandService.
9. Ajoutez un deuxième uap:Extension élément à l’élément Extensions .
10. Ajoutez un Category attribut à cet uap:Extension élément et définissez la valeur de l’attribut Category sur windows.personalAssistantLaunch.
Exemple : manifeste de l’application Adventure Works.
```
<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>
```
Ajoutez ce projet App Service comme référence dans le projet principal.
1. Cliquez avec le bouton droit sur les références.
2. Sélectionnez Ajouter une référence....
3. Dans la boîte de dialogue Gestionnaire de références, développez Projets et sélectionnez le projet App Service.
4. Cliquez sur le bouton OK .

Créer un fichier VCD

Dans Visual Studio, cliquez avec le bouton droit sur le nom de votre projet principal, puis sélectionnez Ajouter > un nouvel élément. Ajoutez un fichier XML.
Tapez un nom pour le fichier VCD.
Exemple : AdventureWorksCommands.xml.
Cliquez sur le bouton Ajouter .
Dans Explorateur de solutions, sélectionnez le fichier VCD.
Dans la fenêtre Propriétés , définissez l’action Générer sur Contenu, puis définissez Copy sur le répertoire de sortie pour Copier si elle est plus récente.

Modifier le fichier VCD

Ajoutez un VoiceCommands élément avec un xmlns attribut pointant vers https://schemas.microsoft.com/voicecommands/1.2.
Pour chaque langue prise en charge par votre application, créez un CommandSet élément qui inclut les commandes vocales prises en charge par votre application.
Vous pouvez déclarer plusieurs CommandSet éléments, chacun avec un attribut différent xml:lang afin que votre application soit utilisée sur différents marchés. Par exemple, une application pour le États-Unis peut avoir un CommandSet anglais et un CommandSet pour l’espagnol.

Important

Pour activer une application et lancer une action à l’aide d’une commande vocale, l’application doit inscrire un fichier VCD qui inclut un élément avec une CommandSet langue qui correspond à la langue vocale indiquée dans l’appareil de l’utilisateur. La langue vocale se trouve dans La langue vocale du système > > de > paramètres.
Ajoutez un Command élément pour chaque commande que vous souhaitez prendre en charge.
Chaque Command déclaré dans un fichier VCD doit inclure ces informations :
- Attribut Name que votre application utilise pour identifier la commande vocale au moment de l’exécution.
- Élément Example qui inclut une expression décrivant comment un utilisateur appelle la commande. Cortana montre l’exemple lorsque l’utilisateur indique What can I say?, Helpou appuie sur Afficher plus.
- Élément ListenFor qui inclut les mots ou expressions que votre application reconnaît en tant que commande. Chaque ListenFor élément peut contenir des références à un ou plusieurs PhraseList éléments qui contiennent des mots spécifiques pertinents pour la commande.
  
  Remarque
  
  ListenFor les éléments ne doivent pas être modifiés par programmation. Toutefois, PhraseList les éléments associés aux ListenFor éléments peuvent être modifiés par programmation. Les applications doivent modifier le contenu de l’élément au moment de l’exécution PhraseList en fonction du jeu de données généré à mesure que l’utilisateur utilise l’application.
  
  Pour plus d’informations, consultez Modifier dynamiquement les listes d’expressions VCD Cortana.
- Élément Feedback qui inclut le texte de Cortana à afficher et à parler à mesure que l’application est lancée.

Un Navigate élément indique que la commande vocale active l’application au premier plan. Dans cet exemple, la showTripToDestination commande est une tâche de premier plan.

Un VoiceCommandService élément indique que la commande vocale active l’application en arrière-plan. La valeur de l’attribut Target de cet élément doit correspondre à la valeur de l’attribut Name de l’élément uap:AppService dans le fichier package.appxmanifest. Dans cet exemple, les commandes et cancelTripToDestination les whenIsTripToDestination commandes sont des tâches en arrière-plan qui spécifient le nom du service d’application en tant que AdventureWorksVoiceCommandService.

Pour plus d’informations, consultez les éléments et attributs VCD v1.2.

Exemple : partie du fichier VCD qui définit les en-us commandes vocales pour l’application Adventure Works.

<?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>

Installer les commandes VCD

Votre application doit s’exécuter une fois pour installer le VCD.

Remarque

Les données de commande vocale ne sont pas conservées dans les installations d’application. Pour vous assurer que les données de commande vocale pour votre application restent intactes, envisagez d’initialiser votre fichier VCD chaque fois que votre application est lancée ou activée, ou de conserver un paramètre qui indique si le VCD est actuellement installé.

Dans le fichier app.xaml.cs :

Ajoutez la directive using suivante :
```
using Windows.Storage;
```

Marquez la OnLaunched méthode avec le modificateur asynchrone.

protected async override void OnLaunched(LaunchActivatedEventArgs e)

Appelez la InstallCommandDefinitionsFromStorageFileAsync méthode dans le OnLaunched gestionnaire pour inscrire les commandes vocales qui doivent être reconnues.
Exemple : l’application Adventure Works définit un StorageFile objet.
Exemple : appelez la GetFileAsync méthode pour initialiser l’objet StorageFile avec le AdventureWorksCommands.xml fichier.
L’objet StorageFile est ensuite passé à la InstallCommandDefinitionsFromStorageFileAsync méthode.

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

Gérer l’activation

Spécifiez la façon dont votre application répond aux activations de commande vocale suivantes.

Remarque

Vous devez lancer votre application au moins une fois après l’installation des jeux de commandes vocales.

Vérifiez que votre application a été activée par une commande vocale.

Remplacez l’événement Application.OnActivated et vérifiez si IActivatedEventArgs.Kind is VoiceCommand.
Déterminez le nom de la commande et ce qui a été parlé.

Obtenez une référence à un VoiceCommandActivatedEventArgs objet à partir de l’IActivatedEventArgs et interrogez la Result propriété d’un SpeechRecognitionResult objet.

Pour déterminer ce que l’utilisateur a dit, vérifiez la valeur du texte ou les propriétés sémantiques de l’expression reconnue dans le SpeechRecognitionSemanticInterpretation dictionnaire.

Effectuez les actions appropriées dans votre application, telles que la navigation vers la page souhaitée.

Remarque

Si vous devez faire référence à votre VCD, consultez la section Modifier le fichier VCD.

Après avoir reçu le résultat de reconnaissance vocale pour la commande vocale, vous obtenez le nom de la commande à partir de la première valeur du RulePath tableau. Étant donné que le fichier VCD définit plusieurs commandes vocales possibles, vous devez vérifier que la valeur correspond aux noms de commandes dans le VCD et effectuer l’action appropriée.

L’action la plus courante pour une application consiste à accéder à une page avec du contenu pertinent pour le contexte de la commande vocale.
Exemple : ouvrez la page TripPage et transmettez la valeur de la commande vocale, la façon dont la commande a été entrée et l’expression de destination reconnue (le cas échéant). L’application peut également envoyer un paramètre de navigation à SpeechRecognitionResult lors de la navigation vers la page TripPage.

Vous pouvez déterminer si la commande vocale qui a lancé votre application a été réellement parlée ou si elle a été tapée en tant que texte, à partir du SpeechRecognitionSemanticInterpretation.Properties dictionnaire à l’aide de la clé commandMode . La valeur de cette clé sera soit voice .text Si la valeur de la clé est voice, envisagez d’utiliser la synthèse vocale (Windows.Media.SpeechSynthesis) dans votre application pour fournir à l’utilisateur des commentaires parlés.

Utilisez SpeechRecognitionSemanticInterpretation.Properties pour connaître le contenu parlé dans les contraintes ou PhraseTopic les PhraseList contraintes d’un ListenFor élément. La clé de dictionnaire est la valeur de l’attribut Label de l’élément ou PhraseTopic de l’élémentPhraseList. Exemple : code suivant pour comment accéder à la valeur de l’expression {destination} .

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

Gérer la commande vocale dans App Service

Traitez la commande vocale dans le service d’application.

Ajoutez les directives d’utilisation suivantes à votre fichier de service de commande vocale.
Exemple : AdventureWorksVoiceCommandService.cs.

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

Prenez un report de service afin que votre service d’application ne soit pas arrêté lors de la gestion de la commande vocale.
Vérifiez que votre tâche en arrière-plan s’exécute en tant que service d’application activé par une commande vocale.
1. Castez IBackgroundTaskInstance.TriggerDetails sur Windows.ApplicationModel.AppService.AppServiceTriggerDetails.
2. Vérifiez que IBackgroundTaskInstance.TriggerDetails.Name est le nom du service d’application dans le Package.appxmanifest fichier.
Utilisez IBackgroundTaskInstance.TriggerDetails pour créer une VoiceCommandServiceConnection à Cortana pour récupérer la commande vocale.
Inscrire un gestionnaire d’événements pour VoiceCommandServiceConnection. VoiceCommandCompleted pour recevoir une notification lorsque le service d’application est fermé en raison d’une annulation de l’utilisateur.
Inscrivez un gestionnaire d’événements pour iBackgroundTaskInstance.Canceled pour recevoir une notification lorsque le service d’application est fermé en raison d’un échec inattendu.
Déterminez le nom de la commande et ce qui a été parlé.
1. Utilisez VoiceCommand.Propriété CommandName pour déterminer le nom de la commande vocale.
2. Pour déterminer ce que l’utilisateur a dit, vérifiez la valeur du texte ou les propriétés sémantiques de l’expression reconnue dans le SpeechRecognitionSemanticInterpretation dictionnaire.
Effectuez l’action appropriée dans votre service d’application.

Affichez et parlez les commentaires à la commande vocale à l’aide de Cortana.

Déterminez les chaînes que Cortana doit afficher et parler à l’utilisateur en réponse à la commande vocale et créer un VoiceCommandResponse objet. Pour obtenir des conseils sur la façon de sélectionner les chaînes de commentaires que Cortana affiche et parle, consultez les instructions de conception cortana.
Utilisez l’instance VoiceCommandServiceConnection pour signaler la progression ou la saisie semi-automatique à Cortana en appelant ReportProgressAsync ou ReportSuccessAsync avec l’objet.VoiceCommandServiceConnection

Remarque

Si vous devez faire référence à votre VCD, consultez la section Modifier le fichier VCD.

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

Une fois activé, app service a 0,5 seconde pour appeler ReportSuccessAsync. Cortana affiche et indique une chaîne de commentaires.

Remarque

Vous pouvez déclarer une chaîne de commentaires dans le fichier VCD. La chaîne n’affecte pas le texte de l’interface utilisateur affiché sur le canevas Cortana, il affecte uniquement le texte prononcé par Cortana.

Si l’application prend plus de 0,5 seconde pour effectuer l’appel, Cortana insère un écran de remise, comme illustré ici. Cortana affiche l’écran de remise jusqu’à ce que l’application appelle ReportSuccessAsync, ou pendant jusqu’à 5 secondes. Si le service d’application n’appelle pas ReportSuccessAsync ou l’une des VoiceCommandServiceConnection méthodes qui fournissent Cortana avec des informations, l’utilisateur reçoit un message d’erreur et le service d’application est annulé.

Capture d’écran de Cortana et d’une requête de base avec des écrans de progression et de résultats à l’aide de l’application AdventureWorks en arrière-plan

Partager via

Activer une application en arrière-plan dans Cortana à l’aide de commandes vocales

Créer une solution avec un projet principal dans Visual Studio

Ajouter des ressources d’image au projet principal et les spécifier dans le manifeste de l’application

Créer un projet App Service

Créer un fichier VCD

Modifier le fichier VCD

Installer les commandes VCD

Gérer l’activation

Gérer la commande vocale dans App Service

Ressources supplémentaires

Partager via

Activer une application en arrière-plan dans Cortana à l’aide de commandes vocales

Créer une solution avec un projet principal dans Visual Studio

Ajouter des ressources d’image au projet principal et les spécifier dans le manifeste de l’application

Créer un projet App Service

Créer un fichier VCD

Modifier le fichier VCD

Installer les commandes VCD

Gérer l’activation

Gérer la commande vocale dans App Service

Articles connexes

Ressources supplémentaires