Énumération du contenu

Le contenu d’un appareil (qu’il s’agisse d’un dossier, d’un annuaire téléphonique, d’une vidéo ou d’une image fixe) est appelé objet dans l’API WPD. Ces objets sont référencés par des identificateurs d’objet et décrits par des propriétés. Vous pouvez énumérer les objets sur un appareil en appelant des méthodes dans l’interface IPortableDevice, l’interface IPortableDeviceContent et l’interface IEnumPortableDeviceObjectIDs.

L’exemple d’application illustre l’énumération de contenu dans la fonction EnumerateAllContent qui se trouve dans le module ContentEnumeration.cpp. Cette fonction, à son tour, appelle une fonction RecursiveEnumerate qui guide la hiérarchie des objets trouvés sur l’appareil sélectionné et retourne un identificateur d’objet pour chaque objet.

Comme indiqué, la fonction RecursiveEnumerate récupère un identificateur d’objet pour chaque objet trouvé sur l’appareil. L’identificateur d’objet est une valeur de chaîne. Une fois que votre application a récupéré cet identificateur, elle peut obtenir des informations plus descriptives sur l’objet (telles que le nom de l’objet, l’identificateur du parent de l’objet, etc.). Ces informations descriptives sont appelées propriétés d’objet (ou métadonnées). Votre application peut récupérer ces propriétés en appelant les membres de l’interface IPortableDeviceProperties.

La fonction EnumerateAllContent commence par récupérer un pointeur vers une interface IPortableDeviceContent. Il récupère ce pointeur en appelant la méthode IPortableDevice::Content .

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

Une fois qu’elle a récupéré le pointeur vers l’interface IPortableDeviceContent, la fonction EnumerateAllContent appelle la fonction RecursiveEnumerate, qui guide la hiérarchie des objets trouvés sur l’appareil donné et retourne un identificateur d’objet pour chacun d’eux.

La fonction RecursiveEnumerate commence par récupérer un pointeur vers une interface IEnumPortableDeviceObjectIDs. Cette interface expose les méthodes utilisées par une application pour parcourir la liste des objets trouvés sur un appareil donné.

Dans cet exemple, la fonction RecursiveEnumerate appelle la méthode IEnumPortableDeviceObjectIDs::Next pour parcourir la liste des objets.

Chaque appel à la méthode IEnumPortableDeviceObjects::Next demande un lot de 10 identificateurs. (Cette valeur est spécifiée par la constante NUM_OBJECTS_TO_REQUEST fournie comme premier 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;
            }
        }
    }
}

Rubriques connexes

IEnumPortableDeviceObjectIDs, interface

IPortableDevice, interface

IPortableDeviceContent, interface

IPortableDeviceProperties, interface

Guide de programmation