WorkIndicator/AudioDevice.cs

using NAudio.CoreAudioApi;
using NAudio.CoreAudioApi.Interfaces;
using Serilog;
using System;
using System.Collections.Generic;
using System.Linq;

namespace WorkIndicator;

internal class AudioDevice : IAudioSessionEventsHandler
{
    private readonly ILogger _logger;
    private readonly string _friendlyName;
    private readonly Dictionary<string, AudioSessionControl> _sessions = new();

    public delegate void AudioSessionsChangedDelegate();

    public event AudioSessionsChangedDelegate AudioSessionsChanged;

    public AudioDevice(MMDevice device)
    {
        _logger = Log.ForContext<AudioDevice>();

        _friendlyName = device.DeviceFriendlyName;
        IsMuted = device.AudioEndpointVolume.Mute;

        _logger.Information("AudioDevice: {name} {muted}", _friendlyName, IsMuted);

        device.AudioEndpointVolume.OnVolumeNotification += AudioEndpointVolume_OnVolumeNotification;
        device.AudioSessionManager.AudioSessionControl.RegisterEventClient(this);
        device.AudioSessionManager.OnSessionCreated += AudioSessionManager_OnSessionCreated;

        device.AudioSessionManager.RefreshSessions();
        var sessions = device.AudioSessionManager.Sessions;

        for (var i = 0; i < sessions.Count; i++)
        {
            SetupSession(sessions[i]);
        }
    }

    private void AudioEndpointVolume_OnVolumeNotification(AudioVolumeNotificationData data)
    {
        _logger.Information("AudioEndpointVolume_OnVolumeNotification: {name} {muted}", _friendlyName, data.Muted);

        IsMuted = data.Muted;

        AudioSessionsChanged?.Invoke();
    }

    private void AudioSessionManager_OnSessionCreated(object sender, IAudioSessionControl newSession)
    {
        var session = new AudioSessionControl(newSession);

        _logger.Information("OnSessionCreated: {name}", session.GetSessionIdentifier);

        SetupSession(session);
    }

    private void SetupSession(AudioSessionControl session)
    {
        _logger.Information("SetupSession: {name}", session.GetSessionIdentifier);

        _sessions[session.GetSessionIdentifier] = session;
        session.RegisterEventClient(this);

        AudioSessionsChanged?.Invoke();
    }

    public int ActiveSessionCount => _sessions.Values.Count(s => s.State == AudioSessionState.AudioSessionStateActive);

    public bool IsMuted { get; private set; }

    void IAudioSessionEventsHandler.OnVolumeChanged(float volume, bool isMuted)
    {
        _logger.Information("OnVolumeChanged: {name} {volume} {isMuted}", _friendlyName, volume, isMuted);
    }

    void IAudioSessionEventsHandler.OnDisplayNameChanged(string displayName)
    {
        _logger.Information("OnDisplayNameChanged: {name}", displayName);
    }

    void IAudioSessionEventsHandler.OnIconPathChanged(string iconPath)
    {
        _logger.Information("OnIconPathChanged: {path}", iconPath);
    }

    void IAudioSessionEventsHandler.OnChannelVolumeChanged(uint channelCount, IntPtr newVolumes, uint channelIndex)
    {
        _logger.Information("OnChannelVolumeChanged: {channelCount} {newVolumes} {channelIndex}", channelCount, newVolumes, channelIndex);
    }

    void IAudioSessionEventsHandler.OnGroupingParamChanged(ref Guid groupingId)
    {
        _logger.Information("OnGroupingParamChanged: {groupingId}", groupingId);
    }

    void IAudioSessionEventsHandler.OnStateChanged(AudioSessionState state)
    {
        _logger.Information("OnStateChanged: {state}", state);

        AudioSessionsChanged?.Invoke();

        if (state == AudioSessionState.AudioSessionStateExpired)
        {
        }
    }

    void IAudioSessionEventsHandler.OnSessionDisconnected(AudioSessionDisconnectReason disconnectReason)
    {
        _logger.Information("OnSessionDisconnected: {disconnectReason}", disconnectReason);
    }
}