Compartilhar via

Criar e hospedar uma extensão de aplicativo

  • Artigo

Este artigo mostra como criar uma extensão de aplicativo do Windows 10 e hospedá-la em um aplicativo. As extensões de aplicativo têm suporte em aplicativos UWP e aplicativos da área de trabalho empacotados.

Para demonstrar como criar uma extensão de aplicativo, este artigo usa XML de manifesto de pacote e snippets de código do exemplo de código da Extensão Matemática. Este exemplo é um aplicativo UWP, mas os recursos demonstrados no exemplo também são aplicáveis a aplicativos da área de trabalho empacotados. Siga estas instruções para começar a usar o exemplo:

  • Baixe e descompacte o exemplo de código da Extensão Matemática.
  • No Visual Studio 2019, abra MathExtensionSample.sln. Defina o tipo de build como x86 (Build>Configuration Manager e, em seguida, altere Platform para x86 para ambos os projetos).
  • Implante a solução: Compilar>Implantar Solução.

Introdução às extensões de aplicativo

No Windows 10, as extensões de aplicativo fornecem funcionalidade semelhante ao que plug-ins, suplementos e complementos fazem em outras plataformas. Extensões de aplicativo foram apresentadas na Edição de Aniversário do Windows 10 (versão 1607, build 10.0.14393).

As extensões de aplicativo são aplicativos UWP ou aplicativos da área de trabalho empacotados que têm uma declaração de extensão que permite compartilhar conteúdo e eventos de implantação com um aplicativo host. Um aplicativo de extensão pode fornecer várias extensões.

Como as extensões de aplicativo são apenas aplicativos UWP ou aplicativos da área de trabalho empacotados, elas também podem ser aplicativos totalmente funcionais, hospedar extensões e fornecer extensões para outros aplicativos, tudo sem criar pacotes de aplicativos separados.

Ao criar um host de extensão de aplicativo, você cria uma oportunidade de desenvolver um ecossistema em torno de seu aplicativo no qual outros desenvolvedores podem aprimorá-lo de maneiras que você pode não esperar ou ter os recursos para as quais. Considere extensões do Microsoft Office, extensões do Visual Studio, extensões de navegador, etc. Eles criam experiências mais ricas para os aplicativos que vão além da funcionalidade que os acompanha. As extensões podem agregar valor e longevidade ao seu aplicativo.

Em um alto nível, para configurar uma relação de extensão de aplicativo, precisamos:

  1. Declare um aplicativo como um host de extensão.
  2. Declare um aplicativo como uma extensão.
  3. Decida se deseja implementar a extensão como um serviço de aplicativo, tarefa em segundo plano ou alguma outra forma.
  4. Defina como os hosts e suas extensões se comunicarão.
  5. Use a API Windows.ApplicationModel.AppExtensions no aplicativo host para acessar as extensões.

Vamos ver como isso é feito examinando o exemplo de código Math Extension, que implementa uma calculadora hipotética à qual você pode adicionar novas funções usando extensões. No Microsoft Visual Studio 2019, carregue MathExtensionSample.sln do exemplo de código.

Exemplo de código de extensão matemática

Declarar um aplicativo como um host de extensão

Um aplicativo se identifica como um host de extensão de aplicativo declarando o <AppExtensionHost> elemento em seu arquivo Package.appxmanifest. Consulte o arquivo Package.appxmanifest no projeto MathExtensionHost para ver como isso é feito.

Package.appxmanifest no projeto MathExtensionHost

<Package
  ...
  xmlns:uap3="http://schemas.microsoft.com/appx/manifest/uap/windows10/3"
  IgnorableNamespaces="uap uap3 mp">
  ...
    <Applications>
      <Application Id="App" ... >
        ...
        <Extensions>
            <uap3:Extension Category="windows.appExtensionHost">
                <uap3:AppExtensionHost>
                  <uap3:Name>com.microsoft.mathext</uap3:Name>
                </uap3:AppExtensionHost>
          </uap3:Extension>
        </Extensions>
      </Application>
    </Applications>
    ...
</Package>

Observe o xmlns:uap3="http://..." e a presença de uap3 em IgnorableNamespaces. Eles são necessários porque estamos usando o namespace uap3.

<uap3:Extension Category="windows.appExtensionHost"> identifica esse aplicativo como um host de extensão.

O elemento Name em <uap3:AppExtensionHost> é o nome do contrato de extensão. Quando uma extensão especificar o mesmo nome de contrato da extensão, o host poderá encontrá-la. Por convenção, recomendamos a criação do nome do contrato de extensão utilizando o nome do seu aplicativo ou editor para evitar possíveis colisões com outros nomes de contratos de extensão.

Você pode definir vários hosts e várias extensões no mesmo aplicativo. Neste exemplo, declaramos um host. A extensão está definida em outro aplicativo.

Declarar um aplicativo como uma extensão

Um aplicativo se identifica como uma extensão de aplicativo declarando o <uap3:AppExtension> elemento em seu arquivo Package.appxmanifest . Abra o arquivo Package.appxmanifest no projeto MathExtension para ver como isso é feito.

Package.appxmanifest no projeto MathExtension:

<Package
  ...
  xmlns:uap3="http://schemas.microsoft.com/appx/manifest/uap/windows10/3"
  IgnorableNamespaces="uap uap3 mp">
  ...
    <Applications>
      <Application Id="App" ... >
        ...
        <Extensions>
          ...
          <uap3:Extension Category="windows.appExtension">
            <uap3:AppExtension Name="com.microsoft.mathext"
                               Id="power"
                               DisplayName="x^y"
                               Description="Exponent"
                               PublicFolder="Public">
              <uap3:Properties>
                <Service>com.microsoft.powservice</Service>
              </uap3:Properties>
              </uap3:AppExtension>
          </uap3:Extension>
        </Extensions>
      </Application>
    </Applications>
    ...
</Package>

Novamente, observe a linha xmlns:uap3="http://..." e a presença de uap3 em IgnorableNamespaces. Eles são necessários porque estamos usando o uap3 namespace.

<uap3:Extension Category="windows.appExtension"> identifica esse aplicativo como uma extensão.

O significado dos atributos é o <uap3:AppExtension> seguinte:

Atributo Descrição Obrigatório
Nome Esse é o nome do contrato da extensão. Quando corresponder ao Nome declarado em um host, esse host poderá encontrar essa extensão. ✔️
ID Identifica essa extensão de forma exclusiva. Como podem existir várias extensões que usam o mesmo nome de contrato de extensão (imagine um aplicativo de pintura que dá suporte a várias extensões), você pode usar a ID para diferenciá-las. Os hosts de extensões de aplicativos podem utilizar a ID para inferir algo sobre o tipo de extensão. Por exemplo, você deve ter uma extensão projetada para desktop e outra para dispositivos móveis, sendo que a ID será o diferencial. Você também pode utilizar o elemento Propriedades, discutido abaixo, para isso. ✔️
DisplayName Pode ser utilizado do seu aplicativo host para identificar a extensão para o usuário. Ele pode ser consultado e pode utilizar o novo sistema de gerenciamento de recursos (ms-resource:TokenName) para localização. O conteúdo localizado é carregado do pacote de extensão do aplicativo, não do aplicativo host.
Descrição Pode ser utilizado do seu aplicativo host para descrever a extensão para o usuário. Ele pode ser consultado e pode utilizar o novo sistema de gerenciamento de recursos (ms-resource:TokenName) para localização. O conteúdo localizado é carregado do pacote de extensão do aplicativo, não do aplicativo host.
PublicFolder O nome de uma pasta, relativa à raiz do pacote, em que você pode compartilhar conteúdos com o host da extensão. Por convenção de nomenclatura, o nome é "Público", mas você pode utilizar qualquer nome que corresponda a uma pasta em sua extensão. ✔️

<uap3:Properties> é um elemento opcional que contém metadados personalizados que os hosts podem fazer a leitura em runtime. No código de exemplo, a extensão é implementada como um serviço de aplicativo, portanto, o host precisa de uma maneira de obter o nome desse serviço de aplicativo para que possa chamá-lo. O nome do serviço de aplicativo é definido no elemento <Serviço>, que definimos (poderíamos tê-lo chamado do que desejássemos). O host no código de exemplo procura essa propriedade em runtime para aprender o nome do serviço de aplicativo.

Decida como você implementará a extensão.

A sessão do Build 2016 sobre extensões de aplicativo demonstra como usar a pasta pública compartilhada entre o host e as extensões. Nesse exemplo, a extensão é implementada por um arquivo JavaScript armazenado na pasta pública, que o host invoca. Essa abordagem tem a vantagem de ser leve, não requer compilação e pode dar suporte à criação da página de aterrissagem padrão que fornece instruções para a extensão e um link para a página da Microsoft Store do aplicativo host. Consulte o exemplo de código de extensão de aplicativo do Build 2016 para obter detalhes. Especificamente, consulte o projeto InvertImageExtension e InvokeLoad() em ExtensionManager.cs no projeto ExtensibilitySample .

Neste exemplo, usaremos um serviço de aplicativo para implementar a extensão. Os serviços de aplicativo têm as seguintes vantagens:

  • Se a extensão falhar, ela não desativará o aplicativo host porque o aplicativo host é executado em seu próprio processo.
  • Você pode usar o idioma de sua escolha para implementar o serviço. Ele não precisa corresponder ao idioma usado para implementar o aplicativo host.
  • O serviço de aplicativo tem acesso ao seu próprio contêiner de aplicativo, que pode ter recursos diferentes dos do host.
  • Há isolamento entre os dados no serviço e o aplicativo host.

Código do serviço de aplicativo host

Aqui está o código do host que invoca o serviço de aplicativo da extensão:

ExtensionManager.cs no projeto MathExtensionHost

public async Task<double> Invoke(ValueSet message)
{
    if (Loaded)
    {
        try
        {
            // make the app service call
            using (var connection = new AppServiceConnection())
            {
                // service name is defined in appxmanifest properties
                connection.AppServiceName = _serviceName;
                // package Family Name is provided by the extension
                connection.PackageFamilyName = AppExtension.Package.Id.FamilyName;

                // open the app service connection
                AppServiceConnectionStatus status = await connection.OpenAsync();
                if (status != AppServiceConnectionStatus.Success)
                {
                    Debug.WriteLine("Failed App Service Connection");
                }
                else
                {
                    // Call the app service
                    AppServiceResponse response = await connection.SendMessageAsync(message);
                    if (response.Status == AppServiceResponseStatus.Success)
                    {
                        ValueSet answer = response.Message as ValueSet;
                        if (answer.ContainsKey("Result")) // When our app service returns "Result", it means it succeeded
                        {
                            return (double)answer["Result"];
                        }
                    }
                }
            }
        }
        catch (Exception)
        {
             Debug.WriteLine("Calling the App Service failed");
        }
    }
    return double.NaN; // indicates an error from the app service
}

Esse é o código típico para invocar um serviço de aplicativo. Para obter detalhes sobre como implementar e chamar um serviço de aplicativo, consulte Como criar e consumir um serviço de aplicativo.

Uma coisa a observar é como o nome do serviço de aplicativo a ser chamado é determinado. Como o host não tem informações sobre a implementação da extensão, a extensão precisa fornecer o nome de seu serviço de aplicativo. No exemplo de código, a extensão declara o nome do serviço de aplicativo em seu arquivo no <uap3:Properties> elemento:

Package.appxmanifest no projeto MathExtension

    ...
    <uap3:Extension Category="windows.appExtension">
      <uap3:AppExtension ...>
        <uap3:Properties>
          <Service>com.microsoft.powservice</Service>
        </uap3:Properties>
        </uap3:AppExtension>
    </uap3:Extension>

Você pode definir seu próprio XML no <uap3:Properties> elemento. Nesse caso, definimos o nome do serviço de aplicativo para que o host possa fazê-lo quando invocar a extensão.

Quando o host carrega uma extensão, um código como este extrai o nome do serviço das propriedades definidas no Package.appxmanifest da extensão:

Update() em ExtensionManager.cs, no projeto MathExtensionHost

...
var properties = await ext.GetExtensionPropertiesAsync() as PropertySet;

...
#region Update Properties
// update app service information
_serviceName = null;
if (_properties != null)
{
   if (_properties.ContainsKey("Service"))
   {
       PropertySet serviceProperty = _properties["Service"] as PropertySet;
       this._serviceName = serviceProperty["#text"].ToString();
   }
}
#endregion

Com o nome do serviço de aplicativo armazenado no _serviceName, o host pode usá-lo para invocar o serviço de aplicativo.

Chamar um serviço de aplicativo também requer o nome da família do pacote que contém o serviço de aplicativo. Felizmente, a API de extensão de aplicativo fornece essas informações que são obtidas na linha: connection.PackageFamilyName = AppExtension.Package.Id.FamilyName;

Defina como o host e a extensão se comunicarão

Os serviços de aplicativo usam um ValueSet para trocar informações. Como autor do host, você precisa criar um protocolo flexível para se comunicar com extensões. No exemplo de código, isso significa contabilizar extensões que podem levar 1, 2 ou mais argumentos no futuro.

Para este exemplo, o protocolo para os argumentos é um ValueSet que contém os pares de valores-chave chamados 'Arg' + o número do argumento, por exemplo, Arg1 e Arg2. O host passa todos os argumentos no ValueSet e a extensão usa os que ele precisa. Se a extensão for capaz de calcular um resultado, o host espera que o ValueSet retornado da extensão tenha uma chave chamada Result que contém o valor do cálculo. Se essa chave não estiver presente, o host presumirá que a extensão não pôde concluir o cálculo.

Código do serviço de aplicativo de extensão

No exemplo de código, o serviço de aplicativo da extensão não é implementado como uma tarefa em segundo plano. Em vez disso, ele usa o modelo de serviço de aplicativo de proc único no qual o serviço de aplicativo é executado no mesmo processo que o aplicativo de extensão que o hospeda. Esse ainda é um processo diferente do aplicativo host, fornecendo os benefícios da separação de processos, ao mesmo tempo em que obtém alguns benefícios de desempenho ao evitar a comunicação entre processos entre o processo de extensão e o processo em segundo plano que implementa o serviço de aplicativo. Consulte Converter um serviço de aplicativo para ser executado no mesmo processo que seu aplicativo host para ver a diferença entre um serviço de aplicativo executado como uma tarefa em segundo plano e no mesmo processo.

O sistema faz quando OnBackgroundActivate() o serviço de aplicativo é ativado. Esse código configura manipuladores de eventos para lidar com a chamada de serviço de aplicativo real quando ela vem (OnAppServiceRequestReceived()), bem como lidar com eventos de manutenção, como obter um objeto de adiamento que manipula um evento de cancelamento ou fechado.

App.xaml.cs no projeto MathExtension.

protected override void OnBackgroundActivated(BackgroundActivatedEventArgs args)
{
    base.OnBackgroundActivated(args);

    if ( _appServiceInitialized == false ) // Only need to setup the handlers once
    {
        _appServiceInitialized = true;

        IBackgroundTaskInstance taskInstance = args.TaskInstance;
        taskInstance.Canceled += OnAppServicesCanceled;

        AppServiceTriggerDetails appService = taskInstance.TriggerDetails as AppServiceTriggerDetails;
        _appServiceDeferral = taskInstance.GetDeferral();
        _appServiceConnection = appService.AppServiceConnection;
        _appServiceConnection.RequestReceived += OnAppServiceRequestReceived;
        _appServiceConnection.ServiceClosed += AppServiceConnection_ServiceClosed;
    }
}

O código que faz o trabalho da extensão está em OnAppServiceRequestReceived(). Essa função é chamada quando o serviço de aplicativo é invocado para executar um cálculo. Ele extrai os valores necessários do ValueSet. Se ele puder fazer o cálculo, ele colocará o resultado, sob uma chave chamada Result, no ValueSet que é retornado ao host. Lembre-se de que, de acordo com o protocolo definido para como esse host e suas extensões se comunicarão, a presença de uma chave Result indicará sucesso; caso contrário, falha.

App.xaml.cs no projeto MathExtension.

private async void OnAppServiceRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
    // Get a deferral because we use an awaitable API below (SendResponseAsync()) to respond to the message
    // and we don't want this call to get cancelled while we are waiting.
    AppServiceDeferral messageDeferral = args.GetDeferral();
    ValueSet message = args.Request.Message;
    ValueSet returnMessage = new ValueSet();

    double? arg1 = Convert.ToDouble(message["arg1"]);
    double? arg2 = Convert.ToDouble(message["arg2"]);
    if (arg1.HasValue && arg2.HasValue)
    {
        returnMessage.Add("Result", Math.Pow(arg1.Value, arg2.Value)); // For this sample, the presence of a "Result" key will mean the call succeeded
    }

    await args.Request.SendResponseAsync(returnMessage);
    messageDeferral.Complete();
}

Gerenciar extensões

Agora que vimos como implementar a relação entre um host e suas extensões, vamos ver como um host encontra extensões instaladas no sistema e reage à adição e remoção de pacotes contendo extensões.

A Microsoft Store fornece extensões como pacotes. O AppExtensionCatalog localiza pacotes instalados que contêm extensões que correspondem ao nome do contrato de extensão do host e fornece eventos que são acionados quando um pacote de extensão de aplicativo relevante para o host é instalado ou removido.

No exemplo de código, a ExtensionManager classe (definida em ExtensionManager.cs no projeto MathExtensionHost ) encapsula a lógica para carregar extensões e responder a instalações e desinstalações de pacotes de extensão.

O ExtensionManager construtor usa o AppExtensionCatalog para localizar as extensões de aplicativo no sistema que têm o mesmo nome de contrato de extensão que o host:

ExtensionManager.cs no projeto MathExtensionHost.

public ExtensionManager(string extensionContractName)
{
   // catalog & contract
   ExtensionContractName = extensionContractName;
   _catalog = AppExtensionCatalog.Open(ExtensionContractName);
   ...
}

Quando um pacote de extensão é instalado, o ExtensionManager coleta informações sobre as extensões no pacote que têm o mesmo nome de contrato de extensão que o host. Uma instalação pode representar uma atualização e, nesse caso, as informações da extensão afetada são atualizadas. Quando um pacote de extensão é desinstalado, o ExtensionManager remove informações sobre as extensões afetadas para que o usuário saiba quais extensões não estão mais disponíveis.

A Extension classe (definida em ExtensionManager.cs no projeto MathExtensionHost ) foi criada para que o exemplo de código acesse a ID, a descrição, o logotipo e as informações específicas do aplicativo de uma extensão, como se o usuário habilitou a extensão.

Dizer que a extensão está carregada (veja Load() em ExtensionManager.cs) significa que o status do pacote está bom e que obtivemos seu ID, logotipo, descrição e pasta pública (que não usamos neste exemplo - é apenas para mostrar como você o obtém). O pacote de extensão em si não está sendo carregado.

O conceito de descarga é usado para acompanhar quais ramais não devem mais ser apresentadas ao usuário.

O ExtensionManager fornece instâncias de coleção Extension para que as extensões, seus nomes, descrições e logotipos possam ser associados a dados à interface do usuário. A página ExtensionsTab é associada a essa coleção e fornece a interface do usuário para habilitar/desabilitar extensões, bem como removê-las.

Exemplo de interface do usuário da guia Extensões

Quando uma extensão é removida, o sistema solicita que o usuário verifique se deseja desinstalar o pacote que contém a extensão (e possivelmente contém outras extensões). Se o usuário concordar, o pacote será desinstalado e ExtensionManager removerá as extensões no pacote desinstalado da lista de extensões disponíveis para o aplicativo host.

Desinstalar interface do usuário

Depurando extensões e hosts de aplicativos

Muitas vezes, o host da extensão e a extensão não fazem parte da mesma solução. Nesse caso, para depurar o host e a extensão:

  1. Carregue seu projeto host em uma instância do Visual Studio.
  2. Carregue sua extensão em outra instância do Visual Studio.
  3. Inicie seu aplicativo host no depurador.
  4. Inicie o aplicativo de extensão no depurador. (Se você quiser implantar a extensão, em vez de depurá-la, para testar o evento de instalação do pacote do host, faça Compilar > Solução de Implantação, em vez disso).

Agora você poderá atingir pontos de interrupção no host e na extensão. Se você começar a depurar o próprio aplicativo de extensão, verá uma janela em branco para o aplicativo. Se você não quiser ver a janela em branco, poderá alterar as configurações de depuração do projeto de extensão para não iniciar o aplicativo, mas depurá-lo quando ele for iniciado (clique com o botão direito do mouse no projeto de extensão, Depurar> Propriedades>selecione Não iniciar, mas depurar meu código quando ele for iniciado) Você ainda precisará iniciar a depuração (F5) do projeto de extensão, mas ele aguardará até que o host ative a extensão e, em seguida, seus pontos de interrupção na extensão serão atingidos.

Depurar o exemplo de código

No exemplo de código, o host e a extensão estão na mesma solução. Faça o seguinte para depurar:

  1. Certifique-se de que MathExtensionHost seja o projeto de inicialização (clique com o botão direito do mouse no projeto MathExtensionHost , clique em Definir como projeto de inicialização).
  2. Coloque um ponto de interrupção em Invoke ExtensionManager.cs, no projeto MathExtensionHost .
  3. F5 para executar o projeto MathExtensionHost .
  4. Coloque um ponto de interrupção em OnAppServiceRequestReceived App.xaml.cs no projeto MathExtension .
  5. Inicie a depuração do projeto MathExtension (clique com o botão direito do mouse no projeto MathExtension , Depurar > Iniciar nova instância) que o implantará e disparará o evento de instalação do pacote no host.
  6. No aplicativo MathExtensionHost, navegue até a página Cálculo e clique em x^y para ativar a extensão. O Invoke() ponto de interrupção é atingido primeiro e você pode ver a chamada do serviço de aplicativo de extensões sendo feita. Em seguida, o OnAppServiceRequestReceived() método na extensão é atingido e você pode ver o serviço de aplicativo calcular o resultado e retorná-lo.

Solução de problemas de extensões implementadas como um serviço de aplicativo

Se o host da extensão tiver problemas para se conectar ao serviço de aplicativo da extensão, verifique se o <uap:AppService Name="..."> atributo corresponde ao que você colocou no <Service> elemento. Se eles não corresponderem, o nome do serviço que sua extensão fornece ao host não corresponderá ao nome do serviço de aplicativo que você implementou e o host não poderá ativar sua extensão.

Package.appxmanifest no projeto MathExtension:

<Extensions>
   <uap:Extension Category="windows.appService">
     <uap:AppService Name="com.microsoft.sqrtservice" />      <!-- This must match the contents of <Service>...</Service> -->
   </uap:Extension>
   <uap3:Extension Category="windows.appExtension">
     <uap3:AppExtension Name="com.microsoft.mathext" Id="sqrt" DisplayName="Sqrt(x)" Description="Square root" PublicFolder="Public">
       <uap3:Properties>
         <Service>com.microsoft.powservice</Service>   <!-- this must match <uap:AppService Name=...> -->
       </uap3:Properties>
     </uap3:AppExtension>
   </uap3:Extension>
</Extensions>

Uma lista de verificação de cenários básicos para testar

Quando você cria um host de extensão e está pronto para testar o quão bem ele dá suporte a extensões, aqui estão alguns cenários básicos para tentar:

  • Execute o host e implante um aplicativo de extensão
    • O host pega novas extensões que aparecem enquanto está em execução?
  • Implante o aplicativo de extensão e, em seguida, implante e execute o host.
    • O host pega ramais existentes anteriormente?
  • Execute o host e remova o aplicativo de extensão.
    • O host detecta a remoção corretamente?
  • Execute o host e atualize o aplicativo de extensão para uma versão mais recente.
    • O host pega a alteração e descarrega as versões antigas da extensão corretamente?

Cenários avançados para testar:

  • Execute o host, mova o aplicativo de extensão para mídia removível, remova a mídia
    • O host detecta a alteração no status do pacote e desabilita a extensão?
  • Execute o host e corrompa o aplicativo de extensão (torne-o inválido, assinado de forma diferente etc.)
    • O host detecta a extensão adulterada e a manipula corretamente?
  • Execute o host e implante um aplicativo de extensão que tenha conteúdo ou propriedades inválidas
    • O host detecta conteúdo inválido e o manipula corretamente?

Considerações sobre o design

  • Forneça a interface do usuário que mostre ao usuário quais extensões estão disponíveis e permita que ele as habilite/desabilite. Você também pode considerar adicionar glifos para extensões que ficam indisponíveis porque um pacote fica offline, etc.
  • Direcione o usuário para onde ele pode obter extensões. Talvez sua página de extensão possa fornecer uma consulta de pesquisa da Microsoft Store que exibe uma lista de extensões que podem ser usadas com seu aplicativo.
  • Considere como notificar o usuário sobre a adição e remoção de extensões. Você pode criar uma notificação para quando uma nova extensão for instalada e convidar o usuário para habilitá-la. As extensões devem ser desabilitadas por padrão para que os usuários estejam no controle.

Como as extensões de aplicativo diferem dos pacotes opcionais

O principal diferencial entre pacotes opcionais e extensões de aplicativo é o ecossistema aberto versus o ecossistema fechado e o pacote dependente versus o pacote independente.

As extensões de aplicativo participam de um ecossistema aberto. Se seu aplicativo puder hospedar extensões de aplicativo, qualquer pessoa poderá escrever uma extensão para seu host, desde que esteja em conformidade com seu método de passar/receber informações da extensão. Isso difere dos pacotes opcionais que participam de um ecossistema fechado em que o editor decide quem tem permissão para criar um pacote opcional que pode ser usado com o aplicativo.

As extensões de aplicativo são pacotes independentes e podem ser aplicativos autônomos. Eles não podem ter uma dependência de implantação em outro aplicativo. Os pacotes opcionais precisam do pacote principal e não podem funcionar sem ele.

Um pacote de expansão para um jogo seria um bom candidato para um pacote opcional porque está fortemente vinculado ao jogo, não pode ser executado independentemente do jogo e você pode não querer que os pacotes de expansão sejam criados por qualquer desenvolvedor no ecossistema.

Se esse mesmo jogo tivesse complementos ou temas de interface do usuário personalizáveis, uma extensão de aplicativo poderia ser uma boa escolha porque o aplicativo que fornece a extensão poderia ser executado por conta própria e qualquer terceiro poderia fazê-los.

Comentários

Este tópico fornece uma introdução às extensões de aplicativo. As principais coisas a serem observadas são a criação do host e marcá-lo como tal em seu arquivo Package.appxmanifest, criar a extensão e marcá-la como tal em seu arquivo Package.appxmanifest, determinar como implementar a extensão (como um serviço de aplicativo, tarefa em segundo plano ou outros meios), definir como o host se comunicará com extensões, e usar a API AppExtensions para acessar e gerenciar extensões.