Impostazione delle proprietà per più oggetti
Alcuni driver di dispositivo supportano l'impostazione delle proprietà per più oggetti in una singola chiamata di funzione, denominata scrittura in blocco. L'applicazione può eseguire una scrittura bulk usando le interfacce descritte nella tabella seguente.
| Interfaccia | Descrizione |
|---|---|
| Interfaccia IPortableDeviceContent | Fornisce l'accesso ai metodi specifici del contenuto. |
| Interfaccia IPortableDeviceProperties | Fornisce l'accesso ai metodi specifici della proprietà. |
| Interfaccia IPortableDevicePropertiesBulk | Supporta l'operazione di scrittura bulk. |
| Interfaccia IPortableDevicePropVariantCollection | Usato per archiviare gli identificatori di oggetto per l'operazione in blocco. |
| Interfaccia IPortableDeviceValuesCollection | Utilizzato per identificare le proprietà da scrivere. |
La WriteContentPropertiesBulk funzione nel modulo ContentProperties.cpp dell'applicazione di esempio illustra un'operazione di scrittura in blocco.
La prima attività eseguita in questo esempio determina se il driver specificato supporta le operazioni bulk. Questa operazione viene eseguita chiamando QueryInterface su un oggetto IPortableDeviceProperties e verificando l'esistenza di IPortableDevicePropertiesBulk.
HRESULT hr = S_OK;
GUID guidContext = GUID_NULL;
CSetBulkValuesCallback* pCallback = NULL;
CComPtr<IPortableDeviceProperties> pProperties;
CComPtr<IPortableDevicePropertiesBulk> pPropertiesBulk;
CComPtr<IPortableDeviceValues> pObjectProperties;
CComPtr<IPortableDeviceContent> pContent;
CComPtr<IPortableDeviceValuesCollection> pPropertiesToWrite;
CComPtr<IPortableDevicePropVariantCollection> pObjectIDs;
DWORD cObjectIDs = 0;
if (SUCCEEDED(hr))
{
hr = pDevice->Content(&pContent);
if (FAILED(hr))
{
printf("! Failed to get IPortableDeviceContent from IPortableDevice, hr = 0x%lx\n",hr);
}
}
if (SUCCEEDED(hr))
{
hr = pContent->Properties(&pProperties);
if (FAILED(hr))
{
printf("! Failed to get IPortableDeviceProperties from IPortableDevice, hr = 0x%lx\n",hr);
}
}
if (SUCCEEDED(hr))
{
hr = pProperties->QueryInterface(IID_PPV_ARGS(&pPropertiesBulk));
if (FAILED(hr))
{
printf("This driver does not support BULK property operations.\n");
}
}
L'attività successiva comporta la creazione di un oggetto IPortableDeviceValuesCollection . Si tratta dell'oggetto che contiene i valori delle proprietà che verranno scritti dall'esempio.
HRESULT hr = S_OK;
GUID guidContext = GUID_NULL;
CSetBulkValuesCallback* pCallback = NULL;
CComPtr<IPortableDeviceProperties> pProperties;
CComPtr<IPortableDevicePropertiesBulk> pPropertiesBulk;
CComPtr<IPortableDeviceValues> pObjectProperties;
CComPtr<IPortableDeviceContent> pContent;
CComPtr<IPortableDeviceValuesCollection> pPropertiesToWrite;
CComPtr<IPortableDevicePropVariantCollection> pObjectIDs;
DWORD cObjectIDs = 0;
if (SUCCEEDED(hr))
{
hr = CoCreateInstance(CLSID_PortableDeviceValuesCollection,
NULL,
CLSCTX_INPROC_SERVER,
IID_IPortableDeviceValuesCollection,
(VOID**) &pPropertiesToWrite);
if (FAILED(hr))
{
printf("! Failed to CoCreate IPortableDeviceValuesCollection for bulk property values, hr = 0x%lx\n", hr);
}
}
Successivamente, l'esempio crea un'istanza dell'interfaccia IPortableDevicePropertiesBulkCallback. L'applicazione userà i metodi in questa interfaccia per tenere traccia dello stato di avanzamento dell'operazione di scrittura bulk asincrona.
HRESULT hr = S_OK;
GUID guidContext = GUID_NULL;
CSetBulkValuesCallback* pCallback = NULL;
CComPtr<IPortableDeviceProperties> pProperties;
CComPtr<IPortableDevicePropertiesBulk> pPropertiesBulk;
CComPtr<IPortableDeviceValues> pObjectProperties;
CComPtr<IPortableDeviceContent> pContent;
CComPtr<IPortableDeviceValuesCollection> pPropertiesToWrite;
CComPtr<IPortableDevicePropVariantCollection> pObjectIDs;
DWORD cObjectIDs = 0;
if (SUCCEEDED(hr))
{
pCallback = new CSetBulkValuesCallback();
if (pCallback == NULL)
{
hr = E_OUTOFMEMORY;
printf("! Failed to allocate CSetBulkValuesCallback, hr = 0x%lx\n", hr);
}
}
La funzione successiva che l'applicazione di esempio chiama è la CreateIPortableDevicePropVariantCollectionWithAllObjectIDs funzione helper. Questa funzione enumera in modo ricorsivo tutti gli oggetti in un determinato dispositivo e restituisce un'interfaccia IPortableDevicePropVariantCollection che contiene un identificatore per ogni oggetto trovato. Questa funzione è definita nel modulo ContentEnumeration.cpp.
// 7) Call our helper function CreateIPortableDevicePropVariantCollectionWithAllObjectIDs
// to enumerate and create an IPortableDevicePropVariantCollection with the object
// identifiers needed to perform the bulk operation on.
if (SUCCEEDED(hr))
{
hr = CreateIPortableDevicePropVariantCollectionWithAllObjectIDs(pDevice,
pContent,
&pObjectIDs);
}
L'oggetto IPortableDevicePropVariantCollection contiene un insieme di valori PROPVARIANT indicizzati dello stesso VARTYPE. In questo caso, questi valori contengono un identificatore di oggetto specificato per ogni oggetto trovato nel dispositivo.
Gli identificatori di oggetto e le rispettive proprietà del nome vengono archiviati in un oggetto IPortableDeviceValuesCollection . Le proprietà del nome sono organizzate in modo che al primo oggetto venga assegnata una proprietà name "NewName0", al secondo oggetto viene assegnata una proprietà name "NewName1" e così via.
Nell'estratto seguente dell'esempio viene illustrato il modo in cui l'oggetto IPortableDeviceValuesCollection è stato inizializzato con identificatori di oggetto e nuove stringhe di nome.
HRESULT hr = S_OK;
GUID guidContext = GUID_NULL;
CSetBulkValuesCallback* pCallback = NULL;
CComPtr<IPortableDeviceProperties> pProperties;
CComPtr<IPortableDevicePropertiesBulk> pPropertiesBulk;
CComPtr<IPortableDeviceValues> pObjectProperties;
CComPtr<IPortableDeviceContent> pContent;
CComPtr<IPortableDeviceValuesCollection> pPropertiesToWrite;
CComPtr<IPortableDevicePropVariantCollection> pObjectIDs;
DWORD cObjectIDs = 0;
if (SUCCEEDED(hr))
{
hr = pObjectIDs->GetCount(&cObjectIDs);
if (FAILED(hr))
{
printf("! Failed to get number of objectIDs from IPortableDevicePropVariantCollection, hr = 0x%lx\n", hr);
}
}
if (SUCCEEDED(hr))
{
for(DWORD dwIndex = 0; (dwIndex < cObjectIDs) && (hr == S_OK); dwIndex++)
{
CComPtr<IPortableDeviceValues> pValues;
PROPVARIANT pv = {0};
PropVariantInit(&pv);
hr = CoCreateInstance(CLSID_PortableDeviceValues,
NULL,
CLSCTX_INPROC_SERVER,
IID_IPortableDeviceValues,
(VOID**) &pValues);
if (FAILED(hr))
{
printf("! Failed to CoCreate CLSID_PortableDeviceValues, hr = 0x%lx\n", hr);
}
// Get the Object ID whose properties we will set
if (hr == S_OK)
{
hr = pObjectIDs->GetAt(dwIndex, &pv);
if (FAILED(hr))
{
printf("! Failed to get next Object ID from list, hr = 0x%lx\n", hr);
}
}
// Save them into the IPortableDeviceValues so the driver knows which object this proeprty set belongs to
if (hr == S_OK)
{
hr = pValues->SetStringValue(WPD_OBJECT_ID, pv.pwszVal);
if (FAILED(hr))
{
printf("! Failed to set WPD_OBJECT_ID, hr = 0x%lx\n", hr);
}
}
// Set the new values. In this sample, we attempt to set the name property.
if (hr == S_OK)
{
CAtlStringW strValue;
strValue.Format(L"NewName%d", dwIndex);
hr = pValues->SetStringValue(WPD_OBJECT_NAME, strValue.GetString());
if (FAILED(hr))
{
printf("! Failed to set WPD_OBJECT_NAME, hr = 0x%lx\n", hr);
}
}
// Add this property set to the collection
if (hr == S_OK)
{
hr = pPropertiesToWrite->Add(pValues);
if (FAILED(hr))
{
printf("! Failed to add values to collection, hr = 0x%lx\n", hr);
}
}
PropVariantClear(&pv);
}
}
Dopo che l'esempio crea l'oggetto IPortableDeviceValuesCollection che contiene l'identificatore dell'oggetto e le coppie di nomi, può iniziare l'operazione asincrona.
L'operazione di scrittura asincrona inizia quando l'esempio chiama il metodo IPortableDevicePropertiesBulk::QueueSetValuesByObjectList . Questo metodo notifica al driver che un'operazione bulk sta per iniziare. Successivamente, l'esempio chiama il metodo IPortableDeviceBulk::Start per iniziare a scrivere effettivamente i nuovi valori del nome.
HRESULT hr = S_OK;
GUID guidContext = GUID_NULL;
CSetBulkValuesCallback* pCallback = NULL;
CComPtr<IPortableDeviceProperties> pProperties;
CComPtr<IPortableDevicePropertiesBulk> pPropertiesBulk;
CComPtr<IPortableDeviceValues> pObjectProperties;
CComPtr<IPortableDeviceContent> pContent;
CComPtr<IPortableDeviceValuesCollection> pPropertiesToWrite;
CComPtr<IPortableDevicePropVariantCollection> pObjectIDs;
DWORD cObjectIDs = 0;
if (SUCCEEDED(hr))
{
hr = pPropertiesBulk->QueueSetValuesByObjectList(pPropertiesToWrite,
pCallback,
&guidContext);
if(SUCCEEDED(hr))
{
// Cleanup any previously created global event handles.
if (g_hBulkPropertyOperationEvent != NULL)
{
CloseHandle(g_hBulkPropertyOperationEvent);
g_hBulkPropertyOperationEvent = NULL;
}
// In order to create a simpler to follow example we create and wait infinitly
// for the bulk property operation to complete and ignore any errors.
// Production code should be written in a more robust manner.
// Create the global event handle to wait on for the bulk operation
// to complete.
g_hBulkPropertyOperationEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
if (g_hBulkPropertyOperationEvent != NULL)
{
// Call Start() to actually being the Asynchronous bulk operation.
hr = pPropertiesBulk->Start(guidContext);
if(FAILED(hr))
{
printf("! Failed to start property operation, hr = 0x%lx\n", hr);
}
}
else
{
printf("! Failed to create the global event handle to wait on for the bulk operation. Aborting operation.\n");
}
}
else
{
printf("! QueueSetValuesByObjectList Failed, hr = 0x%lx\n", hr);
}
}
Si noti che l'esempio attende un periodo di tempo infinito per il completamento dell'operazione. Se si tratta di un'applicazione di produzione, è necessario modificare il codice.
Argomenti correlati