public static void Reload()
{
if (_smtcManager != null)
{
_smtcManager.CurrentSessionChanged -= SmtcManagerOnCurrentSessionChanged;
_smtcManager.SessionsChanged -= SmtcManagerOnSessionsChanged;
}
if (_smtc != null)
{
_smtc.MediaPropertiesChanged -= SmtcOnMediaPropertiesChanged;
_smtc.TimelinePropertiesChanged -= SmtcOnTimelinePropertiesChanged;
}
//TODO: Implement automatic switching to new playing smtc
_smtcManager = GlobalSystemMediaTransportControlsSessionManager.RequestAsync().GetAwaiter().GetResult();
_smtcManager.SessionsChanged += SmtcManagerOnSessionsChanged;
_smtcManager.CurrentSessionChanged += SmtcManagerOnCurrentSessionChanged;
_smtc = _smtcManager.GetCurrentSession();
if (_smtc != null)
{
_smtc.MediaPropertiesChanged += SmtcOnMediaPropertiesChanged;
_smtc.TimelinePropertiesChanged += SmtcOnTimelinePropertiesChanged;
_mediaProperties = _smtc.TryGetMediaPropertiesAsync().GetAwaiter().GetResult();
UpdateMediaProperties();
}
}
private async void Session_MediaPropertiesChanged(GlobalSystemMediaTransportControlsSession sender, MediaPropertiesChangedEventArgs args)
{
properties = await session.TryGetMediaPropertiesAsync();
string status = "[MediaPropertiesChanged] Artist: " + properties.Artist + ", Title: " + properties.Title;
Debug.WriteLine(status);
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { Status.Text = status; });
}
public async Task <GlobalSystemMediaTransportControlsSessionMediaProperties> getMediaProperty(GlobalSystemMediaTransportControlsSession session)
{
if (session == null)
{
return(null);
}
try { return(await session.TryGetMediaPropertiesAsync().AsTask()); }
catch { return(null); }
}
private async void UpdateSessionInfo(GlobalSystemMediaTransportControlsSession session)
{
RaiseMediaPropertiesChanging();
try
{
var mediaInfo = await session.TryGetMediaPropertiesAsync();
if (mediaInfo != null)
{
Title = mediaInfo.Title;
Artist = mediaInfo.Artist;
TrackChangeDirection = (mediaInfo.TrackNumber - currentTrackNumber) switch
{
0 => MediaPlaybackTrackChangeDirection.Unknown,
> 0 => MediaPlaybackTrackChangeDirection.Forward,
< 0 => MediaPlaybackTrackChangeDirection.Backward
};
currentTrackNumber = mediaInfo.TrackNumber;
}
var playback = session.GetPlaybackInfo();
if (playback != null)
{
var playbackControls = playback.Controls;
IsPlayEnabled = playbackControls.IsPlayEnabled;
IsPauseEnabled = playbackControls.IsPauseEnabled;
IsPlayOrPauseEnabled = IsPlayEnabled || IsPauseEnabled;
IsPreviousEnabled = playbackControls.IsPreviousEnabled;
IsNextEnabled = playbackControls.IsNextEnabled;
IsShuffleEnabled = playbackControls.IsShuffleEnabled;
IsRepeatEnabled = playbackControls.IsRepeatEnabled;
IsStopEnabled = playbackControls.IsStopEnabled;
PlaybackType = playback.PlaybackType switch
{
Windows.Media.MediaPlaybackType.Unknown => MediaPlaybackType.Unknown,
Windows.Media.MediaPlaybackType.Music => MediaPlaybackType.Music,
Windows.Media.MediaPlaybackType.Video => MediaPlaybackType.Video,
Windows.Media.MediaPlaybackType.Image => MediaPlaybackType.Image,
_ => throw new NotImplementedException()
};
}
UpdateTimelineInfo(session);
UpdatePlaybackInfo(session);
Thumbnail = await GetThumbnailImageSourceAsync(mediaInfo?.Thumbnail);
}
catch { }
RaiseMediaPropertiesChanged();
}
internal async void OnSongChange(GlobalSystemMediaTransportControlsSession session, MediaPropertiesChangedEventArgs args = null)
{
var props = await session.TryGetMediaPropertiesAsync();
string song = $"{props.Title} | {props.Artist}";
//This is needed because for some reason this method is invoked twice every song change
if (LastSong != song && !(String.IsNullOrWhiteSpace(props.Title) && String.IsNullOrWhiteSpace(props.Artist)))
{
LastSong = song;
OnSongChanged?.Invoke(this, props);
}
}
//TODO: this does not trigger
private static void SmtcManagerOnCurrentSessionChanged(GlobalSystemMediaTransportControlsSessionManager sender, CurrentSessionChangedEventArgs args)
{
if (_smtc != null)
{
_smtc.MediaPropertiesChanged -= SmtcOnMediaPropertiesChanged;
_smtc.TimelinePropertiesChanged -= SmtcOnTimelinePropertiesChanged;
}
_smtc = sender.GetCurrentSession();
if (_smtc != null)
{
_smtc.MediaPropertiesChanged += SmtcOnMediaPropertiesChanged;
_mediaProperties = _smtc.TryGetMediaPropertiesAsync().GetAwaiter().GetResult();
}
}
private void OnMediaPropertiesChanged(GlobalSystemMediaTransportControlsSession session, MediaPropertiesChangedEventArgs args = null)
{
SimpleLogger.DefaultLog("MediaSessionManager::OnMediaPropertiesChanged called...");
try {
if (CurrentSessions.ContainsKey(session))
{
var props = session.TryGetMediaPropertiesAsync().GetAwaiter().GetResult();
var title = props.Title;
var artist = props.Artist;
Image albumArt = null;
if (props.Thumbnail != null)
{
using (var winStream = props.Thumbnail.OpenReadAsync().GetAwaiter().GetResult()) {
using (var stream = winStream.AsStream()) {
if (session.SourceAppUserModelId.ToLower().Contains("spotify"))
{
using (var image = Image.FromStream(stream)) {
using (var bitmap = new Bitmap(image)) {
albumArt = bitmap.Clone(new Rectangle(33, 0, 234, 234), bitmap.PixelFormat);
}
}
}
else
{
albumArt = Image.FromStream(stream);
}
}
}
}
var data = CurrentSessions[session];
if (data.Title != title || data.Artist != artist || data.AlbumArt != albumArt)
{
data.Title = title;
data.Artist = artist;
data.AlbumArt = albumArt;
CurrentSessions[session] = data;
UpdateCurrentSong();
}
}
} catch (Exception e) {
SimpleLogger.DefaultLog($"MediaSessionManager::OnMediaPropertiesChanged - Exception - {e.Message}\n{e.StackTrace}");
}
SimpleLogger.DefaultLog("MediaSessionManager::OnMediaPropertiesChanged DONE");
}
private async void UpdateSessionInfo(GlobalSystemMediaTransportControlsSession session)
{
try
{
var mediaInfo = await session.TryGetMediaPropertiesAsync();
if (mediaInfo.Artist != "")
{
MusicPlaying.Text = mediaInfo.Artist + " - " + mediaInfo.Title;
}
else
{
MusicPlaying.Text = mediaInfo.Title;
}
}
catch (Exception)
{
}
}
private async void UpdateSessionInfo(GlobalSystemMediaTransportControlsSession session)
{
RaiseMediaPropertiesChanging();
try
{
var mediaInfo = await session.TryGetMediaPropertiesAsync();
if (mediaInfo != null)
{
Title = mediaInfo.Title;
Artist = mediaInfo.Artist;
if (currentTrackNumber != mediaInfo.TrackNumber)
{
TrackChangeDirection = (mediaInfo.TrackNumber - currentTrackNumber) switch
{
> 0 => MediaPlaybackTrackChangeDirection.Forward,
< 0 => MediaPlaybackTrackChangeDirection.Backward,
_ => throw new NotImplementedException()
};
}
public async void UpdateMediaProperties()
{
try
{
var mediaInfo = await Session.TryGetMediaPropertiesAsync();
Storyboard sbOut = this.FindResource("NextSongDisappear") as Storyboard;
EventHandler onComplete = null;
onComplete = (s, e) =>
{
sbOut.Completed -= onComplete;
SongTitleText.Text = mediaInfo.Title;
SongArtistText.Text = mediaInfo.Artist;
Storyboard sbIn = this.FindResource("NextSongAppear") as Storyboard;
sbIn.Begin();
};
sbOut.Completed += onComplete;
sbOut.Begin();
await UpdateThumbnail(mediaInfo.Thumbnail);
}
catch (Exception) { }
}
private static void SmtcOnMediaPropertiesChanged(GlobalSystemMediaTransportControlsSession sender, MediaPropertiesChangedEventArgs args)
{
_mediaProperties = sender.TryGetMediaPropertiesAsync().GetAwaiter().GetResult();
MainWindow.Window.Dispatcher?.InvokeAsync(UpdateMediaProperties);
}
//Update the currently playing media
async Task UpdateCurrentMediaInformation()
{
try
{
//Check if volume is currently muted
bool currentOutputVolumeMuted = AudioMuteGetStatus(false);
bool currentInputVolumeMuted = AudioMuteGetStatus(true);
await AVActions.ActionDispatcherInvokeAsync(delegate
{
img_Main_VolumeMute.Visibility = currentOutputVolumeMuted ? Visibility.Visible : Visibility.Collapsed;
img_Main_MicrophoneMute.Visibility = currentInputVolumeMuted ? Visibility.Visible : Visibility.Collapsed;
});
//Check if the application window is activated
if (!vAppActivated)
{
//Debug.WriteLine("Not updating media information, not activated.");
return;
}
//Check if the media popup is opened or setting is enabled
bool mediaUpdateSetting = Convert.ToBoolean(Setting_Load(vConfigurationCtrlUI, "ShowMediaMain"));
await AVActions.ActionDispatcherInvokeAsync(delegate
{
if (!mediaUpdateSetting)
{
main_Media_Information.Visibility = Visibility.Collapsed;
//Debug.WriteLine("Not updating media information, disabled.");
return;
}
else
{
//Update the media information margin
double widthTopButtons = stackpanel_TopButtons.ActualWidth + 10;
double widthClockBattery = grid_ClockBattery.ActualWidth + grid_ClockBattery.Margin.Right + 10;
main_Media_Information.Margin = new Thickness(widthTopButtons, 10, widthClockBattery, 0);
}
});
//Get the media session manager
GlobalSystemMediaTransportControlsSessionManager smtcSessionManager = await GlobalSystemMediaTransportControlsSessionManager.RequestAsync();
if (smtcSessionManager == null)
{
HideMediaInformation();
return;
}
//Get the current media session
GlobalSystemMediaTransportControlsSession smtcSession = smtcSessionManager.GetCurrentSession();
if (smtcSession == null)
{
HideMediaInformation();
return;
}
GlobalSystemMediaTransportControlsSessionMediaProperties mediaProperties = await smtcSession.TryGetMediaPropertiesAsync();
GlobalSystemMediaTransportControlsSessionPlaybackInfo mediaPlayInfo = smtcSession.GetPlaybackInfo();
//Debug.WriteLine("Media: " + mediaProperties.Title + "/" + mediaProperties.Artist + "/" + mediaProperties.AlbumTitle + "/" + mediaProperties.Subtitle + "/" + mediaProperties.PlaybackType + "/" + mediaProperties.TrackNumber + "/" + mediaProperties.AlbumTrackCount);
//Debug.WriteLine("Play: " + mediaPlayInfo.PlaybackStatus + "/" + mediaPlayInfo.PlaybackType);
//Load the media artist
string mediaArtist = mediaProperties.Artist;
if (string.IsNullOrWhiteSpace(mediaArtist))
{
mediaArtist = mediaProperties.Subtitle;
if (string.IsNullOrWhiteSpace(mediaArtist))
{
mediaArtist = "Unknown artist";
}
}
//Load the media title
string mediaTitle = mediaProperties.Title;
if (string.IsNullOrWhiteSpace(mediaTitle))
{
mediaTitle = "Unknown title";
}
//Update the media and volume information
AVActions.ActionDispatcherInvoke(delegate
{
main_Media_Information_Artist.Text = mediaArtist;
main_Media_Information_Title.Text = " " + mediaTitle;
main_Media_Information.Visibility = Visibility.Visible;
if (mediaPlayInfo.PlaybackStatus == GlobalSystemMediaTransportControlsSessionPlaybackStatus.Playing)
{
main_Media_Information_Artist.Opacity = 1;
main_Media_Information_Title.Opacity = 1;
}
else
{
main_Media_Information_Artist.Opacity = 0.40;
main_Media_Information_Title.Opacity = 0.40;
}
});
}
catch
{
//Debug.WriteLine("Failed updating playing media.");
HideMediaInformation();
}
}
private async Task UpdateMediaInfo()
{
try
{
if (SpotifyMediaSession == null)
{
throw new Exception();
}
GlobalSystemMediaTransportControlsSessionMediaProperties mediaProperties = await SpotifyMediaSession.TryGetMediaPropertiesAsync();
GlobalSystemMediaTransportControlsSessionPlaybackControls mediaControls = SpotifyMediaSession.GetPlaybackInfo().Controls;
CurrentArtist = mediaProperties.Artist.Length > 0 ? mediaProperties.Artist : mediaProperties.Title;
IsAdPlaying = !mediaControls.IsNextEnabled || mediaProperties.Title == "Advertisement";
IsPlaying = mediaControls.IsPauseEnabled;
} catch (Exception e)
{
Debug.WriteLine("UpdateMediaInfo exception " + e.ToString());
CurrentArtist = "N/A";
IsAdPlaying = false;
IsPlaying = false;
await RegisterSpotifyMediaSession(true);
}
}
//Update the currently playing media
async Task UpdateCurrentMediaInformation()
{
try
{
//Check if volume is currently muted
bool currentOutputVolumeMuted = AudioMuteGetStatus(false);
bool currentInputVolumeMuted = AudioMuteGetStatus(true);
AVActions.ActionDispatcherInvoke(delegate
{
img_Main_VolumeMute.Visibility = currentOutputVolumeMuted ? Visibility.Visible : Visibility.Collapsed;
img_Main_MicrophoneMute.Visibility = currentInputVolumeMuted ? Visibility.Visible : Visibility.Collapsed;
});
//Get the current audio volume and mute status
string currentVolumeString = string.Empty;
int currentVolumeInt = AudioVolumeGet(false);
if (currentVolumeInt >= 0)
{
currentVolumeString = "Volume " + currentVolumeInt + "%";
if (currentOutputVolumeMuted)
{
currentVolumeString += " (Muted)";
}
}
//Update the media and volume information
AVActions.ActionDispatcherInvoke(delegate
{
textblock_Volume_Level.Text = currentVolumeString;
});
//Get the media session manager
GlobalSystemMediaTransportControlsSessionManager smtcSessionManager = await GlobalSystemMediaTransportControlsSessionManager.RequestAsync();
if (smtcSessionManager == null)
{
HideMediaInformation();
return;
}
//Get the current media session
GlobalSystemMediaTransportControlsSession smtcSession = smtcSessionManager.GetCurrentSession();
if (smtcSession == null)
{
HideMediaInformation();
return;
}
GlobalSystemMediaTransportControlsSessionTimelineProperties mediaTimeline = smtcSession.GetTimelineProperties();
GlobalSystemMediaTransportControlsSessionMediaProperties mediaProperties = await smtcSession.TryGetMediaPropertiesAsync();
GlobalSystemMediaTransportControlsSessionPlaybackInfo mediaPlayInfo = smtcSession.GetPlaybackInfo();
//Debug.WriteLine("Media: " + mediaProperties.Title + "/" + mediaProperties.Artist + "/" + mediaProperties.AlbumTitle + "/" + mediaProperties.Subtitle + "/" + mediaProperties.PlaybackType + "/" + mediaProperties.TrackNumber + "/" + mediaProperties.AlbumTrackCount);
//Debug.WriteLine("Time: " + mediaTimeline.Position + "/" + mediaTimeline.StartTime + "/" + mediaTimeline.EndTime);
//Debug.WriteLine("Play: " + mediaPlayInfo.PlaybackStatus + "/" + mediaPlayInfo.PlaybackType);
//Load the media artist
string mediaArtist = mediaProperties.Artist;
if (string.IsNullOrWhiteSpace(mediaArtist))
{
mediaArtist = mediaProperties.Subtitle;
if (string.IsNullOrWhiteSpace(mediaArtist))
{
mediaArtist = "Unknown artist";
}
}
//Load the track number
string mediaTrackNumber = string.Empty;
int currentTrackNumber = mediaProperties.TrackNumber;
if (currentTrackNumber > 0)
{
int totalTrackNumber = mediaProperties.AlbumTrackCount;
if (totalTrackNumber > 0)
{
mediaTrackNumber = "(" + currentTrackNumber + "/" + totalTrackNumber + ") ";
}
else
{
mediaTrackNumber = "(" + currentTrackNumber + ") ";
}
}
//Load the media title
string mediaTitle = mediaProperties.Title;
if (string.IsNullOrWhiteSpace(mediaTitle))
{
mediaTitle = mediaTrackNumber + "Unknown title";
}
else
{
mediaTitle = mediaTrackNumber + mediaTitle;
}
//Load the media album title
string mediaAlbum = mediaProperties.AlbumTitle;
if (string.IsNullOrWhiteSpace(mediaAlbum))
{
AVActions.ActionDispatcherInvoke(delegate
{
button_Information_Album.Visibility = Visibility.Collapsed;
});
}
else
{
AVActions.ActionDispatcherInvoke(delegate
{
button_Information_Album.Visibility = Visibility.Visible;
});
}
//Calculate the media progression
double mediaProgress = 0;
if (mediaTimeline.Position != new TimeSpan() && mediaTimeline.EndTime != new TimeSpan())
{
mediaProgress = mediaTimeline.Position.TotalSeconds * 100 / mediaTimeline.EndTime.TotalSeconds;
AVActions.ActionDispatcherInvoke(delegate
{
button_Information_Progress.Visibility = Visibility.Visible;
});
}
else
{
AVActions.ActionDispatcherInvoke(delegate
{
button_Information_Progress.Visibility = Visibility.Collapsed;
});
}
//Load the media thumbnail image
BitmapFrame thumbnailBitmap = await GetMediaThumbnail(mediaProperties.Thumbnail);
//Update the media and volume information
AVActions.ActionDispatcherInvoke(delegate
{
button_Information_Artist.Text = mediaArtist;
button_Information_Title.Text = mediaTitle;
button_Information_Album.Text = mediaAlbum;
button_Information_Progress.Value = mediaProgress;
if (thumbnailBitmap != null)
{
button_Information_Thumbnail.Source = thumbnailBitmap;
}
else
{
button_Information_Thumbnail.Source = FileToBitmapImage(new string[] { "Assets/Default/Icons/Music.png" }, vImageSourceFolders, vImageBackupSource, IntPtr.Zero, -1, 0);
}
stackpanel_MediaPlaying.Visibility = Visibility.Visible;
stackpanel_MediaNone.Visibility = Visibility.Collapsed;
});
}
catch
{
//Debug.WriteLine("Failed updating playing media.");
HideMediaInformation();
}
}
private static async void Session_MediaPropertiesChanged(GlobalSystemMediaTransportControlsSession sender, MediaPropertiesChangedEventArgs args)
{
MusicName = (await sender.TryGetMediaPropertiesAsync()).Title;
await UUID.MiBand2Service.Music.SetMusicName(MusicName);
}
private static async void SetPlaybackInfoMediaProperties()
{
while (mediaPropertiesLock)
{
Thread.Sleep(100);
}
mediaPropertiesLock = true;
if (globalSystemMediaTransportControlsSession == null)
{
artist = "";
title = "";
thumbnailBitmap = null;
}
else
{
GlobalSystemMediaTransportControlsSessionMediaProperties mediaProperties = null;
try
{
mediaProperties = await globalSystemMediaTransportControlsSession.TryGetMediaPropertiesAsync();
}
catch (Exception ex)
{
artist = "";
title = "";
thumbnail = null;
mediaPropertiesChanged = true;
mediaPropertiesLock = false;
return;
}
artist = mediaProperties.Artist;
title = mediaProperties.Title;
var thumbnailOpenRead = mediaProperties.Thumbnail;
if (thumbnailOpenRead != null)
{
var thumbnailOpenReadStream = await thumbnailOpenRead.OpenReadAsync();
if (thumbnailOpenReadStream.CanRead)
{
thumbnail = new byte[thumbnailOpenReadStream.Size];
await thumbnailOpenReadStream.ReadAsync(thumbnail.AsBuffer(), (uint)thumbnailOpenReadStream.Size, InputStreamOptions.None);
using (MemoryStream ms = new MemoryStream(thumbnail))
{
ms.Position = 0;
thumbnailBitmap = new System.Drawing.Bitmap(ms);
using (MemoryStream stream = new MemoryStream())
{
thumbnailBitmap.Save(stream, System.Drawing.Imaging.ImageFormat.Jpeg); // Konwersja ze względu na błąd po stronie Androida w przypadku przesyłania pliku *.png: [skia] ------ png error IDAT: CRC error [skia] ---codec->getAndroidPixels() failed.
thumbnail = stream.ToArray();
}
}
}
else
{
thumbnail = null;
}
}
else
{
thumbnail = null;
}
}
mediaPropertiesChanged = true;
mediaPropertiesLock = false;
}
