Delen via

Inhoud opsommen

De inhoud op een apparaat (of deze inhoud nu een map, een telefoonboek, een video of een afbeelding is) wordt een object in de WPD-API genoemd. Naar deze objecten wordt verwezen door object-id's en beschreven door eigenschappen. U kunt de objecten op een apparaat opsommen door methoden aan te roepen in de IPortableDevice-interface, de interface IPortableDeviceContenten de interface IEnumPortableDeviceObjectIDs.

De voorbeeldtoepassing demonstreert de opsomming van inhoud in de functie EnumerateAllContent die in de module ContentEnumeration.cpp is gevonden. Deze functie roept op zijn beurt een RecursiveEnumerate-functie aan waarmee de hiërarchie van objecten op het geselecteerde apparaat wordt begeleid en een object-id voor elk object wordt geretourneerd.

Zoals vermeld, haalt de functie RecursiveEnumerate een object-id op voor elk object dat op het apparaat is gevonden. De object-id is een tekenreekswaarde. Zodra uw toepassing deze id heeft opgehaald, kan deze meer beschrijvende objectgegevens verkrijgen (zoals de naam van het object, de id voor het bovenliggende object, enzovoort). Deze beschrijvende informatie wordt objecteigenschappen (of metagegevens) genoemd. Uw toepassing kan deze eigenschappen ophalen door leden van de IPortableDeviceProperties-interfaceaan te roepen.

De functie EnumerateAllContent begint met het ophalen van een aanwijzer naar een IPortableDeviceContent-interface. Deze aanwijzer wordt opgehaald door de methode IPortableDevice::Content aan te roepen.

void EnumerateAllContent(
    IPortableDevice* pDevice)
{
    HRESULT                         hr = S_OK;
    CComPtr<IPortableDeviceContent> pContent;

    if (pDevice == NULL)
    {
        printf("! A NULL IPortableDevice interface pointer was received\n");
        return;
    }

    // Get an IPortableDeviceContent interface from the IPortableDevice interface to
    // access the content-specific methods.
    hr = pDevice->Content(&pContent);
    if (FAILED(hr))
    {
        printf("! Failed to get IPortableDeviceContent from IPortableDevice, hr = 0x%lx\n",hr);
    }

    // Enumerate content starting from the "DEVICE" object.
    if (SUCCEEDED(hr))
    {
        printf("\n");
        RecursiveEnumerate(WPD_DEVICE_OBJECT_ID, pContent);
    }
}

Zodra de aanwijzer naar de interface IPortableDeviceContent wordt opgehaald, roept de functie EnumerateAllContent de functie RecursiveEnumerate aan, waarmee de hiërarchie van objecten op het opgegeven apparaat wordt doorlopen en een object-id voor elk object wordt geretourneerd.

De RecursiveEnumerate-functie begint met het ophalen van een pointer naar de IEnumPortableDeviceObjectIDs-interface . Deze interface bevat de methoden die een toepassing gebruikt om door de lijst met objecten op een bepaald apparaat te navigeren.

In dit voorbeeld roept de functie RecursiveEnumerate de methode IEnumPortableDeviceObjectIDs::Next methode aan om de lijst met objecten te doorlopen.

Elke aanroep naar de IEnumPortableDeviceObjects::Next methode vraagt een batch met 10 id's aan. (Deze waarde wordt opgegeven door de NUM_OBJECTS_TO_REQUEST constante die wordt opgegeven als het eerste argument.)

#define NUM_OBJECTS_TO_REQUEST  10

// Recursively called function which enumerates using the specified
// object identifier as the parent.
void RecursiveEnumerate(
    PCWSTR                  pszObjectID,
    IPortableDeviceContent* pContent)
{
    CComPtr<IEnumPortableDeviceObjectIDs> pEnumObjectIDs;

    // Print the object identifier being used as the parent during enumeration.
    printf("%ws\n",pszObjectID);

    // Get an IEnumPortableDeviceObjectIDs interface by calling EnumObjects with the
    // specified parent object identifier.
    HRESULT hr = pContent->EnumObjects(0,               // Flags are unused
                                       pszObjectID,     // Starting from the passed in object
                                       NULL,            // Filter is unused
                                       &pEnumObjectIDs);
    if (FAILED(hr))
    {
        printf("! Failed to get IEnumPortableDeviceObjectIDs from IPortableDeviceContent, hr = 0x%lx\n",hr);
    }

    // Loop calling Next() while S_OK is being returned.
    while(hr == S_OK)
    {
        DWORD  cFetched = 0;
        PWSTR  szObjectIDArray[NUM_OBJECTS_TO_REQUEST] = {0};
        hr = pEnumObjectIDs->Next(NUM_OBJECTS_TO_REQUEST,   // Number of objects to request on each NEXT call
                                  szObjectIDArray,          // Array of PWSTR array which will be populated on each NEXT call
                                  &cFetched);               // Number of objects written to the PWSTR array
        if (SUCCEEDED(hr))
        {
            // Traverse the results of the Next() operation and recursively enumerate
            // Remember to free all returned object identifiers using CoTaskMemFree()
            for (DWORD dwIndex = 0; dwIndex < cFetched; dwIndex++)
            {
                RecursiveEnumerate(szObjectIDArray[dwIndex],pContent);

                // Free allocated PWSTRs after the recursive enumeration call has completed.
                CoTaskMemFree(szObjectIDArray[dwIndex]);
                szObjectIDArray[dwIndex] = NULL;
            }
        }
    }
}

IEnumPortableDeviceObjectIDs Interface

IPortableDevice Interface

IPortableDeviceContent Interface

IPortableDeviceProperties Interface

Programmeerhandleiding

 

 

  • Last updated on