Como manipular eventos com WRL

Artigo
02/25/2013

Este documento mostra como usar Biblioteca em Tempo de Execução C++ do Tempo de Execução do Windows () paraWRLassine e para manipular eventos de Tempo de Execução do Windows objeto.

Para um exemplo mais básico que cria uma instância do componente e recupere um valor de propriedade, consulte Como ativar e usar um componente de Tempo de Execução do Windows com WRL.

Assine e manipular eventos

As seguintes etapas início de um objeto de ABI::Windows::System::Threading::IDeviceWatcher e manipuladores de eventos de uso ao monitor progride.A interface de IDeviceWatcher permitem enumerar de forma assíncrona dispositivos, ou no plano de fundo, e recebe-a notificação quando os dispositivos são adicionados, removidos, ou alterados.A função de Retorno de chamada é uma parte importante deste exemplo porque a permite especificar os manipuladores de eventos que processam os resultados da operação de plano de fundo.O exemplo completo maneira.

Cuidado
Embora você normalmente usa WRL em um aplicativo de Windows Store , este exemplo usa um aplicativo de console para a ilustração.As funções como wprintf_s não estão disponíveis de um aplicativo de Windows Store .Para obter mais informações sobre tipos e das funções que você pode usar em um aplicativo de Windows Store , consulte Funções de CRT não suportadas com /ZW e O Win32 e COM para aplicativos da Windows Store.

Embora você normalmente usa WRL em um aplicativo de Windows Store , este exemplo usa um aplicativo de console para a ilustração.As funções como wprintf_s não estão disponíveis de um aplicativo de Windows Store .Para obter mais informações sobre tipos e das funções que você pode usar em um aplicativo de Windows Store , consulte Funções de CRT não suportadas com /ZW e O Win32 e COM para aplicativos da Windows Store.

Inclua ()#includequalquer Tempo de Execução do Windowsnecessário, WRL, ou cabeçalhos padrão da biblioteca C++.
```
#include <Windows.Devices.Enumeration.h>
#include <wrl/event.h>
#include <stdio.h>

using namespace ABI::Windows::Devices::Enumeration;
using namespace ABI::Windows::Foundation;
using namespace Microsoft::WRL;
using namespace Microsoft::WRL::Wrappers;
```
Windows.Devices.Enumeration.h declara os tipos que são necessários para enumerar dispositivos.

Recomendamos que você utiliza a política de using namespace no arquivo de .cpp para tornar o código mais legível.

Declarar variáveis locais para o aplicativo.Este exemplo contém a contagem do número de dispositivos e de símbolos enumerados do registro que permitem que você posteriormente desinscreva-se de eventos.

// Counts the number of enumerated devices.
unsigned int deviceCount = 0;

// Event registration tokens that enable us to later unsubscribe from events.
EventRegistrationToken addedToken;
EventRegistrationToken stoppedToken;
EventRegistrationToken enumCompletedToken;

Inicializar Tempo de Execução do Windows.

// Initialize the Windows Runtime.
RoInitializeWrapper initialize(RO_INIT_MULTITHREADED);
if (FAILED(initialize))
{
    return PrintError(__LINE__, initialize);
}

Crie um objeto de Evento que sincronize a conclusão do processo de enumeração para o aplicativo principal.

// Create an event that is set after device enumeration completes. We later use this event to wait for the timer to complete. 
// This event is for demonstration only in a console app. In most apps, you typically don't wait for async operations to complete.
Event enumerationCompleted(CreateEventEx(nullptr, nullptr, CREATE_EVENT_MANUAL_RESET, WRITE_OWNER | EVENT_ALL_ACCESS));
hr = threadCompleted.IsValid() ? S_OK : HRESULT_FROM_WIN32(GetLastError());
if (FAILED(hr))
{
    return PrintError(__LINE__, hr);
}

Observação
Este evento é para demonstração somente como parte de um aplicativo de console.Este exemplo usa o evento para garantir que uma operação de async terminar antes de sair do aplicativo.Na maioria dos aplicativos, você normalmente não espera operações de async para concluir.

Crie uma fábrica de ativação para a interface de IDeviceWatcher .
```
// Get the activation factory for the IDeviceWatcher interface.
ComPtr<IDeviceInformationStatics> watcherFactory;
HRESULT hr = ABI::Windows::Foundation::GetActivationFactory(HStringReference(RuntimeClass_Windows_Devices_Enumeration_DeviceInformation).Get(), &watcherFactory);
if (FAILED(hr))
{
    return PrintError(__LINE__, hr);
}
```
Os nomes totalmente qualificados dos usos de Tempo de Execução do Windows para identificar tipos.O parâmetro de RuntimeClass_Windows_Devices_Enumeration_DeviceInformation é uma cadeia de caracteres que é fornecida por Tempo de Execução do Windows contendo o nome da classe necessário em tempo de execução.

Criar o objeto de IDeviceWatcher .

// Create a IDeviceWatcher object from the factory.
ComPtr<IDeviceWatcher> watcher;
hr = watcherFactory->CreateWatcher(&watcher);
if (FAILED(hr))
{
    return PrintError(__LINE__, hr);
}

Use a função de Callback para assinar a Added, a EnumerationCompleted, e eventos de Stopped .

// Subscribe to the Added event.
hr = watcher->add_Added(Callback<AddedHandler>([&deviceCount](IDeviceWatcher* watcher, IDeviceInformation*) -> HRESULT
{
    // Print a message and increment the device count.
    // When we reach 10 devices, stop enumerating devices.
    wprintf_s(L"Added device...\n");
    deviceCount++;
    if (deviceCount == 10)
    {
        return watcher->Stop();
    }
    return S_OK;

}).Get(), &addedToken);
if (FAILED(hr))
{
    return PrintError(__LINE__, hr);
}

hr = watcher->add_Stopped(Callback<StoppedHandler>([=, &enumerationCompleted](IDeviceWatcher* watcher, IInspectable*) -> HRESULT
{
    wprintf_s(L"Device enumeration stopped.\nRemoving event handlers...");

    // Unsubscribe from the events. This is shown for demonstration.
    // The need to remove event handlers depends on the requirements of 
    // your app. For instance, if you only need to handle an event for 
    // a short period of time, you might remove the event handler when you
    // no longer need it. If you handle an event for the duration of the app,
    // you might not need to explicitly remove it.
    HRESULT hr1 = watcher->remove_Added(addedToken);
    HRESULT hr2 = watcher->remove_Stopped(stoppedToken);
    HRESULT hr3 = watcher->remove_EnumerationCompleted(enumCompletedToken);

    // Set the completion event and return.
    SetEvent(enumerationCompleted.Get());

    return FAILED(hr1) ? hr1 : FAILED(hr2) ? hr2 : hr3;

}).Get(), &stoppedToken);
if (FAILED(hr))
{
    return PrintError(__LINE__, hr);
}

// Subscribe to the EnumerationCompleted event.
hr = watcher->add_EnumerationCompleted(Callback<EnumerationCompletedHandler>([](IDeviceWatcher* watcher, IInspectable*) -> HRESULT
{
    wprintf_s(L"Enumeration completed.\n");

    return watcher->Stop();

}).Get(), &enumCompletedToken);
if (FAILED(hr))
{
    return PrintError(__LINE__, hr);
}

O manipulador de eventos de Added incrementa a contagem de dispositivos enumerados.Para o processo de enumeração depois que dez dispositivos são encontrados.

O manipulador de eventos de Stopped remover os manipuladores de eventos e define o evento de conclusão.

O manipulador de eventos de EnumerationCompleted para o processo de enumeração.Este evento se tratarmos que há menos que dez dispositivos.

Dica
Este exemplo usa uma expressão lambda para definir os retornos de chamada.Você também pode usar objetos de função (functors), ponteiros de função, ou objetos de std::function .Para obter mais informações sobre expressões lambda, consulte Expressões lambda C++.

Inicie o processo de enumeração.

wprintf_s(L"Starting device enumeration...\n");
hr = watcher->Start();
if (FAILED(hr))
{
    return PrintError(__LINE__, hr);
}

Espere o processo da enumeração para concluir e imprimir em uma mensagem.Qualquer ComPtr e objetos de RAII deixe o escopo e são liberados automaticamente.

// Wait for the operation to complete.
WaitForSingleObjectEx(enumerationCompleted.Get(), INFINITE, FALSE);

wprintf_s(L"Enumerated %u devices.\n", deviceCount);

// All smart pointers and RAII objects go out of scope here.

Aqui está um exemplo completo:

// wrl-consume-events.cpp
// compile with: runtimeobject.lib
#include <Windows.Devices.Enumeration.h>
#include <wrl/event.h>
#include <stdio.h>

using namespace ABI::Windows::Devices::Enumeration;
using namespace ABI::Windows::Foundation;
using namespace Microsoft::WRL;
using namespace Microsoft::WRL::Wrappers;

// Prints an error string for the provided source code line and HRESULT
// value and returns the HRESULT value as an int.
int PrintError(unsigned int line, HRESULT hr)
{
    wprintf_s(L"ERROR: Line:%d HRESULT: 0x%X\n", line, hr);
    return hr;
}

int wmain()
{
    // Type define the event handler types to make the code more readable.
    typedef __FITypedEventHandler_2_Windows__CDevices__CEnumeration__CDeviceWatcher_Windows__CDevices__CEnumeration__CDeviceInformation AddedHandler;
    typedef __FITypedEventHandler_2_Windows__CDevices__CEnumeration__CDeviceWatcher_IInspectable EnumerationCompletedHandler;
    typedef __FITypedEventHandler_2_Windows__CDevices__CEnumeration__CDeviceWatcher_IInspectable StoppedHandler;

    // Counts the number of enumerated devices.
    unsigned int deviceCount = 0;

    // Event registration tokens that enable us to later unsubscribe from events.
    EventRegistrationToken addedToken;
    EventRegistrationToken stoppedToken;
    EventRegistrationToken enumCompletedToken;

    // Initialize the Windows Runtime.
    RoInitializeWrapper initialize(RO_INIT_MULTITHREADED);
    if (FAILED(initialize))
    {
        return PrintError(__LINE__, initialize);
    }

    // Create an event that is set after device enumeration completes. We later use this event to wait for the timer to complete. 
    // This event is for demonstration only in a console app. In most apps, you typically don't wait for async operations to complete.
    Event enumerationCompleted(CreateEventEx(nullptr, nullptr, CREATE_EVENT_MANUAL_RESET, WRITE_OWNER | EVENT_ALL_ACCESS));
    hr = threadCompleted.IsValid() ? S_OK : HRESULT_FROM_WIN32(GetLastError());
    if (FAILED(hr))
    {
        return PrintError(__LINE__, hr);
    }

    // Get the activation factory for the IDeviceWatcher interface.
    ComPtr<IDeviceInformationStatics> watcherFactory;
    HRESULT hr = ABI::Windows::Foundation::GetActivationFactory(HStringReference(RuntimeClass_Windows_Devices_Enumeration_DeviceInformation).Get(), &watcherFactory);
    if (FAILED(hr))
    {
        return PrintError(__LINE__, hr);
    }

    // Create a IDeviceWatcher object from the factory.
    ComPtr<IDeviceWatcher> watcher;
    hr = watcherFactory->CreateWatcher(&watcher);
    if (FAILED(hr))
    {
        return PrintError(__LINE__, hr);
    }

    // Subscribe to the Added event.
    hr = watcher->add_Added(Callback<AddedHandler>([&deviceCount](IDeviceWatcher* watcher, IDeviceInformation*) -> HRESULT
    {
        // Print a message and increment the device count.
        // When we reach 10 devices, stop enumerating devices.
        wprintf_s(L"Added device...\n");
        deviceCount++;
        if (deviceCount == 10)
        {
            return watcher->Stop();
        }
        return S_OK;

    }).Get(), &addedToken);
    if (FAILED(hr))
    {
        return PrintError(__LINE__, hr);
    }

    hr = watcher->add_Stopped(Callback<StoppedHandler>([=, &enumerationCompleted](IDeviceWatcher* watcher, IInspectable*) -> HRESULT
    {
        wprintf_s(L"Device enumeration stopped.\nRemoving event handlers...");

        // Unsubscribe from the events. This is shown for demonstration.
        // The need to remove event handlers depends on the requirements of 
        // your app. For instance, if you only need to handle an event for 
        // a short period of time, you might remove the event handler when you
        // no longer need it. If you handle an event for the duration of the app,
        // you might not need to explicitly remove it.
        HRESULT hr1 = watcher->remove_Added(addedToken);
        HRESULT hr2 = watcher->remove_Stopped(stoppedToken);
        HRESULT hr3 = watcher->remove_EnumerationCompleted(enumCompletedToken);

        // Set the completion event and return.
        SetEvent(enumerationCompleted.Get());

        return FAILED(hr1) ? hr1 : FAILED(hr2) ? hr2 : hr3;

    }).Get(), &stoppedToken);
    if (FAILED(hr))
    {
        return PrintError(__LINE__, hr);
    }

    // Subscribe to the EnumerationCompleted event.
    hr = watcher->add_EnumerationCompleted(Callback<EnumerationCompletedHandler>([](IDeviceWatcher* watcher, IInspectable*) -> HRESULT
    {
        wprintf_s(L"Enumeration completed.\n");

        return watcher->Stop();

    }).Get(), &enumCompletedToken);
    if (FAILED(hr))
    {
        return PrintError(__LINE__, hr);
    }

    wprintf_s(L"Starting device enumeration...\n");
    hr = watcher->Start();
    if (FAILED(hr))
    {
        return PrintError(__LINE__, hr);
    }

    // Wait for the operation to complete.
    WaitForSingleObjectEx(enumerationCompleted.Get(), INFINITE, FALSE);

    wprintf_s(L"Enumerated %u devices.\n", deviceCount);

    // All smart pointers and RAII objects go out of scope here.
}
/*
Sample output:
Starting device enumeration...
Added device...
Added device...
Added device...
Added device...
Added device...
Added device...
Added device...
Added device...
Added device...
Added device...
Device enumeration stopped.
Removing event handlers...
Enumerated 10 devices.
*/

Compilando o código

Para compilar o código, copie e cole em um projeto Visual Studio, ou cole em um arquivo denominado wrl-consume-events.cpp e execute o seguinte comando em uma janela de prompt de comando do Visual Studio.

cl.exe wrl-consume-events.cpp runtimeobject.lib

Consulte também

Conceitos

Biblioteca de Modelos C++ do Tempo de Execução do Windows (WRL)

Compartilhar via

Como manipular eventos com WRL

Assine e manipular eventos

Compilando o código

Consulte também

Conceitos

Recursos adicionais