Uso de eventos de Sensor API
Sensor API proporciona notificaciones de eventos a través de interfaces de devolución de llamada.
Para recibir notificaciones de eventos, el programa debe implementar las interfaces de devolución de llamada COM necesarias. Para recibir eventos de sensores, debe implementar ISensorEvents. Para recibir eventos del administrador de sensores, debe implementar ISensorManagerEvents.
El código de ejemplo siguiente crea una clase que implementa ISensorEvents.
class CMyEvents : public ISensorEvents
{
public:
STDMETHODIMP QueryInterface(REFIID iid, void** ppv)
{
if (ppv == NULL)
{
return E_POINTER;
}
if (iid == __uuidof(IUnknown))
{
*ppv = static_cast<IUnknown*>(this);
}
else if (iid == __uuidof(ISensorEvents))
{
*ppv = static_cast<ISensorEvents*>(this);
}
else
{
*ppv = NULL;
return E_NOINTERFACE;
}
AddRef();
return S_OK;
}
STDMETHODIMP_(ULONG) AddRef()
{
return InterlockedIncrement(&m_cRef);
}
STDMETHODIMP_(ULONG) Release()
{
ULONG count = InterlockedDecrement(&m_cRef);
if (count == 0)
{
delete this;
return 0;
}
return count;
}
//
// ISensorEvents methods.
//
STDMETHODIMP OnEvent(
ISensor *pSensor,
REFGUID eventID,
IPortableDeviceValues *pEventData)
{
HRESULT hr = S_OK;
// Handle custom events here.
return hr;
}
STDMETHODIMP OnDataUpdated(
ISensor *pSensor,
ISensorDataReport *pNewData)
{
HRESULT hr = S_OK;
if(NULL == pNewData ||
NULL == pSensor)
{
return E_INVALIDARG;
}
ULONG ulHour = 0;
ULONG ulMinute = 0;
ULONG ulSecond = 0;
PROPVARIANT var = {};
hr = pNewData->GetSensorValue(SAMPLE_SENSOR_DATA_TYPE_HOUR, &var);
if(SUCCEEDED(hr))
{
if(var.vt == VT_UI4)
{
// Get the hour value.
ulHour = var.ulVal;
}
}
PropVariantClear(&var);
if(SUCCEEDED(hr))
{
hr = pNewData->GetSensorValue(SAMPLE_SENSOR_DATA_TYPE_MINUTE, &var);
}
if(SUCCEEDED(hr))
{
if(var.vt == VT_UI4)
{
// Get the hour value.
ulMinute = var.ulVal;
}
}
PropVariantClear(&var);
if(SUCCEEDED(hr))
{
hr = pNewData->GetSensorValue(SAMPLE_SENSOR_DATA_TYPE_SECOND, &var);
}
if(SUCCEEDED(hr))
{
if(var.vt == VT_UI4)
{
// Get the hour value.
ulSecond = var.ulVal;
}
}
PropVariantClear(&var);
if(SUCCEEDED(hr))
{
// Print
wprintf_s(L"Current local time is: \n");
wprintf_s(L"%02d:%02d:%02d (asynchronous)\n", ulHour, ulMinute, ulSecond);
}
return hr;
}
STDMETHODIMP OnLeave(
REFSENSOR_ID sensorID)
{
HRESULT hr = S_OK;
// Peform any housekeeping tasks for the sensor that is leaving.
// For example, if you have maintained a reference to the sensor,
// release it now and set the pointer to NULL.
return hr;
}
STDMETHODIMP OnStateChanged(
ISensor* pSensor,
SensorState state)
{
HRESULT hr = S_OK;
if(NULL == pSensor)
{
return E_INVALIDARG;
}
if(state == SENSOR_STATE_READY)
{
wprintf_s(L"\nTime sensor is now ready.");
}
else if(state == SENSOR_STATE_ACCESS_DENIED)
{
wprintf_s(L"\nNo permission for the time sensor.\n");
wprintf_s(L"Enable the sensor in the control panel.\n");
}
return hr;
}
private:
long m_cRef;
};
Después de implementar la interfaz de devolución de llamada, puede proporcionar un sensor determinado con un puntero a una instancia de la clase de devolución de llamada para empezar a recibir notificaciones de eventos desde el sensor.
El siguiente código de ejemplo crea una instancia de la clase de devolución de llamada, y luego solicita notificaciones de eventos de un sensor.
CMyEvents* pEventClass = NULL;
ISensorEvents* pMyEvents = NULL;
if(SUCCEEDED(hr))
{
// Create an instance of the event class.
pEventClass = new(std::nothrow) CMyEvents();
}
if(SUCCEEDED(hr))
{
// Retrieve the pointer to the callback interface.
hr = pEventClass->QueryInterface(IID_PPV_ARGS(&pMyEvents));
}
if(SUCCEEDED(hr))
{
// Start receiving events.
hr = pSensor->SetEventSink(pMyEvents);
}
Puedes escribir un código similar para recibir eventos del administrador de sensores.
El siguiente código de ejemplo muestra cómo dejar de recibir notificaciones de eventos.
if(SUCCEEDED(hr))
{
hr = pSensor->SetEventSink(NULL);
}
Puede sugerir un valor para la frecuencia con la que la aplicación recibe eventos actualizados de datos. Sin embargo, los sensores no están obligados a proporcionar eventos en un intervalo determinado. Debe tener en cuenta que el valor sugerido puede no coincidir con el intervalo de informe real que utiliza el sensor para generar eventos. Para conocer el intervalo de informe real, recupere el valor de la propiedad SENSOR_PROPERTY_CURRENT_REPORT_INTERVAL, como se describe en Recuperar y establecer propiedades del sensor.
El código de ejemplo siguiente crea una función auxiliar que solicita un nuevo valor para la propiedad SENSOR_PROPERTY_CURRENT_REPORT_INTERVAL. La función toma un puntero al sensor para el que se va a establecer la propiedad y un valor de ULONG que indica el nuevo intervalo de informe que se va a establecer.
HRESULT SetCurrentReportInterval(ISensor* pSensor, ULONG ulNewInterval)
{
assert(pSensor);
HRESULT hr = S_OK;
IPortableDeviceValues* pPropsToSet = NULL; // Input
IPortableDeviceValues* pPropsReturn = NULL; // Output
// Create the input object.
hr = CoCreateInstance(__uuidof(PortableDeviceValues),
NULL,
CLSCTX_INPROC_SERVER,
IID_PPV_ARGS(&pPropsToSet));
if(SUCCEEDED(hr))
{
// Add the current report interval property.
hr = pPropsToSet->SetUnsignedIntegerValue(SENSOR_PROPERTY_CURRENT_REPORT_INTERVAL, ulNewInterval);
}
if(SUCCEEDED(hr))
{
// Only setting a single property, here.
hr = pSensor->SetProperties(pPropsToSet, &pPropsReturn);
}
// Test for failure.
if(hr == S_FALSE)
{
HRESULT hrError = S_OK;
// Check results for failure.
hr = pPropsReturn->GetErrorValue(SENSOR_PROPERTY_CURRENT_REPORT_INTERVAL, &hrError);
if(SUCCEEDED(hr))
{
// Print an error message.
wprintf_s(L"\nSetting current report interval failed with error 0x%X\n", hrError);
// Return the error code.
hr = hrError;
}
}
else if(hr == E_ACCESSDENIED)
{
// No permission. Take appropriate action.
}
SafeRelease(&pPropsToSet);
SafeRelease(&pPropsReturn);
return hr;
}