Partager via

Obtention d’événements de canardage

  • Article

Une application multimédia qui souhaite fournir une expérience de canardage personnalisée doit écouter les notifications d’événements lorsqu’un flux de communication est ouvert ou fermé dans le système. L’implémentation personnalisée peut être fournie à l’aide de MediaFoundation, DirectShow ou DirectSound, qui utilisent les API Core Audio. Un client WASAPI direct peut également remplacer la gestion par défaut s’il sait quand la session de communication commence et se termine.

Pour fournir une implémentation personnalisée, une application multimédia doit recevoir des notifications du système lorsqu’une application de communication démarre ou met fin à un flux de communication. L’application multimédia doit implémenter l’interface IAudioVolumeDuckNotification et inscrire l’implémentation auprès du système audio. Une fois l’inscription réussie, l’application multimédia reçoit des notifications d’événements sous forme de rappels via les méthodes de l’interface. Pour plus d’informations, consultez Considérations d’implémentation pour les notifications de canardage.

Pour envoyer des notifications de canardage, le système audio doit savoir quelle session audio écoute pour les événements de canardage. Chaque session audio est identifiée de manière unique avec un GUID( session instance identificateur). Le gestionnaire de session permet à une application d’obtenir des informations sur la session, telles que le titre de la session audio, l’état de rendu et l’identificateur instance session. L’identificateur peut être récupéré à l’aide de l’interface de contrôle de stratégie, IAudioSessionControl2.

Les étapes suivantes résument le processus d’obtention de l’identificateur instance session de l’application multimédia :

  1. Instanciez l’énumérateur d’appareil et utilisez-le pour obtenir une référence au point de terminaison de l’appareil que l’application multimédia utilise pour restituer le flux de non-communication.
  2. Activez le gestionnaire de sessions à partir du point de terminaison de l’appareil et obtenez une référence à l’interface IAudioSessionManager2 du gestionnaire de session.
  3. En utilisant le pointeur IAudioSessionManager2 , obtenez une référence à l’interface IAudioSessionControl du gestionnaire de sessions.
  4. Interrogez le IAudioSessionControl2 à partir de l’interface IAudioSessionControl .
  5. Appelez IAudioSessionControl2::GetSessionInstanceIdentifier et récupérez une chaîne qui contient l’identificateur de session pour la session audio active.

Pour obtenir des notifications d’esquive sur les flux de communication, l’application multimédia appelle IAudioSessionManager2::RegisterDuckNotification. L’application multimédia fournit son identificateur instance session au système audio et un pointeur vers l’implémentation IAudioVolumeDuckNotification. L’application peut maintenant recevoir une notification d’événement lorsqu’un flux s’est ouvert sur l’appareil de communication. Pour ne plus recevoir de notification, l’application multimédia doit appeler IAudioSessionManager2::UnregisterDuckNotification.

Le code suivant montre comment une application peut s’inscrire pour obtenir des notifications de canardage. La classe CMediaPlayer est définie dans Considérations d’implémentation pour les notifications de canardage. L’exemple DuckingMediaPlayer implémente cette fonctionnalité.

////////////////////////////////////////////////////////////////////
//Description: Registers for duck notifications depending on the 
//             the ducking options specified by the caller.
//Parameters: 
//    If DuckingOptOutChecked is TRUE, the client is registered for
//    to receive ducking notifications; 
//    FALSE, the client's registration is deleted.
////////////////////////////////////////////////////////////////////

HRESULT CMediaPlayer::DuckingOptOut(bool DuckingOptOutChecked)
{
    HRESULT hr = S_OK;

    IMMDeviceEnumerator* pDeviceEnumerator NULL;
    IMMDevice* pEndpoint = NULL;
    IAudioSessionManager2* pSessionManager2 = NULL;
    IAudioSessionControl* pSessionControl = NULL;
    IAudioSessionControl2* pSessionControl2 = NULL;

    LPWSTR sessionId = NULL;

    //  Start with the default endpoint.

    hr = CoCreateInstance(__uuidof(MMDeviceEnumerator), 
                          NULL, 
                          CLSCTX_INPROC_SERVER, 
                          IID_PPV_ARGS(&pDeviceEnumerator));
    
    if (SUCCEEDED(hr))
    {
        hr = pDeviceEnumerator>GetDefaultAudioEndpoint(
              eRender, eConsole, &pEndpoint);

        pDeviceEnumerator>Release();
        pDeviceEnumerator = NULL;
    }

    // Activate the session manager.
    if (SUCCEEDED(hr))
    {
        hr = pEndpoint->Activate(__uuidof(IAudioSessionManager2), 
                                 CLSCTX_INPROC_SERVER,
                                 NULL, 
                                 reinterpret_cast<void **>
                                 (&pSessionManager2));
        pEndpoint->Release();
        pEndpoint = NULL;
    }
    if (SUCCEEDED(hr))
    {
        hr = pSessionManager2->GetAudioSessionControl(
                                  NULL, 0, &pSessionControl);
        
    }

    if (SUCCEEDED(hr))
    {
        hr = pSessionControl->QueryInterface(
                               IID_PPV_ARGS(&pSessionControl2));
                
        pSessionControl->Release();
        pSessionControl = NULL;
    }

    // Get the session instance identifier.
    
    if (SUCCEEDED(hr))
    {
        hr = pSessionControl2->GetSessionInstanceIdentifier(
                                 sessionId);
                
        pSessionControl2->Release();
        pSessionControl2 = NULL;
    }

    //  Register for ducking events depending on 
    //  the specified preference.

    if (SUCCEEDED(hr))
    {
        if (DuckingOptOutChecked)
        {
            hr = pSessionManager2->RegisterDuckNotification(
                                    sessionId, this);
        }
        else
        {
            hr = pSessionManager2->UnregisterDuckNotification
                                      (FALSE);
        }
        pSessionManager2->Release();
        pSessionManager2 = NULL;
    }
    return hr;
}

Utilisation d’un appareil de communication

Expérience de canardage par défaut

Désactivation de l’expérience de canardage par défaut

Fourniture d’un comportement de canardage personnalisé

Considérations relatives à l’implémentation des notifications de mise en page