Partilhar via

Implementar um provedor de feed em um aplicativo win32 (C++/WinRT)

Observação

Algumas informações estão relacionadas ao produto pré-lançado, que pode ser substancialmente modificado antes de ser lançado comercialmente. A Microsoft não oferece garantias, expressas ou implícitas, em relação às informações fornecidas aqui.

Este artigo orienta você na criação de um provedor de feed simples que registra um URI de conteúdo de feed e implementa a interface IFeedProvider . Os métodos dessa interface são invocados pelo Widgets Board para solicitar parâmetros de cadeia de caracteres de consulta personalizados, normalmente para oferecer suporte a cenários de autenticação. Os fornecedores de feeds podem suportar um único feed ou vários feeds.

Para implementar um provedor de feed usando C++/WinRT, consulte Implementar um provedor de feed em um aplicativo C# do Windows (C++/WinRT).

Pré-requisitos

  • Seu dispositivo deve ter o modo de desenvolvedor ativado. Para obter mais informações, consulte Configurações para desenvolvedores.
  • Visual Studio 2026 ou posterior com a carga de trabalho de desenvolvimento de aplicações WinUI . Certifique-se de adicionar o componente para C++ (v143) na lista suspensa opcional.

Criar um novo aplicativo de console C++/WinRT win32

No Visual Studio, crie um novo projeto. Na caixa de diálogo Criar um novo projeto, defina o filtro de idioma como "C++" e o filtro de plataforma como Windows, depois selecione o modelo de projeto Aplicação de Consola do Windows (C++/WinRT). Nomeie o novo projeto como "ExampleFeedProvider". Para este passo a passo, verifique se a opção Colocar solução e projeto no mesmo diretório está desmarcada. Quando solicitado, defina a versão de destino do Windows para o aplicativo como 10.022631.2787 ou posterior.

Adicionar referências aos pacotes NuGet do SDK de Aplicativos Windows e Biblioteca de Implementação do Windows

Este exemplo usa o pacote NuGet estável mais recente do SDK de Aplicativo Windows. No Explorador de Soluções, clique com o botão direito do rato em Referências e selecione Gerir pacotes NuGet.... No gestor de pacotes NuGet, selecione o separador Procurar e procure por "Microsoft.WindowsAppSDK". Selecione a versão estável mais recente no menu suspenso Versão e clique em Instalar.

Este exemplo também usa o pacote NuGet da Biblioteca de Implementação do Windows. No Explorador de Soluções, clique direito em Referências e selecione Gerir pacotes NuGet.... No gerenciador de pacotes NuGet, selecione a guia Procurar e pesquise por "Microsoft.Windows.ImplementationLibrary". Selecione a versão mais recente na lista suspensa Versão e clique em Instalar.

No arquivo de cabeçalho pré-compilado, pch.h, adicione as seguintes diretivas de inclusão.

//pch.h 
#pragma once
#include <wil/cppwinrt.h>
#include <wil/resource.h>
...
#include <winrt/Microsoft.Windows.Widgets.Providers.h>

Observação

Você deve incluir o cabeçalho wil/cppwinrt.h primeiro, antes de qualquer cabeçalho WinRT.

Para gerir corretamente o encerramento do aplicativo do provedor de feed, temos que criar uma implementação personalizada de winrt::get_module_lock. Nós pré-declaramos o método SignalLocalServerShutdown que será definido em nosso arquivo de main.cpp e definirá um evento que sinaliza o aplicativo para sair. Adicione o seguinte código ao seu ficheiro pch.h, logo abaixo da diretiva #pragma once, antes das outras inclusões.

//pch.h
#include <stdint.h>
#include <combaseapi.h>

// In .exe local servers the class object must not contribute to the module ref count, and use
// winrt::no_module_lock, the other objects must and this is the hook into the C++ WinRT ref counting system
// that enables this.
void SignalLocalServerShutdown();

namespace winrt
{
    inline auto get_module_lock() noexcept
    {
        struct service_lock
        {
            uint32_t operator++() noexcept
            {
                return ::CoAddRefServerProcess();
            }

            uint32_t operator--() noexcept
            {
                const auto ref = ::CoReleaseServerProcess();

                if (ref == 0)
                {
                    SignalLocalServerShutdown();
                }
                return ref;
            }
        };

        return service_lock{};
    }
}


#define WINRT_CUSTOM_MODULE_LOCK

Adicionar uma classe FeedProvider para gerir operações de fluxo

No Visual Studio, clique com o botão direito do mouse no projeto ExampleFeedProvider no Gerenciador de Soluções e selecione Adicionar Classe>. Na caixa de diálogo Adicionar classe , nomeie a classe "FeedProvider" e clique em Adicionar.

Declarar uma classe que implementa a interface IFeedProvider

A interface IFeedProvider define métodos que o Widgets Board invocará para iniciar operações com o provedor de feed. Substitua a definição de classe vazia no arquivo FeedProvider.h pelo código a seguir. Este código declara uma estrutura que implementa a interface IFeedProvider e declara protótipos para os métodos de interface.

// FeedProvider.h
#pragma once
struct FeedProvider : winrt::implements<FeedProvider, winrt::Microsoft::Windows::Widgets::Feeds::Providers::IFeedProvider>
{
    FeedProvider() {}

    /* IFeedrovider required functions that need to be implemented */
    void OnFeedProviderEnabled(winrt::Microsoft::Windows::Widgets::Feeds::Providers::FeedProviderEnabledArgs args);
    void OnFeedProviderDisabled(winrt::Microsoft::Windows::Widgets::Feeds::Providers::FeedProviderDisabledArgs args);
    void OnFeedEnabled(winrt::Microsoft::Windows::Widgets::Feeds::Providers::FeedEnabledArgs args);
    void OnFeedDisabled(winrt::Microsoft::Windows::Widgets::Feeds::Providers::FeedDisabledArgs args);
    void OnCustomQueryParametersRequested(winrt::Microsoft::Windows::Widgets::Feeds::Providers::CustomQueryParametersRequestedArgs args);
    /* IFeedProvider required functions that need to be implemented */

};

Implementar os métodos IFeedProvider

Nas próximas seções, implementaremos os métodos da interface IFeedProvider . Antes de mergulhar nos métodos de interface, adicione as seguintes linhas ao FeedProvider.cpp, após as diretivas include, para puxar as APIs do provedor de feed para o namespace winrt e permitir o acesso ao mapa declarado na etapa anterior.

Observação

Os objetos passados para os métodos de callback da interface IFeedProvider só são garantidos como válidos dentro do callback. Você não deve armazenar referências a esses objetos porque seu comportamento fora do contexto do retorno de chamada é indefinido.

// WidgetProvider.cpp
namespace winrt
{
    using namespace Microsoft::Windows::Widgets::Feeds::Providers;
}

OnFeedProviderEnabled

O método OnFeedProviderEnabled é invocado quando um feed associado ao provedor é criado pelo host do Widgets Board. Na implementação desse método, gere uma cadeia de caracteres de consulta com os parâmetros que serão passados para a URL que fornece o conteúdo do feed, incluindo quaisquer tokens de autenticação necessários. Crie uma instância de CustomQueryParametersUpdateOptions, passando o FeedProviderDefinitionId a partir dos argumentos do evento que identifica o feed que foi habilitado e a string de consulta. Obtenha o FeedManager padrão e chame SetCustomQueryParameters para registrar os parâmetros da cadeia de caracteres de consulta com o Widgets Board.

// FeedProvider.cs
void FeedProvider::OnFeedProviderEnabled(winrt::Microsoft::Windows::Widgets::Feeds::Providers::FeedProviderEnabledArgs args)
{
    std::wstringstream wstringstream;
wstringstream << args.FeedProviderDefinitionId().c_str() << L" feed provider was enabled." << std::endl;
    _putws(wstringstream.str().c_str());

    auto updateOptions = winrt::CustomQueryParametersUpdateOptions(args.FeedProviderDefinitionId(), L"param1&param2");
    winrt::FeedManager::GetDefault().SetCustomQueryParameters(updateOptions);
}

QuandoFornecedorDeFeedDesativado

OnFeedProviderDisabled é chamado quando o Quadro de Widgets tem todos os feeds desse provedor desativados. Os provedores de feed não são obrigados a executar nenhuma ação em resposta a essa chamada de método. A invocação do método pode ser usada para fins de telemetria ou para atualizar os parâmetros da cadeia de caracteres de consulta ou revogar tokens de autenticação, se necessário. Se a aplicação oferecer suporte apenas a um único fornecedor de feed ou se todos os fornecedores de feed suportados pela aplicação tiverem sido desativados, a aplicação pode encerrar em resposta a este retorno de chamada.

// FeedProvider.cs

void FeedProvider::OnFeedProviderDisabled(winrt::Microsoft::Windows::Widgets::Feeds::Providers::FeedProviderDisabledArgs args)
{
    std::wstringstream wstringstream;
    wstringstream << args.FeedProviderDefinitionId().c_str() << L" feed provider was disabled." << std::endl;
    _putws(wstringstream.str().c_str());
}

OnFeedEnabled, OnFeedDesabled

OnFeedEnabled e OnFeedDisabled são invocados pelo Widgets Board quando um feed é ativado ou desativado. Os provedores de feed não são obrigados a executar nenhuma ação em resposta a essas chamadas de método. A invocação do método pode ser usada para fins de telemetria ou para atualizar os parâmetros da cadeia de caracteres de consulta ou revogar tokens de autenticação, se necessário.

// FeedProvider.cs

void FeedProvider::OnFeedEnabled(winrt::Microsoft::Windows::Widgets::Feeds::Providers::FeedEnabledArgs args)
{
    std::wstringstream wstringstream;
    wstringstream << args.FeedDefinitionId().c_str() << L" feed was enabled." << std::endl;
    _putws(wstringstream.str().c_str());
}

// FeedProvider.cs

void FeedProvider::OnFeedDisabled(winrt::Microsoft::Windows::Widgets::Feeds::Providers::FeedDisabledArgs args)
{
    std::wstringstream wstringstream;
    wstringstream << args.FeedDefinitionId().c_str() << L" feed was disabled." << std::endl;
    _putws(wstringstream.str().c_str());
}

OnCustomQueryParametersRequested

OnCustomQueryParametersRequested é gerado quando o Widgets Board determina que os parâmetros de consulta personalizados associados ao provedor de feed precisam ser atualizados. Por exemplo, este método pode ser invocado se a operação para buscar conteúdo de fluxo do serviço web remoto falhar. A propriedade FeedProviderDefinitionId do CustomQueryParametersRequestedArgs passada para esse método especifica o feed para o qual os parâmetros de cadeia de caracteres de consulta estão sendo solicitados. O provedor deve regenerar a cadeia de caracteres de consulta e passá-la de volta para o Widgets Board chamando SetCustomQueryParameters.

// FeedProvider.cs

void FeedProvider::OnCustomQueryParametersRequested(winrt::Microsoft::Windows::Widgets::Feeds::Providers::CustomQueryParametersRequestedArgs args)
{
    std::wstringstream wstringstream;
    wstringstream << L"CustomQueryParameters were requested for " << args.FeedProviderDefinitionId().c_str() << std::endl;
    _putws(wstringstream.str().c_str());

    auto updateOptions = winrt::CustomQueryParametersUpdateOptions(args.FeedProviderDefinitionId(), L"param1&param2");
    winrt::FeedManager::GetDefault().SetCustomQueryParameters(updateOptions);
}

Registrar uma fábrica de classes que instanciará o FeedProvider mediante solicitação

Adicione o cabeçalho que define a classe FeedProvider às inclusões na parte superior do arquivo do main.cpp seu aplicativo. Também incluiremos mutex aqui.

// main.cpp
...
#include "FeedProvider.h"
#include <mutex>

Declare o evento que acionará nosso aplicativo para sair e a função SignalLocalServerShutdown que definirá o evento. Cole o código a seguir no main.cpp.

// main.cpp
wil::unique_event g_shudownEvent(wil::EventOptions::None);

void SignalLocalServerShutdown()
{
    g_shudownEvent.SetEvent();
}

Em seguida, você precisará criar um CLSID que será usado para identificar seu provedor de feed para ativação COM. Gere um GUID no Visual Studio indo para Ferramentas->Criar GUID. Selecione a opção "static const GUID =" e clique em Copiar e, em seguida, cole em main.cpp. Atualize a definição de GUID com a seguinte sintaxe C++/WinRT, definindo o nome da variável GUID feed_provider_clsid. Deixe a versão comentada do GUID porque você precisará desse formato mais tarde, ao empacotar seu aplicativo.

// main.cpp
...
// {80F4CB41-5758-4493-9180-4FB8D480E3F5}
static constexpr GUID feed_provider_clsid
{
    0x80f4cb41, 0x5758, 0x4493, { 0x91, 0x80, 0x4f, 0xb8, 0xd4, 0x80, 0xe3, 0xf5 }
};

Adicione a seguinte definição de fábrica de classe a main.cpp. Este é principalmente um código clichê que não é específico para implementações de provedor de feed. Observe que CoWaitForMultipleObjects aguarda que nosso evento de desligamento seja acionado antes que o aplicativo seja encerrado.

// main.cpp
template <typename T>
struct SingletonClassFactory : winrt::implements<SingletonClassFactory<T>, IClassFactory>
{
    STDMETHODIMP CreateInstance(
        ::IUnknown* outer,
        GUID const& iid,
        void** result) noexcept final
    {
        *result = nullptr;

        std::unique_lock lock(mutex);

        if (outer)
        {
            return CLASS_E_NOAGGREGATION;
        }

        if (!instance)
        {
            instance = winrt::make<FeedProvider>();
        }

        return instance.as(iid, result);
    }

    STDMETHODIMP LockServer(BOOL) noexcept final
    {
        return S_OK;
    }

private:
    T instance{ nullptr };
    std::mutex mutex;
};

int main()
{
    winrt::init_apartment();
    wil::unique_com_class_object_cookie feedProviderFactory;
    auto factory = winrt::make<SingletonClassFactory<winrt::Microsoft::Windows::Widgets::Feeds::Providers::IFeedProvider>>();

    winrt::check_hresult(CoRegisterClassObject(
        feed_provider_clsid,
        factory.get(),
        CLSCTX_LOCAL_SERVER,
        REGCLS_MULTIPLEUSE,
        feedProviderFactory.put()));

    DWORD index{};
    HANDLE events[] = { g_shudownEvent.get() };
    winrt::check_hresult(CoWaitForMultipleObjects(CWMO_DISPATCH_CALLS | CWMO_DISPATCH_WINDOW_MESSAGES,
        INFINITE,
        static_cast<ULONG>(std::size(events)), events, &index));

    return 0;
}

Empacote seu aplicativo de provedor de feed

Na versão atual, apenas aplicativos empacotados podem ser registrados como provedores de feed. As etapas a seguir o guiarão pelo processo de empacotamento do aplicativo e atualização do manifesto do aplicativo para registrar seu aplicativo no sistema operacional como um provedor de feed.

Criar um projeto de empacotamento MSIX

NoGerenciador de Soluções , clique com o botão direito do mouse em sua solução e selecione Adicionar-Novo Projeto.... Na caixa de diálogo Adicionar um novo projeto, selecione o modelo "Projeto de empacotamento de aplicativos do Windows" e clique em Avançar. Defina o nome do projeto como "ExampleFeedProviderPackage" e clique em Criar. Quando solicitado, defina a versão de destino para a versão 1809 ou posterior e clique em OK. Em seguida, clique com o botão direito do mouse no projeto ExampleFeedProviderPackage e selecione Adicionar referência ao projeto>. Selecione o projeto ExampleFeedProvider e clique em OK.

Adicionar referência de pacote do SDK de Aplicativo Windows ao projeto de empacotamento

Você precisa adicionar uma referência ao pacote NuGet do Windows App SDK ao projeto de empacotamento MSIX. No Gerenciador de Soluções, clique duas vezes no projeto ExampleFeedProviderPackage para abrir o arquivo ExampleFeedProviderPackage.wapproj. Adicione o seguinte xml dentro do Project elemento.

<!--ExampleFeedProviderPackage.wapproj-->
<ItemGroup>
    <PackageReference Include="Microsoft.WindowsAppSDK" Version="1.5.231116003-experimentalpr">
        <IncludeAssets>build</IncludeAssets>
    </PackageReference>  
</ItemGroup>

Observação

Verifique se a versão especificada no elemento PackageReference corresponde à última versão estável que mencionou na etapa anterior.

Se a versão correta do SDK do Aplicativo Windows já estiver instalada no computador e você não quiser agrupar o tempo de execução do SDK em seu pacote, poderá especificar a dependência do pacote no arquivo Package.appxmanifest para o projeto ExampleFeedProviderPackage.

<!--Package.appxmanifest-->
...
<Dependencies>
...
    <PackageDependency Name="Microsoft.WindowsAppRuntime.1.5.233430000-experimental1" MinVersion="2000.638.7.0" Publisher="CN=Microsoft Corporation, O=Microsoft Corporation, L=Redmond, S=Washington, C=US" />
...
</Dependencies>
...

Atualizar o manifesto do pacote

No Explorador de Soluções , clique com o botão direito do rato no ficheiro Package.appxmanifest e selecione "Ver Código" para abrir o ficheiro XML do manifesto. Em seguida, você precisa adicionar algumas declarações de namespace para as extensões de pacote de aplicativo que usaremos. Adicione as seguintes definições de namespace ao elemento de nível superior Package.

<!-- Package.appmanifest -->
<Package
  ...
  xmlns:uap3="http://schemas.microsoft.com/appx/manifest/uap/windows10/3"
  xmlns:com="http://schemas.microsoft.com/appx/manifest/com/windows10"

Dentro do elemento Application, crie um novo elemento vazio chamado Extensions. Assegure-se de que isso apareça após a tag de fechamento para uap:VisualElements.

<!-- Package.appxmanifest -->
<Application>
...
    <Extensions>

    </Extensions>
</Application>

A primeira extensão que precisamos adicionar é a extensão ComServer. Isso registra o ponto de entrada do executável com o sistema operacional. Esta extensão é a aplicação empacotada equivalente ao registo de um servidor COM definindo uma chave de registo e não é específica para fornecedores de feeds. Adicione o seguinte elemento com:Extension como um elemento filho do Extensions. Altere o GUID no atributo Id do elemento com:Class para o GUID gerado num passo anterior.

<!-- Package.appxmanifest -->
<Extensions>
    <com:Extension Category="windows.comServer">
        <com:ComServer>
            <com:ExeServer Executable="ExampleFeedProvider\ExampleFeedProvider.exe" Arguments="-RegisterProcessAsComServer" DisplayName="C++ Feed Provider App">
                <com:Class Id="xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" DisplayName="FeedProvider" />
            </com:ExeServer>
        </com:ComServer>
    </com:Extension>
</Extensions>

Em seguida, adicione a extensão que registra o aplicativo como um provedor de feed. Cole o elemento uap3:Extension no seguinte trecho de código, como filho do elemento Extensions. Certifique-se de substituir o atributo ClassId do elemento COM pelo GUID usado nas etapas anteriores.

<!-- Package.appxmanifest -->
<Extensions>
    ...
    <uap3:Extension Category="windows.appExtension">
        <uap3:AppExtension Name="com.microsoft.windows.widgets.feeds" DisplayName="ContosoFeed" Id="com.examplewidgets.examplefeed" PublicFolder="Public">
            <uap3:Properties>
                <FeedProvider Icon="ms-appx:Assets\StoreLogo.png" Description="FeedDescription">
                    <Activation>
                        <!-- Apps exports COM interface which implements IFeedProvider -->
                        <CreateInstance ClassId="xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" />
                    </Activation>
                    <Definitions>
                        <Definition Id="Contoso_Feed"
                            DisplayName="Contoso_Feed Feed"
                            Description="Feed representing Contoso"
                            ContentUri="https://www.contoso.com/"
                            Icon="ms-appx:Images\StoreLogo.png">
                        </Definition>
                        <Definition Id="Fabrikam_Feed"
                            DisplayName="Fabrikam Feed"
                            Description="Feed representing Example"
                            ContentUri="https://www.fabrikam.com/"
                            Icon="ms-appx:Images\StoreLogo.png">
                        </Definition>
                    </Definitions>
                </FeedProvider>
            </uap3:Properties>
        </uap3:AppExtension>
    </uap3:Extension>
</Extensions>

Para obter descrições detalhadas e informações de formato para todos esses elementos, consulte Formato XML do manifesto do pacote do provedor de feed.

Adicionar ícones ao seu projeto de embalagem

No Gerenciador de Soluções, clique com o botão direito do mouse em ExampleFeedProviderPackage e selecione Adicionar> Nova Pasta. Nomeie essa pasta como ProviderAssets, pois é o que foi usado no Package.appxmanifest da etapa anterior. É aqui que armazenaremos o nosso ícone para os nossos feeds. Depois de adicionar os ícones desejados, certifique-se de que os nomes das imagens correspondam ao que vem depois de Path=ProviderAssets\ no seu Package.appxmanifest ou os feeds não aparecerão no Widget Board.

Testando o seu provedor de alimentação

Certifique-se de ter selecionado a arquitetura que corresponde à sua máquina de desenvolvimento na lista suspensa Solution Platforms, por exemplo, "x64". No Gerenciador de Soluções, clique com o botão direito do mouse em sua solução e selecione Build Solution. Feito isso, clique com o botão direito do mouse no ExampleWidgetProviderPackage e selecione Implantar. O aplicativo de console deve ser iniciado na implantação e você verá os feeds serem ativados na saída do console. Abra o Painel de widgets e você verá os novos feeds nas guias ao longo da parte superior da seção de feeds.

Corrigir o seu fornecedor de feeds

Depois de fixar seus feeds, a Widget Platform iniciará seu aplicativo de provedor de feed para receber e enviar informações relevantes sobre o feed. Para depurar o feed em execução, você pode anexar um depurador ao aplicativo do provedor de feed em execução ou configurar o Visual Studio para iniciar automaticamente a depuração do processo do provedor de feed assim que ele for iniciado.

Para se ligar ao processo em execução:

  1. No Visual Studio, clique em Depurar -> Anexar ao processo.
  2. Filtre os processos e encontre o aplicativo de provedor de feed desejado.
  3. Anexe o depurador.

Para anexar automaticamente o depurador ao processo quando é iniciado:

  1. No Visual Studio, clique em Depurar -> Outros Destinos de Depuração -> Depurar Pacote de Aplicativo Instalado.
  2. Filtre os pacotes e encontre o pacote do fornecedor de feeds que deseja.
  3. Selecione-o e marque a caixa que diz Não iniciar, mas depurar o meu código quando ele estiver iniciado.
  4. Clique em Anexar.

Converter seu aplicativo de console em um aplicativo do Windows

Para converter o aplicativo de console criado neste passo a passo em um aplicativo do Windows:

  1. Clique com o botão direito do mouse no projeto ExampleWidgetProvider no Gerenciador de Soluções e selecione Propriedades. Navegue até Linker -> System e mude o SubSistema de "Console" para "Windows". Isso também pode ser feito adicionando <SubSystem>Windows</SubSystem> à seção <Link>..</Link> do .vcxproj.
  2. Em main.cpp, mude int main() para int WINAPI wWinMain(_In_ HINSTANCE /*hInstance*/, _In_opt_ HINSTANCE /*hPrevInstance*/, _In_ PWSTR pCmdLine, _In_ int /*nCmdShow*/).

Uma captura de tela mostrando as propriedades do projeto do provedor de feed C++ com o tipo de saída definido como Aplicativo do Windows

Publicação do seu aplicativo de provedor de feed

Depois de desenvolver e testar seu provedor de feeds, você pode publicar seu aplicativo na Microsoft Store para que os usuários instalem seus feeds em seus dispositivos. Para obter orientações passo a passo para publicar uma aplicação, consulte Publicar a sua aplicação na Microsoft Store.

A coleção Feeds Store

Depois que seu aplicativo for publicado na Microsoft Store, você poderá solicitar que seu aplicativo seja incluído na Coleção da Loja de feeds que ajuda os usuários a descobrir aplicativos que apresentam feeds do Windows. Para enviar sua solicitação, consulte Enviar seu feed/quadro para adição à Coleção da loja.

  • Last updated on