Ställa in och hämta sensoregenskaper

Viktigt!

Använd UWP-sensor-API :et i stället.

COM-baserade sensor-API:et är inaktuellt och bör inte användas i nya program. Inga ytterligare funktioner eller förbättringar planeras och stödet begränsas.

I det här avsnittet beskrivs hur du hämtar och anger värden för sensoregenskaper. Gränssnittet ISensor innehåller metoder för att ange och hämta värden för sensoregenskaper.

Hämtar sensoregenskaper

Du kan hämta vissa egenskapsvärden från en sensor innan användaren har aktiverat den. Information som tillverkarens namn eller sensormodellen kan hjälpa dig att avgöra om programmet kan använda sensorn.

Du kan välja att hämta ett enda egenskapsvärde eller hämta en samling egenskapsvärden tillsammans. Om du vill hämta ett enda värde anropar du ISensor::GetProperty. Om du vill hämta en samling värden anropar du ISensor::GetProperties. Du kan hämta alla egenskaper för en sensor genom att skicka NULL- via den första parametern till ISensor::GetProperties.

I följande exempelkod skapas en hjälpfunktion som skriver ut värdet för en enskild egenskap. Funktionen tar emot en pekare till sensorn som värdet ska hämtas från och en egenskapsnyckel som innehåller egenskapen som ska skrivas ut. Funktionen kan skriva ut värden för tal, strängar och GUIDs, men inte andra, mer komplexa typer.

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

I följande exempelkod skapas en funktion som hämtar och skriver ut en samling egenskaper. Uppsättningen egenskaper som ska skrivas ut definieras av matrisen med namnet SensorProperties.

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

Ange sensoregenskaper

Innan du kan ange egenskapsvärden för en sensor måste användaren aktivera sensorn. Dessutom kan inte alla sensoregenskaper anges.

Om du vill ange ett eller flera värden för egenskaper anropar du ISensor::SetProperties. Du anger den här metoden med en IPortableDeviceValues pekare som innehåller den samling egenskaper som ska anges och deras associerade värden. Metoden returnerar en motsvarande IPortableDeviceValues gränssnitt som kan innehålla felkoder för egenskaper som inte kunde anges.

I följande exempelkod skapas en hjälpfunktion som anger ett nytt värde för egenskapen SENSOR_PROPERTY_CURRENT_REPORT_INTERVAL. Funktionen tar en pekare till sensorn som egenskapen ska anges för och ett ULONG- värde som anger det nya rapportintervallet som ska anges. (Observera att inställningen av ett värde för den här egenskapen inte garanterar att sensorn accepterar det angivna värdet. Se sensoregenskaper för information om hur den här egenskapen fungerar.)

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

Relaterade ämnen

sensoregenskaper