Énumération du contenu du service

Une fois que votre application a ouvert un service, elle peut commencer à effectuer des opérations liées au service. Dans le cas de l’application WpdServicesApiSample, l’une de ces opérations est l’énumération du contenu pour un service Contacts donné. Le tableau suivant décrit les interfaces utilisées.

Interface	Description
IPortableDeviceService	Permet de récupérer l’interface IPortableDeviceContent2 pour accéder au contenu du service.
IPortableDeviceContent2	Permet de récupérer l’interface IEnumPortableDeviceObjectIDs pour énumérer des objets sur le service.
IEnumPortableDeviceObjectIDs	Utilisé pour énumérer des objets sur le service.

 

Le code d’énumération de contenu se trouve dans le module ContentEnumeration.cpp. Ce code réside dans les méthodes EnumerateAllContent et RecursiveEnumerate . La première méthode appelle la seconde.

La méthode EnumerateContent prend un pointeur vers un objet IPortableDeviceService comme paramètre unique. Cet objet correspond à un service que l’application a ouvert précédemment lorsqu’elle a appelé la méthode IPortableDeviceService::Open .

La méthode EnumerateContent crée un objet IPortableDeviceContent2 et transmet cet objet à la méthode IPortableDeviceService::Content . Cette méthode, à son tour, récupère le contenu au niveau racine du service, puis commence à récupérer de manière récursive le contenu trouvé sous la racine.

Le code suivant correspond à la méthode EnumerateContent .

// Enumerate all content on the service starting with the
// "DEVICE" object
void EnumerateAllContent(
    IPortableDeviceService* pService)
{
    HRESULT                          hr = S_OK;
    CComPtr<IPortableDeviceContent2> pContent;

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

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

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

Le code suivant correspond à la méthode RecursiveEnumerate . La méthode RecursiveEnumerate instancie une interface IEnumPortableDeviceObjectIDs pour l’objet parent fourni et appelle IEnumPortableDeviceObjectIDs::Next, récupérant un lot d’objets enfants immédiats. Pour chaque objet enfant, RecursiveEnumerate est appelé à nouveau pour retourner ses objets enfants descendants, et ainsi de suite.

// Recursively called function which enumerates using the specified
// object identifier as the parent.
void RecursiveEnumerate(
    PCWSTR                   pszObjectID,
    IPortableDeviceContent2* 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 IPortableDeviceContent2, 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

IPortableDeviceContent2, interface

IPortableDeviceService, interface

Ouverture d’un service

WpdServicesApiSample