113 lines
4.5 KiB
Rust
113 lines
4.5 KiB
Rust
use std::{
|
|
error::Error,
|
|
sync::{Arc, Mutex},
|
|
};
|
|
|
|
use crate::{
|
|
device_notification_client::DeviceNotificationClient, session_notification::SessionNotification,
|
|
};
|
|
use windows::{
|
|
core::{Interface, PCWSTR},
|
|
Win32::{
|
|
Devices::FunctionDiscovery::PKEY_Device_FriendlyName,
|
|
Media::Audio::{
|
|
eRender, IAudioSessionControl2, IAudioSessionManager2, IAudioSessionNotification,
|
|
IMMDeviceEnumerator, IMMNotificationClient, MMDeviceEnumerator, DEVICE_STATE_ACTIVE,
|
|
},
|
|
System::Com::{CoCreateInstance, CLSCTX_ALL, STGM_READ},
|
|
},
|
|
};
|
|
pub(crate) struct SMSessionNotifier {
|
|
device_enumerator: IMMDeviceEnumerator,
|
|
device_notification_client: IMMNotificationClient,
|
|
session_notification: IAudioSessionNotification,
|
|
session_managers: Vec<IAudioSessionManager2>,
|
|
notification_function: Box<dyn Fn(IAudioSessionControl2)>,
|
|
}
|
|
|
|
impl SMSessionNotifier {
|
|
pub(crate) fn new(
|
|
callback: Box<dyn Fn(IAudioSessionControl2)>,
|
|
) -> Arc<Mutex<Option<SMSessionNotifier>>> {
|
|
let session_notifier_arc: Arc<Mutex<Option<SMSessionNotifier>>> =
|
|
Arc::new(Mutex::new(None));
|
|
let sn2 = session_notifier_arc.clone();
|
|
let sn3 = session_notifier_arc.clone();
|
|
let notifier = SMSessionNotifier {
|
|
session_managers: Vec::new(),
|
|
device_enumerator: unsafe {
|
|
CoCreateInstance(&MMDeviceEnumerator, None, CLSCTX_ALL).unwrap()
|
|
},
|
|
device_notification_client: IMMNotificationClient::from(DeviceNotificationClient {
|
|
callback: Box::new(move |id| {
|
|
match sn2.lock().unwrap().as_mut().unwrap().add_device_by_id(id) {
|
|
Ok(_) => {},
|
|
Err(e) => {
|
|
println!("Failed to add new device: {:?}", e);
|
|
},
|
|
}
|
|
}),
|
|
}),
|
|
session_notification: IAudioSessionNotification::from(SessionNotification {
|
|
callback: Box::new(move |session| {
|
|
(sn3.lock().unwrap().as_mut().unwrap().notification_function)(session)
|
|
}),
|
|
}),
|
|
notification_function: callback,
|
|
};
|
|
*session_notifier_arc.lock().unwrap() = Some(notifier);
|
|
return session_notifier_arc.clone();
|
|
}
|
|
|
|
pub(crate) fn boot_devices(self: &mut SMSessionNotifier) -> Result<(), Box<dyn Error>> {
|
|
unsafe {
|
|
self.device_enumerator
|
|
.RegisterEndpointNotificationCallback(&self.device_notification_client)?;
|
|
let device_collection = self
|
|
.device_enumerator
|
|
.EnumAudioEndpoints(eRender, DEVICE_STATE_ACTIVE)?;
|
|
for device in (0..device_collection.GetCount()?).map(|x| device_collection.Item(x)) {
|
|
let mmdevice = device?;
|
|
self.add_device(mmdevice)?;
|
|
}
|
|
println!("All devices initialized.");
|
|
return Ok(());
|
|
}
|
|
}
|
|
|
|
fn add_device_by_id(self: &mut SMSessionNotifier, id: &PCWSTR) -> Result<(), Box<dyn Error>> {
|
|
unsafe {
|
|
let device_enumerator: IMMDeviceEnumerator =
|
|
CoCreateInstance(&MMDeviceEnumerator, None, CLSCTX_ALL)?;
|
|
let device = device_enumerator.GetDevice(id)?;
|
|
self.add_device(device)?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
unsafe fn add_device(
|
|
self: &mut SMSessionNotifier,
|
|
device: windows::Win32::Media::Audio::IMMDevice,
|
|
) -> Result<(), Box<dyn Error>> {
|
|
let sm: IAudioSessionManager2 = device.Activate(CLSCTX_ALL, None)?;
|
|
sm.RegisterSessionNotification(&self.session_notification)?;
|
|
let session_enumerator = sm.GetSessionEnumerator()?;
|
|
let session_count = session_enumerator.GetCount()?;
|
|
let device_sessions = (0..session_count)
|
|
.map(|idx| {
|
|
session_enumerator
|
|
.GetSession(idx)
|
|
.and_then(|session| session.cast())
|
|
})
|
|
.collect::<Result<Vec<IAudioSessionControl2>, _>>()?;
|
|
for session in device_sessions {
|
|
(self.notification_function)(session);
|
|
}
|
|
let prop_store = device.OpenPropertyStore(STGM_READ)?;
|
|
let prop_var = prop_store.GetValue(&PKEY_Device_FriendlyName)?;
|
|
println!("Device Added: {} Existing Sessions: {}", prop_var.Anonymous.Anonymous.Anonymous.pwszVal.to_string()?, session_count);
|
|
self.session_managers.push(sm);
|
|
Ok(())
|
|
}
|
|
}
|