Hyperbar/Hyperbar.Widget.MediaController.Windows/MediaController.cs

using System.Collections.Concurrent;
using System.Diagnostics;
using Windows.Media.Control;
using Windows.Storage.Streams;

namespace Hyperbar.Widget.MediaController.Windows;

public class MediaController :
    INotificationHandler<Request<MediaPrevious>>,
    INotificationHandler<Request<MediaNext>>,
    INotificationHandler<Request<MediaInformation>>,
    INotificationHandler<Request<MediaPreviousButton>>,
    INotificationHandler<Request<MediaNextButton>>,
    IDisposable
{
    private readonly AsyncLock asyncLock = new();
    private readonly IDisposer disposer;
    private readonly IMediator mediator;
    private readonly GlobalSystemMediaTransportControlsSession session;

    private GlobalSystemMediaTransportControlsSessionPlaybackStatus playbackStatus;

    public MediaController(IMediator mediator,
        IDisposer disposer,
        GlobalSystemMediaTransportControlsSession session)
    {
        this.mediator = mediator;
        this.disposer = disposer;
        this.session = session;

        disposer.Add(this);
        mediator.Subscribe(this);

        session.MediaPropertiesChanged += OnMediaPropertiesChanged;
        session.PlaybackInfoChanged += OnPlaybackInfoChanged;
    }

    public void Dispose()
    {
        GC.SuppressFinalize(this);
        disposer.Dispose(this);
    }

    public async Task Handle(Request<MediaInformation> args,
        CancellationToken cancellationToken) => await UpdateMediaInformationAsync();

    public async Task Handle(Request<MediaNext> args,
        CancellationToken cancellationToken)
    {
        await session.TrySkipNextAsync();
        await UpdateMediaStateAsync();
    }

    public async Task Handle(Request<MediaPrevious> args, CancellationToken cancellationToken)
    {
        await session.TrySkipPreviousAsync();
        await UpdateMediaStateAsync();
    }

    public async Task Handle(Request<MediaPreviousButton> args,
        CancellationToken cancellationToken) => await UpdateMediaStateAsync();

    public async Task Handle(Request<MediaNextButton> args, 
        CancellationToken cancellationToken) => await UpdateMediaStateAsync();

    private async void OnMediaPropertiesChanged(GlobalSystemMediaTransportControlsSession sender,
            MediaPropertiesChangedEventArgs args)
    {
        await UpdateMediaInformationAsync();
        await UpdateMediaStateAsync();
    }

    private async void OnPlaybackInfoChanged(GlobalSystemMediaTransportControlsSession sender,
        PlaybackInfoChangedEventArgs args) => await UpdateMediaStateAsync();

    private async Task UpdateMediaInformationAsync()
    {
        try
        {
            GlobalSystemMediaTransportControlsSessionMediaProperties mediaProperties =
                 await session.TryGetMediaPropertiesAsync();

            byte[]? buffer = null;

            if (mediaProperties.Thumbnail is not null)
            {
                IRandomAccessStreamWithContentType randomAccessStream =
                    await mediaProperties.Thumbnail.OpenReadAsync();

                var stream = randomAccessStream.AsStream();

                using MemoryStream memoryStream = new();
                await stream.CopyToAsync(memoryStream);
                buffer = memoryStream.ToArray();
            }

            await mediator.PublishAsync(new Changed<MediaInformation>(new MediaInformation(mediaProperties.Title,
                mediaProperties.Artist, buffer)));
        }
        catch
        {

        }
    }

    private bool isPreviousEnabled;
    private bool isNextEnabled;

    private async Task UpdateMediaStateAsync()
    {
        try
        {
            GlobalSystemMediaTransportControlsSessionPlaybackInfo playbackInfo =
                session.GetPlaybackInfo();

            bool isPreviousEnabled = playbackInfo.Controls.IsPreviousEnabled;
            if (this.isPreviousEnabled != isPreviousEnabled)
            {
                await mediator.PublishAsync(new Changed<MediaPreviousButton>(new
                    MediaPreviousButton(isPreviousEnabled)));

                this.isPreviousEnabled = isPreviousEnabled;
            }

            bool isNextEnabled = playbackInfo.Controls.IsNextEnabled;
            if (this.isNextEnabled != isNextEnabled)
            {
                await mediator.PublishAsync(new Changed<MediaNextButton>(new
                    MediaNextButton(isNextEnabled)));

                this.isNextEnabled = isNextEnabled;
            }

        }
        catch
        {

        }
    }
}