|
| 1 | +use std::{ |
| 2 | + sync::{Arc, Mutex}, |
| 3 | + time, |
| 4 | +}; |
| 5 | + |
| 6 | +use async_trait::async_trait; |
| 7 | +use serde::{Deserialize, Serialize}; |
| 8 | +use tokio::sync::mpsc::Sender; |
| 9 | +use tracing::debug; |
| 10 | +use windows::{ |
| 11 | + Foundation::{EventRegistrationToken, TypedEventHandler}, |
| 12 | + Media::Control::{ |
| 13 | + GlobalSystemMediaTransportControlsSession as MediaSession, |
| 14 | + GlobalSystemMediaTransportControlsSessionManager as MediaManager, |
| 15 | + GlobalSystemMediaTransportControlsSessionPlaybackStatus as MediaPlaybackStatus, |
| 16 | + }, |
| 17 | +}; |
| 18 | + |
| 19 | +use crate::providers::{Provider, ProviderOutput, ProviderResult}; |
| 20 | + |
| 21 | +#[derive(Deserialize, Debug)] |
| 22 | +#[serde(rename_all = "camelCase")] |
| 23 | +pub struct MediaProviderConfig {} |
| 24 | + |
| 25 | +#[derive(Debug, Clone, PartialEq, Serialize)] |
| 26 | +#[serde(rename_all = "camelCase")] |
| 27 | +pub struct MediaOutput { |
| 28 | + pub title: String, |
| 29 | + pub artist: String, |
| 30 | + pub album_title: String, |
| 31 | + pub album_artist: String, |
| 32 | + pub track_number: u32, |
| 33 | + pub start_time: u64, |
| 34 | + pub end_time: u64, |
| 35 | + pub position: u64, |
| 36 | + pub is_playing: bool, |
| 37 | +} |
| 38 | + |
| 39 | +#[derive(Clone, Debug)] |
| 40 | +struct EventTokens { |
| 41 | + playback_info_changed_token: EventRegistrationToken, |
| 42 | + media_properties_changed_token: EventRegistrationToken, |
| 43 | + timeline_properties_changed_token: EventRegistrationToken, |
| 44 | +} |
| 45 | + |
| 46 | +pub struct MediaProvider { |
| 47 | + _config: MediaProviderConfig, |
| 48 | + current_session: Arc<Mutex<Option<MediaSession>>>, |
| 49 | + event_tokens: Arc<Mutex<Option<EventTokens>>>, |
| 50 | +} |
| 51 | + |
| 52 | +impl MediaProvider { |
| 53 | + pub fn new(config: MediaProviderConfig) -> MediaProvider { |
| 54 | + MediaProvider { |
| 55 | + _config: config, |
| 56 | + current_session: Arc::new(Mutex::new(None)), |
| 57 | + event_tokens: Arc::new(Mutex::new(None)), |
| 58 | + } |
| 59 | + } |
| 60 | + |
| 61 | + fn emit_media_info( |
| 62 | + session: &MediaSession, |
| 63 | + emit_result_tx: Sender<ProviderResult>, |
| 64 | + ) { |
| 65 | + if let Ok(media_output) = Self::media_output(session) { |
| 66 | + let _ = emit_result_tx |
| 67 | + .try_send(Ok(ProviderOutput::Media(media_output)).into()); |
| 68 | + } |
| 69 | + } |
| 70 | + |
| 71 | + fn media_output(session: &MediaSession) -> anyhow::Result<MediaOutput> { |
| 72 | + let media_properties = session.TryGetMediaPropertiesAsync()?.get()?; |
| 73 | + let timeline_properties = session.GetTimelineProperties()?; |
| 74 | + let playback_info = session.GetPlaybackInfo()?; |
| 75 | + |
| 76 | + let is_playing = |
| 77 | + playback_info.PlaybackStatus()? == MediaPlaybackStatus::Playing; |
| 78 | + let start_time = |
| 79 | + timeline_properties.StartTime()?.Duration as u64 / 10_000_000; |
| 80 | + let end_time = |
| 81 | + timeline_properties.EndTime()?.Duration as u64 / 10_000_000; |
| 82 | + let position = |
| 83 | + timeline_properties.Position()?.Duration as u64 / 10_000_000; |
| 84 | + |
| 85 | + Ok(MediaOutput { |
| 86 | + title: media_properties.Title()?.to_string(), |
| 87 | + artist: media_properties.Artist()?.to_string(), |
| 88 | + album_title: media_properties.AlbumTitle()?.to_string(), |
| 89 | + album_artist: media_properties.AlbumArtist()?.to_string(), |
| 90 | + track_number: media_properties.TrackNumber()? as u32, |
| 91 | + start_time, |
| 92 | + end_time, |
| 93 | + position, |
| 94 | + is_playing, |
| 95 | + }) |
| 96 | + } |
| 97 | + |
| 98 | + fn create_session_manager( |
| 99 | + &self, |
| 100 | + emit_result_tx: Sender<ProviderResult>, |
| 101 | + ) -> anyhow::Result<()> { |
| 102 | + // Find the current GSMTC session & add listeners. |
| 103 | + let session_manager = MediaManager::RequestAsync()?.get()?; |
| 104 | + let current_session = session_manager.GetCurrentSession()?; |
| 105 | + let event_tokens = Self::add_session_listeners( |
| 106 | + ¤t_session, |
| 107 | + emit_result_tx.clone(), |
| 108 | + )?; |
| 109 | + |
| 110 | + debug!("Media session manager obtained."); |
| 111 | + |
| 112 | + // Emit initial media info. |
| 113 | + Self::emit_media_info(¤t_session, emit_result_tx.clone()); |
| 114 | + |
| 115 | + *self.current_session.lock().unwrap() = Some(current_session); |
| 116 | + *self.event_tokens.lock().unwrap() = Some(event_tokens); |
| 117 | + |
| 118 | + // Clean up & rebind listeners when session changes. |
| 119 | + let current_session = self.current_session.clone(); |
| 120 | + let event_tokens = self.event_tokens.clone(); |
| 121 | + let session_changed_handler = TypedEventHandler::new( |
| 122 | + move |session_manager: &Option<MediaManager>, _| { |
| 123 | + { |
| 124 | + let mut current_session = current_session.lock().unwrap(); |
| 125 | + let mut event_tokens = event_tokens.lock().unwrap(); |
| 126 | + |
| 127 | + // Remove listeners from the previous session. |
| 128 | + if let Err(err) = Self::remove_session_listeners( |
| 129 | + ¤t_session.as_ref().unwrap(), |
| 130 | + event_tokens.as_ref().unwrap(), |
| 131 | + ) { |
| 132 | + debug!("Error removing media session listeners: {:?}", err); |
| 133 | + } |
| 134 | + |
| 135 | + // Set up new session. |
| 136 | + let new_session = |
| 137 | + MediaManager::RequestAsync()?.get()?.GetCurrentSession()?; |
| 138 | + |
| 139 | + let tokens = Self::add_session_listeners( |
| 140 | + &new_session, |
| 141 | + emit_result_tx.clone(), |
| 142 | + ); |
| 143 | + *event_tokens = tokens.ok(); |
| 144 | + |
| 145 | + Self::emit_media_info(&new_session, emit_result_tx.clone()); |
| 146 | + *current_session = Some(new_session); |
| 147 | + } |
| 148 | + |
| 149 | + Ok(()) |
| 150 | + }, |
| 151 | + ); |
| 152 | + |
| 153 | + session_manager.CurrentSessionChanged(&session_changed_handler)?; |
| 154 | + |
| 155 | + loop { |
| 156 | + std::thread::sleep(time::Duration::from_secs(1)); |
| 157 | + } |
| 158 | + } |
| 159 | + |
| 160 | + fn remove_session_listeners( |
| 161 | + session: &MediaSession, |
| 162 | + tokens: &EventTokens, |
| 163 | + ) -> anyhow::Result<()> { |
| 164 | + session.RemoveMediaPropertiesChanged( |
| 165 | + tokens.media_properties_changed_token, |
| 166 | + )?; |
| 167 | + |
| 168 | + session |
| 169 | + .RemovePlaybackInfoChanged(tokens.playback_info_changed_token)?; |
| 170 | + |
| 171 | + session.RemoveTimelinePropertiesChanged( |
| 172 | + tokens.timeline_properties_changed_token, |
| 173 | + )?; |
| 174 | + |
| 175 | + Ok(()) |
| 176 | + } |
| 177 | + |
| 178 | + fn add_session_listeners( |
| 179 | + session: &MediaSession, |
| 180 | + emit_result_tx: Sender<ProviderResult>, |
| 181 | + ) -> anyhow::Result<EventTokens> { |
| 182 | + let media_properties_changed_handler = { |
| 183 | + let emit_result_tx = emit_result_tx.clone(); |
| 184 | + |
| 185 | + TypedEventHandler::new(move |session: &Option<MediaSession>, _| { |
| 186 | + debug!("Media properties changed event triggered."); |
| 187 | + |
| 188 | + if let Some(session) = session { |
| 189 | + Self::emit_media_info(session, emit_result_tx.clone()); |
| 190 | + } |
| 191 | + |
| 192 | + Ok(()) |
| 193 | + }) |
| 194 | + }; |
| 195 | + |
| 196 | + let playback_info_changed_handler = { |
| 197 | + let emit_result_tx = emit_result_tx.clone(); |
| 198 | + |
| 199 | + TypedEventHandler::new(move |session: &Option<MediaSession>, _| { |
| 200 | + debug!("Playback info changed event triggered."); |
| 201 | + |
| 202 | + if let Some(session) = session { |
| 203 | + Self::emit_media_info(session, emit_result_tx.clone()); |
| 204 | + } |
| 205 | + |
| 206 | + Ok(()) |
| 207 | + }) |
| 208 | + }; |
| 209 | + |
| 210 | + let timeline_properties_changed_handler = { |
| 211 | + let emit_result_tx = emit_result_tx.clone(); |
| 212 | + |
| 213 | + TypedEventHandler::new(move |session: &Option<MediaSession>, _| { |
| 214 | + debug!("Timeline properties changed event triggered."); |
| 215 | + |
| 216 | + if let Some(session) = session { |
| 217 | + Self::emit_media_info(session, emit_result_tx.clone()); |
| 218 | + } |
| 219 | + |
| 220 | + Ok(()) |
| 221 | + }) |
| 222 | + }; |
| 223 | + |
| 224 | + let timeline_token = session |
| 225 | + .TimelinePropertiesChanged(&timeline_properties_changed_handler)?; |
| 226 | + let playback_token = |
| 227 | + session.PlaybackInfoChanged(&playback_info_changed_handler)?; |
| 228 | + let media_token = |
| 229 | + session.MediaPropertiesChanged(&media_properties_changed_handler)?; |
| 230 | + |
| 231 | + Ok({ |
| 232 | + EventTokens { |
| 233 | + playback_info_changed_token: playback_token, |
| 234 | + media_properties_changed_token: media_token, |
| 235 | + timeline_properties_changed_token: timeline_token, |
| 236 | + } |
| 237 | + }) |
| 238 | + } |
| 239 | +} |
| 240 | + |
| 241 | +#[async_trait] |
| 242 | +impl Provider for MediaProvider { |
| 243 | + async fn run(&self, emit_result_tx: Sender<ProviderResult>) { |
| 244 | + if let Err(err) = self.create_session_manager(emit_result_tx.clone()) { |
| 245 | + let _ = emit_result_tx.send(Err(err).into()).await; |
| 246 | + } |
| 247 | + } |
| 248 | +} |
0 commit comments