feat: add option to mute specific device ID with setMute

Author: lars-berger

packages/client-api/src/desktop/desktop-commands.ts

@@ -30,14 +30,21 @@ export type ProviderFunction =
 
 export interface AudioFunction {
   type: 'audio';
-  function: {
-    name: 'set_volume' | 'set_mute';
-    args: {
-      volume?: number;
-      mute?: boolean;
-      deviceId?: string;
-    };
-  };
+  function:
+    | {
+        name: 'set_volume';
+        args: {
+          volume?: number;
+          deviceId?: string;
+        };
+      }
+    | {
+        name: 'set_mute';
+        args: {
+          mute?: boolean;
+          deviceId?: string;
+        };
+      };
 }
 
 export interface MediaFunction {

packages/client-api/src/providers/audio/audio-provider-types.ts

@@ -12,13 +12,17 @@ export interface AudioOutput {
   playbackDevices: AudioDevice[];
   recordingDevices: AudioDevice[];
   setVolume(volume: number, options?: SetVolumeOptions): Promise<void>;
-  setMute(mute: boolean): Promise<void>;
+  setMute(mute: boolean, options?: SetMuteOptions): Promise<void>;
 }
 
 export interface SetVolumeOptions {
   deviceId?: string;
 }
 
+export interface SetMuteOptions {
+  deviceId?: string;
+}
+
 export interface AudioDevice {
   deviceId: string;
   name: string;

packages/client-api/src/providers/audio/create-audio-provider.ts

@@ -6,6 +6,7 @@ import type {
   AudioOutput,
   AudioProvider,
   AudioProviderConfig,
+  SetMuteOptions,
   SetVolumeOptions,
 } from './audio-provider-types';
 
@@ -36,12 +37,12 @@ export function createAudioProvider(
                 },
               });
             },
-            setMute: (mute: boolean) => {
+            setMute: (mute: boolean, options?: SetMuteOptions) => {
               return desktopCommands.callProviderFunction(configHash, {
                 type: 'audio',
                 function: {
                   name: 'set_mute',
-                  args: { mute },
+                  args: { mute, deviceId: options?.deviceId },
                 },
               });
             },

packages/desktop/src/providers/audio/audio_provider.rs

@@ -89,8 +89,7 @@ enum AudioEvent {
   DeviceAdded(String),
   DeviceRemoved(String),
   DefaultDeviceChanged(String, DeviceType),
-  VolumeChanged(String, f32),
-  MuteChanged(String, bool),
+  VolumeChanged(String, f32, bool),
 }
 
 /// Holds the state of an audio device.
@@ -437,13 +436,9 @@ impl AudioProvider {
           }
         }
       }
-      AudioEvent::VolumeChanged(device_id, new_volume) => {
+      AudioEvent::VolumeChanged(device_id, new_volume, new_mute) => {
         if let Some(state) = self.device_states.get_mut(&device_id) {
           state.volume = (new_volume * 100.0).round() as u32;
-        }
-      }
-      AudioEvent::MuteChanged(device_id, new_mute) => {
-        if let Some(state) = self.device_states.get_mut(&device_id) {
           state.is_muted = new_mute;
         }
       }
@@ -457,41 +452,40 @@ impl AudioProvider {
     &mut self,
     function: AudioFunction,
   ) -> anyhow::Result<ProviderFunctionResponse> {
+    let device_id = match function {
+      AudioFunction::SetVolume(ref args) => args.device_id.as_ref(),
+      AudioFunction::SetMute(ref args) => args.device_id.as_ref(),
+    };
+
     // Get target device - use specified ID or default playback
     // device.
-    let get_device_state =
-      |device_id: &Option<String>| -> Result<&DeviceState, anyhow::Error> {
-        if let Some(id) = device_id {
-          self
-            .device_states
-            .get(id)
-            .context("Specified device not found.")
-        } else {
-          self
-            .default_playback_id
-            .as_ref()
-            .and_then(|id| self.device_states.get(id))
-            .context("No active playback device.")
-        }
-      };
+    let device_state = if let Some(id) = device_id {
+      self
+        .device_states
+        .get(id)
+        .context("Specified device not found.")?
+    } else {
+      self
+        .default_playback_id
+        .as_ref()
+        .and_then(|id| self.device_states.get(id))
+        .context("No active playback device.")?
+    };
+
     match function {
       AudioFunction::SetVolume(args) => {
         unsafe {
-          get_device_state(&args.device_id)?
-            .com_volume
-            .SetMasterVolumeLevelScalar(
-              args.volume / 100.,
-              &GUID::zeroed(),
-            )
+          device_state.com_volume.SetMasterVolumeLevelScalar(
+            args.volume / 100.,
+            &GUID::zeroed(),
+          )
         }?;
 
         Ok(ProviderFunctionResponse::Null)
       }
       AudioFunction::SetMute(args) => {
         unsafe {
-          get_device_state(&args.device_id)?
-            .com_volume
-            .SetMute(args.mute, &GUID::zeroed())
+          device_state.com_volume.SetMute(args.mute, &GUID::zeroed())
         }?;
 
         Ok(ProviderFunctionResponse::Null)
@@ -545,9 +539,6 @@ impl IAudioEndpointVolumeCallback_Impl for VolumeCallback_Impl {
       let _ = self.event_tx.send(AudioEvent::VolumeChanged(
         self.device_id.clone(),
         data.fMasterVolume,
-      ));
-      let _ = self.event_tx.send(AudioEvent::MuteChanged(
-        self.device_id.clone(),
         data.bMuted.as_bool(),
       ));
     }

packages/desktop/src/providers/provider_function.rs

@@ -16,12 +16,14 @@ pub enum AudioFunction {
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
 pub struct SetVolumeArgs {
   pub volume: f32,
   pub device_id: Option<String>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
 pub struct SetMuteArgs {
   pub mute: bool,
   pub device_id: Option<String>,