HRESULT FakeDevice::GetCommandOptions(
_In_ REFPROPERTYKEY Command,
_In_ IPortableDeviceValues* pOptions)
{
HRESULT hr = S_OK;
if(pOptions == NULL)
{
hr = E_POINTER;
CHECK_HR(hr, "Cannot have NULL parameter");
return hr;
}
// Check for command options
if (IsEqualPropertyKey(WPD_COMMAND_OBJECT_MANAGEMENT_DELETE_OBJECTS, Command))
{
// This driver does not support recursive deletion
hr = pOptions->SetBoolValue(WPD_OPTION_OBJECT_MANAGEMENT_RECURSIVE_DELETE_SUPPORTED, TRUE);
CHECK_HR(hr, "Failed to set WPD_OPTION_OBJECT_MANAGEMENT_RECURSIVE_DELETE_SUPPORTED");
}
if (IsEqualPropertyKey(WPD_COMMAND_OBJECT_RESOURCES_READ, Command))
{
// For better read performance, tell the API not to provide the input buffer parameter
// when issuing a WPD_COMMAND_OBJECT_RESOURCES_READ command.
hr = pOptions->SetBoolValue(WPD_OPTION_OBJECT_RESOURCES_NO_INPUT_BUFFER_ON_READ, TRUE);
CHECK_HR(hr, "Failed to set WPD_OPTION_OBJECT_RESOURCES_NO_INPUT_BUFFER_ON_READ");
}
return hr;
}
static void test_getat(IPropertyStore *store)
{
HRESULT hr;
DWORD propcount;
DWORD prop;
PROPERTYKEY pkey;
BOOL found_name = FALSE;
BOOL found_desc = FALSE;
char temp[128];
temp[sizeof(temp)-1] = 0;
hr = IPropertyStore_GetCount(store, &propcount);
ok(hr == S_OK, "Failed with %08x\n", hr);
ok(propcount > 0, "Propcount %d should be greather than zero\n", propcount);
for (prop = 0; prop < propcount; prop++) {
hr = IPropertyStore_GetAt(store, prop, &pkey);
ok(hr == S_OK, "Failed with %08x\n", hr);
if (IsEqualPropertyKey(pkey, DEVPKEY_Device_FriendlyName))
found_name = TRUE;
if (IsEqualPropertyKey(pkey, DEVPKEY_Device_DeviceDesc))
found_desc = TRUE;
}
ok(found_name || broken(!found_name), "DEVPKEY_Device_FriendlyName not found\n");
ok(found_desc == TRUE, "DEVPKEY_Device_DeviceDesc not found\n");
}
HRESULT WpdService::DispatchWpdMessage(
REFPROPERTYKEY Command,
_In_ IPortableDeviceValues* pParams,
_Inout_ IPortableDeviceValues* pResults)
{
HRESULT hr = S_OK;
LPWSTR pszRequestFilename = NULL;
// Get the request filename to process the service message
hr = pParams->GetStringValue(PRIVATE_SAMPLE_DRIVER_REQUEST_FILENAME, &pszRequestFilename);
if (FAILED(hr))
{
hr = E_INVALIDARG;
CHECK_HR(hr, "Failed to get the required requested filename");
}
if (hr == S_OK)
{
hr = CheckRequestFilename(pszRequestFilename);
CHECK_HR(hr, "Unknown request filename %ws received", pszRequestFilename);
}
if (hr == S_OK)
{
if (Command.fmtid == WPD_CATEGORY_SERVICE_CAPABILITIES)
{
hr = m_ServiceCapabilities.DispatchWpdMessage(Command, pParams, pResults);
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_SERVICE_METHODS_START_INVOKE))
{
hr = m_ServiceMethods.OnStartInvoke(pParams, pResults);
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_SERVICE_METHODS_END_INVOKE))
{
hr = m_ServiceMethods.OnEndInvoke(pParams, pResults);
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_SERVICE_METHODS_CANCEL_INVOKE))
{
hr = m_ServiceMethods.OnCancelInvoke(pParams, pResults);
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_SERVICE_COMMON_GET_SERVICE_OBJECT_ID))
{
hr = OnGetServiceObjectID(pszRequestFilename, pParams, pResults);
}
else
{
hr = E_NOTIMPL;
CHECK_HR(hr, "Unknown command %ws.%d received",CComBSTR(Command.fmtid), Command.pid);
}
}
CoTaskMemFree(pszRequestFilename);
return hr;
}
HRESULT WpdObjectResources::DispatchWpdMessage(
_In_ REFPROPERTYKEY Command,
_In_ IPortableDeviceValues* pParams,
_In_ IPortableDeviceValues* pResults)
{
HRESULT hr = S_OK;
if (Command.fmtid != WPD_CATEGORY_OBJECT_RESOURCES)
{
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_RESOURCES_GET_SUPPORTED))
{
hr = OnGetSupportedResources(pParams, pResults);
CHECK_HR(hr, "Failed to get supported resources");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_OBJECT_RESOURCES_OPEN))
{
hr = OnOpenResource(pParams, pResults);
CHECK_HR(hr, "Failed to open resource");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_OBJECT_RESOURCES_READ))
{
hr = OnReadResource(pParams, pResults);
CHECK_HR(hr, "Failed to read resource");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_OBJECT_RESOURCES_CLOSE))
{
hr = OnCloseResource(pParams, pResults);
CHECK_HR(hr, "Failed to close resource");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_OBJECT_RESOURCES_GET_ATTRIBUTES))
{
hr = OnGetResourceAttributes(pParams, pResults);
CHECK_HR(hr, "Failed to get resource attributes");
}
else
{
hr = E_NOTIMPL;
CHECK_HR(hr, "This object does not support this command id %d", Command.pid);
}
}
return hr;
}
HRESULT WpdStorage::DispatchWpdMessage(_In_ REFPROPERTYKEY Command,
_In_ IPortableDeviceValues* pParams,
_In_ IPortableDeviceValues* pResults)
{
HRESULT hr = S_OK;
if (hr == S_OK)
{
if (Command.fmtid != WPD_CATEGORY_STORAGE)
{
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_STORAGE_FORMAT))
{
hr = OnFormat(pParams, pResults);
CHECK_HR(hr, "Failed to format storage");
}
else
{
hr = E_NOTIMPL;
CHECK_HR(hr, "This object does not support this command id %d", Command.pid);
}
}
return hr;
}
static HRESULT STDMETHODCALLTYPE sIMMNotificationClient_OnPropertyValueChanged(
IMMNotificationClient *This,
LPCWSTR pwstrDeviceId,
const PROPERTYKEY key)
{
change_notify *change = (change_notify *)This;
struct ao *ao = change->ao;
if (!change->is_hotplug && pwstrDeviceId &&
!wcscmp(pwstrDeviceId, change->monitored))
{
MP_VERBOSE(ao, "OnPropertyValueChanged triggered on device %S\n",
pwstrDeviceId);
if (IsEqualPropertyKey(PKEY_AudioEngine_DeviceFormat, key)) {
MP_VERBOSE(change->ao,
"Changed property: PKEY_AudioEngine_DeviceFormat "
"- requesting ao reload\n");
ao_request_reload(change->ao);
} else {
MP_VERBOSE(ao, "Changed property: %s\n", mp_PKEY_to_str(&key));
}
}
return S_OK;
}
STDMETHODIMP CNativeRibbonApp::Execute(UINT32 commandId, UI_EXECUTIONVERB verb, const PROPERTYKEY* key, const PROPVARIANT* currentValue, IUISimplePropertySet* /*commandExecutionProperties*/)
{
if (verb == UI_EXECUTIONVERB_EXECUTE)
{
if (key && IsEqualPropertyKey(*key, UI_PKEY_SelectedItem))
{
CComPtr<IUICollection> items = GetUICommandItemsSource(commandId);
UINT32 selectedItemIdx = 0;
UIPropertyToUInt32(UI_PKEY_SelectedItem, *currentValue, &selectedItemIdx);
UINT32 count = 0;
items->GetCount(&count);
if (selectedItemIdx < count)
{
CComPtr<IUnknown> selectedItemUnk;
items->GetItem(selectedItemIdx, &selectedItemUnk);
CComQIPtr<IUISimplePropertySet> selectedItemPropSet(selectedItemUnk);
if (selectedItemPropSet)
m_pFrame->PostMessage(WM_COMMAND, GetCommandIdProperty(selectedItemPropSet));
}
}
else
m_pFrame->PostMessage(WM_COMMAND, commandId);
return S_OK;
}
return S_FALSE;
}
HRESULT WpdNetworkConfig::DispatchWpdMessage(_In_ REFPROPERTYKEY Command,
_In_ IPortableDeviceValues* pParams,
_In_ IPortableDeviceValues* pResults)
{
HRESULT hr = S_OK;
if (hr == S_OK)
{
if (Command.fmtid != WPD_CATEGORY_NETWORK_CONFIGURATION)
{
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_PROCESS_WIRELESS_PROFILE))
{
hr = OnProcessWFCObject(pParams, pResults);
CHECK_HR(hr, "Failed to commit WFC file");
}
else
{
hr = E_NOTIMPL;
CHECK_HR(hr, "This object does not support this command id %d", Command.pid);
}
}
return hr;
}
HRESULT AbstractDeviceContent::WriteValue(
REFPROPERTYKEY Key,
const PROPVARIANT& Value)
{
HRESULT hr = S_OK;
PropVariantWrapper pvValue;
if(IsEqualPropertyKey(Key, WPD_OBJECT_NAME))
{
if(Value.vt == VT_LPWSTR)
{
if (wcslen(Value.pwszVal) > 0)
{
Name = Value.pwszVal;
}
else
{
hr = E_INVALIDARG;
CHECK_HR(hr, "Failed to set WPD_OBJECT_NAME because value was an empty string");
}
}
else
{
hr = E_INVALIDARG;
CHECK_HR(hr, "Failed to set WPD_OBJECT_NAME because type was not VT_LPWSTR");
}
}
else
{
hr = E_ACCESSDENIED;
CHECK_HR(hr, "Property %ws.%d on [%ws] does not support set value operation", CComBSTR(Key.fmtid), Key.pid, ObjectID);
}
return hr;
}
/**
* This method is called when we receive a WPD_COMMAND_CAPABILITIES_GET_COMMAND_OPTIONS
* command.
*
* The parameters sent to us are:
* - WPD_PROPERTY_CAPABILITIES_COMMAND: a collection of property keys containing a single value,
* which identifies the specific command options are requested to return.
*
* The driver should:
* - Return an IPortableDeviceValues in WPD_PROPERTY_CAPABILITIES_COMMAND_OPTIONS, containing
* the relevant options. If no options are available for this command, the driver should
* return an IPortableDeviceValues with no elements in it.
*/
HRESULT WpdCapabilities::OnGetCommandOptions(
_In_ IPortableDeviceValues* pParams,
_In_ IPortableDeviceValues* pResults)
{
HRESULT hr = S_OK;
PROPERTYKEY Command = WPD_PROPERTY_NULL;
CComPtr<IPortableDeviceValues> pOptions;
// 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 command whose options have been requested
if (hr == S_OK)
{
hr = pParams->GetKeyValue(WPD_PROPERTY_CAPABILITIES_COMMAND, &Command);
CHECK_HR(hr, "Missing value for WPD_PROPERTY_CAPABILITIES_COMMAND");
}
// CoCreate a collection to store the command options.
if (hr == S_OK)
{
hr = CoCreateInstance(CLSID_PortableDeviceValues,
NULL,
CLSCTX_INPROC_SERVER,
IID_IPortableDeviceValues,
(VOID**) &pOptions);
CHECK_HR(hr, "Failed to CoCreateInstance CLSID_PortableDeviceValues");
}
// Add command options to the collection
if (hr == S_OK)
{
// If your driver supports command options, then they should be added here
// to the command options collection 'pOptions'.
if (IsEqualPropertyKey(WPD_COMMAND_OBJECT_RESOURCES_READ, Command))
{
// For better read performance, tell the API not to provide the input buffer parameter
// when issuing a WPD_COMMAND_OBJECT_RESOURCES_READ command.
hr = pOptions->SetBoolValue(WPD_OPTION_OBJECT_RESOURCES_NO_INPUT_BUFFER_ON_READ, TRUE);
CHECK_HR(hr, "Failed to set WPD_OPTION_OBJECT_RESOURCES_NO_INPUT_BUFFER_ON_READ");
}
}
// Set the WPD_PROPERTY_CAPABILITIES_COMMAND_OPTIONS value in the results.
if (hr == S_OK)
{
hr = pResults->SetIUnknownValue(WPD_PROPERTY_CAPABILITIES_COMMAND_OPTIONS, pOptions);
CHECK_HR(hr, "Failed to set WPD_PROPERTY_CAPABILITIES_COMMAND_OPTIONS");
}
return hr;
}
HRESULT AbstractDeviceContent::GetPropertyAttributes(
REFPROPERTYKEY Key,
_Out_ IPortableDeviceValues* pAttributes)
{
HRESULT hr = S_OK;
if(pAttributes == NULL)
{
hr = E_POINTER;
CHECK_HR(hr, "Cannot have NULL attributes parameter");
return hr;
}
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)
{
if (IsEqualPropertyKey(Key, WPD_OBJECT_NAME))
{
hr = pAttributes->SetBoolValue(WPD_PROPERTY_ATTRIBUTE_CAN_WRITE, TRUE);
CHECK_HR(hr, "Failed to set WPD_PROPERTY_ATTRIBUTE_CAN_WRITE");
}
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)
{
hr = pAttributes->SetUnsignedIntegerValue(WPD_PROPERTY_ATTRIBUTE_FORM, WPD_PROPERTY_ATTRIBUTE_FORM_UNSPECIFIED);
CHECK_HR(hr, "Failed to set WPD_PROPERTY_ATTRIBUTE_FORM");
}
return hr;
}
HRESULT WpdCapabilities::DispatchWpdMessage(const PROPERTYKEY& Command,
IPortableDeviceValues* pParams,
IPortableDeviceValues* pResults)
{
HRESULT hr = S_OK;
if (hr == S_OK)
{
if (Command.fmtid != WPD_CATEGORY_CAPABILITIES)
{
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_CAPABILITIES_GET_SUPPORTED_COMMANDS))
{
hr = OnGetSupportedCommands(pParams, pResults);
CHECK_HR(hr, "Failed to get supported commands");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_CAPABILITIES_GET_COMMAND_OPTIONS))
{
hr = OnGetCommandOptions(pParams, pResults);
CHECK_HR(hr, "Failed to get command options");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_CAPABILITIES_GET_SUPPORTED_FUNCTIONAL_CATEGORIES))
{
hr = OnGetFunctionalCategories(pParams, pResults);
CHECK_HR(hr, "Failed to get functional categories");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_CAPABILITIES_GET_FUNCTIONAL_OBJECTS))
{
hr = OnGetFunctionalObjects(pParams, pResults);
CHECK_HR(hr, "Failed to get functional objects");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_CAPABILITIES_GET_SUPPORTED_EVENTS))
{
hr = OnGetSupportedEvents(pParams, pResults);
CHECK_HR(hr, "Failed to get supported events");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_CAPABILITIES_GET_EVENT_OPTIONS))
{
hr = OnGetEventOptions(pParams, pResults);
CHECK_HR(hr, "Failed to get event options");
}
else
{
hr = E_NOTIMPL;
CHECK_HR(hr, "This object does not support this command id %d", Command.pid);
}
}
return hr;
}
HRESULT FakeDevice::GetCommandOptions(
_In_ REFPROPERTYKEY Command,
_In_ IPortableDeviceValues* pOptions)
{
HRESULT hr = S_OK;
if(pOptions == NULL)
{
hr = E_POINTER;
CHECK_HR(hr, "Cannot have NULL parameter");
return hr;
}
// Check for command options
if (IsEqualPropertyKey(WPD_COMMAND_OBJECT_MANAGEMENT_DELETE_OBJECTS, Command))
{
// This driver does not support recursive deletion
hr = pOptions->SetBoolValue(WPD_OPTION_OBJECT_MANAGEMENT_RECURSIVE_DELETE_SUPPORTED, TRUE);
CHECK_HR(hr, "Failed to set WPD_OPTION_OBJECT_MANAGEMENT_RECURSIVE_DELETE_SUPPORTED");
}
return hr;
}
static HRESULT WINAPI MMDevPropStore_GetValue(IPropertyStore *iface, REFPROPERTYKEY key, PROPVARIANT *pv)
{
MMDevPropStore *This = impl_from_IPropertyStore(iface);
TRACE("(%p)->(\"%s,%u\", %p\n", This, debugstr_guid(&key->fmtid), key ? key->pid : 0, pv);
if (!key || !pv)
return E_POINTER;
if (This->access != STGM_READ
&& This->access != STGM_READWRITE)
return STG_E_ACCESSDENIED;
/* Special case */
if (IsEqualPropertyKey(*key, PKEY_AudioEndpoint_GUID))
{
pv->vt = VT_LPWSTR;
pv->u.pwszVal = CoTaskMemAlloc(39 * sizeof(WCHAR));
if (!pv->u.pwszVal)
return E_OUTOFMEMORY;
StringFromGUID2(&This->parent->devguid, pv->u.pwszVal, 39);
return S_OK;
}
return MMDevice_GetPropValue(&This->parent->devguid, This->parent->flow, key, pv);
}
HRESULT WpdCapabilities::DispatchWpdMessage(_In_ REFPROPERTYKEY Command,
_In_ IPortableDeviceValues* pParams,
_In_ IPortableDeviceValues* pResults)
{
HRESULT hr = S_OK;
if (Command.fmtid != WPD_CATEGORY_CAPABILITIES)
{
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_CAPABILITIES_GET_SUPPORTED_COMMANDS))
{
hr = OnGetSupportedCommands(pParams, pResults);
CHECK_HR(hr, "Failed to get supported commands");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_CAPABILITIES_GET_COMMAND_OPTIONS))
{
hr = OnGetCommandOptions(pParams, pResults);
CHECK_HR(hr, "Failed to get command options");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_CAPABILITIES_GET_SUPPORTED_FUNCTIONAL_CATEGORIES))
{
hr = OnGetFunctionalCategories(pParams, pResults);
CHECK_HR(hr, "Failed to get functional categories");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_CAPABILITIES_GET_FUNCTIONAL_OBJECTS))
{
hr = OnGetFunctionalObjects(pParams, pResults);
CHECK_HR(hr, "Failed to get functional objects");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_CAPABILITIES_GET_SUPPORTED_CONTENT_TYPES))
{
hr = OnGetSupportedContentTypes(pParams, pResults);
CHECK_HR(hr, "Failed to get supported content types");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_CAPABILITIES_GET_SUPPORTED_FORMATS))
{
hr = OnGetSupportedFormats(pParams, pResults);
CHECK_HR(hr, "Failed to get supported formats");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_CAPABILITIES_GET_SUPPORTED_FORMAT_PROPERTIES))
{
hr = OnGetSupportedFormatProperties(pParams, pResults);
CHECK_HR(hr, "Failed to get supported format properties");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_CAPABILITIES_GET_FIXED_PROPERTY_ATTRIBUTES))
{
hr = OnGetFixedPropertyAttributes(pParams, pResults);
CHECK_HR(hr, "Failed to get fixed property attributes");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_CAPABILITIES_GET_SUPPORTED_EVENTS))
{
hr = OnGetSupportedEvents(pParams, pResults);
CHECK_HR(hr, "Failed to get supported events");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_CAPABILITIES_GET_EVENT_OPTIONS))
{
hr = OnGetEventOptions(pParams, pResults);
CHECK_HR(hr, "Failed to get event options");
}
else
{
hr = E_NOTIMPL;
CHECK_HR(hr, "This object does not support this command id %d", Command.pid);
}
}
return hr;
}
HRESULT FakeContactsServiceContent::GetValue(
REFPROPERTYKEY Key,
__out IPortableDeviceValues* pStore)
{
HRESULT hr = S_OK;
PropVariantWrapper pvValue;
if (IsEqualPropertyKey(Key, WPD_OBJECT_ID))
{
// Add WPD_OBJECT_ID
pvValue = ObjectID;
hr = pStore->SetValue(WPD_OBJECT_ID, &pvValue);
CHECK_HR(hr, ("Failed to set WPD_OBJECT_ID"));
}
else if (IsEqualPropertyKey(Key, WPD_OBJECT_NAME))
{
// Add WPD_OBJECT_NAME
pvValue = Name;
hr = pStore->SetValue(WPD_OBJECT_NAME, &pvValue);
CHECK_HR(hr, ("Failed to set WPD_OBJECT_NAME"));
}
else if (IsEqualPropertyKey(Key, WPD_OBJECT_PERSISTENT_UNIQUE_ID))
{
// Add WPD_OBJECT_PERSISTENT_UNIQUE_ID
pvValue = PersistentUniqueID;
hr = pStore->SetValue(WPD_OBJECT_PERSISTENT_UNIQUE_ID, &pvValue);
CHECK_HR(hr, ("Failed to set WPD_OBJECT_PERSISTENT_UNIQUE_ID"));
}
else if (IsEqualPropertyKey(Key, WPD_OBJECT_PARENT_ID))
{
// Add WPD_OBJECT_PARENT_ID
pvValue = ParentID;
hr = pStore->SetValue(WPD_OBJECT_PARENT_ID, &pvValue);
CHECK_HR(hr, ("Failed to set WPD_OBJECT_PARENT_ID"));
}
else if (IsEqualPropertyKey(Key, WPD_OBJECT_FORMAT))
{
// Add WPD_OBJECT_FORMAT
hr = pStore->SetGuidValue(WPD_OBJECT_FORMAT, Format);
CHECK_HR(hr, ("Failed to set WPD_OBJECT_FORMAT"));
}
else if (IsEqualPropertyKey(Key, WPD_OBJECT_CONTENT_TYPE))
{
// Add WPD_OBJECT_CONTENT_TYPE
hr = pStore->SetGuidValue(WPD_OBJECT_CONTENT_TYPE, ContentType);
CHECK_HR(hr, ("Failed to set WPD_OBJECT_CONTENT_TYPE"));
}
else if (IsEqualPropertyKey(Key, WPD_OBJECT_CAN_DELETE))
{
// Add WPD_OBJECT_CAN_DELETE
hr = pStore->SetBoolValue(WPD_OBJECT_CAN_DELETE, CanDelete);
CHECK_HR(hr, ("Failed to set WPD_OBJECT_CAN_DELETE"));
}
else if (IsEqualPropertyKey(Key, WPD_FUNCTIONAL_OBJECT_CATEGORY))
{
// Add WPD_FUNCTIONAL_OBJECT_CATEGORY
hr = pStore->SetGuidValue(WPD_FUNCTIONAL_OBJECT_CATEGORY, FunctionalCategory);
CHECK_HR(hr, ("Failed to set WPD_FUNCTIONAL_OBJECT_CATEGORY"));
}
else if (IsEqualPropertyKey(Key, WPD_OBJECT_CONTAINER_FUNCTIONAL_OBJECT_ID))
{
// Add WPD_OBJECT_CONTAINER_FUNCTIONAL_OBJECT_ID
hr = pStore->SetStringValue(WPD_OBJECT_CONTAINER_FUNCTIONAL_OBJECT_ID, ContainerFunctionalObjectID);
CHECK_HR(hr, ("Failed to set WPD_OBJECT_CONTAINER_FUNCTIONAL_OBJECT_ID"));
}
else if (IsEqualPropertyKey(Key, WPD_SERVICE_VERSION))
{
// Add WPD_SERVICE_VERSION
hr = pStore->SetStringValue(WPD_SERVICE_VERSION, Version);
CHECK_HR(hr, ("Failed to set WPD_SERVICE_VERSION"));
}
else if (IsEqualPropertyKey(Key, PKEY_Services_ServiceDisplayName))
{
pvValue = HumanReadableName;
hr = pStore->SetValue(PKEY_Services_ServiceDisplayName, &pvValue);
CHECK_HR(hr, ("Failed to set PKEY_Services_ServiceDisplayName"));
}
else if (IsEqualPropertyKey(Key, PKEY_FullEnumSyncSvc_SyncFormat))
{
hr = pStore->SetGuidValue(PKEY_FullEnumSyncSvc_SyncFormat, PreferredSyncFormat);
CHECK_HR(hr, ("Failed to set PKEY_FullEnumSyncSvc_SyncFormat"));
}
else if (IsEqualPropertyKey(Key, PKEY_Services_ServiceIcon))
{
hr = GetIconData(pStore);
CHECK_HR(hr, "Failed to set PKEY_Services_ServiceIcon");
}
else if (IsEqualPropertyKey(Key, PKEY_FullEnumSyncSvc_VersionProps))
{
hr = GetVICData(pStore);
CHECK_HR(hr, "Failed to set PKEY_FullEnumSyncSvc_VersionProps");
}
else
{
hr = HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
CHECK_HR(hr, "Property {%ws}.%d is not supported", CComBSTR(Key.fmtid), Key.pid);
}
return hr;
}
STDMETHODIMP CDriveItemPropertyStore::GetValue(REFPROPERTYKEY key, __out PROPVARIANT *ppropvar)
{
Log::WriteOutput(LogType::Debug, L"CDriveItemPropertyStore::GetValue(REFPROPERTYKEY key, __out PROPVARIANT *ppropvar)");
HRESULT hr = S_OK;
if (_flags & GPS_DELAYCREATION)
{
// Find this prop in the delayed key list
for (size_t i = 0; i < _rgDelayedKeys.GetCount(); i++)
{
if (IsEqualPropertyKey(key, _rgDelayedKeys[i]))
{
_rgDelayedKeys.RemoveAt(i);
CComPtr<IDriveItemPropertyHandler> sprph;
hr = _gDriveShlExt->QueryInterface(IID_PPV_ARGS(&sprph));
if (!SUCCEEDED(hr))
{
Log::WriteOutput(LogType::Error, L"CComPtr<IDriveItemPropertyHandler>->QueryInterface returned hr=%d", hr);
}
else
{
CPropVariant spropvar;
hr = sprph->GetProperty(_cpidl, key, &spropvar);
if (!SUCCEEDED(hr) && hr != E_INVALIDARG)
{
Log::WriteOutput(LogType::Error, L"CComPtr<IDriveItemPropertyHandler>->GetProperty returned hr=%d", hr);
}
else
{
hr = _sppropstore->SetValue(key, spropvar);
if (!SUCCEEDED(hr))
{
Log::WriteOutput(LogType::Error, L"_sppropstore->SetValue returned hr=%d", hr);
}
}
break;
}
}
}
}
if (SUCCEEDED(hr))
{
hr = _sppropstore->GetValue(key, ppropvar);
if (!SUCCEEDED(hr))
{
Log::WriteOutput(LogType::Error, L"_sppropstore->GetValue returned hr=%d", hr);
}
}
return hr;
}
HRESULT WpdObjectPropertiesBulk::DispatchWpdMessage(
_In_ REFPROPERTYKEY Command,
_In_ IPortableDeviceValues* pParams,
_In_ IPortableDeviceValues* pResults)
{
HRESULT hr = S_OK;
if (Command.fmtid != WPD_CATEGORY_OBJECT_PROPERTIES_BULK)
{
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_BULK_GET_VALUES_BY_OBJECT_LIST_START))
{
hr = OnGetValuesByObjectListStart(pParams, pResults);
if(FAILED(hr))
{
CHECK_HR(hr, "Failed to start bulk property operation");
}
}
else if(IsEqualPropertyKey(Command, WPD_COMMAND_OBJECT_PROPERTIES_BULK_GET_VALUES_BY_OBJECT_LIST_NEXT))
{
hr = OnGetValuesByObjectListNext(pParams, pResults);
if(FAILED(hr))
{
CHECK_HR(hr, "Failed to do next bulk property operation");
}
}
else if(IsEqualPropertyKey(Command, WPD_COMMAND_OBJECT_PROPERTIES_BULK_GET_VALUES_BY_OBJECT_LIST_END))
{
hr = OnGetValuesByObjectListEnd(pParams, pResults);
if(FAILED(hr))
{
CHECK_HR(hr, "Failed to end bulk property operation");
}
}
else if(IsEqualPropertyKey(Command, WPD_COMMAND_OBJECT_PROPERTIES_BULK_GET_VALUES_BY_OBJECT_FORMAT_START))
{
hr = OnGetValuesByObjectFormatStart(pParams, pResults);
if(FAILED(hr))
{
CHECK_HR(hr, "Failed to start bulk property operation");
}
}
else if(IsEqualPropertyKey(Command, WPD_COMMAND_OBJECT_PROPERTIES_BULK_GET_VALUES_BY_OBJECT_FORMAT_NEXT))
{
hr = OnGetValuesByObjectFormatNext(pParams, pResults);
if(FAILED(hr))
{
CHECK_HR(hr, "Failed to do next bulk property operation");
}
}
else if(IsEqualPropertyKey(Command, WPD_COMMAND_OBJECT_PROPERTIES_BULK_GET_VALUES_BY_OBJECT_FORMAT_END))
{
hr = OnGetValuesByObjectFormatEnd(pParams, pResults);
if(FAILED(hr))
{
CHECK_HR(hr, "Failed to end bulk property operation ");
}
}
else if(IsEqualPropertyKey(Command, WPD_COMMAND_OBJECT_PROPERTIES_BULK_SET_VALUES_BY_OBJECT_LIST_START))
{
hr = OnSetValuesByObjectListStart(pParams, pResults);
if(FAILED(hr))
{
CHECK_HR(hr, "Failed to set bulk property operation");
}
}
else if(IsEqualPropertyKey(Command, WPD_COMMAND_OBJECT_PROPERTIES_BULK_SET_VALUES_BY_OBJECT_LIST_NEXT))
{
hr = OnSetValuesByObjectListNext(pParams, pResults);
if(FAILED(hr))
{
CHECK_HR(hr, "Failed to set bulk property operation");
}
}
else if(IsEqualPropertyKey(Command, WPD_COMMAND_OBJECT_PROPERTIES_BULK_SET_VALUES_BY_OBJECT_LIST_END))
{
hr = OnSetValuesByObjectListEnd(pParams, pResults);
if(FAILED(hr))
{
CHECK_HR(hr, "Failed to set bulk property operation");
}
}
else
{
hr = E_NOTIMPL;
CHECK_HR(hr, "This object does not support this command id %d", Command.pid);
}
}
return hr;
}
HRESULT WpdObjectResources::OnCreate(
IPortableDeviceValues* pParams,
IPortableDeviceValues* pResults)
{
HRESULT hr = S_OK;
LPWSTR pszObjectID = NULL;
LPWSTR pszContext = NULL;
ContextMap* pContextMap = NULL;
PROPERTYKEY ResourceKey = WPD_PROPERTY_NULL;
GUID guidObjectFormat = GUID_NULL;
CComPtr<IPortableDeviceValues> pResourceAttributes;
// Getthe Resource Attributes
hr = pParams->GetIPortableDeviceValuesValue(WPD_PROPERTY_OBJECT_RESOURCES_RESOURCE_ATTRIBUTES, &pResourceAttributes);
if (hr != S_OK)
{
hr = E_INVALIDARG;
CHECK_HR(hr, "Missing value for WPD_PROPERTY_OBJECT_RESOURCES_RESOURCE_ATTRIBUTES");
}
// Get the Resource Key
if (hr == S_OK)
{
hr = pResourceAttributes->GetKeyValue(WPD_RESOURCE_ATTRIBUTE_RESOURCE_KEY, &ResourceKey);
if (hr != S_OK)
{
hr = E_INVALIDARG;
CHECK_HR(hr, "Missing value for WPD_RESOURCE_ATTRIBUTE_RESOURCE_KEY");
}
}
if (hr == S_OK)
{
if (!IsEqualPropertyKey(ResourceKey, WPD_RESOURCE_CONTACT_PHOTO))
{
hr = E_INVALIDARG;
CHECK_HR(hr, "CreateResource is only supported on WPD_RESOURCE_CONTACT_PHOTO");
}
}
if (hr == S_OK)
{
// Get the Object ID
hr = pResourceAttributes->GetStringValue(WPD_OBJECT_ID, &pszObjectID);
if (hr != S_OK)
{
hr = E_INVALIDARG;
CHECK_HR(hr, "Missing value for WPD_OBJECT_ID");
}
}
if (hr == S_OK)
{
hr = m_pFakeDevice->GetContentFormat(pszObjectID, guidObjectFormat);
CHECK_HR(hr, "Failed to get content object format");
if (hr == S_OK)
{
if (!IsEqualGUID(guidObjectFormat, WPD_OBJECT_FORMAT_VCARD2))
{
hr = E_INVALIDARG;
CHECK_HR(hr, "CreateResource is only supported on contact objects");
}
}
}
// Get the context map which the driver stored in pParams for convenience
if (hr == S_OK)
{
hr = pParams->GetIUnknownValue(PRIVATE_SAMPLE_DRIVER_CLIENT_CONTEXT_MAP, (IUnknown**)&pContextMap);
CHECK_HR(hr, "Failed to get PRIVATE_SAMPLE_DRIVER_CLIENT_CONTEXT_MAP");
}
// Create the context
if (hr == S_OK)
{
hr = CreateResourceContext(pContextMap, pszObjectID, ResourceKey, TRUE, &pszContext);
CHECK_HR(hr, "Failed to create resource context for %ws.%d on %ws", CComBSTR(ResourceKey.fmtid), ResourceKey.pid, pszObjectID);
}
if (hr == S_OK)
{
hr = pResults->SetStringValue(WPD_PROPERTY_OBJECT_RESOURCES_CONTEXT, pszContext);
CHECK_HR(hr, "Failed to set WPD_PROPERTY_OBJECT_RESOURCES_CONTEXT");
}
// Set the optimal buffer size
if (hr == S_OK)
{
hr = pResults->SetUnsignedIntegerValue(WPD_PROPERTY_OBJECT_RESOURCES_OPTIMAL_TRANSFER_BUFFER_SIZE, OPTIMAL_BUFFER_SIZE);
CHECK_HR(hr, "Failed to set WPD_PROPERTY_OBJECT_RESOURCES_OPTIMAL_TRANSFER_BUFFER_SIZE value");
}
// Free the memory. CoTaskMemFree ignores NULLs so no need to check.
CoTaskMemFree(pszObjectID);
// Free the memory. CoTaskMemFree ignores NULLs so no need to check.
CoTaskMemFree(pszContext);
SAFE_RELEASE(pContextMap);
return hr;
}
HRESULT WpdObjectResources::DispatchWpdMessage(
const PROPERTYKEY& Command,
IPortableDeviceValues* pParams,
IPortableDeviceValues* pResults)
{
HRESULT hr = S_OK;
if (hr == S_OK)
{
if (Command.fmtid != WPD_CATEGORY_OBJECT_RESOURCES)
{
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_RESOURCES_GET_SUPPORTED))
{
hr = OnGetSupportedResources(pParams, pResults);
CHECK_HR(hr, "Failed to get supported resources");
}
else if(IsEqualPropertyKey(Command, WPD_COMMAND_OBJECT_RESOURCES_GET_ATTRIBUTES))
{
hr = OnGetAttributes(pParams, pResults);
if(FAILED(hr))
{
CHECK_HR(hr, "Failed to get resource attributes");
}
}
else if(IsEqualPropertyKey(Command, WPD_COMMAND_OBJECT_RESOURCES_OPEN))
{
hr = OnOpen(pParams, pResults);
CHECK_HR(hr, "Failed to open resource");
}
else if(IsEqualPropertyKey(Command, WPD_COMMAND_OBJECT_RESOURCES_READ))
{
hr = OnRead(pParams, pResults);
CHECK_HR(hr, "Failed to read resource data");
}
else if(IsEqualPropertyKey(Command, WPD_COMMAND_OBJECT_RESOURCES_WRITE))
{
hr = OnWrite(pParams, pResults);
CHECK_HR(hr, "Failed to write resource data");
}
else if(IsEqualPropertyKey(Command, WPD_COMMAND_OBJECT_RESOURCES_CLOSE))
{
hr = OnClose(pParams, pResults);
CHECK_HR(hr, "Failed to close resource");
}
else if(IsEqualPropertyKey(Command, WPD_COMMAND_OBJECT_RESOURCES_DELETE))
{
hr = OnDelete(pParams, pResults);
CHECK_HR(hr, "Failed to delete resources");
}
else if(IsEqualPropertyKey(Command, WPD_COMMAND_OBJECT_RESOURCES_CREATE_RESOURCE))
{
hr = OnCreate(pParams, pResults);
CHECK_HR(hr, "Failed to create resource");
}
else if(IsEqualPropertyKey(Command, WPD_COMMAND_OBJECT_RESOURCES_REVERT))
{
hr = OnRevert(pParams, pResults);
CHECK_HR(hr, "Failed to revert resource operation");
}
else if(IsEqualPropertyKey(Command, WPD_COMMAND_OBJECT_RESOURCES_SEEK))
{
hr = OnSeek(pParams, pResults);
CHECK_HR(hr, "Failed resource seek operation");
}
else
{
hr = E_NOTIMPL;
CHECK_HR(hr, "This object does not support this command id %d", Command.pid);
}
}
return hr;
}
HRESULT BthLEDeviceContent::GetValue(
REFPROPERTYKEY Key,
_Out_ IPortableDeviceValues* pStore)
{
HRESULT hr = S_OK;
if (pStore == NULL)
{
hr = E_INVALIDARG;
return hr;
}
// Set DEVICE object properties
if (IsEqualPropertyKey(Key, WPD_DEVICE_FIRMWARE_VERSION))
{
hr = pStore->SetStringValue(WPD_DEVICE_FIRMWARE_VERSION, FirmwareVersion);
CHECK_HR(hr, "Failed to set WPD_DEVICE_FIRMWARE_VERSION");
}
else if (IsEqualPropertyKey(Key, WPD_DEVICE_PROTOCOL))
{
hr = pStore->SetStringValue(WPD_DEVICE_PROTOCOL, Protocol);
CHECK_HR(hr, "Failed to set WPD_DEVICE_PROTOCOL");
}
else if (IsEqualPropertyKey(Key, WPD_DEVICE_MODEL))
{
hr = pStore->SetStringValue(WPD_DEVICE_MODEL, Model);
CHECK_HR(hr, "Failed to set WPD_DEVICE_MODEL");
}
else if (IsEqualPropertyKey(Key, WPD_DEVICE_SERIAL_NUMBER))
{
hr = pStore->SetStringValue(WPD_DEVICE_SERIAL_NUMBER, SerialNumber);
CHECK_HR(hr, "Failed to set WPD_DEVICE_SERIAL_NUMBER");
}
else if (IsEqualPropertyKey(Key, WPD_DEVICE_MANUFACTURER))
{
hr = pStore->SetStringValue(WPD_DEVICE_MANUFACTURER, Manufacturer);
CHECK_HR(hr, "Failed to set WPD_DEVICE_MANUFACTURER");
}
else if (IsEqualPropertyKey(Key, WPD_DEVICE_FRIENDLY_NAME))
{
hr = pStore->SetStringValue(WPD_DEVICE_FRIENDLY_NAME, FriendlyName);
CHECK_HR(hr, "Failed to set WPD_DEVICE_FRIENDLY_NAME");
}
else if (IsEqualPropertyKey(Key, WPD_DEVICE_TYPE))
{
hr = pStore->SetUnsignedIntegerValue(WPD_DEVICE_TYPE, DeviceType);
CHECK_HR(hr, "Failed to set WPD_DEVICE_TYPE");
}
// Set general properties for DEVICE
else if (IsEqualPropertyKey(Key, WPD_OBJECT_ID))
{
hr = pStore->SetStringValue(WPD_OBJECT_ID, ObjectID);
CHECK_HR(hr, "Failed to set WPD_OBJECT_ID");
}
else if (IsEqualPropertyKey(Key, WPD_OBJECT_NAME))
{
hr = pStore->SetStringValue(WPD_OBJECT_NAME, Name);
CHECK_HR(hr, "Failed to set WPD_OBJECT_NAME");
}
else if (IsEqualPropertyKey(Key, WPD_OBJECT_PERSISTENT_UNIQUE_ID))
{
hr = pStore->SetStringValue(WPD_OBJECT_PERSISTENT_UNIQUE_ID, PersistentUniqueID);
CHECK_HR(hr, "Failed to set WPD_OBJECT_PERSISTENT_UNIQUE_ID");
}
else if (IsEqualPropertyKey(Key, WPD_OBJECT_FORMAT))
{
hr = pStore->SetGuidValue(WPD_OBJECT_FORMAT, Format);
CHECK_HR(hr, "Failed to set WPD_OBJECT_FORMAT");
}
else if (IsEqualPropertyKey(Key, WPD_OBJECT_CONTENT_TYPE))
{
hr = pStore->SetGuidValue(WPD_OBJECT_CONTENT_TYPE, ContentType);
CHECK_HR(hr, "Failed to set WPD_OBJECT_CONTENT_TYPE");
}
else if (IsEqualPropertyKey(Key, WPD_FUNCTIONAL_OBJECT_CATEGORY))
{
hr = pStore->SetGuidValue(WPD_FUNCTIONAL_OBJECT_CATEGORY, FunctionalCategory);
CHECK_HR(hr, "Failed to set WPD_FUNCTIONAL_OBJECT_CATEGORY");
}
else if (IsEqualPropertyKey(Key, WPD_OBJECT_CONTAINER_FUNCTIONAL_OBJECT_ID))
{
hr = pStore->SetStringValue(WPD_OBJECT_CONTAINER_FUNCTIONAL_OBJECT_ID, ContainerFunctionalObjectID);
CHECK_HR(hr, "Failed to set WPD_OBJECT_CONTAINER_FUNCTIONAL_OBJECT_ID");
}
else
{
hr = HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
CHECK_HR(hr, "Property %ws.%d is not supported", CComBSTR(Key.fmtid), Key.pid);
}
return hr;
}
HRESULT WpdObjectProperties::DispatchWpdMessage(const PROPERTYKEY& Command,
IPortableDeviceValues* pParams,
IPortableDeviceValues* pResults)
{
HRESULT hr = S_OK;
if (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 = OnGetValues(pParams, pResults);
if(FAILED(hr))
{
CHECK_HR(hr, "Failed to read properties");
}
}
else if(IsEqualPropertyKey(Command, WPD_COMMAND_OBJECT_PROPERTIES_GET_ALL))
{
hr = OnGetAllValues(pParams, pResults);
if(FAILED(hr))
{
CHECK_HR(hr, "Failed to read all properties");
}
}
else if(IsEqualPropertyKey(Command, WPD_COMMAND_OBJECT_PROPERTIES_SET))
{
hr = OnWriteProperties(pParams, pResults);
if(FAILED(hr))
{
CHECK_HR(hr, "Failed to write properties");
}
}
else if(IsEqualPropertyKey(Command, WPD_COMMAND_OBJECT_PROPERTIES_GET_ATTRIBUTES))
{
hr = OnGetAttributes(pParams, pResults);
if(FAILED(hr))
{
CHECK_HR(hr, "Failed to get property attributes");
}
}
else if(IsEqualPropertyKey(Command, WPD_COMMAND_OBJECT_PROPERTIES_DELETE))
{
hr = OnDelete(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_RESOURCES_OPEN
* command.
*
* The parameters sent to us are:
* - WPD_PROPERTY_OBJECT_RESOURCES_OBJECT_ID: the object identifier of the
* object which contains the specified resource
*
* - WPD_PROPERTY_OBJECT_RESOURCES_RESOURCE_KEYS: the specified resource
* to open
*
* - WPD_PROPERTY_OBJECT_RESOURCES_ACCESS_MODE: the access mode to which to
* open the specified resource
*
* The driver should:
* - Create a new context for this resource operation.
* - Return an identifier for the context in WPD_PROPERTY_OBJECT_RESOURCES_CONTEXT.
* - Set the optimal transfer size in WPD_PROPERTY_OBJECT_RESOURCES_OPTIMAL_TRANSFER_BUFFER_SIZE
*
*/
HRESULT WpdObjectResources::OnOpenResource(
_In_ IPortableDeviceValues* pParams,
_In_ IPortableDeviceValues* pResults)
{
HRESULT hr = S_OK;
LPWSTR wszObjectID = NULL;
PROPERTYKEY Key = WPD_PROPERTY_NULL;
DWORD dwMode = STGM_READ;
CAtlStringW strStrObjectID;
CAtlStringW strResourceContext;
ContextMap* pContextMap = NULL;
// Get the Object identifier of the object which contains the specified resource
hr = pParams->GetStringValue(WPD_PROPERTY_OBJECT_RESOURCES_OBJECT_ID, &wszObjectID);
if (hr != S_OK)
{
hr = E_INVALIDARG;
CHECK_HR(hr, "Missing value for WPD_PROPERTY_OBJECT_RESOURCES_OBJECT_ID");
}
// Get the resource key
if (hr == S_OK)
{
hr = pParams->GetKeyValue(WPD_PROPERTY_OBJECT_RESOURCES_RESOURCE_KEYS, &Key);
CHECK_HR(hr, "Missing value for WPD_PROPERTY_OBJECT_RESOURCES_RESOURCE_KEYS");
}
// Get the access mode
if (hr == S_OK)
{
hr = pParams->GetUnsignedIntegerValue(WPD_PROPERTY_OBJECT_RESOURCES_ACCESS_MODE, &dwMode);
CHECK_HR(hr, "Missing value for WPD_PROPERTY_OBJECT_RESOURCES_ACCESS_MODE");
}
// Validate whether the params given to us are correct. In this case, we need to check that the object
// supports the resource requested, and can be opened in the requested access mode.
if (hr == S_OK)
{
// In this sample, we only have one object (README_FILE_OBJECT_ID) which supports a
// resource (WPD_RESOURCE_DEFAULT) for reading only.
// So if any other Object ID or any other resource is specified, it must be invalid.
strStrObjectID = wszObjectID;
if(strStrObjectID.CompareNoCase(README_FILE_OBJECT_ID) != 0)
{
hr = E_INVALIDARG;
CHECK_HR(hr, "Object [%ws] does not support resources", wszObjectID);
}
if (hr == S_OK)
{
if (!IsEqualPropertyKey(Key, WPD_RESOURCE_DEFAULT))
{
hr = E_INVALIDARG;
CHECK_HR(hr, "Only WPD_RESOURCE_DEFAULT is supported in this sample driver");
}
}
if (hr == S_OK)
{
if ((dwMode & STGM_WRITE) != 0)
{
hr = E_ACCESSDENIED;
CHECK_HR(hr, "This resource is not available for write access");
}
}
}
// Get the context map which the driver stored in pParams for convenience
if (hr == S_OK)
{
hr = pParams->GetIUnknownValue(PRIVATE_SAMPLE_DRIVER_CLIENT_CONTEXT_MAP, (IUnknown**)&pContextMap);
CHECK_HR(hr, "Failed to get PRIVATE_SAMPLE_DRIVER_CLIENT_CONTEXT_MAP");
}
// Create a new resource operation context, initialize it, and add it to the client context map.
if (hr == S_OK)
{
WpdObjectResourceContext* pResourceContext = new WpdObjectResourceContext();
if (pResourceContext != NULL)
{
// Initialize the resource context with ...
pResourceContext->m_strObjectID = wszObjectID;
pResourceContext->m_Resource = Key;
pResourceContext->m_BytesTransferred = 0;
pResourceContext->m_BytesTotal = GetObjectSize(wszObjectID);
// Add the resource context to the context map
pContextMap->Add(pResourceContext, strResourceContext);
// Release the resource context because it has been AddRef'ed during Add()
SAFE_RELEASE(pResourceContext);
}
else
{
hr = E_OUTOFMEMORY;
CHECK_HR(hr, "Failed to allocate resource context");
}
}
if (hr == S_OK)
{
hr = pResults->SetStringValue(WPD_PROPERTY_OBJECT_RESOURCES_CONTEXT, strResourceContext);
CHECK_HR(hr, "Failed to set WPD_PROPERTY_OBJECT_RESOURCES_CONTEXT");
}
// Set the optimal buffer size
if (hr == S_OK)
{
hr = pResults->SetUnsignedIntegerValue(WPD_PROPERTY_OBJECT_RESOURCES_OPTIMAL_TRANSFER_BUFFER_SIZE, FILE_OPTIMAL_READ_BUFFER_SIZE_VALUE);
CHECK_HR(hr, "Failed to set WPD_PROPERTY_OBJECT_RESOURCES_OPTIMAL_TRANSFER_BUFFER_SIZE value");
}
// Free the memory. CoTaskMemFree ignores NULLs so no need to check.
CoTaskMemFree(wszObjectID);
SAFE_RELEASE(pContextMap);
return hr;
}
void DirectShowMetaDataControl::updateMetadata(IFilterGraph2 *graph, IBaseFilter *source, const QString &fileSrc)
{
m_metadata.clear();
#ifndef QT_NO_SHELLITEM
if (!sHCreateItemFromParsingName) {
QSystemLibrary lib(QStringLiteral("shell32"));
sHCreateItemFromParsingName = (q_SHCreateItemFromParsingName)(lib.resolve("SHCreateItemFromParsingName"));
}
if (!fileSrc.isEmpty() && sHCreateItemFromParsingName) {
IShellItem2* shellItem = 0;
if (sHCreateItemFromParsingName(reinterpret_cast<const WCHAR*>(fileSrc.utf16()),
0, IID_PPV_ARGS(&shellItem)) == S_OK) {
IPropertyStore *pStore = 0;
if (shellItem->GetPropertyStore(GPS_DEFAULT, IID_PPV_ARGS(&pStore)) == S_OK) {
DWORD cProps;
if (SUCCEEDED(pStore->GetCount(&cProps))) {
for (DWORD i = 0; i < cProps; ++i)
{
PROPERTYKEY key;
PROPVARIANT var;
PropVariantInit(&var);
if (FAILED(pStore->GetAt(i, &key)))
continue;
if (FAILED(pStore->GetValue(key, &var)))
continue;
if (IsEqualPropertyKey(key, PKEY_Author)) {
m_metadata.insert(QMediaMetaData::Author, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Title)) {
m_metadata.insert(QMediaMetaData::Title, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Media_SubTitle)) {
m_metadata.insert(QMediaMetaData::SubTitle, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_ParentalRating)) {
m_metadata.insert(QMediaMetaData::ParentalRating, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Comment)) {
m_metadata.insert(QMediaMetaData::Description, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Copyright)) {
m_metadata.insert(QMediaMetaData::Copyright, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Media_ProviderStyle)) {
m_metadata.insert(QMediaMetaData::Genre, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Media_Year)) {
m_metadata.insert(QMediaMetaData::Year, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Media_DateEncoded)) {
m_metadata.insert(QMediaMetaData::Date, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Rating)) {
m_metadata.insert(QMediaMetaData::UserRating,
int((convertValue(var).toUInt() - 1) / qreal(98) * 100));
} else if (IsEqualPropertyKey(key, PKEY_Keywords)) {
m_metadata.insert(QMediaMetaData::Keywords, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Language)) {
m_metadata.insert(QMediaMetaData::Language, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Media_Publisher)) {
m_metadata.insert(QMediaMetaData::Publisher, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Media_Duration)) {
m_metadata.insert(QMediaMetaData::Duration,
(convertValue(var).toLongLong() + 10000) / 10000);
} else if (IsEqualPropertyKey(key, PKEY_Audio_EncodingBitrate)) {
m_metadata.insert(QMediaMetaData::AudioBitRate, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Media_AverageLevel)) {
m_metadata.insert(QMediaMetaData::AverageLevel, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Audio_ChannelCount)) {
m_metadata.insert(QMediaMetaData::ChannelCount, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Audio_PeakValue)) {
m_metadata.insert(QMediaMetaData::PeakValue, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Audio_SampleRate)) {
m_metadata.insert(QMediaMetaData::SampleRate, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Music_AlbumTitle)) {
m_metadata.insert(QMediaMetaData::AlbumTitle, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Music_AlbumArtist)) {
m_metadata.insert(QMediaMetaData::AlbumArtist, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Music_Artist)) {
m_metadata.insert(QMediaMetaData::ContributingArtist, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Music_Composer)) {
m_metadata.insert(QMediaMetaData::Composer, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Music_Conductor)) {
m_metadata.insert(QMediaMetaData::Conductor, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Music_Lyrics)) {
m_metadata.insert(QMediaMetaData::Lyrics, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Music_Mood)) {
m_metadata.insert(QMediaMetaData::Mood, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Music_TrackNumber)) {
m_metadata.insert(QMediaMetaData::TrackNumber, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Music_Genre)) {
m_metadata.insert(QMediaMetaData::Genre, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_ThumbnailStream)) {
m_metadata.insert(QMediaMetaData::ThumbnailImage, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Video_FrameHeight)) {
QSize res;
res.setHeight(convertValue(var).toUInt());
if (SUCCEEDED(pStore->GetValue(PKEY_Video_FrameWidth, &var)))
res.setWidth(convertValue(var).toUInt());
m_metadata.insert(QMediaMetaData::Resolution, res);
} else if (IsEqualPropertyKey(key, PKEY_Video_HorizontalAspectRatio)) {
QSize aspectRatio;
aspectRatio.setWidth(convertValue(var).toUInt());
if (SUCCEEDED(pStore->GetValue(PKEY_Video_VerticalAspectRatio, &var)))
aspectRatio.setHeight(convertValue(var).toUInt());
m_metadata.insert(QMediaMetaData::PixelAspectRatio, aspectRatio);
} else if (IsEqualPropertyKey(key, PKEY_Video_FrameRate)) {
m_metadata.insert(QMediaMetaData::VideoFrameRate,
convertValue(var).toReal() / 1000);
} else if (IsEqualPropertyKey(key, PKEY_Video_EncodingBitrate)) {
m_metadata.insert(QMediaMetaData::VideoBitRate, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Video_Director)) {
m_metadata.insert(QMediaMetaData::Director, convertValue(var));
} else if (IsEqualPropertyKey(key, PKEY_Media_Writer)) {
m_metadata.insert(QMediaMetaData::Writer, convertValue(var));
}
PropVariantClear(&var);
}
}
pStore->Release();
}
shellItem->Release();
}
}
if (!m_metadata.isEmpty())
goto send_event;
#endif
#ifndef QT_NO_WMSDK
IWMHeaderInfo *info = com_cast<IWMHeaderInfo>(source, IID_IWMHeaderInfo);
if (info) {
Q_FOREACH (const QWMMetaDataKey &key, *qt_wmMetaDataKeys()) {
QVariant var = getValue(info, key.wmName);
if (var.isValid()) {
if (key.qtName == QMediaMetaData::Duration) {
// duration is provided in 100-nanosecond units, convert to milliseconds
var = (var.toLongLong() + 10000) / 10000;
} else if (key.qtName == QMediaMetaData::Resolution) {
QSize res;
res.setHeight(var.toUInt());
res.setWidth(getValue(info, L"WM/VideoWidth").toUInt());
var = res;
} else if (key.qtName == QMediaMetaData::VideoFrameRate) {
var = var.toReal() / 1000.f;
} else if (key.qtName == QMediaMetaData::PixelAspectRatio) {
QSize aspectRatio;
aspectRatio.setWidth(var.toUInt());
aspectRatio.setHeight(getValue(info, L"AspectRatioY").toUInt());
var = aspectRatio;
} else if (key.qtName == QMediaMetaData::UserRating) {
var = (var.toUInt() - 1) / qreal(98) * 100;
}
m_metadata.insert(key.qtName, var);
}
}
info->Release();
}
if (!m_metadata.isEmpty())
goto send_event;
#endif
{
IAMMediaContent *content = 0;
if ((!graph || graph->QueryInterface(
IID_IAMMediaContent, reinterpret_cast<void **>(&content)) != S_OK)
&& (!source || source->QueryInterface(
IID_IAMMediaContent, reinterpret_cast<void **>(&content)) != S_OK)) {
content = 0;
}
if (content) {
BSTR string = 0;
if (content->get_AuthorName(&string) == S_OK)
m_metadata.insert(QMediaMetaData::Author, convertBSTR(&string));
if (content->get_Title(&string) == S_OK)
m_metadata.insert(QMediaMetaData::Title, convertBSTR(&string));
if (content->get_Description(&string) == S_OK)
m_metadata.insert(QMediaMetaData::Description, convertBSTR(&string));
if (content->get_Rating(&string) == S_OK)
m_metadata.insert(QMediaMetaData::UserRating, convertBSTR(&string));
if (content->get_Copyright(&string) == S_OK)
m_metadata.insert(QMediaMetaData::Copyright, convertBSTR(&string));
content->Release();
}
}
send_event:
// DirectShowMediaPlayerService holds a lock at this point so defer emitting signals to a later
// time.
QCoreApplication::postEvent(this, new QEvent(QEvent::Type(MetaDataChanged)));
}
HRESULT AbstractDeviceContent::GetValue(
REFPROPERTYKEY Key,
_Out_ IPortableDeviceValues* pStore)
{
HRESULT hr = S_OK;
PropVariantWrapper pvValue;
if(pStore == NULL)
{
hr = E_POINTER;
CHECK_HR(hr, "Cannot have NULL parameter");
return hr;
}
if (IsEqualPropertyKey(Key, WPD_OBJECT_ID))
{
// Add WPD_OBJECT_ID
pvValue = ObjectID;
hr = pStore->SetValue(WPD_OBJECT_ID, &pvValue);
CHECK_HR(hr, ("Failed to set WPD_OBJECT_ID"));
}
else if (IsEqualPropertyKey(Key, WPD_OBJECT_PERSISTENT_UNIQUE_ID))
{
// Add WPD_OBJECT_PERSISTENT_UNIQUE_ID
pvValue = this->PersistentUniqueID;
hr = pStore->SetValue(WPD_OBJECT_PERSISTENT_UNIQUE_ID, &pvValue);
CHECK_HR(hr, ("Failed to set WPD_OBJECT_PERSISTENT_UNIQUE_ID"));
}
else if (IsEqualPropertyKey(Key, WPD_OBJECT_PARENT_ID))
{
// Add WPD_OBJECT_PARENT_ID
pvValue = ParentID;
hr = pStore->SetValue(WPD_OBJECT_PARENT_ID, &pvValue);
CHECK_HR(hr, ("Failed to set WPD_OBJECT_PARENT_ID"));
}
else if (IsEqualPropertyKey(Key, WPD_OBJECT_NAME))
{
// Add WPD_OBJECT_NAME
pvValue = Name;
hr = pStore->SetValue(WPD_OBJECT_NAME, &pvValue);
CHECK_HR(hr, ("Failed to set WPD_OBJECT_NAME"));
}
else if (IsEqualPropertyKey(Key, WPD_OBJECT_CONTENT_TYPE))
{
// Add WPD_OBJECT_CONTENT_TYPE
hr = pStore->SetGuidValue(WPD_OBJECT_CONTENT_TYPE, ContentType);
CHECK_HR(hr, ("Failed to set WPD_OBJECT_CONTENT_TYPE"));
}
else if (IsEqualPropertyKey(Key, WPD_OBJECT_FORMAT))
{
// Add WPD_OBJECT_FORMAT
hr = pStore->SetGuidValue(WPD_OBJECT_FORMAT, Format);
CHECK_HR(hr, ("Failed to set WPD_OBJECT_FORMAT"));
}
else if (IsEqualPropertyKey(Key, WPD_OBJECT_CAN_DELETE))
{
// Add WPD_OBJECT_CAN_DELETE
hr = pStore->SetBoolValue(WPD_OBJECT_CAN_DELETE, CanDelete);
CHECK_HR(hr, ("Failed to set WPD_OBJECT_CAN_DELETE"));
}
else
{
hr = HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
CHECK_HR(hr, "Property {%ws}.%d is not supported", CComBSTR(Key.fmtid), Key.pid);
}
return hr;
}
HRESULT HealthThermometerServiceContent::GetValue(
REFPROPERTYKEY Key,
_Inout_ IPortableDeviceValues* pStore)
{
HRESULT hr = S_OK;
PropVariantWrapper pvValue;
//
// Common Service properties
//
if (IsEqualPropertyKey(Key, WPD_OBJECT_ID))
{
// Add WPD_OBJECT_ID
pvValue = ObjectID;
hr = pStore->SetValue(WPD_OBJECT_ID, &pvValue);
CHECK_HR(hr, ("Failed to set WPD_OBJECT_ID"));
}
else if (IsEqualPropertyKey(Key, WPD_OBJECT_NAME))
{
// Add WPD_OBJECT_NAME
pvValue = Name;
hr = pStore->SetValue(WPD_OBJECT_NAME, &pvValue);
CHECK_HR(hr, ("Failed to set WPD_OBJECT_NAME"));
}
else if (IsEqualPropertyKey(Key, WPD_OBJECT_PERSISTENT_UNIQUE_ID))
{
// Add WPD_OBJECT_PERSISTENT_UNIQUE_ID
pvValue = PersistentUniqueID;
hr = pStore->SetValue(WPD_OBJECT_PERSISTENT_UNIQUE_ID, &pvValue);
CHECK_HR(hr, ("Failed to set WPD_OBJECT_PERSISTENT_UNIQUE_ID"));
}
else if (IsEqualPropertyKey(Key, WPD_OBJECT_PARENT_ID))
{
// Add WPD_OBJECT_PARENT_ID
pvValue = ParentID;
hr = pStore->SetValue(WPD_OBJECT_PARENT_ID, &pvValue);
CHECK_HR(hr, ("Failed to set WPD_OBJECT_PARENT_ID"));
}
else if (IsEqualPropertyKey(Key, WPD_OBJECT_FORMAT))
{
// Add WPD_OBJECT_FORMAT
hr = pStore->SetGuidValue(WPD_OBJECT_FORMAT, Format);
CHECK_HR(hr, ("Failed to set WPD_OBJECT_FORMAT"));
}
else if (IsEqualPropertyKey(Key, WPD_OBJECT_CONTENT_TYPE))
{
// Add WPD_OBJECT_CONTENT_TYPE
hr = pStore->SetGuidValue(WPD_OBJECT_CONTENT_TYPE, ContentType);
CHECK_HR(hr, ("Failed to set WPD_OBJECT_CONTENT_TYPE"));
}
else if (IsEqualPropertyKey(Key, WPD_OBJECT_CAN_DELETE))
{
// Add WPD_OBJECT_CAN_DELETE
hr = pStore->SetBoolValue(WPD_OBJECT_CAN_DELETE, CanDelete);
CHECK_HR(hr, ("Failed to set WPD_OBJECT_CAN_DELETE"));
}
else if (IsEqualPropertyKey(Key, WPD_FUNCTIONAL_OBJECT_CATEGORY))
{
// Add WPD_FUNCTIONAL_OBJECT_CATEGORY
hr = pStore->SetGuidValue(WPD_FUNCTIONAL_OBJECT_CATEGORY, FunctionalCategory);
CHECK_HR(hr, ("Failed to set WPD_FUNCTIONAL_OBJECT_CATEGORY"));
}
else if (IsEqualPropertyKey(Key, WPD_OBJECT_CONTAINER_FUNCTIONAL_OBJECT_ID))
{
// Add WPD_OBJECT_CONTAINER_FUNCTIONAL_OBJECT_ID
hr = pStore->SetStringValue(WPD_OBJECT_CONTAINER_FUNCTIONAL_OBJECT_ID, ContainerFunctionalObjectID);
CHECK_HR(hr, ("Failed to set WPD_OBJECT_CONTAINER_FUNCTIONAL_OBJECT_ID"));
}
else if (IsEqualPropertyKey(Key, WPD_SERVICE_VERSION))
{
// Add WPD_SERVICE_VERSION
hr = pStore->SetStringValue(WPD_SERVICE_VERSION, Version);
CHECK_HR(hr, ("Failed to set WPD_SERVICE_VERSION"));
}
else if (IsEqualPropertyKey(Key, PKEY_Services_ServiceDisplayName))
{
// Add PKEY_Services_ServiceDisplayName
pvValue = HumanReadableName;
hr = pStore->SetValue(PKEY_Services_ServiceDisplayName, &pvValue);
CHECK_HR(hr, ("Failed to set PKEY_Services_ServiceDisplayName"));
}
//
// Begin Gatt Service properties
//
//
// End Gatt Service properties
//
else
{
hr = HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
CHECK_HR(hr, "Property {%ws}.%d is not supported", CComBSTR(Key.fmtid), Key.pid);
}
return hr;
}
HRESULT WpdServiceCapabilities::DispatchWpdMessage(
_In_ REFPROPERTYKEY Command,
_In_ IPortableDeviceValues* pParams,
_In_ IPortableDeviceValues* pResults)
{
HRESULT hr = S_OK;
if (Command.fmtid != WPD_CATEGORY_SERVICE_CAPABILITIES)
{
hr = E_INVALIDARG;
CHECK_HR(hr, "This object does not support this command category %ws",CComBSTR(Command.fmtid));
return hr;
}
if (IsEqualPropertyKey(Command, WPD_COMMAND_SERVICE_CAPABILITIES_GET_SUPPORTED_COMMANDS))
{
hr = OnGetSupportedCommands(pParams, pResults);
CHECK_HR(hr, "Failed to get supported commands");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_SERVICE_CAPABILITIES_GET_COMMAND_OPTIONS))
{
hr = OnGetCommandOptions(pParams, pResults);
CHECK_HR(hr, "Failed to get command options");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_SERVICE_CAPABILITIES_GET_SUPPORTED_METHODS))
{
hr = OnGetSupportedMethods(pParams, pResults);
CHECK_HR(hr, "Failed to get supported methods");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_SERVICE_CAPABILITIES_GET_SUPPORTED_METHODS_BY_FORMAT))
{
hr = OnGetSupportedMethodsByFormat(pParams, pResults);
CHECK_HR(hr, "Failed to get supported methods by format");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_SERVICE_CAPABILITIES_GET_METHOD_ATTRIBUTES))
{
hr = OnGetMethodAttributes(pParams, pResults);
CHECK_HR(hr, "Failed to get method attributes");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_SERVICE_CAPABILITIES_GET_METHOD_PARAMETER_ATTRIBUTES))
{
hr = OnGetMethodParameterAttributes(pParams, pResults);
CHECK_HR(hr, "Failed to get method parameter attributes");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_SERVICE_CAPABILITIES_GET_SUPPORTED_FORMATS))
{
hr = OnGetSupportedFormats(pParams, pResults);
CHECK_HR(hr, "Failed to get supported formats");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_SERVICE_CAPABILITIES_GET_FORMAT_ATTRIBUTES))
{
hr = OnGetFormatAttributes(pParams, pResults);
CHECK_HR(hr, "Failed to get format attributes");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_SERVICE_CAPABILITIES_GET_SUPPORTED_FORMAT_PROPERTIES))
{
hr = OnGetSupportedFormatProperties(pParams, pResults);
CHECK_HR(hr, "Failed to get supported format properties");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_SERVICE_CAPABILITIES_GET_FORMAT_PROPERTY_ATTRIBUTES))
{
hr = OnGetFormatPropertyAttributes(pParams, pResults);
CHECK_HR(hr, "Failed to get format property attributes");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_SERVICE_CAPABILITIES_GET_SUPPORTED_EVENTS))
{
hr = OnGetSupportedEvents(pParams, pResults);
CHECK_HR(hr, "Failed to get supported events");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_SERVICE_CAPABILITIES_GET_EVENT_ATTRIBUTES))
{
hr = OnGetEventAttributes(pParams, pResults);
CHECK_HR(hr, "Failed to get event attributes");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_SERVICE_CAPABILITIES_GET_EVENT_PARAMETER_ATTRIBUTES))
{
hr = OnGetEventParameterAttributes(pParams, pResults);
CHECK_HR(hr, "Failed to get event parameter attributes");
}
else if (IsEqualPropertyKey(Command, WPD_COMMAND_SERVICE_CAPABILITIES_GET_INHERITED_SERVICES))
{
hr = OnGetInheritedServices(pParams, pResults);
CHECK_HR(hr, "Failed to get inherited services");
}
else
{
hr = E_NOTIMPL;
CHECK_HR(hr, "This object does not support this command id %d", Command.pid);
}
return hr;
}
HRESULT WpdBaseDriver::DispatchWpdMessage(IPortableDeviceValues* pParams,
IPortableDeviceValues* pResults)
{
HRESULT hr = S_OK;
GUID guidCommandCategory = {0};
DWORD dwCommandID = 0;
PROPERTYKEY CommandKey = WPD_PROPERTY_NULL;
if (hr == S_OK)
{
hr = pParams->GetGuidValue(WPD_PROPERTY_COMMON_COMMAND_CATEGORY, &guidCommandCategory);
CHECK_HR(hr, "Failed to get WPD_PROPERTY_COMMON_COMMAND_CATEGORY from input parameters");
}
if (hr == S_OK)
{
hr = pParams->GetUnsignedIntegerValue(WPD_PROPERTY_COMMON_COMMAND_ID, &dwCommandID);
CHECK_HR(hr, "Failed to get WPD_PROPERTY_COMMON_COMMAND_ID from input parameters");
}
// If WPD_PROPERTY_COMMON_COMMAND_CATEGORY or WPD_PROPERTY_COMMON_COMMAND_ID could not be extracted
// properly then we should return E_INVALIDARG to the client.
if (FAILED(hr))
{
hr = E_INVALIDARG;
CHECK_HR(hr, "Failed to get WPD_PROPERTY_COMMON_COMMAND_CATEGORY or WPD_PROPERTY_COMMON_COMMAND_ID from input parameters");
}
if (hr == S_OK)
{
CommandKey.fmtid = guidCommandCategory;
CommandKey.pid = dwCommandID;
if (CommandKey.fmtid == WPD_CATEGORY_OBJECT_ENUMERATION)
{
hr = m_ObjectEnum.DispatchWpdMessage(CommandKey, pParams, pResults);
}
else if (CommandKey.fmtid == WPD_CATEGORY_OBJECT_PROPERTIES)
{
hr = m_ObjectProperties.DispatchWpdMessage(CommandKey, pParams, pResults);
}
else if (CommandKey.fmtid == WPD_CATEGORY_CAPABILITIES)
{
hr = m_Capabilities.DispatchWpdMessage(CommandKey, pParams, pResults);
}
else if (IsEqualPropertyKey(CommandKey, WPD_COMMAND_COMMON_GET_OBJECT_IDS_FROM_PERSISTENT_UNIQUE_IDS))
{
hr = OnGetObjectIDsFromPersistentUniqueIDs(pParams, pResults);
}
else
{
hr = E_NOTIMPL;
CHECK_HR(hr, "Unknown command %ws.%d received",CComBSTR(CommandKey.fmtid), CommandKey.pid);
}
}
HRESULT hrTemp = pResults->SetErrorValue(WPD_PROPERTY_COMMON_HRESULT, hr);
CHECK_HR(hrTemp, ("Failed to set WPD_PROPERTY_COMMON_HRESULT"));
// Set to a success code, to indicate that the message was received.
// the return code for the actual command's results is stored in the
// WPD_PROPERTY_COMMON_HRESULT property.
hr = S_OK;
return hr;
}
/**
* This method is called to populate resource attributes found on a particular object
* resource.
*
* The parameters sent to us are:
* wszObjectID - the object whose resource attributes are being requested
* Key - the resource on the specified object whose attributes are being returned
* pAttributes - An IPortableDeviceValues to be populated with resource attributes.
*
* The driver should:
* Add attributes pertaining to the resource on the specified object.
*/
HRESULT WpdObjectResources::GetResourceAttributesForObject(
_In_ LPCWSTR wszObjectID,
_In_ REFPROPERTYKEY Key,
_In_ IPortableDeviceValues* pAttributes)
{
HRESULT hr = S_OK;
CAtlStringW strObjectID;
if ((wszObjectID == NULL) ||
(pAttributes == NULL))
{
hr = E_INVALIDARG;
return hr;
}
strObjectID = wszObjectID;
if ((strObjectID.CompareNoCase(README_FILE_OBJECT_ID) == 0) && (IsEqualPropertyKey(Key, WPD_RESOURCE_DEFAULT)))
{
if (hr == S_OK)
{
hr = pAttributes->SetBoolValue(WPD_RESOURCE_ATTRIBUTE_CAN_DELETE, FALSE);
CHECK_HR(hr, "Failed to set WPD_RESOURCE_ATTRIBUTE_CAN_DELETE");
}
if (hr == S_OK)
{
hr = pAttributes->SetUnsignedLargeIntegerValue(WPD_RESOURCE_ATTRIBUTE_TOTAL_SIZE, GetObjectSize(strObjectID));
CHECK_HR(hr, "Failed to set WPD_RESOURCE_ATTRIBUTE_TOTAL_SIZE");
}
if (hr == S_OK)
{
hr = pAttributes->SetBoolValue(WPD_RESOURCE_ATTRIBUTE_CAN_READ, TRUE);
CHECK_HR(hr, "Failed to set WPD_RESOURCE_ATTRIBUTE_CAN_READ");
}
if (hr == S_OK)
{
hr = pAttributes->SetBoolValue(WPD_RESOURCE_ATTRIBUTE_CAN_WRITE, FALSE);
CHECK_HR(hr, "Failed to set WPD_RESOURCE_ATTRIBUTE_CAN_WRITE");
}
if (hr == S_OK)
{
hr = pAttributes->SetBoolValue(WPD_RESOURCE_ATTRIBUTE_CAN_DELETE, FALSE);
CHECK_HR(hr, "Failed to set WPD_RESOURCE_ATTRIBUTE_CAN_DELETE");
}
if (hr == S_OK)
{
hr = pAttributes->SetGuidValue(WPD_RESOURCE_ATTRIBUTE_FORMAT, GetObjectFormat(strObjectID));
CHECK_HR(hr, "Failed to set WPD_RESOURCE_ATTRIBUTE_FORMAT");
}
if (hr == S_OK)
{
hr = pAttributes->SetUnsignedIntegerValue(WPD_RESOURCE_ATTRIBUTE_OPTIMAL_READ_BUFFER_SIZE, FILE_OPTIMAL_READ_BUFFER_SIZE_VALUE);
CHECK_HR(hr, "Failed to set WPD_RESOURCE_ATTRIBUTE_OPTIMAL_READ_BUFFER_SIZE");
}
if (hr == S_OK)
{
hr = pAttributes->SetUnsignedIntegerValue(WPD_RESOURCE_ATTRIBUTE_OPTIMAL_WRITE_BUFFER_SIZE, FILE_OPTIMAL_WRITE_BUFFER_SIZE_VALUE);
CHECK_HR(hr, "Failed to set WPD_RESOURCE_ATTRIBUTE_OPTIMAL_WRITE_BUFFER_SIZE");
}
}
return hr;
}
static bool IsEqual(const T& t1, const T& t2) { return IsEqualPropertyKey(t1, t2); };
