Compartilhar via

Ativar um aplicativo em segundo plano na Cortana usando comandos de voz

  • Artigo

Aviso

Não há mais suporte para este recurso a partir da atualização de maio de 2020 do Windows 10 (versão 2004, codinome "20H1").

Além de usar comandos de voz na Cortana para acessar os recursos do sistema, você também pode estender a Cortana com recursos e funcionalidades do seu aplicativo (como uma tarefa em segundo plano) usando comandos de voz que especificam uma ação ou comando a ser executado. Quando um aplicativo manipula um comando de voz em segundo plano, ele não recebe foco. Em vez disso, ele retorna todos os comentários e resultados por meio da tela da Cortana e da voz da Cortana .

Observação

APIs importantes

Os aplicativos podem ser ativados em primeiro plano (o aplicativo recebe o foco) ou ativados em segundo plano (a Cortana mantém o foco), dependendo da complexidade da interação. Por exemplo, comandos de voz que exigem contexto adicional ou entrada do usuário (como enviar uma mensagem para um contato específico) são melhor tratados em um aplicativo em primeiro plano, enquanto comandos básicos (como listar as próximas viagens) podem ser tratados na Cortana por meio de um aplicativo em segundo plano.

Se você quiser ativar um aplicativo em primeiro plano usando comandos de voz, consulte Ativar um aplicativo em primeiro plano com comandos de voz por meio da Cortana.

Observação

Um comando de voz é um único enunciado com uma intenção específica, definido em um arquivo VCD (Definição de Comando de Voz), direcionado a um aplicativo instalado por meio da Cortana.

Um arquivo VCD define um ou mais comandos de voz, cada um com uma intenção exclusiva.

As definições de comando de voz podem variar em complexidade. Eles podem dar suporte a qualquer coisa, desde um único enunciado restrito até uma coleção de enunciados de linguagem natural mais flexíveis, todos denotando a mesma intenção.

Usamos um aplicativo de planejamento e gerenciamento de viagens chamado Adventure Works integrado à interface do usuário da Cortana , mostrada aqui, para demonstrar muitos dos conceitos e recursos que discutimos. Para obter mais informações, consulte o exemplo de comando de voz da Cortana.

Captura de tela da Cortana iniciando o aplicativo em primeiro plano

Para exibir uma viagem da Adventure Works sem a Cortana, um usuário iniciaria o aplicativo e navegaria até a página Próximas viagens .

Usando comandos de voz por meio da Cortana para iniciar seu aplicativo em segundo plano, o usuário pode apenas dizer: Adventure Works, when is my trip to Las Vegas?. Seu aplicativo manipula o comando e a Cortana exibe os resultados junto com o ícone do aplicativo e outras informações do aplicativo, se fornecidas.

Captura de tela da Cortana com uma consulta básica e tela de resultados usando o aplicativo AdventureWorks em segundo plano

As etapas básicas a seguir adicionam a funcionalidade de comando de voz e estendem a Cortana com a funcionalidade em segundo plano do seu aplicativo usando entrada de fala ou teclado.

  1. Crie um serviço de aplicativo (consulte Windows.ApplicationModel.AppService) que a Cortana invoca em segundo plano.
  2. Crie um arquivo VCD. O arquivo VCD é um documento XML que define todos os comandos falados que o usuário pode dizer para iniciar ações ou invocar comandos ao ativar seu aplicativo. Consulte Elementos e atributos VCD v1.2.
  3. Registre os conjuntos de comandos no arquivo VCD quando o aplicativo for iniciado.
  4. Manipule a ativação em segundo plano do serviço de aplicativo e a execução do comando de voz.
  5. Exiba e fale os comentários apropriados para o comando de voz na Cortana.

Dica

Pré-requisitos

Se você não estiver familiarizado com o desenvolvimento de aplicativos UWP (Plataforma Universal do Windows), dê uma olhada nestes tópicos para se familiarizar com as tecnologias discutidas aqui.

Diretrizes de experiência do usuário

Consulte as diretrizes de design da Cortana para obter informações sobre como integrar seu aplicativo à Cortana e às interações de fala para obter dicas úteis sobre como criar um aplicativo habilitado para fala útil e envolvente.

Criar uma nova solução com um projeto primário no Visual Studio

  1. Inicie o Microsoft Visual Studio 2015.
    A página inicial do Visual Studio 2015 é exibida.

  2. No menu Arquivo, selecione Novo>Projeto.
    A caixa de diálogo Novo Projeto será exibida. O painel esquerdo da caixa de diálogo permite selecionar o tipo de modelos a serem exibidos.

  3. No painel esquerdo, expanda Modelos Instalados > > do Visual C# > Windows e escolha o grupo de modelos Universal . O painel central da caixa de diálogo exibe uma lista de modelos de projeto para aplicativos da Plataforma Universal do Windows (UWP).

  4. No painel central, selecione o modelo Aplicativo em Branco (Universal do Windows).
    O modelo de aplicativo em branco cria um aplicativo UWP mínimo que é compilado e executado. O modelo de aplicativo em branco não inclui controles ou dados de interface do usuário. Você adiciona controles ao aplicativo usando esta página como guia.

  5. Na caixa de texto Nome, digite o nome do projeto. Exemplo: use AdventureWorks.

  6. Clique no botão OK para criar o projeto.
    O Microsoft Visual Studio cria seu projeto e o exibe no Gerenciador de Soluções.

Adicionar ativos de imagem ao projeto principal e especificá-los no manifesto do aplicativo

Os aplicativos UWP devem selecionar automaticamente as imagens mais apropriadas. A seleção é baseada em configurações específicas e recursos do dispositivo (alto contraste, pixels efetivos, localidade e assim por diante). Você deve fornecer as imagens e garantir que use a convenção de nomenclatura e a organização de pastas apropriadas em seu projeto de aplicativo para as diferentes versões de recursos.
Se você não fornecer as versões de recursos recomendadas, a experiência do usuário poderá ser prejudicada das seguintes maneiras.

  • Acessibilidade
  • Localização
  • Qualidade de imagem
    As versões de recursos são usadas para adaptar as seguintes alterações na experiência do usuário.
  • Preferências do usuário
  • Habilidades
  • Tipo de dispositivo
  • Localidade

Para obter mais detalhes sobre recursos de imagem para fatores de alto contraste e escala, visite a página Diretrizes para ativos de bloco e ícone localizada em msdn.microsoft.com/windows/uwp/controls-and-patterns/tiles-and-notifications-app-assets.

Você deve nomear recursos usando qualificadores. Os qualificadores de recursos são modificadores de pasta e nome de arquivo que identificam o contexto no qual uma versão específica de um recurso deve ser usada.

A convenção de nomenclatura padrão é foldername/qualifiername-value[_qualifiername-value]/filename.qualifiername-value[_qualifiername-value].ext.
Exemplo: images/logo.scale-100_contrast-white.png, que pode se referir ao código usando apenas a pasta raiz e o nome do arquivo: images/logo.png.
Para obter mais informações, visite a página Como nomear recursos usando qualificadores localizada em msdn.microsoft.com/library/windows/apps/xaml/hh965324.aspx.

A Microsoft recomenda que você marque o idioma padrão em arquivos de recurso de cadeia de caracteres (como en-US\resources.resw) e o fator de escala padrão em imagens (como logo.scale-100.png), mesmo que você não planeje fornecer recursos de resolução localizados ou múltiplos. No entanto, no mínimo, a Microsoft recomenda que você forneça ativos para fatores de escala de 100, 200 e 400.

Importante

O ícone do aplicativo usado na área de título da tela da Cortana é o ícone Square44x44Logo especificado no Package.appxmanifest arquivo.
Você também pode especificar um ícone para cada entrada na área de conteúdo da tela da Cortana . Os tamanhos de imagem válidos para os ícones de resultados são:

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

O bloco de conteúdo não é validado até que um objeto VoiceCommandResponse seja passado para a classe VoiceCommandServiceConnection. Se você passar um objeto VoiceCommandResponse para a Cortana que inclui um bloco de conteúdo com uma imagem que não adere a essas taxas de tamanho, poderá ocorrer uma exceção. 

Exemplo: o aplicativo Adventure Works (VoiceCommandService\\AdventureWorksVoiceCommandService.cs) especifica um quadrado cinza simples (GreyTile.png) na classe VoiceCommandContentTile usando o modelo de bloco TitleWith68x68IconAndText. As variantes de logotipo estão localizadas em VoiceCommandService\\Imagese são recuperadas usando o método GetFileFromApplicationUriAsync .

var destinationTile = new VoiceCommandContentTile();  

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

Criar um projeto do Serviço de Aplicativo

  1. Clique com o botão direito do mouse no nome da solução e selecione Novo > projeto.

  2. Em Modelos Instalados > > Visual C# > Windows > Universal, selecione Componente do Tempo de Execução do Windows. O Componente do Tempo de Execução do Windows é o componente que implementa o serviço de aplicativo (Windows.ApplicationModel.AppService).

  3. Digite um nome para o projeto e clique no botão OK .
    Exemplo: VoiceCommandService.

  4. No Gerenciador de Soluções, selecione o VoiceCommandService projeto e renomeie o Class1.cs arquivo gerado pelo Visual Studio. Exemplo: A Adventure Works usa AdventureWorksVoiceCommandService.cs.

  5. Clique no botão Sim ; quando perguntado se você deseja renomear todas as ocorrências de Class1.cs.

  6. No arquivo AdventureWorksVoiceCommandService.cs:

    1. Adicione a seguinte diretiva using.
      using Windows.ApplicationModel.Background;
    2. Quando você cria um novo projeto, o nome do projeto é usado como o namespace raiz padrão em todos os arquivos. Renomeie o namespace para aninhar o código do serviço de aplicativo no projeto primário. Exemplo: namespace AdventureWorks.VoiceCommands.
    3. Clique com o botão direito do mouse no nome do projeto do serviço de aplicativo no Gerenciador de Soluções e selecione Propriedades.
    4. Na guia Biblioteca, atualize o campo Namespace padrão com esse mesmo valor.
      Exemplo: AdventureWorks.VoiceCommands.
    5. Crie uma nova classe que implemente a interface IBackgroundTask . Essa classe requer um método Run , que é o ponto de entrada quando a Cortana reconhece o comando de voz.

    Exemplo: uma classe de tarefa básica em segundo plano do aplicativo Adventure Works .

    Observação

    A própria classe de tarefa em segundo plano, bem como todas as classes no projeto de tarefa em segundo plano, devem ser classes públicas seladas.

    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. Declare sua tarefa em segundo plano como um AppService no manifesto do aplicativo.

    1. No Gerenciador de Soluções, clique com o botão direito do Package.appxmanifest mouse no arquivo e selecione Exibir Código.
    2. Localize o elemento Application.
    3. Adicione um Extensions elemento ao Application elemento.
    4. Adicione um elemento uap:Extension ao elemento Extensions.
    5. Adicione um Category atributo ao uap:Extension elemento e defina o valor do Category atributo como windows.appService.
    6. Adicione um EntryPoint atributo ao uap: Extension elemento e defina o valor do EntryPoint atributo como o nome da classe que implementa IBackgroundTask.
      Exemplo: AdventureWorks.VoiceCommands.AdventureWorksVoiceCommandService.
    7. Adicione um elemento uap:AppService ao elemento uap:Extension.
    8. Adicione um Name atributo ao uap:AppService elemento e defina o valor do Name atributo como um nome para o serviço de aplicativo, nesse caso AdventureWorksVoiceCommandService.
    9. Adicione um segundo uap:Extension elemento ao Extensions elemento.
    10. Adicione um Category atributo a esse uap:Extension elemento e defina o valor do Category atributo como windows.personalAssistantLaunch.

    Exemplo: um manifesto do aplicativo 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>

  8. Adicione esse projeto do serviço de aplicativo como uma referência no projeto primário.

    1. Clique com o botão direito do mouse nas Referências.
    2. Selecione Adicionar referência....
    3. Na caixa de diálogo Gerenciador de Referências, expanda Projetos e selecione o projeto do serviço de aplicativo.
    4. Clique no botão OK .

Criar um arquivo VCD

  1. No Visual Studio, clique com o botão direito do mouse no nome do projeto principal e selecione Adicionar > Novo Item. Adicione um arquivo XML.
  2. Digite um nome para o arquivo VCD.
    Exemplo: AdventureWorksCommands.xml.
  3. Clique no botão Adicionar .
  4. No Gerenciador de Soluções, selecione o arquivo VCD .
  5. Na janela Propriedades, defina Ação de compilação como Conteúdo e, em seguida, defina Copiar para o diretório de saída como Copiar se for mais recente.

Edite o arquivo VCD

  1. Adicione um VoiceCommands elemento com um xmlns atributo apontando para https://schemas.microsoft.com/voicecommands/1.2.

  2. Para cada idioma compatível com seu aplicativo, crie um CommandSet elemento que inclua os comandos de voz compatíveis com seu aplicativo.
    Você pode declarar vários CommandSet elementos, cada um com um atributo diferente xml:lang , para que seu aplicativo seja usado em diferentes mercados. Por exemplo, um aplicativo para os Estados Unidos pode ter um CommandSet para inglês e um CommandSet para espanhol.

    Importante

    Para ativar um aplicativo e iniciar uma ação usando um comando de voz, o aplicativo deve registrar um arquivo VCD que inclua um CommandSet elemento com um idioma que corresponda ao idioma de fala indicado no dispositivo do usuário. O idioma da fala está localizado em Configurações > Sistema > de Fala > Idioma da Fala.

  3. Adicione um Command elemento para cada comando que você deseja suportar.
    Cada Command um declarado em um arquivo VCD deve incluir estas informações:

    • Um Name atributo que seu aplicativo usa para identificar o comando de voz em runtime.

    • Um Example elemento que inclui uma frase que descreve como um usuário invoca o comando. A Cortana mostra o exemplo quando o usuário diz What can I say?, Help, ou toca em Ver mais.

    • Um ListenFor elemento que inclui as palavras ou frases que seu aplicativo reconhece como um comando. Cada ListenFor elemento pode conter referências a um ou mais PhraseList elementos que contêm palavras específicas relevantes para o comando.

      Observação

      ListenFor Os elementos não devem ser modificados programaticamente. No entanto, PhraseList os elementos associados aos ListenFor elementos podem ser modificados programaticamente. Os aplicativos devem modificar o PhraseList conteúdo do elemento em tempo de execução com base no conjunto de dados gerado à medida que o usuário usa o aplicativo.

      Para obter mais informações, consulte Modificar dinamicamente as listas de frases VCD da Cortana.

    • Um Feedback elemento que inclui o texto para a Cortana exibir e falar quando o aplicativo é iniciado.

Um Navigate elemento indica que o comando de voz ativa o aplicativo em primeiro plano. Neste exemplo, o showTripToDestination comando é uma tarefa em primeiro plano.

Um VoiceCommandService elemento indica que o comando de voz ativa o aplicativo em segundo plano. O valor do Target atributo desse elemento deve corresponder ao valor do Name atributo do uap:AppService elemento no arquivo package.appxmanifest. Neste exemplo, os whenIsTripToDestination comandos e cancelTripToDestination são tarefas em segundo plano que especificam o nome do serviço de aplicativo como AdventureWorksVoiceCommandService.

Para obter mais detalhes, consulte a referência de elementos e atributos VCD v1.2.

Exemplo: uma parte do arquivo VCD que define os en-us comandos de voz para o aplicativo 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>

Instale os comandos VCD

Seu aplicativo deve ser executado uma vez para instalar o VCD.

Observação

Os dados de comando de voz não são preservados nas instalações do aplicativo. Para garantir que os dados de comando de voz do seu aplicativo permaneçam intactos, considere inicializar o arquivo VCD sempre que o aplicativo for iniciado ou ativado ou mantenha uma configuração que indique se o VCD está instalado no momento.

No arquivo app.xaml.cs:

  1. Adicione a seguinte diretiva using:

    using Windows.Storage;

  2. Marque o método com o modificador assíncrono OnLaunched .

    protected async override void OnLaunched(LaunchActivatedEventArgs e)

  3. Chame o InstallCommandDefinitionsFromStorageFileAsync método no OnLaunched manipulador para registrar os comandos de voz que devem ser reconhecidos.
    Exemplo: o aplicativo Adventure Works define um StorageFile objeto.
    Exemplo: Chame o GetFileAsync método para inicializar o StorageFile objeto com o AdventureWorksCommands.xml arquivo.
    O StorageFile objeto é então passado para o InstallCommandDefinitionsFromStorageFileAsync método.

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

Ativação do identificador

Especifique como seu aplicativo responde às ativações de comando de voz subsequentes.

Observação

Você deve iniciar seu aplicativo pelo menos uma vez após a instalação dos conjuntos de comandos de voz.

  1. Confirme se seu aplicativo foi ativado por um comando de voz.

    Substitua o Application.OnActivated evento e verifique se IActivatedEventArgs.Kind é o VoiceCommand.

  2. Determine o nome do comando e o que foi falado.

    Obtenha uma referência a um VoiceCommandActivatedEventArgs objeto do IActivatedEventArgs e consulte a Result propriedade de um SpeechRecognitionResult objeto.

    Para determinar o que o usuário disse, verifique o valor de Text ou as propriedades semânticas da frase reconhecida no SpeechRecognitionSemanticInterpretation dicionário.

  3. Execute a ação apropriada em seu aplicativo, como navegar até a página desejada.

    Observação

    Se você precisar consultar seu VCD, visite a seção Editar o arquivo VCD.

    Depois de receber o resultado do reconhecimento de fala para o comando de voz, você obtém o nome do comando do primeiro valor na RulePath matriz. Como o arquivo VCD define mais de um comando de voz possível, você deve verificar se o valor corresponde aos nomes dos comandos no VCD e executar a ação apropriada.

    A ação mais comum para um aplicativo é navegar até uma página com conteúdo relevante para o contexto do comando de voz.
    Exemplo: abra a página TripPage e transmita o valor do comando de voz, como o comando foi inserido e a frase de destino reconhecida (se aplicável). Como alternativa, o aplicativo pode enviar um parâmetro de navegação para o SpeechRecognitionResult ao navegar até a página TripPage .

    Você pode descobrir se o comando de voz que iniciou seu aplicativo foi realmente falado ou se foi digitado como texto, no SpeechRecognitionSemanticInterpretation.Properties dicionário usando a tecla commandMode . O valor dessa chave será ou voice text. Se o valor da chave for voice, considere usar a síntese de fala (Windows.Media.SpeechSynthesis) em seu aplicativo para fornecer ao usuário comentários falados.

    Use o SpeechRecognitionSemanticInterpretation.Properties para descobrir o conteúdo falado nas PhraseList restrições or PhraseTopic de um ListenFor elemento. A chave do dicionário é o valor do Label atributo do PhraseList elemento or PhraseTopic . Exemplo: o código a seguir para Como acessar o valor da frase {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();
}

Manipular o comando de voz no Serviço de Aplicativo

Processe o comando de voz no serviço de aplicativo.

  1. Adicione as seguintes diretivas using ao arquivo de serviço de comando de voz.
    Exemplo: AdventureWorksVoiceCommandService.cs.

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

  2. Faça um adiamento de serviço para que o serviço de aplicativo não seja encerrado durante o tratamento do comando de voz.

  3. Confirme se sua tarefa em segundo plano está sendo executada como um serviço de aplicativo ativado por um comando de voz.

    1. Converta o IBackgroundTaskInstance.TriggerDetails em Windows.ApplicationModel.AppService.AppServiceTriggerDetails.
    2. Verifique se IBackgroundTaskInstance.TriggerDetails.Name é o nome do serviço de aplicativo no Package.appxmanifest arquivo.

  4. Use IBackgroundTaskInstance.TriggerDetails para criar um VoiceCommandServiceConnection com a Cortana para recuperar o comando de voz.

  5. Registre um manipulador de eventos para VoiceCommandServiceConnection. VoiceCommandCompleted para receber notificação quando o serviço de aplicativo for fechado devido a um cancelamento do usuário.

  6. Registre um manipulador de eventos para o IBackgroundTaskInstance.Canceled para receber notificação quando o serviço de aplicativo for fechado devido a uma falha inesperada.

  7. Determine o nome do comando e o que foi falado.

    1. Use o VoiceCommand.CommandName para determinar o nome do comando de voz.
    2. Para determinar o que o usuário disse, verifique o valor de Text ou as propriedades semânticas da frase reconhecida no SpeechRecognitionSemanticInterpretation dicionário.

  8. Execute a ação apropriada em seu serviço de aplicativo.

  9. Exiba e fale os comentários para o comando de voz usando a Cortana.

    1. Determine as cadeias de caracteres que você deseja que a Cortana exiba e fale com o usuário em resposta ao comando de voz e crie um VoiceCommandResponse objeto. Para obter diretrizes sobre como selecionar as cadeias de caracteres de comentários que a Cortana mostra e fala, consulte Diretrizes de design da Cortana.
    2. Use a instância VoiceCommandServiceConnection para relatar o progresso ou a conclusão para a Cortana chamando ReportProgressAsync ou ReportSuccessAsync com o VoiceCommandServiceConnection objeto.

    Observação

    Se você precisar consultar seu VCD, visite a seção Editar o arquivo 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);
    }
}

Depois de ativado, o serviço de aplicativo tem 0,5 segundo para chamar ReportSuccessAsync. A Cortana mostra e diz uma cadeia de caracteres de comentários.

Observação

Você pode declarar uma string de feedback no arquivo VCD. A cadeia de caracteres não afeta o texto da interface do usuário exibido na tela da Cortana, afeta apenas o texto falado pela Cortana.

Se o aplicativo demorar mais de 0,5 segundo para fazer a chamada, a Cortana inserirá uma tela de entrega, conforme mostrado aqui. A Cortana exibe a tela de entrega até que o aplicativo chame ReportSuccessAsync ou por até 5 segundos. Se o serviço de aplicativo não chamar ReportSuccessAsync ou qualquer um dos métodos que fornecem informações à VoiceCommandServiceConnection Cortana, o usuário receberá uma mensagem de erro e o serviço de aplicativo será cancelado.

Captura de tela da Cortana e uma consulta básica com telas de progresso e resultado usando o aplicativo AdventureWorks em segundo plano