feat(cast): proxy volume control to Chromecast receiver when casting

Agent-Logs-Url: https://github.com/huynhsontung/Screenbox/sessions/a7e8afc9-0c2e-45f0-ab40-ae36e09963df

Co-authored-by: huynhsontung <31434093+huynhsontung@users.noreply.github.com>

Author: Copilot

Screenbox.Core/Contexts/CastContext.cs

@@ -5,6 +5,7 @@
 using Screenbox.Core.Helpers;
 using Screenbox.Core.Models;
 using Sharpcaster;
+using Sharpcaster.Models.ChromecastStatus;
 using Sharpcaster.Models.Media;
 using Windows.System;
 
@@ -56,6 +57,21 @@ public sealed partial class CastContext : ObservableObject
     [ObservableProperty]
     private bool _castIsBuffering;
 
+    /// <summary>
+    /// The current receiver volume level reported by the Chromecast device, as a value
+    /// between 0.0 (silent) and 1.0 (full volume).
+    /// Updated from <see cref="Sharpcaster.Channels.ReceiverChannel.ReceiverStatusChanged"/>.
+    /// </summary>
+    [ObservableProperty]
+    private double _castVolume;
+
+    /// <summary>
+    /// <c>true</c> when the Chromecast device's receiver is muted.
+    /// Updated from <see cref="Sharpcaster.Channels.ReceiverChannel.ReceiverStatusChanged"/>.
+    /// </summary>
+    [ObservableProperty]
+    private bool _castIsMuted;
+
     /// <summary>
     /// Raised when the Chromecast device transitions to the <c>IDLE</c> state with reason
     /// <c>FINISHED</c>, <c>ERROR</c>, or <c>CANCELLED</c>, indicating that playback ended
@@ -83,11 +99,13 @@ partial void OnClientChanged(ChromecastClient? oldValue, ChromecastClient? newVa
         if (oldValue is not null)
         {
             oldValue.MediaChannel.StatusChanged -= OnMediaStatusChanged;
+            oldValue.ReceiverChannel.ReceiverStatusChanged -= OnReceiverStatusChanged;
         }
 
         if (newValue is not null)
         {
             newValue.MediaChannel.StatusChanged += OnMediaStatusChanged;
+            newValue.ReceiverChannel.ReceiverStatusChanged += OnReceiverStatusChanged;
         }
     }
 
@@ -120,4 +138,24 @@ private void OnMediaStatusChanged(object sender, MediaStatus status)
             }
         });
     }
+
+    /// <summary>
+    /// Handles receiver status updates pushed by the active Chromecast device.
+    /// Marshals volume and mute state updates onto the UI thread.
+    /// </summary>
+    private void OnReceiverStatusChanged(object sender, ChromecastStatus status)
+    {
+        _dispatcherQueue.TryEnqueue(() =>
+        {
+            if (status.Volume?.Level is { } level)
+            {
+                CastVolume = level;
+            }
+
+            if (status.Volume?.Muted is { } muted)
+            {
+                CastIsMuted = muted;
+            }
+        });
+    }
 }

Screenbox.Core/Services/CastService.cs

@@ -165,6 +165,32 @@ public async Task SeekAsync(ChromecastClient client, TimeSpan position)
         }
     }
 
+    /// <inheritdoc/>
+    public async Task SetVolumeAsync(ChromecastClient client, double level)
+    {
+        try
+        {
+            await client.ReceiverChannel.SetVolume(Math.Clamp(level, 0.0, 1.0));
+        }
+        catch (Exception)
+        {
+            // Ignore — the device may be disconnecting or the session may have ended.
+        }
+    }
+
+    /// <inheritdoc/>
+    public async Task SetMuteAsync(ChromecastClient client, bool muted)
+    {
+        try
+        {
+            await client.ReceiverChannel.SetMute(muted);
+        }
+        catch (Exception)
+        {
+            // Ignore — the device may be disconnecting or the session may have ended.
+        }
+    }
+
     // -------------------------------------------------------------------------
     // Helpers
     // -------------------------------------------------------------------------

Screenbox.Core/Services/ICastService.cs

@@ -57,5 +57,19 @@ public interface ICastService
     /// <param name="client">The active cast client.</param>
     /// <param name="position">The target playback position.</param>
     Task SeekAsync(ChromecastClient client, TimeSpan position);
+
+    /// <summary>
+    /// Sets the receiver volume level on the Chromecast device.
+    /// </summary>
+    /// <param name="client">The active cast client.</param>
+    /// <param name="level">Volume level between 0.0 (silent) and 1.0 (full).</param>
+    Task SetVolumeAsync(ChromecastClient client, double level);
+
+    /// <summary>
+    /// Sets the receiver mute state on the Chromecast device.
+    /// </summary>
+    /// <param name="client">The active cast client.</param>
+    /// <param name="muted">Whether the receiver should be muted.</param>
+    Task SetMuteAsync(ChromecastClient client, bool muted);
 }
 

Screenbox.Core/ViewModels/VolumeViewModel.cs

@@ -1,6 +1,7 @@
 #nullable enable
 
 using System;
+using System.ComponentModel;
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Messaging;
 using CommunityToolkit.Mvvm.Messaging.Messages;
@@ -26,11 +27,20 @@ public sealed partial class VolumeViewModel : ObservableRecipient,
         private readonly DispatcherQueue _dispatcherQueue;
         private readonly ISettingsService _settingsService;
         private readonly PlayerContext _playerContext;
+        private readonly CastContext _castContext;
+        private readonly ICastService _castService;
 
-        public VolumeViewModel(ISettingsService settingsService, PlayerContext playerContext)
+        // Guards against a re-entrant SetVolumeAsync/SetMuteAsync call when Volume or IsMute
+        // is updated programmatically from a Chromecast status event.
+        private bool _updatingFromCast;
+
+        public VolumeViewModel(ISettingsService settingsService, PlayerContext playerContext,
+            CastContext castContext, ICastService castService)
         {
             _settingsService = settingsService;
             _playerContext = playerContext;
+            _castContext = castContext;
+            _castService = castService;
             _volume = settingsService.PersistentVolume;
             _maxVolume = settingsService.MaxVolume;
             _isMute = _volume == 0;
@@ -42,6 +52,8 @@ public VolumeViewModel(ISettingsService settingsService, PlayerContext playerCon
                 MediaPlayer.IsMutedChanged += OnIsMutedChanged;
             }
 
+            _castContext.PropertyChanged += OnCastContextPropertyChanged;
+
             // View model doesn't receive any messages
             IsActive = true;
         }
@@ -77,6 +89,17 @@ public void Receive(ChangeVolumeRequestMessage message)
 
         partial void OnVolumeChanged(int value)
         {
+            // While casting, proxy the volume change to the Chromecast receiver.
+            if (_castContext.IsCasting && _castContext.Client is { } castClient)
+            {
+                if (!_updatingFromCast)
+                {
+                    _ = _castService.SetVolumeAsync(castClient, value / 100.0);
+                }
+
+                return;
+            }
+
             if (MediaPlayer == null) return;
             double newValue = value / 100d;
             // bool stayMute = IsMute && newValue - MediaPlayer.Volume < 0.005;
@@ -87,6 +110,17 @@ partial void OnVolumeChanged(int value)
 
         partial void OnIsMuteChanged(bool value)
         {
+            // While casting, proxy the mute change to the Chromecast receiver.
+            if (_castContext.IsCasting && _castContext.Client is { } castClient)
+            {
+                if (!_updatingFromCast)
+                {
+                    _ = _castService.SetMuteAsync(castClient, value);
+                }
+
+                return;
+            }
+
             if (MediaPlayer == null) return;
             MediaPlayer.IsMuted = value;
         }
@@ -108,6 +142,49 @@ private void OnIsMutedChanged(IMediaPlayer sender, object? args)
             }
         }
 
+        /// <summary>
+        /// Handles changes to the <see cref="CastContext"/> so that the volume control reflects
+        /// the Chromecast device's receiver volume while casting and reverts to the local player
+        /// once the session ends.
+        /// </summary>
+        private void OnCastContextPropertyChanged(object sender, PropertyChangedEventArgs e)
+        {
+            switch (e.PropertyName)
+            {
+                case nameof(CastContext.IsCasting):
+                    _updatingFromCast = true;
+                    if (_castContext.IsCasting)
+                    {
+                        // Casting just started — seed Volume and IsMute from the receiver's
+                        // last known state. The receiver will push a status update shortly
+                        // with the authoritative values.
+                        Volume = (int)Math.Round(_castContext.CastVolume * 100);
+                        IsMute = _castContext.CastIsMuted;
+                    }
+                    else
+                    {
+                        // Casting ended — restore volume from the local player / persisted setting.
+                        Volume = _settingsService.PersistentVolume;
+                        IsMute = Volume == 0;
+                    }
+
+                    _updatingFromCast = false;
+                    break;
+
+                case nameof(CastContext.CastVolume) when _castContext.IsCasting:
+                    _updatingFromCast = true;
+                    Volume = (int)Math.Round(_castContext.CastVolume * 100);
+                    _updatingFromCast = false;
+                    break;
+
+                case nameof(CastContext.CastIsMuted) when _castContext.IsCasting:
+                    _updatingFromCast = true;
+                    IsMute = _castContext.CastIsMuted;
+                    _updatingFromCast = false;
+                    break;
+            }
+        }
+
         /// <summary>
         /// Sets the volume to a specified value or adjusts it by a given amount.
         /// </summary>