Initial publish

1 files changed, 1314 insertions, 0 deletions

diff --git a/wpd/WpdBasicHardwareDriver/WpdObjectProperties.cpp b/wpd/WpdBasicHardwareDriver/WpdObjectProperties.cpp
new file mode 100644
index 00000000..927b8a19
--- /dev/null
+++ b/wpd/WpdBasicHardwareDriver/WpdObjectProperties.cpp
@@ -0,0 +1,1314 @@
+#include "stdafx.h"
+
+#include "WpdObjectProperties.tmh"
+
+const PROPERTYKEY g_SupportedCommonProperties[] =
+{
+    WPD_OBJECT_ID,
+    WPD_OBJECT_PERSISTENT_UNIQUE_ID,
+    WPD_OBJECT_PARENT_ID,
+    WPD_OBJECT_NAME,
+    WPD_OBJECT_FORMAT,
+    WPD_OBJECT_CONTENT_TYPE,
+    WPD_OBJECT_CAN_DELETE,
+};
+
+const PROPERTYKEY g_SupportedDeviceProperties[] =
+{
+    WPD_DEVICE_FIRMWARE_VERSION,
+    WPD_DEVICE_POWER_LEVEL,
+    WPD_DEVICE_POWER_SOURCE,
+    WPD_DEVICE_PROTOCOL,
+    WPD_DEVICE_MODEL,
+    WPD_DEVICE_SERIAL_NUMBER,
+    WPD_DEVICE_SUPPORTS_NON_CONSUMABLE,
+    WPD_DEVICE_MANUFACTURER,
+    WPD_DEVICE_FRIENDLY_NAME,
+    WPD_DEVICE_TYPE,
+    WPD_FUNCTIONAL_OBJECT_CATEGORY,
+};
+
+const PROPERTYKEY g_SupportedSensorProperties[] = 
+{
+    SENSOR_READING,
+    SENSOR_UPDATE_INTERVAL,
+    WPD_FUNCTIONAL_OBJECT_CATEGORY,
+};
+
+
+WpdObjectProperties::WpdObjectProperties() : 
+    m_dwUpdateInterval(0), 
+    m_llSensorReading(0)
+{
+
+}
+
+WpdObjectProperties::~WpdObjectProperties()
+{
+    m_pBaseDriver = NULL;
+}
+
+HRESULT WpdObjectProperties::Initialize(_In_ WpdBaseDriver* pBaseDriver)
+{
+    m_pBaseDriver = pBaseDriver;
+    return S_OK;
+}
+
+HRESULT WpdObjectProperties::DispatchWpdMessage(
+    _In_ REFPROPERTYKEY         Command,
+    _In_ IPortableDeviceValues* pParams,
+    _In_ IPortableDeviceValues* pResults)
+{
+    HRESULT hr = S_OK;
+
+    if (Command.fmtid != WPD_CATEGORY_OBJECT_PROPERTIES)
+    {
+        hr = E_INVALIDARG;
+        CHECK_HR(hr, "This object does not support this command category %ws",CComBSTR(Command.fmtid));
+    }
+
+    if (hr == S_OK)
+    {
+        if (IsEqualPropertyKey(Command, WPD_COMMAND_OBJECT_PROPERTIES_GET_SUPPORTED))
+        {
+            hr = OnGetSupportedProperties(pParams, pResults);
+            CHECK_HR(hr, "Failed to get supported properties");
+        }
+        else if(IsEqualPropertyKey(Command, WPD_COMMAND_OBJECT_PROPERTIES_GET))
+        {
+            hr = OnGetPropertyValues(pParams, pResults);
+            if(FAILED(hr))
+            {
+                CHECK_HR(hr, "Failed to get properties");
+            }
+        }
+        else if(IsEqualPropertyKey(Command, WPD_COMMAND_OBJECT_PROPERTIES_GET_ALL))
+        {
+            hr = OnGetAllPropertyValues(pParams, pResults);
+            if(FAILED(hr))
+            {
+                CHECK_HR(hr, "Failed to get all properties");
+            }
+        }
+        else if(IsEqualPropertyKey(Command, WPD_COMMAND_OBJECT_PROPERTIES_SET))
+        {
+            hr = OnSetPropertyValues(pParams, pResults);
+            if(FAILED(hr))
+            {
+                CHECK_HR(hr, "Failed to set properties");
+            }
+        }
+        else if(IsEqualPropertyKey(Command, WPD_COMMAND_OBJECT_PROPERTIES_GET_ATTRIBUTES))
+        {
+            hr = OnGetPropertyAttributes(pParams, pResults);
+            if(FAILED(hr))
+            {
+                CHECK_HR(hr, "Failed to get property attributes");
+            }
+        }
+        else if(IsEqualPropertyKey(Command, WPD_COMMAND_OBJECT_PROPERTIES_DELETE))
+        {
+            hr = OnDeleteProperties(pParams, pResults);
+            if(FAILED(hr))
+            {
+                CHECK_HR(hr, "Failed to delete properties");
+            }
+        }
+        else
+        {
+            hr = E_NOTIMPL;
+            CHECK_HR(hr, "This object does not support this command id %d", Command.pid);
+        }
+    }
+    return hr;
+}
+
+/**
+ *  This method is called when we receive a WPD_COMMAND_OBJECT_PROPERTIES_GET_SUPPORTED
+ *  command.
+ *
+ *  The parameters sent to us are:
+ *  - WPD_PROPERTY_OBJECT_PROPERTIES_OBJECT_ID: identifies the object whose supported properties have
+ *      been requested.
+ *
+ *  - WPD_PROPERTY_OBJECT_PROPERTIES_FILTER: the filter to use when returning supported properties.
+ *      Since this parameter is optional, it may not exist.
+ *      ! This driver currently ignores the filter parameter. !
+ *
+ *  The driver should:
+ *  - Return supported property keys for the specified object in WPD_PROPERTY_OBJECT_PROPERTIES_PROPERTY_KEYS
+ */
+HRESULT WpdObjectProperties::OnGetSupportedProperties(
+    _In_ IPortableDeviceValues*  pParams,
+    _In_ IPortableDeviceValues*  pResults)
+{
+    HRESULT hr          = S_OK;
+    LPWSTR  wszObjectID = NULL;
+    CComPtr<IPortableDeviceKeyCollection> pKeys;
+
+    // First get ALL parameters for this command.  If we cannot get ALL parameters
+    // then E_INVALIDARG should be returned and no further processing should occur.
+
+    // Get the object identifier whose supported properties have been requested
+    hr = pParams->GetStringValue(WPD_PROPERTY_OBJECT_PROPERTIES_OBJECT_ID, &wszObjectID);
+    if (hr != S_OK)
+    {
+        hr = E_INVALIDARG;
+        CHECK_HR(hr, "Missing string value for WPD_PROPERTY_OBJECT_PROPERTIES_OBJECT_ID");
+    }
+
+    // CoCreate a collection to store the supported property keys.
+    if (hr == S_OK)
+    {
+        hr = CoCreateInstance(CLSID_PortableDeviceKeyCollection,
+                              NULL,
+                              CLSCTX_INPROC_SERVER,
+                              IID_IPortableDeviceKeyCollection,
+                              (VOID**) &pKeys);
+        CHECK_HR(hr, "Failed to CoCreate CLSID_PortableDeviceKeyCollection");
+    }
+
+    // Add supported property keys for the specified object to the collection
+    if (hr == S_OK)
+    {
+        hr = AddSupportedPropertyKeys(wszObjectID, pKeys);
+        CHECK_HR(hr, "Failed to add supported property keys for object '%ws'", wszObjectID);
+    }
+
+    // Set the WPD_PROPERTY_OBJECT_PROPERTIES_PROPERTY_KEYS value in the results.
+    if (hr == S_OK)
+    {
+        hr = pResults->SetIPortableDeviceKeyCollectionValue(WPD_PROPERTY_OBJECT_PROPERTIES_PROPERTY_KEYS, pKeys);
+        CHECK_HR(hr, "Failed to set WPD_PROPERTY_OBJECT_PROPERTIES_PROPERTY_KEYS");
+    }
+
+    // Free the memory.
+    CoTaskMemFree(wszObjectID);
+    wszObjectID = NULL;
+
+    return hr;
+}
+
+/**
+ *  This method is called when we receive a WPD_COMMAND_OBJECT_PROPERTIES_GET
+ *  command.
+ *
+ *  The parameters sent to us are:
+ *  - WPD_PROPERTY_OBJECT_PROPERTIES_OBJECT_ID: identifies the object whose property values have been requested.
+ *  - WPD_PROPERTY_OBJECT_PROPERTIES_PROPERTY_KEYS: a collection of property keys, identifying which
+ *      specific property values we are requested to return.
+ *
+ *  The driver should:
+ *  - Return all requested property values in WPD_PROPERTY_OBJECT_PROPERTIES_PROPERTY_VALUES.  If any property read failed, the corresponding value should be
+ *      set to type VT_ERROR with the 'scode' member holding the HRESULT reason for the failure.
+ *  - S_OK should be returned if all properties were read successfully.
+ *  - S_FALSE should be returned if any property read failed.
+ *  - Any error return indicates that the driver did not fill in any results, and the caller will
+ *      not attempt to unpack any property values.
+ */
+HRESULT WpdObjectProperties::OnGetPropertyValues(
+    _In_ IPortableDeviceValues*  pParams,
+    _In_ IPortableDeviceValues*  pResults)
+{
+    HRESULT hr          = S_OK;
+    LPWSTR  wszObjectID = NULL;
+    CComPtr<IPortableDeviceValues>        pValues;
+    CComPtr<IPortableDeviceKeyCollection> pKeys;
+
+    // First get ALL parameters for this command.  If we cannot get ALL parameters
+    // then E_INVALIDARG should be returned and no further processing should occur.
+
+    // Get the object identifier whose property values have been requested
+    if (hr == S_OK)
+    {
+        hr = pParams->GetStringValue(WPD_PROPERTY_OBJECT_PROPERTIES_OBJECT_ID, &wszObjectID);
+        CHECK_HR(hr, "Missing value for WPD_PROPERTY_OBJECT_PROPERTIES_OBJECT_ID");
+    }
+
+    // Get the list of property keys for the property values the caller wants to retrieve from the specified object
+    if (hr == S_OK)
+    {
+        hr = pParams->GetIPortableDeviceKeyCollectionValue(WPD_PROPERTY_OBJECT_PROPERTIES_PROPERTY_KEYS, &pKeys);
+        CHECK_HR(hr, "Missing value for WPD_PROPERTY_OBJECT_PROPERTIES_PROPERTY_KEYS");
+    }
+
+    // CoCreate a collection to store the property values.
+    if (hr == S_OK)
+    {
+        hr = CoCreateInstance(CLSID_PortableDeviceValues,
+                              NULL,
+                              CLSCTX_INPROC_SERVER,
+                              IID_IPortableDeviceValues,
+                              (VOID**) &pValues);
+        CHECK_HR(hr, "Failed to CoCreate CLSID_PortableDeviceValues");
+    }
+
+    // Read the specified properties on the specified object and add the property values to the collection.
+    if (hr == S_OK)
+    {
+        hr = GetPropertyValuesForObject(wszObjectID, pKeys, pValues);
+        CHECK_HR(hr, "Failed to get property values for object '%ws'", wszObjectID);
+    }
+
+    // S_OK or S_FALSE can be returned from GetPropertyValuesForObject( ).
+    // S_FALSE means that 1 or more property values could not be retrieved successfully.
+    // The value for the specified property should be set to an error HRESULT of
+    // the reason why the property could not be read.
+    // (e.g. If the property being requested is not supported on the object then an error of
+    // HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED) should be set as the value.
+    if (SUCCEEDED(hr))
+    {
+        // Set the WPD_PROPERTY_OBJECT_PROPERTIES_PROPERTY_VALUES value in the results.
+        HRESULT hrTemp = S_OK;
+        hrTemp = pResults->SetIPortableDeviceValuesValue(WPD_PROPERTY_OBJECT_PROPERTIES_PROPERTY_VALUES, pValues);
+        CHECK_HR(hrTemp, ("Failed to set WPD_PROPERTY_OBJECT_PROPERTIES_PROPERTY_VALUES"));
+
+        if(FAILED(hrTemp))
+        {
+            hr = hrTemp;
+        }
+    }
+
+    // Free the memory.
+    CoTaskMemFree(wszObjectID);
+    wszObjectID = NULL;
+
+    return hr;
+}
+
+/**
+ *  This method is called when we receive a WPD_COMMAND_OBJECT_PROPERTIES_GET_ALL
+ *  command.
+ *
+ *  The parameters sent to us are:
+ *  - WPD_PROPERTY_OBJECT_PROPERTIES_OBJECT_ID: identifies the object whose property values have been requested.
+ *
+ *  The driver should:
+ *  - Return all property values in WPD_PROPERTY_OBJECT_PROPERTIES_PROPERTY_VALUES.  If any property read failed, the corresponding value should be
+ *      set to type VT_ERROR with the 'scode' member holding the HRESULT reason for the failure.
+ *  - S_OK should be returned if all properties were read successfully.
+ *  - S_FALSE should be returned if any property read failed.
+ *  - Any error return indicates that the driver did not fill in any results, and the caller will
+ *      not attempt to unpack any property values.
+ */
+HRESULT WpdObjectProperties::OnGetAllPropertyValues(
+    _In_ IPortableDeviceValues*  pParams,
+    _In_ IPortableDeviceValues*  pResults)
+{
+    HRESULT hr          = S_OK;
+    LPWSTR  wszObjectID = NULL;
+    CComPtr<IPortableDeviceValues>        pValues;
+    CComPtr<IPortableDeviceKeyCollection> pKeys;
+
+    // First get ALL parameters for this command.  If we cannot get ALL parameters
+    // then E_INVALIDARG should be returned and no further processing should occur.
+
+    // Get the object identifier whose property values have been requested
+    if (hr == S_OK)
+    {
+        hr = pParams->GetStringValue(WPD_PROPERTY_OBJECT_PROPERTIES_OBJECT_ID, &wszObjectID);
+        CHECK_HR(hr, "Missing value for WPD_PROPERTY_OBJECT_PROPERTIES_OBJECT_ID");
+    }
+
+    // CoCreate a collection to store the property values.
+    if (hr == S_OK)
+    {
+        hr = CoCreateInstance(CLSID_PortableDeviceValues,
+                              NULL,
+                              CLSCTX_INPROC_SERVER,
+                              IID_IPortableDeviceValues,
+                              (VOID**) &pValues);
+        CHECK_HR(hr, "Failed to CoCreate CLSID_PortableDeviceValues");
+    }
+
+    // CoCreate a collection to store the property keys we are going to use
+    // to request the property values of.
+    if (hr == S_OK)
+    {
+        hr = CoCreateInstance(CLSID_PortableDeviceKeyCollection,
+                              NULL,
+                              CLSCTX_INPROC_SERVER,
+                              IID_IPortableDeviceKeyCollection,
+                              (VOID**) &pKeys);
+        CHECK_HR(hr, "Failed to CoCreate CLSID_PortableDeviceKeyCollection");
+    }
+
+    // First we make a request for ALL supported property keys for the specified object.
+    // Next, we delegate to our helper function GetPropertyValuesForObject( ) passing
+    // the entire property key collection.  This will reuse existing implementation
+    // in our driver to perform the GetAllPropertyValues operation.
+    if (hr == S_OK)
+    {
+        hr = AddSupportedPropertyKeys(wszObjectID, pKeys);
+        CHECK_HR(hr, "Failed to get ALL supported properties for object '%ws'", wszObjectID);
+        if (hr == S_OK)
+        {
+            hr = GetPropertyValuesForObject(wszObjectID, pKeys, pValues);
+            CHECK_HR(hr, "Failed to get property values for object '%ws'", wszObjectID);
+        }
+    }
+
+    // S_OK or S_FALSE can be returned from GetPropertyValuesForObject( ).
+    // S_FALSE means that 1 or more property values could not be retrieved successfully.
+    // The value for the specified property key should be set to the error HRESULT of
+    // the reason why the property could not be read.
+    // (i.e. an error of HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED) if a property value was
+    //  requested and is not supported by the specified object.)
+    if (SUCCEEDED(hr))
+    {
+        // Set the WPD_PROPERTY_OBJECT_PROPERTIES_PROPERTY_VALUES value in the results
+        HRESULT hrTemp = S_OK;
+        hrTemp = pResults->SetIPortableDeviceValuesValue(WPD_PROPERTY_OBJECT_PROPERTIES_PROPERTY_VALUES, pValues);
+        CHECK_HR(hrTemp, ("Failed to set WPD_PROPERTY_OBJECT_PROPERTIES_PROPERTY_VALUES"));
+
+        if(FAILED(hrTemp))
+        {
+            hr = hrTemp;
+        }
+    }
+
+    // Free the memory.
+    CoTaskMemFree(wszObjectID);
+    wszObjectID = NULL;
+
+    return hr;
+}
+
+/**
+ *  This method is called when we receive a WPD_COMMAND_OBJECT_PROPERTIES_SET
+ *  command.
+ *
+ *  The parameters sent to us are:
+ *  - WPD_PROPERTY_OBJECT_PROPERTIES_OBJECT_ID: identifies the object whose property values we want to return.
+ *  - WPD_PROPERTY_OBJECT_PROPERTIES_PROPERTY_VALUES: an IPortableDeviceValues of values, identifying which
+ *      specific property values we are requested to write.
+ *
+ *  The driver should:
+ *  - Write all requested property values.  For each property, a write result should be returned in the
+ *      write result property store.
+ *  - If any property write failed, the corresponding write result value should be
+ *      set to type VT_ERROR with the 'scode' member holding the HRESULT reason for the failure.
+ *  - S_OK should be returned if all properties were written successfully.
+ *  - S_FALSE should be returned if any property write failed.
+ *  - Any error return indicates that the driver did not write any results, and the caller will
+ *      not attempt to unpack any property write results.
+ */
+HRESULT WpdObjectProperties::OnSetPropertyValues(
+    _In_ IPortableDeviceValues*  pParams,
+    _In_ IPortableDeviceValues*  pResults)
+{
+    HRESULT      hr          = S_OK;
+    HRESULT      hrResult    = S_OK;
+    LPWSTR       wszObjectID = NULL;
+    DWORD        cValues     = 0;
+    CAtlStringW  strObjectID;   
+
+    CComPtr<IPortableDeviceValues> pValues;
+    CComPtr<IPortableDeviceValues> pWriteResults;
+    CComPtr<IPortableDeviceValues> pEventParams;
+
+
+    // First get ALL parameters for this command.  If we cannot get ALL parameters
+    // then E_INVALIDARG should be returned and no further processing should occur.
+
+    // Get the object identifier whose property values are being set
+    if (hr == S_OK)
+    {
+        hr = pParams->GetStringValue(WPD_PROPERTY_OBJECT_PROPERTIES_OBJECT_ID, &wszObjectID);
+        CHECK_HR(hr, "Missing value for WPD_PROPERTY_OBJECT_PROPERTIES_OBJECT_ID");
+    }
+
+    // Get the caller-supplied property values requested to be set on the object
+    if (hr == S_OK)
+    {
+        strObjectID = wszObjectID;
+
+        hr = pParams->GetIPortableDeviceValuesValue(WPD_PROPERTY_OBJECT_PROPERTIES_PROPERTY_VALUES, &pValues);
+        CHECK_HR(hr, "Missing value for WPD_PROPERTY_OBJECT_PROPERTIES_PROPERTY_VALUES");
+    }
+
+    // CoCreate a collection to store the property set operation results.
+    if (hr == S_OK)
+    {
+        hr = CoCreateInstance(CLSID_PortableDeviceValues,
+                              NULL,
+                              CLSCTX_INPROC_SERVER,
+                              IID_IPortableDeviceValues,
+                              (VOID**) &pWriteResults);
+        CHECK_HR(hr, "Failed to CoCreate CLSID_PortableDeviceValues");
+    }
+
+    // Set the property values on the specified object
+    if (hr == S_OK)
+    {
+        // Since this driver does not support setting any properties, all property set operation
+        // results will be set to E_ACCESSDENIED.
+        if (hr == S_OK)
+        {
+            hr = pValues->GetCount(&cValues);
+            CHECK_HR(hr, "Failed to get total number of values");
+        }
+
+        if (hr == S_OK)
+        {
+            for (DWORD dwIndex = 0; dwIndex < cValues; dwIndex++)
+            {
+                PROPERTYKEY Key = WPD_PROPERTY_NULL;
+                PROPVARIANT Value = {0};
+
+                PropVariantInit(&Value);
+
+                hr = pValues->GetAt(dwIndex, &Key, &Value);
+                CHECK_HR(hr, "Failed to get PROPERTYKEY at index %d", dwIndex);
+
+                if (hr == S_OK)
+                {
+                    // TODO: Add other ...OBJECT_ID strings where applicable
+                    if (
+                           (strObjectID.CompareNoCase(SENSOR_OBJECT_ID) == 0)           ||
+                           (strObjectID.CompareNoCase(TEMP_SENSOR_OBJECT_ID) == 0)      ||
+                           (strObjectID.CompareNoCase(FLEX_SENSOR_OBJECT_ID) == 0)      ||
+                           (strObjectID.CompareNoCase(PIR_SENSOR_OBJECT_ID) == 0)       ||
+                           (strObjectID.CompareNoCase(PING_SENSOR_OBJECT_ID) == 0)      ||
+                           (strObjectID.CompareNoCase(QTI_SENSOR_OBJECT_ID) == 0)       ||
+                           (strObjectID.CompareNoCase(MEMSIC_SENSOR_OBJECT_ID) == 0)    ||
+                           (strObjectID.CompareNoCase(HITACHI_SENSOR_OBJECT_ID) == 0)   ||
+                           (strObjectID.CompareNoCase(PIEZO_SENSOR_OBJECT_ID) == 0)     ||
+                           (strObjectID.CompareNoCase(COMPASS_SENSOR_OBJECT_ID) == 0)
+                       )
+                    {
+                        if (IsEqualPropertyKey(Key, SENSOR_UPDATE_INTERVAL))
+                        {
+                            if (Value.vt == VT_UI4)
+                            {
+                                hr = SendUpdateIntervalToDevice(Value.ulVal);
+                                CHECK_HR(hr, "Failed to send the new SENSOR_UPDATE_INTERVAL %d on the device", Value.ulVal);
+                            }
+                            else
+                            {
+                                // property failed to be set as it is an invalid vartype
+                                hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
+                                CHECK_HR(hr, "Failed to update the SENSOR_UPDATE_INTERVAL because the vartype is invalid.  Expected VT_UI4, got %d", Value.vt);
+                            }
+
+                            // An error has occurred, set the overall result to S_FALSE
+                            if (hr != S_OK)
+                            {
+                                hrResult = S_FALSE;
+                            }
+
+                            hr = pWriteResults->SetErrorValue(Key, hr);
+                            CHECK_HR(hr, "Failed to set error result value of SENSOR_UPDATE_INTERVAL for '%ws'", wszObjectID);
+                        }
+                        else
+                        {
+                            // Other properties for the sensor object are read only
+                            hr = pWriteResults->SetErrorValue(Key, E_ACCESSDENIED);
+                            CHECK_HR(hr, "Failed to set error result value at index %d for '%ws'", dwIndex, wszObjectID);
+                            hrResult = S_FALSE;
+                        }
+                    } 
+                    else
+                    {
+                        // Properties for all other objects are read only
+                        hr = pWriteResults->SetErrorValue(Key, E_ACCESSDENIED);
+                        CHECK_HR(hr, "Failed to set error result value at index %d for '%ws'", dwIndex, wszObjectID);                           
+                        hrResult = S_FALSE;
+                    }
+                }
+
+                PropVariantClear(&Value);
+
+            } // end for
+        } // end if
+    }
+
+    // At least one property failed to be set
+    if (hrResult != S_OK)
+    {
+        hr = hrResult;
+    }
+
+    if (SUCCEEDED(hr))
+    {
+        // Set the WPD_PROPERTY_OBJECT_PROPERTIES_PROPERTY_WRITE_RESULTS value in the results
+        HRESULT hrTemp = pResults->SetIPortableDeviceValuesValue(WPD_PROPERTY_OBJECT_PROPERTIES_PROPERTY_WRITE_RESULTS, pWriteResults);
+        CHECK_HR(hrTemp, ("Failed to set WPD_PROPERTY_OBJECT_PROPERTIES_PROPERTY_WRITE_RESULTS"));
+
+        // Don't override the S_FALSE hresult that indicates at least one property had failed
+        if (hr == S_OK)
+        {
+            hr = hrTemp;
+        }
+    }
+
+    // Free the memory.
+    CoTaskMemFree(wszObjectID);
+    wszObjectID = NULL;
+
+    return hr;
+}
+
+/**
+ *  This method is called when we receive a WPD_COMMAND_OBJECT_PROPERTIES_GET_ATTRIBUTES
+ *  command.
+ *
+ *  The parameters sent to us are:
+ *  - WPD_PROPERTY_OBJECT_PROPERTIES_OBJECT_ID: identifies the object whose property attributes we want to return.
+ *  - WPD_PROPERTY_OBJECT_PROPERTIES_PROPERTY_KEYS: a collection of property keys containing a single value,
+ *      which is the key identifying the specific property attributes we are requested to return.
+ *
+ *  The driver should:
+ *  - Return the requested property attributes.  If any property attributes failed to be retrieved,
+ *    the corresponding value should be set to type VT_ERROR with the 'scode' member holding the
+ *    HRESULT reason for the failure.
+ *  - S_OK should be returned if all property attributes were read successfully.
+ *  - S_FALSE should be returned if any property attribute failed.
+ *  - Any error return indicates that the driver did not fill in any results, and the caller will
+ *      not attempt to unpack any property values.
+ */
+HRESULT WpdObjectProperties::OnGetPropertyAttributes(
+    _In_ IPortableDeviceValues*  pParams,
+    _In_ IPortableDeviceValues*  pResults)
+{
+    HRESULT     hr          = S_OK;
+    LPWSTR      wszObjectID = NULL;
+    PROPERTYKEY Key         = WPD_PROPERTY_NULL;
+    CComPtr<IPortableDeviceValues>  pAttributes;
+
+    // First get ALL parameters for this command.  If we cannot get ALL parameters
+    // then E_INVALIDARG should be returned and no further processing should occur.
+
+    // Get the object identifier whose property attributes have been requested
+    if (hr == S_OK)
+    {
+        hr = pParams->GetStringValue(WPD_PROPERTY_OBJECT_PROPERTIES_OBJECT_ID, &wszObjectID);
+        CHECK_HR(hr, "Missing value for WPD_PROPERTY_OBJECT_PROPERTIES_OBJECT_ID");
+    }
+
+    // Get the list of property keys whose attributes are being requested
+    if (hr == S_OK)
+    {
+        hr = pParams->GetKeyValue(WPD_PROPERTY_OBJECT_PROPERTIES_PROPERTY_KEYS, &Key);
+        CHECK_HR(hr, "Missing value for WPD_PROPERTY_OBJECT_PROPERTIES_PROPERTY_KEYS");
+    }
+
+    // CoCreate a collection to store the property attributes.
+    if (hr == S_OK)
+    {
+        hr = CoCreateInstance(CLSID_PortableDeviceValues,
+                              NULL,
+                              CLSCTX_INPROC_SERVER,
+                              IID_IPortableDeviceValues,
+                              (VOID**) &pAttributes);
+        CHECK_HR(hr, "Failed to CoCreate CLSID_PortableDeviceValues");
+    }
+
+    // Get the attributes for the specified properties on the specified object and add them
+    // to the collection.
+    if (hr == S_OK)
+    {
+        hr = GetPropertyAttributesForObject(wszObjectID, Key, pAttributes);
+        CHECK_HR(hr, "Failed to get property attributes");
+    }
+
+    if (SUCCEEDED(hr))
+    {
+        // Set the WPD_PROPERTY_OBJECT_PROPERTIES_PROPERTY_ATTRIBUTES value in the results
+        HRESULT hrTemp = S_OK;
+        hrTemp = pResults->SetIPortableDeviceValuesValue(WPD_PROPERTY_OBJECT_PROPERTIES_PROPERTY_ATTRIBUTES, pAttributes);
+        CHECK_HR(hrTemp, ("Failed to set WPD_PROPERTY_OBJECT_PROPERTIES_PROPERTY_ATTRIBUTES"));
+
+        if(FAILED(hrTemp))
+        {
+            hr = hrTemp;
+        }
+    }
+
+    // Free the memory.
+    CoTaskMemFree(wszObjectID);
+    wszObjectID = NULL;
+
+    return hr;
+}
+
+/**
+ *  This method is called when we receive a WPD_COMMAND_OBJECT_PROPERTIES_DELETE
+ *  command.
+ *
+ *  The parameters sent to us are:
+ *  - WPD_PROPERTY_OBJECT_PROPERTIES_OBJECT_ID: identifies the object whose properties should be deleted.
+ *  - WPD_PROPERTY_OBJECT_PROPERTIES_PROPERTY_KEYS: a collection of property keys indicating which
+ *      properties to delete.
+ *
+ *  The driver should:
+ *  - Delete the specified properties from the object.
+ *  - S_OK should be returned if all specified properties were successfully deleted.
+ *  - E_ACCESSDENIED should be returned if the client attempts to delete a property which is not deletable (i.e.
+ *    WPD_PROPERTY_ATTRIBUTE_CAN_DELETE is FALSE for that property.)
+ */
+HRESULT WpdObjectProperties::OnDeleteProperties(
+    _In_ IPortableDeviceValues*  pParams,
+    _In_ IPortableDeviceValues*  pResults)
+{
+    HRESULT hr = E_ACCESSDENIED;
+
+    UNREFERENCED_PARAMETER(pParams);
+    UNREFERENCED_PARAMETER(pResults);
+
+    // This driver has no properties which can be deleted.
+
+    return hr;
+}
+
+/**
+ *  This method is called to populate supported PROPERTYKEYs found on objects.
+ *
+ *  The parameters sent to us are:
+ *  wszObjectID - the object whose supported property keys are being requested
+ *  pKeys - An IPortableDeviceKeyCollection to be populated with supported PROPERTYKEYs
+ *
+ *  The driver should:
+ *  Add PROPERTYKEYs pertaining to the specified object.
+ */
+HRESULT AddSupportedPropertyKeys(
+    _In_ LPCWSTR                        wszObjectID,
+    _In_ IPortableDeviceKeyCollection*  pKeys)
+{
+    HRESULT     hr          = S_OK;
+    CAtlStringW strObjectID = wszObjectID;
+
+    // Add Common PROPERTYKEYs for ALL WPD objects
+    AddCommonPropertyKeys(pKeys);
+
+    if (strObjectID.CompareNoCase(WPD_DEVICE_OBJECT_ID) == 0)
+    {
+        // Add the PROPERTYKEYs for the 'DEVICE' object
+        AddDevicePropertyKeys(pKeys);
+    }
+
+    // Add other PROPERTYKEYs for other supported objects...
+    // TODO: Add comparison to other ..._OBJECT_IDs where applicable
+    if (
+           (strObjectID.CompareNoCase(SENSOR_OBJECT_ID) == 0) ||
+           (strObjectID.CompareNoCase(TEMP_SENSOR_OBJECT_ID) == 0) ||
+           (strObjectID.CompareNoCase(FLEX_SENSOR_OBJECT_ID) == 0) ||
+           (strObjectID.CompareNoCase(PIR_SENSOR_OBJECT_ID) == 0) ||
+           (strObjectID.CompareNoCase(PING_SENSOR_OBJECT_ID) == 0) ||
+           (strObjectID.CompareNoCase(QTI_SENSOR_OBJECT_ID) == 0) ||
+           (strObjectID.CompareNoCase(MEMSIC_SENSOR_OBJECT_ID) == 0) ||
+           (strObjectID.CompareNoCase(HITACHI_SENSOR_OBJECT_ID) == 0) ||
+           (strObjectID.CompareNoCase(PIEZO_SENSOR_OBJECT_ID) == 0) ||
+           (strObjectID.CompareNoCase(COMPASS_SENSOR_OBJECT_ID) == 0)
+       )
+    {
+        // Add the PROPERTYKEYs for the Sensor object
+        AddSensorPropertyKeys(pKeys);
+    }
+
+    
+
+    return hr;
+}
+
+/**
+ *  This method is called to populate common PROPERTYKEYs found on ALL objects.
+ *
+ *  The parameters sent to us are:
+ *  pKeys - An IPortableDeviceKeyCollection to be populated with PROPERTYKEYs
+ *
+ *  The driver should:
+ *  Add PROPERTYKEYs pertaining to the ALL objects.
+ */
+VOID AddCommonPropertyKeys(
+    _In_ IPortableDeviceKeyCollection* pKeys)
+{
+    if (pKeys != NULL)
+    {
+        for (DWORD dwIndex = 0; dwIndex < ARRAYSIZE(g_SupportedCommonProperties); dwIndex++)
+        {
+            HRESULT hr = S_OK;
+            hr = pKeys->Add(g_SupportedCommonProperties[dwIndex] );
+            CHECK_HR(hr, "Failed to add common property");
+        }
+    }
+}
+
+/**
+ *  This method is called to populate PROPERTYKEYs found on the SENSOR object.
+ *
+ *  The parameters sent to us are:
+ *  pKeys - An IPortableDeviceKeyCollection to be populated with PROPERTYKEYs
+ *
+ *  The driver should:
+ *  Add PROPERTYKEYs pertaining to the DEVICE object.
+ */
+VOID AddSensorPropertyKeys(
+    _In_ IPortableDeviceKeyCollection* pKeys)
+{
+    if (pKeys != NULL)
+    {
+        for (DWORD dwIndex = 0; dwIndex < ARRAYSIZE(g_SupportedSensorProperties); dwIndex++)
+        {
+            HRESULT hr = S_OK;
+            hr = pKeys->Add(g_SupportedSensorProperties[dwIndex] );
+            CHECK_HR(hr, "Failed to add sensor property");
+        }
+    }
+}
+
+/**
+ *  This method is called to populate common PROPERTYKEYs found on the DEVICE object.
+ *
+ *  The parameters sent to us are:
+ *  pKeys - An IPortableDeviceKeyCollection to be populated with PROPERTYKEYs
+ *
+ *  The driver should:
+ *  Add PROPERTYKEYs pertaining to the DEVICE object.
+ */
+VOID AddDevicePropertyKeys(
+    _In_ IPortableDeviceKeyCollection* pKeys)
+{
+    if (pKeys != NULL)
+    {
+        for (DWORD dwIndex = 0; dwIndex < ARRAYSIZE(g_SupportedDeviceProperties); dwIndex++)
+        {
+            HRESULT hr = S_OK;
+            hr = pKeys->Add(g_SupportedDeviceProperties[dwIndex] );
+            CHECK_HR(hr, "Failed to add device property");
+        }
+    }
+}
+
+
+/**
+ *  This method is called to populate property values for the object specified.
+ *
+ *  The parameters sent to us are:
+ *  wszObjectID - the object whose properties are being requested.
+ *  pKeys - the list of property keys of the properties to request from the object
+ *  pValues - an IPortableDeviceValues which will contain the property values retreived from the object
+ *
+ *  The driver should:
+ *  Read the specified properties for the specified object and populate pValues with the
+ *  results.
+ */
+HRESULT WpdObjectProperties::GetPropertyValuesForObject(
+    _In_ LPCWSTR                        wszObjectID,
+    _In_ IPortableDeviceKeyCollection*  pKeys,
+    _In_ IPortableDeviceValues*         pValues)
+{
+    HRESULT     hr          = S_OK;
+    CAtlStringW strObjectID = wszObjectID;
+    DWORD       cKeys       = 0;
+
+    if ((wszObjectID == NULL) ||
+        (pKeys       == NULL) ||
+        (pValues     == NULL))
+    {
+        hr = E_INVALIDARG;
+        return hr;
+    }
+
+    hr = pKeys->GetCount(&cKeys);
+    CHECK_HR(hr, "Failed to number of PROPERTYKEYs in collection");
+
+    if (hr == S_OK)
+    {
+        // Get values for the DEVICE object
+        if (strObjectID.CompareNoCase(WPD_DEVICE_OBJECT_ID) == 0)
+        {
+            for (DWORD dwIndex = 0; dwIndex < cKeys; dwIndex++)
+            {
+                PROPERTYKEY Key = WPD_PROPERTY_NULL;
+                hr = pKeys->GetAt(dwIndex, &Key);
+                CHECK_HR(hr, "Failed to get PROPERTYKEY at index %d in collection", dwIndex);
+
+                if (hr == S_OK)
+                {
+                    // Preset the property value to 'error not supported'.  The actual value
+                    // will replace this value, if read from the device.
+                    pValues->SetErrorValue(Key, HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED));
+
+                    // Set DEVICE object properties
+                    if (IsEqualPropertyKey(Key, WPD_DEVICE_FIRMWARE_VERSION))
+                    {
+                        hr = pValues->SetStringValue(WPD_DEVICE_FIRMWARE_VERSION, DEVICE_FIRMWARE_VERSION_VALUE);
+                        CHECK_HR(hr, "Failed to set WPD_DEVICE_FIRMWARE_VERSION");
+                    }
+
+                    else if (IsEqualPropertyKey(Key, WPD_DEVICE_POWER_LEVEL))
+                    {
+                        hr = pValues->SetUnsignedIntegerValue(WPD_DEVICE_POWER_LEVEL, DEVICE_POWER_LEVEL_VALUE);
+                        CHECK_HR(hr, "Failed to set WPD_DEVICE_POWER_LEVEL");
+                    }
+
+                    else if (IsEqualPropertyKey(Key, WPD_DEVICE_POWER_SOURCE))
+                    {
+                        hr = pValues->SetUnsignedIntegerValue(WPD_DEVICE_POWER_SOURCE, WPD_POWER_SOURCE_EXTERNAL);
+                        CHECK_HR(hr, "Failed to set WPD_DEVICE_POWER_SOURCE");
+                    }
+
+                    else if (IsEqualPropertyKey(Key, WPD_DEVICE_PROTOCOL))
+                    {
+                        hr = pValues->SetStringValue(WPD_DEVICE_PROTOCOL, DEVICE_PROTOCOL_VALUE);
+                        CHECK_HR(hr, "Failed to set WPD_DEVICE_PROTOCOL");
+                    }
+
+                    else if (IsEqualPropertyKey(Key, WPD_DEVICE_MODEL))
+                    {
+                        hr = pValues->SetStringValue(WPD_DEVICE_MODEL, DEVICE_MODEL_VALUE);
+                        CHECK_HR(hr, "Failed to set WPD_DEVICE_MODEL");
+                    }
+
+                    else if (IsEqualPropertyKey(Key, WPD_DEVICE_SERIAL_NUMBER))
+                    {
+                        hr = pValues->SetStringValue(WPD_DEVICE_SERIAL_NUMBER, DEVICE_SERIAL_NUMBER_VALUE);
+                        CHECK_HR(hr, "Failed to set WPD_DEVICE_SERIAL_NUMBER");
+                    }
+
+                    else if (IsEqualPropertyKey(Key, WPD_DEVICE_SUPPORTS_NON_CONSUMABLE))
+                    {
+                        hr = pValues->SetBoolValue(WPD_DEVICE_SUPPORTS_NON_CONSUMABLE, DEVICE_SUPPORTS_NONCONSUMABLE_VALUE);
+                        CHECK_HR(hr, "Failed to set WPD_DEVICE_SUPPORTS_NON_CONSUMABLE");
+                    }
+
+                    else if (IsEqualPropertyKey(Key, WPD_DEVICE_MANUFACTURER))
+                    {
+                        hr = pValues->SetStringValue(WPD_DEVICE_MANUFACTURER, DEVICE_MANUFACTURER_VALUE);
+                        CHECK_HR(hr, "Failed to set WPD_DEVICE_MANUFACTURER");
+                    }
+
+                    else if (IsEqualPropertyKey(Key, WPD_DEVICE_FRIENDLY_NAME))
+                    {
+                        hr = pValues->SetStringValue(WPD_DEVICE_FRIENDLY_NAME, DEVICE_FRIENDLY_NAME_VALUE);
+                        CHECK_HR(hr, "Failed to set WPD_DEVICE_FRIENDLY_NAME");
+                    }
+
+                    else if (IsEqualPropertyKey(Key, WPD_DEVICE_TYPE))
+                    {
+                        hr = pValues->SetUnsignedIntegerValue(WPD_DEVICE_TYPE, WPD_DEVICE_TYPE_GENERIC);
+                        CHECK_HR(hr, "Failed to set WPD_DEVICE_TYPE");
+                    }
+
+                    // Set general properties for DEVICE
+                    else if (IsEqualPropertyKey(Key, WPD_OBJECT_ID))
+                    {
+                        hr = pValues->SetStringValue(WPD_OBJECT_ID, WPD_DEVICE_OBJECT_ID);
+                        CHECK_HR(hr, "Failed to set WPD_OBJECT_ID");
+                    }
+
+                    else if (IsEqualPropertyKey(Key, WPD_OBJECT_NAME))
+                    {
+                        // Retrieves the "DEVICE" string that identifies the root device
+                        hr = pValues->SetStringValue(WPD_OBJECT_NAME, WPD_DEVICE_OBJECT_ID);
+                        CHECK_HR(hr, "Failed to set WPD_OBJECT_NAME");
+                    }
+
+                    else if (IsEqualPropertyKey(Key, WPD_OBJECT_PERSISTENT_UNIQUE_ID))
+                    {
+                        hr = pValues->SetStringValue(WPD_OBJECT_PERSISTENT_UNIQUE_ID, WPD_DEVICE_OBJECT_ID);
+                        CHECK_HR(hr, "Failed to set WPD_OBJECT_PERSISTENT_UNIQUE_ID");
+                    }
+
+                    else if (IsEqualPropertyKey(Key, WPD_OBJECT_PARENT_ID))
+                    {
+                        hr = pValues->SetStringValue(WPD_OBJECT_PARENT_ID, L"");
+                        CHECK_HR(hr, "Failed to set WPD_OBJECT_PARENT_ID");
+                    }
+
+                    else if (IsEqualPropertyKey(Key, WPD_OBJECT_FORMAT))
+                    {
+                        hr = pValues->SetGuidValue(WPD_OBJECT_FORMAT, WPD_OBJECT_FORMAT_UNSPECIFIED);
+                        CHECK_HR(hr, "Failed to set WPD_OBJECT_FORMAT");
+                    }
+
+                    else if (IsEqualPropertyKey(Key, WPD_OBJECT_CONTENT_TYPE))
+                    {
+                        hr = pValues->SetGuidValue(WPD_OBJECT_CONTENT_TYPE, WPD_CONTENT_TYPE_FUNCTIONAL_OBJECT);
+                        CHECK_HR(hr, "Failed to set WPD_OBJECT_CONTENT_TYPE");
+                    }
+
+                    else if (IsEqualPropertyKey(Key, WPD_OBJECT_CAN_DELETE))
+                    {
+                        hr = pValues->SetBoolValue(WPD_OBJECT_CAN_DELETE, FALSE);
+                        CHECK_HR(hr, "Failed to set WPD_OBJECT_CAN_DELETE");
+                    }
+
+                    else if (IsEqualPropertyKey(Key, WPD_FUNCTIONAL_OBJECT_CATEGORY))
+                    {
+                        hr = pValues->SetGuidValue(WPD_FUNCTIONAL_OBJECT_CATEGORY, WPD_FUNCTIONAL_CATEGORY_DEVICE);
+                        CHECK_HR(hr, "Failed to set WPD_FUNCTIONAL_OBJECT_CATEGORY");
+                    }
+                }
+            }
+        }
+        // Retrieve the temperature sensor properties
+        else if (
+                 (strObjectID.CompareNoCase(SENSOR_OBJECT_ID) == 0)         ||
+                 (strObjectID.CompareNoCase(TEMP_SENSOR_OBJECT_ID) == 0)    ||
+                 (strObjectID.CompareNoCase(FLEX_SENSOR_OBJECT_ID) == 0)    ||
+                 (strObjectID.CompareNoCase(PIR_SENSOR_OBJECT_ID) == 0)     ||
+                 (strObjectID.CompareNoCase(PING_SENSOR_OBJECT_ID) == 0)    ||
+                 (strObjectID.CompareNoCase(QTI_SENSOR_OBJECT_ID) == 0)     ||
+                 (strObjectID.CompareNoCase(MEMSIC_SENSOR_OBJECT_ID) == 0)  ||
+                 (strObjectID.CompareNoCase(HITACHI_SENSOR_OBJECT_ID) == 0) ||
+                 (strObjectID.CompareNoCase(PIEZO_SENSOR_OBJECT_ID) == 0)   ||
+                 (strObjectID.CompareNoCase(COMPASS_SENSOR_OBJECT_ID) == 0)
+                )
+        {
+            for (DWORD dwIndex = 0; dwIndex < cKeys; dwIndex++)
+            {
+                PROPERTYKEY Key = WPD_PROPERTY_NULL;
+                hr = pKeys->GetAt(dwIndex, &Key);
+                CHECK_HR(hr, "Failed to get PROPERTYKEY at index %d in collection", dwIndex);
+
+                if (hr == S_OK)
+                {
+                    // Preset the property value to 'error not supported'.  The actual value
+                    // will replace this value, if read from the device.
+                    pValues->SetErrorValue(Key, HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED));
+                    if (IsEqualPropertyKey(Key, WPD_OBJECT_ID))
+                    {
+                        hr = pValues->SetStringValue(WPD_OBJECT_ID, strObjectID);
+                        CHECK_HR(hr, "Failed to set WPD_OBJECT_ID");
+                    }
+
+                    else if (IsEqualPropertyKey(Key, WPD_OBJECT_PERSISTENT_UNIQUE_ID))
+                    {
+
+                        // Retrieve the ID of the sensor using the m_SensorType member of the
+                        // basedriver that is set during the data-read operation.
+                        hr = pValues->SetStringValue(WPD_OBJECT_PERSISTENT_UNIQUE_ID, strObjectID);
+                        CHECK_HR(hr, "Failed to set WPD_OBJECT_PERSISTENT_UNIQUE_ID");
+                    }
+
+                    else if (IsEqualPropertyKey(Key, WPD_OBJECT_PARENT_ID))
+                    {
+                        hr = pValues->SetStringValue(WPD_OBJECT_PARENT_ID, WPD_DEVICE_OBJECT_ID);
+                        CHECK_HR(hr, "Failed to set WPD_OBJECT_PARENT_ID");
+                    }
+
+                    else if (IsEqualPropertyKey(Key, WPD_OBJECT_NAME))
+                    {
+                        // Retrieve the name of the sensor using the m_SensorType member of the
+                        // basedriver that is set during the data-read operation.
+                        if (m_pBaseDriver->m_SensorType == 0)
+                            hr = pValues->SetStringValue(WPD_OBJECT_NAME, SENSOR_OBJECT_NAME_VALUE);
+                        else if (m_pBaseDriver->m_SensorType == 2)
+                            hr = pValues->SetStringValue(WPD_OBJECT_NAME, TEMP_SENSOR_OBJECT_NAME_VALUE);
+                        else if (m_pBaseDriver->m_SensorType == 3)
+                            hr = pValues->SetStringValue(WPD_OBJECT_NAME, FLEX_SENSOR_OBJECT_NAME_VALUE);
+                        else if (m_pBaseDriver->m_SensorType == 4)
+                            hr = pValues->SetStringValue(WPD_OBJECT_NAME, PING_SENSOR_OBJECT_NAME_VALUE);
+                        else if (m_pBaseDriver->m_SensorType == 5)
+                            hr = pValues->SetStringValue(WPD_OBJECT_NAME, PIR_SENSOR_OBJECT_NAME_VALUE);
+                        else if (m_pBaseDriver->m_SensorType == 6)
+                            hr = pValues->SetStringValue(WPD_OBJECT_NAME, MEMSIC_SENSOR_OBJECT_NAME_VALUE);
+                        else if (m_pBaseDriver->m_SensorType == 7)
+                            hr = pValues->SetStringValue(WPD_OBJECT_NAME, QTI_SENSOR_OBJECT_NAME_VALUE);
+                        else if (m_pBaseDriver->m_SensorType == 8)
+                            hr = pValues->SetStringValue(WPD_OBJECT_NAME, PIEZO_SENSOR_OBJECT_NAME_VALUE);
+                        else if (m_pBaseDriver->m_SensorType == 9)
+                            hr = pValues->SetStringValue(WPD_OBJECT_NAME, HITACHI_SENSOR_OBJECT_NAME_VALUE);
+                        CHECK_HR(hr, "Failed to set WPD_OBJECT_NAME");
+                    }
+
+                    else if (IsEqualPropertyKey(Key, WPD_OBJECT_FORMAT))
+                    {
+                        hr = pValues->SetGuidValue(WPD_OBJECT_FORMAT, WPD_OBJECT_FORMAT_UNSPECIFIED);
+                        CHECK_HR(hr, "Failed to set WPD_OBJECT_FORMAT");
+                    }
+
+                    else if (IsEqualPropertyKey(Key, WPD_OBJECT_CONTENT_TYPE))
+                    {
+                        hr = pValues->SetGuidValue(WPD_OBJECT_CONTENT_TYPE, WPD_CONTENT_TYPE_FUNCTIONAL_OBJECT);
+                        CHECK_HR(hr, "Failed to set WPD_OBJECT_CONTENT_TYPE");
+                    }
+
+                    else if (IsEqualPropertyKey(Key, WPD_OBJECT_CAN_DELETE))
+                    {
+                        hr = pValues->SetBoolValue(WPD_OBJECT_CAN_DELETE, FALSE);
+                        CHECK_HR(hr, "Failed to set WPD_OBJECT_CAN_DELETE");
+                    }
+
+                    else if (IsEqualPropertyKey(Key, SENSOR_READING))
+                    {
+                        hr = pValues->SetUnsignedLargeIntegerValue(SENSOR_READING, GetSensorReading());
+                        CHECK_HR(hr, "Failed to set SENSOR_READING");
+                    }
+
+                    else if (IsEqualPropertyKey(Key, SENSOR_UPDATE_INTERVAL))
+                    {
+                        hr = pValues->SetUnsignedLargeIntegerValue(SENSOR_UPDATE_INTERVAL, GetUpdateInterval());
+                        CHECK_HR(hr, "Failed to set SENSOR_UPDATE_INTERVAL");
+                    }
+                    else if (IsEqualPropertyKey(Key, WPD_FUNCTIONAL_OBJECT_CATEGORY))
+                    {
+                        hr = pValues->SetGuidValue(WPD_FUNCTIONAL_OBJECT_CATEGORY, FUNCTIONAL_CATEGORY_SENSOR_SAMPLE);
+                        CHECK_HR(hr, "Failed to set WPD_FUNCTIONAL_OBJECT_CATEGORY");
+                    }
+                }
+             } // end for
+        } // end else if
+    }
+
+    return hr;
+}
+
+/**
+ *  This method is called to populate property attributes for the object and property specified.
+ *
+ *  The parameters sent to us are:
+ *  wszObjectID - the object whose property attributes are being requested.
+ *  Key - the property whose attributes are being requested
+ *  pAttributes - an IPortableDeviceValues which will contain the resulting property attributes
+ *
+ *  The driver should:
+ *  Read the property attributes for the specified property on the specified object and
+ *  populate pAttributes with the results.
+ */
+HRESULT WpdObjectProperties::GetPropertyAttributesForObject(
+    _In_ LPCWSTR                wszObjectID,
+    _In_ REFPROPERTYKEY         Key,
+    _In_ IPortableDeviceValues* pAttributes)
+{
+    HRESULT hr = S_OK;
+
+    if ((wszObjectID == NULL) ||
+        (pAttributes == NULL))
+    {
+        hr = E_INVALIDARG;
+        return hr;
+    }
+
+    //
+    // Since ALL of our properties have the same attributes, we are ignoring the
+    // passed in wszObjectID parameter.  This parameter allows you to
+    // customize attributes for properties on specific objects. (i.e. WPD_OBJECT_ORIGINAL_FILE_NAME
+    // may be READ/WRITE on some objects and READONLY on others. )
+    //
+
+    if (hr == S_OK)
+    {
+        hr = pAttributes->SetBoolValue(WPD_PROPERTY_ATTRIBUTE_CAN_DELETE, FALSE);
+        CHECK_HR(hr, "Failed to set WPD_PROPERTY_ATTRIBUTE_CAN_DELETE");
+    }
+
+    if (hr == S_OK)
+    {
+        hr = pAttributes->SetBoolValue(WPD_PROPERTY_ATTRIBUTE_CAN_READ, TRUE);
+        CHECK_HR(hr, "Failed to set WPD_PROPERTY_ATTRIBUTE_CAN_READ");
+    }
+
+    if (hr == S_OK)
+    {
+        // Allow writes for the update interval property
+        if (IsEqualPropertyKey(Key, SENSOR_UPDATE_INTERVAL))
+        {
+            hr = pAttributes->SetBoolValue(WPD_PROPERTY_ATTRIBUTE_CAN_WRITE, TRUE);
+            CHECK_HR(hr, "Failed to set WPD_PROPERTY_ATTRIBUTE_CAN_WRITE for SENSOR_UPDATE_INTERVAL");
+        }
+        else
+        {
+            hr = pAttributes->SetBoolValue(WPD_PROPERTY_ATTRIBUTE_CAN_WRITE, FALSE);
+            CHECK_HR(hr, "Failed to set WPD_PROPERTY_ATTRIBUTE_CAN_WRITE");
+        }
+    }
+
+    if (hr == S_OK)
+    {
+        hr = pAttributes->SetBoolValue(WPD_PROPERTY_ATTRIBUTE_FAST_PROPERTY, TRUE);
+        CHECK_HR(hr, "Failed to set WPD_PROPERTY_ATTRIBUTE_FAST_PROPERTY");
+    }
+
+    if (hr == S_OK)
+    {
+        if (IsEqualPropertyKey(Key, SENSOR_UPDATE_INTERVAL))
+        {
+            // Form range attributes for the update interval property
+            hr = pAttributes->SetUnsignedIntegerValue(WPD_PROPERTY_ATTRIBUTE_FORM, WPD_PROPERTY_ATTRIBUTE_FORM_RANGE);
+            CHECK_HR(hr, "Failed to set WPD_PROPERTY_ATTRIBUTE_RANGE_MIN for SENSOR_UPDATE_INTERVAL");
+
+            hr = pAttributes->SetUnsignedIntegerValue(WPD_PROPERTY_ATTRIBUTE_RANGE_MIN, SENSOR_UPDATE_INTERVAL_MIN);
+            CHECK_HR(hr, "Failed to set WPD_PROPERTY_ATTRIBUTE_RANGE_MIN for SENSOR_UPDATE_INTERVAL");
+
+            hr = pAttributes->SetUnsignedIntegerValue(WPD_PROPERTY_ATTRIBUTE_RANGE_MAX, SENSOR_UPDATE_INTERVAL_MAX);
+            CHECK_HR(hr, "Failed to set WPD_PROPERTY_ATTRIBUTE_RANGE_MAX for SENSOR_UPDATE_INTERVAL");
+
+            hr = pAttributes->SetUnsignedIntegerValue(WPD_PROPERTY_ATTRIBUTE_RANGE_STEP, SENSOR_UPDATE_INTERVAL_STEP);
+            CHECK_HR(hr, "Failed to set WPD_PROPERTY_ATTRIBUTE_RANGE_STEP for SENSOR_UPDATE_INTERVAL");
+        }
+        else if (IsEqualPropertyKey(Key, SENSOR_READING))
+        {
+            // Form range attributes for the reading property
+            hr = pAttributes->SetUnsignedIntegerValue(WPD_PROPERTY_ATTRIBUTE_FORM, WPD_PROPERTY_ATTRIBUTE_FORM_RANGE);
+            CHECK_HR(hr, "Failed to set WPD_PROPERTY_ATTRIBUTE_RANGE_MIN for SENSOR_READING");
+
+            hr = pAttributes->SetUnsignedIntegerValue(WPD_PROPERTY_ATTRIBUTE_RANGE_MIN, SENSOR_READING_MIN);
+            CHECK_HR(hr, "Failed to set WPD_PROPERTY_ATTRIBUTE_RANGE_MIN for SENSOR_READING");
+
+            hr = pAttributes->SetUnsignedIntegerValue(WPD_PROPERTY_ATTRIBUTE_RANGE_MAX, SENSOR_READING_MAX);
+            CHECK_HR(hr, "Failed to set WPD_PROPERTY_ATTRIBUTE_RANGE_MAX for SENSOR_READING");
+
+            hr = pAttributes->SetUnsignedIntegerValue(WPD_PROPERTY_ATTRIBUTE_RANGE_STEP, SENSOR_READING_STEP);
+            CHECK_HR(hr, "Failed to set WPD_PROPERTY_ATTRIBUTE_RANGE_STEP for SENSOR_READING");   
+        }
+        else
+        {
+            hr = pAttributes->SetUnsignedIntegerValue(WPD_PROPERTY_ATTRIBUTE_FORM, WPD_PROPERTY_ATTRIBUTE_FORM_UNSPECIFIED);
+            CHECK_HR(hr, "Failed to set WPD_PROPERTY_ATTRIBUTE_FORM");
+        }
+    }
+
+    return hr;
+}
+
+
+/**
+ *  This method is called to update the sensor reading
+ *
+ *  The parameters sent to us are:
+ *  dwNewReading - the temperature reading to set
+ *
+ *  The driver should:
+ *  Update the sensor reading.
+ */
+VOID WpdObjectProperties::SetSensorReading(LONGLONG llNewReading)
+{    
+    // Ensure that this value isn't currently being accessed by another thread
+    CComCritSecLock<CComAutoCriticalSection> Lock(m_SensorReadingCriticalSection);
+
+    m_llSensorReading = llNewReading;
+}
+
+
+/**
+ *  This method is called to retrieve the sensor reading
+ *
+ *  The parameters sent to us are:
+ *
+ *  The driver should:
+ *  Return the saved sensor reading.
+ */
+LONGLONG WpdObjectProperties::GetSensorReading()
+{    
+    // Ensure that this value isn't currently being accessed by another thread
+    CComCritSecLock<CComAutoCriticalSection> Lock(m_SensorReadingCriticalSection);
+
+    return m_llSensorReading;
+}
+
+
+/**
+ *  This method is called to set the cached sensor interval  
+ *
+ *  The parameters sent to us are:
+ *  dwNewInterval - the sensor update interval to set
+ *
+ *  The driver should:
+ *  Update the cached sensor interval property.
+ */
+VOID WpdObjectProperties::SetUpdateInterval(DWORD dwNewInterval)
+{    
+    m_dwUpdateInterval = dwNewInterval;
+}
+
+
+/**
+ *  This method is called to retrieve the sensor update interval
+ *
+ *  The parameters sent to us are: 
+ *
+ *  The driver should:
+ *  Return the interval property.
+ */
+DWORD WpdObjectProperties::GetUpdateInterval()
+{    
+    return m_dwUpdateInterval;
+}
+
+
+/**
+ *  This method is called to update the sensor interval on the device
+ *
+ *  The parameters sent to us are:
+ *  dwNewInterval - the sensor update interval to set
+ *
+ *  The driver should:
+ *  Update the cached sensor property and send a write request to the device
+ */
+HRESULT WpdObjectProperties::SendUpdateIntervalToDevice(DWORD dwNewInterval)
+{    
+    HRESULT      hr                           = S_OK;
+    RS232Target* pDeviceTarget                = NULL;
+
+    CHAR  szInterval[INTERVAL_DATA_LENGTH+1]  = {0};
+
+    // Check the input value
+    if (IsValidUpdateInterval(dwNewInterval) == FALSE)
+    {
+        hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
+        CHECK_HR(hr, "Invalid update interval: %d", dwNewInterval);
+    }
+
+    // Format a write request with the input value
+    if (hr == S_OK)
+    {
+        hr = StringCchPrintfA(szInterval, ARRAYSIZE(szInterval), "%u", dwNewInterval);
+        CHECK_HR(hr, "Failed to convert the new interval to a CHAR string");
+    }
+
+    // Send the write request to the device
+    if (hr == S_OK)
+    {
+        pDeviceTarget = m_pBaseDriver->GetRS232Target();
+
+        if (pDeviceTarget->IsReady())
+        {
+            hr = pDeviceTarget->SendWriteRequest((BYTE *)szInterval, sizeof(szInterval));
+            CHECK_HR(hr, "Failed to send the write request to set the new sensor update interval");
+
+            if (hr == S_OK)
+            {
+                TraceEvents(TRACE_LEVEL_VERBOSE, TRACE_FLAG_DRIVER, "%!FUNC! Sent new interval: %s", szInterval);
+            }
+        }
+        else
+        {
+            hr = HRESULT_FROM_WIN32(ERROR_NOT_READY);
+            CHECK_HR(hr, "Device is not ready to receive write requests");
+        }
+    }
+    
+    if (hr == S_OK)
+    {
+        // Update the cached value on the driver
+        SetUpdateInterval(dwNewInterval);
+    }
+
+    return hr;
+}
+
+
+/**
+ *  This method is called to check that interval value falls within the accepted range
+ *  of 2000 to 60000 milliseconds
+ *
+ *  The parameters sent to us are: 
+ *  wszInterval - the sensor update interval to check
+ *
+ *  The driver should:
+ *  Return TRUE if the interval is within range
+ */
+BOOL WpdObjectProperties::IsValidUpdateInterval(DWORD dwInterval)
+{
+    if ((dwInterval >= SENSOR_UPDATE_INTERVAL_MIN) && 
+        (dwInterval <= SENSOR_UPDATE_INTERVAL_MAX))
+    {
+        return TRUE;
+    }
+
+    return FALSE;
+}
+