Condividi tramite


Enumerazione dei dispositivi Windows Media Gestione dispositivi

Dopo l'autenticazione di un'applicazione, è possibile iniziare a enumerare i dispositivi rilevati da Windows Media Gestione dispositivi. L'enumerazione viene eseguita usando un'interfaccia di enumerazione , IWMDMEnumDevice, ottenuta usando IWMDeviceManager2::EnumDevices2 o IWMDeviceManager::EnumDevices. Se supportato, usare il metodo EnumDevices2 , perché la versione precedente ha restituito solo interfacce legacy nei dispositivi, mentre la nuova versione restituisce sia la versione legacy che le nuove interfacce.

Prima di ottenere un enumeratore, è necessario decidere quale visualizzazione di enumerazione usare. Alcuni dispositivi espongono ogni risorsa di archiviazione come dispositivo diverso. Ad esempio, due schede di memoria flash in un dispositivo enumereranno come se fossero dispositivi separati. È possibile specificare che tutte le risorse di archiviazione in un dispositivo vengono enumerate insieme come singolo dispositivo. È possibile impostare questa preferenza una sola volta nell'applicazione; se si vuole modificarla, è necessario arrestare l'applicazione e riavviarla. Si noti tuttavia che i dispositivi legacy talvolta ignoreranno una richiesta per enumerare le risorse di archiviazione dei dispositivi separate come un singolo dispositivo e continuare a enumerarle separatamente.

I passaggi seguenti illustrano come enumerare i dispositivi connessi:

  1. Impostare la preferenza di enumerazione del dispositivo usando IWMDeviceManager3::SetDeviceEnumPreference. Se questo metodo non viene chiamato, il metodo predefinito consiste nel mostrare le risorse di archiviazione come dispositivi separati. Per determinare se i singoli "dispositivi" sono effettivamente archivi nello stesso dispositivo, chiamare IWMDMDevice2::GetCanonicalName; le risorse di archiviazione dello stesso dispositivo restituiranno valori identici, ad eccezione della cifra finale dopo l'ultimo segno "$".
  2. Eseguire una query per IWMDeviceManager o IWMDeviceManager2 e quindi chiamare IWMDeviceManager2::EnumDevices2 per ottenere l'interfaccia dell'enumeratore del dispositivo , IWMDMEnumDevice. Se supportato, usare EnumDevices2, che è più efficiente, perché la versione precedente potrebbe non restituire dispositivi MTP.
  3. Chiamare il metodo IWMDMEnumDevices::Next per recuperare uno o più dispositivi alla volta. Continuare a chiamare questo metodo fino a quando il metodo non restituisce S_FALSE o un messaggio di errore. Se si recupera un solo dispositivo alla volta, non è necessario allocare una matrice per contenere i dispositivi.

Poiché gli utenti possono collegare o rimuovere dispositivi dal computer durante l'esecuzione dell'applicazione, è consigliabile implementare la notifica della connessione o della rimozione del dispositivo. Questa operazione viene eseguita implementando l'interfaccia IWMDMNotification e registrandola. Per altre informazioni, vedere Abilitazione delle notifiche.

Il codice C++ seguente enumera i dispositivi e richiede informazioni su ogni dispositivo.

HRESULT CWMDMController::EnumDevices()
{
    HRESULT hr = S_OK;

    // Change behavior to show devices as one object, not each storage as a device.
    // This can be called only once for each instance of this application.
    CComQIPtr<IWMDeviceManager3>pDevMgr3(m_IWMDMDeviceMgr);
    hr = pDevMgr3->SetDeviceEnumPreference(DO_NOT_VIRTUALIZE_STORAGES_AS_DEVICES);
    
    // Get number of attached devices.
    DWORD iDevices = 0;
    hr = m_IWMDMDeviceMgr->GetDeviceCount(&iDevices);
    if (hr == S_OK)
    {
        // TODO: Display count of devices.
    }

    //
    // Get a device enumerator to enumerate devices.
    //
    CComPtr<IWMDeviceManager2> pDevMgr2;
    hr = m_IWMDMDeviceMgr->QueryInterface (__uuidof(IWMDeviceManager2), (void**) &pDevMgr2);
    if (hr == S_OK)
    {
        // TODO: Display message indicating that application obtained IWMDeviceManager2.
    }
    else
    {
        // TODO: Display message indicating that we couldn't 
        // get IWMDeviceManager2 in EnumDevices.
        return hr;
    }
   CComPtr<IWMDMEnumDevice> pEnumDevice;
   hr = pDevMgr2->EnumDevices2(&pEnumDevice);
    if (hr != S_OK)
    {
        // TODO: Display messaging indicating that an error occurred 
        // in calling EnumDevices2.
        return hr;
    }

    // Length of all the strings we'll send in. 
    const UINT MAX_CHARS = 100;

    // Iterate through devices.
    while(TRUE)
    {
        // Get a device handle.
        IWMDMDevice *pIWMDMDevice;
        ULONG ulFetched = 0;
        hr = pEnumDevice->Next(1, &pIWMDMDevice, &ulFetched);
        if ((hr != S_OK) || (ulFetched != 1))
        {
            break;
        }
        
        // Get a display icon for the device.
        ULONG deviceIcon = 0;
        hr = pIWMDMDevice->GetDeviceIcon(&deviceIcon);

        // Print the device manufacturer.
        WCHAR manufacturer[MAX_CHARS];
        hr = pIWMDMDevice->GetManufacturer((LPWSTR)&manufacturer, MAX_CHARS);
        if (hr == S_OK)
        {
            // TODO: Display manufacturer name.
        }

        // Get the device name.
        WCHAR name[MAX_CHARS];
        hr = pIWMDMDevice->GetName((LPWSTR)&name, MAX_CHARS);
        if (hr == S_OK)
        {
            // TODO: Display name.
        }

        // TODO: Get other device information if wanted.

        // Obtain an IWMDMDevice2 interface and call some methods.
        CComQIPtr<IWMDMDevice2> pIWMDMDevice2(pIWMDMDevice);
        if (pIWMDMDevice2 != NULL)
        {
            // Get the canonical name.
            WCHAR canonicalName[MAX_CHARS];
            hr = pIWMDMDevice2->GetCanonicalName(canonicalName, MAX_CHARS);
            if (hr == S_OK)
            {
                // TODO: Display canonical name.
            }
        }

        // Obtain an IWMDMDevice3 interface and call some methods.
        CComQIPtr<IWMDMDevice3>pIWMDMDevice3(pIWMDMDevice);
        if (pIWMDMDevice3 != NULL)
        {
            // Find out what protocol is being used.
            PROPVARIANT val;
            PropVariantInit(&val);
            hr = pIWMDMDevice3->GetProperty(g_wszWMDMDeviceProtocol, &val);

            if (hr == S_OK)
            {
                if (*val.puuid == WMDM_DEVICE_PROTOCOL_RAPI)
                {
                    // TODO: Display message indicating device is a RAPI device.
                }
                else if (*val.puuid == WMDM_DEVICE_PROTOCOL_MTP)
                {
                    / /TODO: Display message indicating device is an MTP device.
                }
                else if (*val.puuid == WMDM_DEVICE_PROTOCOL_MSC)
                {
                    // TODO: Display message indicating device is an MSC device.
                }
                else
                {
                    // TODO: Display message indicating that the 
                    // application encountered an unknown protocol.
                }
                PropVariantClear(&val);
            }
        }

        // Examine the device capabilities. You could use some of these
        // to enable or disable the application's UI elements.
        CComQIPtr<IWMDMDeviceControl> pDeviceControl(pIWMDMDevice);
        if (pDeviceControl != NULL)
        {
            DWORD caps = 0;
            hr = pDeviceControl->GetCapabilities(&caps);
            if (caps & WMDM_DEVICECAP_CANPLAY)
            {
                // TODO: Display message indicating that the media 
                // device can play MP3 audio.
            }
            // TODO: Test for other capabilities here.
        }
    } // Get the next device.
    return hr;
}

Creazione di un'applicazione windows Media Gestione dispositivi