Cómo: Controlar eventos mediante WRL

Artículo
02/20/2013

En este documento se muestra cómo utilizar Biblioteca de plantillas de Windows Runtime C++ (WRL) para suscribirse y para controlar los eventos de un objeto de Windows en tiempo de ejecución.

Para obtener un ejemplo básico que crea una instancia de ese componente y recuperar un valor de propiedad, vea Cómo: Activar y usar un componente de Windows en tiempo de ejecución mediante WRL.

La suscripción a y controlar eventos

Los pasos siguientes inician un objeto de ABI::Windows::System::Threading::IDeviceWatcher y controladores de eventos de uso a supervisar progreso.La interfaz de IDeviceWatcher permite enumerar los dispositivos de forma asincrónica, o en segundo plano, y recibe la notificación cuando se agregan, se quitan, o se cambian los dispositivos.La función de Devolución de llamada es una parte importante de este ejemplo porque permite especificar controladores de eventos que procesan los resultados de la operación de fondo.A continuación se muestra el ejemplo completo.

Precaución
Aunque use normalmente WRL en una aplicación de Tienda Windows, este ejemplo utiliza una aplicación de consola a la ilustración.Las funciones como wprintf_s no están disponibles de una aplicación de Tienda Windows.Para obtener más información sobre los tipos y funciones que puede utilizar en una aplicación de Tienda Windows, vea Funciones CRT no compatibles con /ZW y Win32 y COM para las aplicaciones del almacén de Windows.

Aunque use normalmente WRL en una aplicación de Tienda Windows, este ejemplo utiliza una aplicación de consola a la ilustración.Las funciones como wprintf_s no están disponibles de una aplicación de Tienda Windows.Para obtener más información sobre los tipos y funciones que puede utilizar en una aplicación de Tienda Windows, vea Funciones CRT no compatibles con /ZW y Win32 y COM para las aplicaciones del almacén de Windows.

Incluya (#include) cualquier Windows en tiempo de ejecución necesario, WRL, o encabezado de la biblioteca estándar de 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 los tipos necesarios para enumerar los dispositivos.

Recomendamos utilizar la directiva de using namespace en el archivo .cpp para hacer el código más legible.

Declare las variables locales de la aplicación.Este ejemplo contiene el recuento del número de dispositivos enumerados y tokens de registro que permiten cancelar la suscripción después 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;

Inicializa Windows en tiempo de ejecución.

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

Cree un objeto de Evento que sincronice el proceso de enumeración a la aplicación 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);
}

[!NOTA]

Este evento es para la demostración solo como parte de una aplicación de consola.Este ejemplo utiliza el evento para asegurarse de que una operación async completa antes de salir de la aplicación.En la mayoría de las aplicaciones, no suele esperar operaciones async para completar.

Cree un generador de activación para la interfaz 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);
}
```
Windows en tiempo de ejecución utiliza nombres completos para identificar tipos.El parámetro de RuntimeClass_Windows_Devices_Enumeration_DeviceInformation es una cadena proporcionada por Windows en tiempo de ejecución y contiene el nombre de clase necesario en tiempo de ejecución.

Cree el objeto de IDeviceWatcher.

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

Utilice la función de Callback para suscribirse a Added, a EnumerationCompleted, y 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);
}

El controlador de eventos Added incrementa el recuento de dispositivos enumerados.Detiene el proceso de enumeración después de que se encuentren diez dispositivos.

El controlador de eventos Stopped quitar los controladores de eventos y establece el evento de finalización.

El controlador de eventos EnumerationCompleted detiene el proceso de enumeración.Manejamos este evento cuando hay menos que diez dispositivos.

Sugerencia
Este ejemplo utiliza una expresión lambda para definir las devoluciones de llamada.También puede utilizar los objetos de función (functors), punteros a función, o los objetos de std::function.Para obtener más información sobre las expresiones lambda, vea Expresiones lambda en C++.

Inicia el proceso de enumeración.

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

Espere a que el proceso de enumeración para completar y después para imprimir un mensaje.Todo el ComPtr y objetos RAII permiten ámbito y se libera automáticamente.

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

A continuación se muestra el ejemplo 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.
*/

Compilar el código

Para compilar el código, cópielo y péguelo en un proyecto de Visual Studio, o péguelo en un archivo denominado wrl-consume-events.cpp y después se ejecute el siguiente comando en una ventana de símbolo del sistema de Visual Studio.

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

Vea también

Conceptos

Biblioteca de plantillas de Windows Runtime C++ (WRL)

Compartir a través de

Cómo: Controlar eventos mediante WRL

La suscripción a y controlar eventos

Compilar el código

Vea también

Conceptos

Recursos adicionales