Festlegen und Abrufen von Sensoreigenschaften

In diesem Thema wird beschrieben, wie Werte für Sensoreigenschaften abgerufen und festgelegt werden. Die ISensor Schnittstelle stellt die Methoden zum Festlegen und Abrufen von Werten für Sensoreigenschaften bereit.

Abrufen von Sensoreigenschaften

Sie können einige Eigenschaftswerte von einem Sensor abrufen, bevor der Benutzer ihn aktiviert hat. Informationen wie der Name des Herstellers oder das Modell des Sensors können Ihnen helfen zu entscheiden, ob Ihr Programm den Sensor verwenden kann.

Sie können einen einzelnen Eigenschaftswert abrufen oder eine Sammlung von Eigenschaftswerten zusammen abrufen. Rufen Sie zum Abrufen eines einzelnen Werts ISensor::GetPropertyauf. Rufen Sie zum Abrufen einer Auflistung von Werten ISensor::GetPropertiesauf. Sie können alle Eigenschaften für einen Sensor abrufen, indem Sie NULL- über den ersten Parameter an ISensor::GetPropertiesübergeben.

Im folgenden Beispielcode wird eine Hilfsfunktion erstellt, die den Wert einer einzelnen Eigenschaft druckt. Die Funktion empfängt einen Zeiger auf den Sensor, aus dem der Wert abgerufen werden soll, und einen Eigenschaftsschlüssel, der die zu druckde Eigenschaft enthält. Die Funktion kann Werte für Zahlen, Zeichenfolgen und GUIDs, aber nicht für andere, komplexere Typen drucken.

HRESULT PrintSensorProperty(ISensor* pSensor, REFPROPERTYKEY pk)
{
    assert(pSensor);

    HRESULT hr = S_OK;

    PROPVARIANT pv = {};

    hr = pSensor->GetProperty(pk, &pv);

    if(SUCCEEDED(hr))
    {
        if(pv.vt == VT_UI4)  // Number
        {
            wprintf_s(L"\nSensor integer value: %u\n", pv.ulVal);
        }
        else if(pv.vt == VT_LPWSTR)  // String
        {
            wprintf_s(L"\nSensor string value: %s\n", pv.pwszVal);
        }
        else if(pv.vt == VT_CLSID)  // GUID
        {
            int iRet = 0;

            // Convert the GUID to a string.
            OLECHAR wszGuid[39] = {}; // Buffer for string.
            iRet = ::StringFromGUID2(*(pv.puuid), wszGuid, 39);

            assert(39 == iRet); // Count of characters returned for GUID.

            wprintf_s(L"\nSensor GUID value: %s\n", wszGuid);
        }
        else  // Interface or vector
        {
            wprintf_s(L"\nSensor property is a compound type. Unable to print value.");
        }
    }

    PropVariantClear(&pv);

    return hr;    
}

Im folgenden Beispielcode wird eine Funktion erstellt, die eine Auflistung von Eigenschaften abruft und druckt. Der Satz der zu druckende Eigenschaften wird durch das Array mit dem Namen "SensorProperties" definiert.

HRESULT PrintSensorProperties(ISensor* pSensor)
{
    assert(pSensor);

    HRESULT hr = S_OK;

    DWORD cVals = 0; // Count of returned properties.
    IPortableDeviceKeyCollection* pKeys = NULL; // Input
    IPortableDeviceValues* pValues = NULL;  // Output

    // Properties to print.
    const PROPERTYKEY SensorProperties[] =
    {
        SENSOR_PROPERTY_MANUFACTURER,
        SENSOR_PROPERTY_SERIAL_NUMBER,
        SENSOR_PROPERTY_DESCRIPTION,
        SENSOR_PROPERTY_FRIENDLY_NAME
    };

    // CoCreate a key collection to store property keys.
    hr = CoCreateInstance(CLSID_PortableDeviceKeyCollection, 
                                NULL, 
                                CLSCTX_INPROC_SERVER,                                 
                                IID_PPV_ARGS(&pKeys));

    if(SUCCEEDED(hr))
    {
        // Add the properties to the key collection.
        for (DWORD dwIndex = 0; dwIndex < ARRAYSIZE(SensorProperties); dwIndex++)
        {
            hr = pKeys->Add(SensorProperties[dwIndex]);

            if(FAILED(hr))
            {
                // Unexpected.
                // This example returns the failed HRESULT.
                // You may choose to ignore failures, here.
                break;
            }
        }
    }

    if(SUCCEEDED(hr))
    {
        // Retrieve the properties from the sensor.
        hr = pSensor->GetProperties(pKeys, &pValues);
    }

    if(SUCCEEDED(hr))
    {
        // Get the number of values returned.        
        hr = pValues->GetCount(&cVals);
    }

    if(SUCCEEDED(hr))
    {
        PROPERTYKEY pk; // Keys
        PROPVARIANT pv = {}; // Values

        // Loop through the values;
        for (DWORD i = 0; i < cVals; i++)
        {
            // Get the value at the current index.
            hr = pValues->GetAt(i, &pk, &pv);

            if(SUCCEEDED(hr))
            { 
                // Find and print the property.
                if(IsEqualPropertyKey(pk, SENSOR_PROPERTY_MANUFACTURER))
                {
                    wprintf_s(L"\nManufacturer: %s\n", pv.pwszVal);
                }
                else if(IsEqualPropertyKey(pk, SENSOR_PROPERTY_SERIAL_NUMBER))
                {
                    wprintf_s(L"Serial number: %s\n", pv.pwszVal);
                }
                else if(IsEqualPropertyKey(pk, SENSOR_PROPERTY_FRIENDLY_NAME))
                {
                    wprintf_s(L"Friendly name: %s\n", pv.pwszVal);
                }
                else if(IsEqualPropertyKey(pk, SENSOR_PROPERTY_DESCRIPTION))
                {
                    wprintf_s(L"Description: %s\n", pv.pwszVal);
                }
            }

            PropVariantClear(&pv);
        } // end i loop        
    }

    SafeRelease(&pKeys);
    SafeRelease(&pValues);

    return hr;
};

Festlegen von Sensoreigenschaften

Bevor Sie Eigenschaftswerte für einen Sensor festlegen können, muss der Benutzer den Sensor aktivieren. Außerdem können nicht alle Sensoreigenschaften festgelegt werden.

Um einen oder mehrere Werte für Eigenschaften festzulegen, rufen Sie ISensor::SetPropertiesauf. Sie stellen diese Methode mit einem IPortableDeviceValues Zeiger bereit, der die Auflistung der festzulegenden Eigenschaften und deren zugeordneten Werte enthält. Die Methode gibt eine entsprechende IPortableDeviceValues Schnittstelle zurück, die Fehlercodes für Eigenschaften enthalten kann, die nicht festgelegt werden konnten.

Im folgenden Beispielcode wird eine Hilfsfunktion erstellt, die einen neuen Wert für die eigenschaft SENSOR_PROPERTY_CURRENT_REPORT_INTERVAL festlegt. Die Funktion verwendet einen Zeiger auf den Sensor, für den die Eigenschaft festgelegt werden soll, und einen ULONG- Wert, der das festzulegende neue Berichtsintervall angibt. (Beachten Sie, dass das Festlegen eines Werts für diese bestimmte Eigenschaft nicht garantiert, dass der Sensor den angegebenen Wert akzeptiert. Informationen zur Funktionsweise dieser Eigenschaft finden Sie unter Sensoreigenschaften.)

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;
}

Verwandte Themen

Sensoreigenschaften