syncplay improvements

insomniachi · insomniachi · commit 9d3a824efece · 2025-03-30T15:56:08.000+05:30
diff --git a/FluentFin/Controls/MediaPlayerHost.xaml b/FluentFin/Controls/MediaPlayerHost.xaml
@@ -18,6 +18,7 @@
             HorizontalAlignment="Stretch"
             VerticalAlignment="Stretch"
             IsSkipButtonVisible="{x:Bind IsSkipButtonVisible, Mode=OneWay}"
+            JellyfinClient="{x:Bind JellyfinClient, Mode=OneWay}"
             Player="{x:Bind Player, Mode=TwoWay}"
             Playlist="{x:Bind Playlist, Mode=OneWay}"
             SkipCommand="{x:Bind SkipCommand, Mode=OneWay}"
diff --git a/FluentFin/Controls/MediaPlayerHost.xaml.cs b/FluentFin/Controls/MediaPlayerHost.xaml.cs
@@ -37,6 +37,9 @@ public sealed partial class MediaPlayerHost : UserControl
     [GeneratedDependencyProperty]
     public partial MediaPlayerType? MediaPlayerType { get; set; }
 
+    [GeneratedDependencyProperty]
+    public partial IJellyfinClient? JellyfinClient { get; set; }
+
     public IMediaPlayerController? Player
     {
         get
diff --git a/FluentFin/Controls/TransportControls.xaml.cs b/FluentFin/Controls/TransportControls.xaml.cs
@@ -34,6 +34,9 @@ public sealed partial class TransportControls : UserControl
 	[GeneratedDependencyProperty]
 	public partial TrickplayViewModel Trickplay { get; set; }
 
+	[GeneratedDependencyProperty]
+	public partial IJellyfinClient JellyfinClient { get; set; }
+
 	public IMediaPlayerController Player
 	{
 		get
@@ -156,14 +159,26 @@ private async void SkipBackwardButton_Click(object sender, RoutedEventArgs e)
 	{
 		var ts = Player.Position - TimeSpan.FromSeconds(10);
 		Player.SeekTo(ts);
-        await App.GetService<IJellyfinClient>().SignalSeekForSyncPlay(ts);
+
+        if (JellyfinClient is null)
+        {
+            return;
+        }
+
+        await JellyfinClient.SignalSeekForSyncPlay(ts);
     }
 
 	private async void SkipForwardButton_Click(object sender, RoutedEventArgs e)
 	{
 		var ts = Player.Position + TimeSpan.FromSeconds(30);
 		Player.SeekTo(ts);
-		await App.GetService<IJellyfinClient>().SignalSeekForSyncPlay(ts);
+
+		if(JellyfinClient is null)
+        {
+			return;
+        }
+
+        await JellyfinClient.SignalSeekForSyncPlay(ts);
 	}
 
 	private void TimeSlider_PointerEntered(object sender, Microsoft.UI.Xaml.Input.PointerRoutedEventArgs e)
@@ -195,21 +210,30 @@ private async void PlayPauseButton_Click(object sender, RoutedEventArgs e)
     {
 		Player.TogglePlayPlause();
 
-		var client = App.GetService<IJellyfinClient>();
+		if(JellyfinClient is null)
+		{
+			return;
+		}
+
+
 		if (Player.State == MediaPlayerState.Playing)
 		{
-			await client.SignalUnpauseForSyncPlay();
+			await JellyfinClient.SignalUnpauseForSyncPlay();
 		}
 		else
 		{
-			await client.SignalPauseForSyncPlay();
+			await JellyfinClient.SignalPauseForSyncPlay();
 		}
     }
 
     private async void CastButton_Click(object sender, RoutedEventArgs e)
     {
-		var jellyfinClient = App.GetService<IJellyfinClient>();
-		var sessions = await jellyfinClient.GetControllableSessions();
+		if(JellyfinClient is null)
+		{
+			return;
+		}
+
+		var sessions = await JellyfinClient.GetControllableSessions();
 
 		if(sessions.FirstOrDefault(x => x.Id == SessionInfo.SessionId) is { } session && session.NowPlayingItem is { } dto)
 		{
diff --git a/FluentFin/Services/WebSocketMessageHandler.cs b/FluentFin/Services/WebSocketMessageHandler.cs
@@ -30,7 +30,7 @@ public Task StartAsync(CancellationToken cancellationToken)
                                                 gcm.Data.Arguments["Text"],
                                                 TimeSpan.FromMilliseconds(double.Parse(gcm.Data.Arguments["TimeoutMs"])));
                      break;
-                 case PlayQueueUpdateMessage { Data: not null } playMessage:
+                 case PlayQueueUpdateMessage { Data.Data.PlayingItemIndex: >= 0 } playMessage:
                      navigationService.NavigateTo<VideoPlayerViewModel>(playMessage.Data.Data);
                      break;
                  case GroupJoinedUpdateMessage groupJoined:
diff --git a/FluentFin/ViewModels/VideoPlayerViewModel.cs b/FluentFin/ViewModels/VideoPlayerViewModel.cs
@@ -40,6 +40,7 @@ public partial class VideoPlayerViewModel(IJellyfinClient jellyfinClient,
 
 
     public TrickplayViewModel TrickplayViewModel { get; } = trickplayViewModel;
+    public IJellyfinClient JellyfinClient { get; } = jellyfinClient;
 
 
     [ObservableProperty]
@@ -78,15 +79,14 @@ public async Task OnNavigatedFrom()
         NativeMethods.AllowSleep();
 
         taskBarProgress.Clear();
-        await jellyfinClient.Stop();
+        await JellyfinClient.Stop();
 
 		if(MediaPlayer is null)
 		{
 			return;
 		}
 
-		MediaPlayer.Pause();
-		MediaPlayer.Dispose();
+		MediaPlayer.Stop();
 	}
 
 	public async Task OnNavigatedTo(object parameter)
@@ -121,7 +121,7 @@ public async Task OnNavigatedTo(object parameter)
 			.Subscribe(async mp =>
 			{
                 _keyboardController?.UnsubscribeEvents();
-				_keyboardController = new KeyboardMediaPlayerController(mp, jellyfinClient, Skip, ToggleFullScreen);
+				_keyboardController = new KeyboardMediaPlayerController(mp, JellyfinClient, Skip, ToggleFullScreen);
 
                 if(_playQueueUpdate is null)
                 {
@@ -132,7 +132,7 @@ public async Task OnNavigatedTo(object parameter)
                     Playlist.SelectedItem = Playlist.Items.FirstOrDefault();
                 }
 
-                await jellyfinClient.Playing(Dto);
+                await JellyfinClient.Playing(Dto);
             });
 
 		Observable.Timer(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(20))
@@ -149,7 +149,7 @@ private async Task Initialize(Guid? id)
             return;
         }
 
-        Dto = await jellyfinClient.GetItem(id.Value);
+        Dto = await JellyfinClient.GetItem(id.Value);
 
         if(Dto is null)
         {
@@ -159,9 +159,9 @@ private async Task Initialize(Guid? id)
         Playlist = Dto.Type switch
         {
             BaseItemDto_Type.Movie => PlaylistViewModel.FromMovie(Dto),
-            BaseItemDto_Type.Episode => await PlaylistViewModel.FromEpisode(jellyfinClient, Dto),
-            BaseItemDto_Type.Series => await PlaylistViewModel.FromSeries(jellyfinClient, Dto),
-            BaseItemDto_Type.Season => await PlaylistViewModel.FromSeason(jellyfinClient, Dto),
+            BaseItemDto_Type.Episode => await PlaylistViewModel.FromEpisode(JellyfinClient, Dto),
+            BaseItemDto_Type.Series => await PlaylistViewModel.FromSeries(JellyfinClient, Dto),
+            BaseItemDto_Type.Season => await PlaylistViewModel.FromSeason(JellyfinClient, Dto),
             _ => new PlaylistViewModel()
         };
     }
@@ -174,7 +174,7 @@ private async Task InitializeForSyncPlay(PlayQueueUpdate pqu)
         }
 
         var id = pqu.Playlist[pqu.PlayingItemIndex].ItemId;
-        Dto = await jellyfinClient.GetItem(id);
+        Dto = await JellyfinClient.GetItem(id);
         Playlist = PlaylistViewModel.FromSyncPlay(pqu.Playlist);
     }
 
@@ -198,7 +198,7 @@ private async Task Skip()
 
         if (_playQueueUpdate is not null)
         {
-            await jellyfinClient.SignalSeekForSyncPlay(endPosition);
+            await JellyfinClient.SignalSeekForSyncPlay(endPosition);
         }
 
 		MediaPlayer.SeekTo(endPosition);
@@ -223,7 +223,7 @@ private async void OnPlaylistPropertyChanged(object? sender, System.ComponentMod
 
         MediaPlayer.Stop();
 
-        var full = await jellyfinClient.GetItem(selectedItem.Dto.Id ?? Guid.Empty);
+        var full = await JellyfinClient.GetItem(selectedItem.Dto.Id ?? Guid.Empty);
 
         if (full is null)
         {
@@ -238,7 +238,7 @@ private async void OnPlaylistPropertyChanged(object? sender, System.ComponentMod
         }
 
 
-        await jellyfinClient.Stop();
+        await JellyfinClient.Stop();
         TrickplayViewModel.SetItem(full);
 
         var defaultSubtitleIndex = mediaResponse.MediaSourceInfo.DefaultSubtitleStreamIndex;
@@ -277,7 +277,7 @@ private void OpenSubtitles(IMediaPlayerController mp, MediaResponse response, Me
         {
             if (stream.IsExternal == true)
             {
-                var url = HttpUtility.UrlDecode(jellyfinClient.BaseUrl.AppendPathSegment(stream.DeliveryUrl).ToString());
+                var url = HttpUtility.UrlDecode(JellyfinClient.BaseUrl.AppendPathSegment(stream.DeliveryUrl).ToString());
                 mp.OpenExternalSubtitleTrack(url);
             }
             else
@@ -297,14 +297,14 @@ private void OpenSubtitles(IMediaPlayerController mp, MediaResponse response, Me
 
     private async Task<MediaResponse?> GetMediaUrl(BaseItemDto dto)
 	{
-		var segments = await jellyfinClient.GetMediaSegments(dto, [MediaSegmentType.Intro, MediaSegmentType.Outro]);
+		var segments = await JellyfinClient.GetMediaSegments(dto, [MediaSegmentType.Intro, MediaSegmentType.Outro]);
 
 		if (segments is { Items: not null })
 		{
 			Segments = segments.Items;
 		}
 
-		return await jellyfinClient.GetMediaUrl(dto);
+		return await JellyfinClient.GetMediaUrl(dto);
 	}
 
 	private async Task UpdateStatus()
@@ -348,7 +348,7 @@ private async Task UpdateStatus()
 
         taskBarProgress.SetProgressPercent((int)((MediaPlayer.Position.TotalSeconds / _duration.TotalSeconds) * 100));
 
-        await jellyfinClient.Progress(_playbackProgressInfo);
+        await JellyfinClient.Progress(_playbackProgressInfo);
 	}
 
     private void SubscribeEvents(IMediaPlayerController mp)
@@ -359,11 +359,11 @@ private void SubscribeEvents(IMediaPlayerController mp)
             taskBarProgress.Clear();
             Playlist.SelectNext();
         });
-        mp.Stopped.Subscribe(async _ => await jellyfinClient.Stop());
+        mp.Stopped.Subscribe(async _ => await JellyfinClient.Stop());
         mp.Errored.Subscribe(async _ =>
         {
             logger.LogError("An error occurred while playing media");
-            await jellyfinClient.Stop();
+            await JellyfinClient.Stop();
         });
         mp.PositionChanged
             .Where(_ => MediaPlayer?.State == MediaPlayerState.Playing)
@@ -376,7 +376,7 @@ private void SubscribeEvents(IMediaPlayerController mp)
 
         mp.MediaLoaded
           .Where(_ => _playQueueUpdate is not null)
-          .SelectMany(_ => jellyfinClient.SignalReadyForSyncPlay(new ReadyRequestDto
+          .SelectMany(_ => JellyfinClient.SignalReadyForSyncPlay(new ReadyRequestDto
           {
               When = TimeProvider.System.GetUtcNow(),
               IsPlaying = mp.IsPlaying,
@@ -397,7 +397,6 @@ private void SubscribeWebsocketMessage()
                     return;
                 }
 
-
                 switch (message)
                 {
                     case PlayStateMessage { Data.Command: PlaystateCommand.PlayPause }:
@@ -406,7 +405,7 @@ private void SubscribeWebsocketMessage()
                         break;
                     case PlayStateMessage { Data.Command: PlaystateCommand.Stop }:
                         MediaPlayer.Stop();
-                        await jellyfinClient.Stop();
+                        await JellyfinClient.Stop();
                         navigationService.NavigateTo<HomeViewModel>(new());
                         break;
                     case SyncPlayCommandMessage { Data: not null } syncPlay:
@@ -445,7 +444,7 @@ private async Task SchedulePause(SyncPlaySendCommand command, IMediaPlayerContro
             return;
         }
 
-        var currentTime = await jellyfinClient.SyncTime();
+        var currentTime = await JellyfinClient.SyncTime();
         var commandTime = command.When;
 
         mp.SeekTo(new TimeSpan(command.PositionTicks));
@@ -467,7 +466,7 @@ private async Task SchedulePlay(SyncPlaySendCommand command, IMediaPlayerControl
             return;
         }
 
-        var currentTime = await jellyfinClient.SyncTime();
+        var currentTime = await JellyfinClient.SyncTime();
         var commandTime = command.When;
 
         if (commandTime > currentTime)
diff --git a/FluentFin/Views/VideoPlayerPage.xaml b/FluentFin/Views/VideoPlayerPage.xaml
@@ -14,6 +14,7 @@
     <controls:MediaPlayerHost
         x:Name="MediaPlayerHost"
         IsSkipButtonVisible="{x:Bind ViewModel.IsSkipButtonVisible, Mode=OneWay}"
+        JellyfinClient="{x:Bind ViewModel.JellyfinClient}"
         MediaPlayerType="{x:Bind ViewModel.MediaPlayerType, Mode=OneWay}"
         Player="{x:Bind ViewModel.MediaPlayer, Mode=TwoWay}"
         Playlist="{x:Bind ViewModel.Playlist, Mode=OneWay}"

Original file line number	Diff line number	Diff line change
`@@ -37,6 +37,9 @@ public sealed partial class MediaPlayerHost : UserControl`
`37`	`37`	`[GeneratedDependencyProperty]`
`38`	`38`	`public partial MediaPlayerType? MediaPlayerType { get; set; }`
`39`	`39`
	`40`	`+ [GeneratedDependencyProperty]`
	`41`	`+ public partial IJellyfinClient? JellyfinClient { get; set; }`
	`42`	`+`
`40`	`43`	`public IMediaPlayerController? Player`
`41`	`44`	`{`
`42`	`45`	`get`
Original file line number	Diff line number	Diff line change
`@@ -34,6 +34,9 @@ public sealed partial class TransportControls : UserControl`
`34`	`34`	`[GeneratedDependencyProperty]`
`35`	`35`	`public partial TrickplayViewModel Trickplay { get; set; }`
`36`	`36`
	`37`	`+ [GeneratedDependencyProperty]`
	`38`	`+ public partial IJellyfinClient JellyfinClient { get; set; }`
	`39`	`+`
`37`	`40`	`public IMediaPlayerController Player`
`38`	`41`	`{`
`39`	`42`	`get`
`@@ -156,14 +159,26 @@ private async void SkipBackwardButton_Click(object sender, RoutedEventArgs e)`
`156`	`159`	`{`
`157`	`160`	`var ts = Player.Position - TimeSpan.FromSeconds(10);`
`158`	`161`	`Player.SeekTo(ts);`
`159`		`- await App.GetService<IJellyfinClient>().SignalSeekForSyncPlay(ts);`
	`162`	`+`
	`163`	`+ if (JellyfinClient is null)`
	`164`	`+ {`
	`165`	`+ return;`
	`166`	`+ }`
	`167`	`+`
	`168`	`+ await JellyfinClient.SignalSeekForSyncPlay(ts);`
`160`	`169`	`}`
`161`	`170`
`162`	`171`	`private async void SkipForwardButton_Click(object sender, RoutedEventArgs e)`
`163`	`172`	`{`
`164`	`173`	`var ts = Player.Position + TimeSpan.FromSeconds(30);`
`165`	`174`	`Player.SeekTo(ts);`
`166`		`- await App.GetService<IJellyfinClient>().SignalSeekForSyncPlay(ts);`
	`175`	`+`
	`176`	`+ if(JellyfinClient is null)`
	`177`	`+ {`
	`178`	`+ return;`
	`179`	`+ }`
	`180`	`+`
	`181`	`+ await JellyfinClient.SignalSeekForSyncPlay(ts);`
`167`	`182`	`}`
`168`	`183`
`169`	`184`	`private void TimeSlider_PointerEntered(object sender, Microsoft.UI.Xaml.Input.PointerRoutedEventArgs e)`
`@@ -195,21 +210,30 @@ private async void PlayPauseButton_Click(object sender, RoutedEventArgs e)`
`195`	`210`	`{`
`196`	`211`	`Player.TogglePlayPlause();`
`197`	`212`
`198`		`- var client = App.GetService<IJellyfinClient>();`
	`213`	`+ if(JellyfinClient is null)`
	`214`	`+ {`
	`215`	`+ return;`
	`216`	`+ }`
	`217`	`+`
	`218`	`+`
`199`	`219`	`if (Player.State == MediaPlayerState.Playing)`
`200`	`220`	`{`
`201`		`- await client.SignalUnpauseForSyncPlay();`
	`221`	`+ await JellyfinClient.SignalUnpauseForSyncPlay();`
`202`	`222`	`}`
`203`	`223`	`else`
`204`	`224`	`{`
`205`		`- await client.SignalPauseForSyncPlay();`
	`225`	`+ await JellyfinClient.SignalPauseForSyncPlay();`
`206`	`226`	`}`
`207`	`227`	`}`
`208`	`228`
`209`	`229`	`private async void CastButton_Click(object sender, RoutedEventArgs e)`
`210`	`230`	`{`
`211`		`- var jellyfinClient = App.GetService<IJellyfinClient>();`
`212`		`- var sessions = await jellyfinClient.GetControllableSessions();`
	`231`	`+ if(JellyfinClient is null)`
	`232`	`+ {`
	`233`	`+ return;`
	`234`	`+ }`
	`235`	`+`
	`236`	`+ var sessions = await JellyfinClient.GetControllableSessions();`
`213`	`237`
`214`	`238`	`if(sessions.FirstOrDefault(x => x.Id == SessionInfo.SessionId) is { } session && session.NowPlayingItem is { } dto)`
`215`	`239`	`{`
Original file line number	Diff line number	Diff line change
`@@ -40,6 +40,7 @@ public partial class VideoPlayerViewModel(IJellyfinClient jellyfinClient,`
`40`	`40`
`41`	`41`
`42`	`42`	`public TrickplayViewModel TrickplayViewModel { get; } = trickplayViewModel;`
	`43`	`+ public IJellyfinClient JellyfinClient { get; } = jellyfinClient;`
`43`	`44`
`44`	`45`
`45`	`46`	`[ObservableProperty]`
`@@ -78,15 +79,14 @@ public async Task OnNavigatedFrom()`
`78`	`79`	`NativeMethods.AllowSleep();`
`79`	`80`
`80`	`81`	`taskBarProgress.Clear();`
`81`		`- await jellyfinClient.Stop();`
	`82`	`+ await JellyfinClient.Stop();`
`82`	`83`
`83`	`84`	`if(MediaPlayer is null)`
`84`	`85`	`{`
`85`	`86`	`return;`
`86`	`87`	`}`
`87`	`88`
`88`		`- MediaPlayer.Pause();`
`89`		`- MediaPlayer.Dispose();`
	`89`	`+ MediaPlayer.Stop();`
`90`	`90`	`}`
`91`	`91`
`92`	`92`	`public async Task OnNavigatedTo(object parameter)`
`@@ -121,7 +121,7 @@ public async Task OnNavigatedTo(object parameter)`
`121`	`121`	`.Subscribe(async mp =>`
`122`	`122`	`{`
`123`	`123`	`_keyboardController?.UnsubscribeEvents();`
`124`		`- _keyboardController = new KeyboardMediaPlayerController(mp, jellyfinClient, Skip, ToggleFullScreen);`
	`124`	`+ _keyboardController = new KeyboardMediaPlayerController(mp, JellyfinClient, Skip, ToggleFullScreen);`
`125`	`125`
`126`	`126`	`if(_playQueueUpdate is null)`
`127`	`127`	`{`
`@@ -132,7 +132,7 @@ public async Task OnNavigatedTo(object parameter)`
`132`	`132`	`Playlist.SelectedItem = Playlist.Items.FirstOrDefault();`
`133`	`133`	`}`
`134`	`134`
`135`		`- await jellyfinClient.Playing(Dto);`
	`135`	`+ await JellyfinClient.Playing(Dto);`
`136`	`136`	`});`
`137`	`137`
`138`	`138`	`Observable.Timer(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(20))`
`@@ -149,7 +149,7 @@ private async Task Initialize(Guid? id)`
`149`	`149`	`return;`
`150`	`150`	`}`
`151`	`151`
`152`		`- Dto = await jellyfinClient.GetItem(id.Value);`
	`152`	`+ Dto = await JellyfinClient.GetItem(id.Value);`
`153`	`153`
`154`	`154`	`if(Dto is null)`
`155`	`155`	`{`
`@@ -159,9 +159,9 @@ private async Task Initialize(Guid? id)`
`159`	`159`	`Playlist = Dto.Type switch`
`160`	`160`	`{`
`161`	`161`	`BaseItemDto_Type.Movie => PlaylistViewModel.FromMovie(Dto),`
`162`		`- BaseItemDto_Type.Episode => await PlaylistViewModel.FromEpisode(jellyfinClient, Dto),`
`163`		`- BaseItemDto_Type.Series => await PlaylistViewModel.FromSeries(jellyfinClient, Dto),`
`164`		`- BaseItemDto_Type.Season => await PlaylistViewModel.FromSeason(jellyfinClient, Dto),`
	`162`	`+ BaseItemDto_Type.Episode => await PlaylistViewModel.FromEpisode(JellyfinClient, Dto),`
	`163`	`+ BaseItemDto_Type.Series => await PlaylistViewModel.FromSeries(JellyfinClient, Dto),`
	`164`	`+ BaseItemDto_Type.Season => await PlaylistViewModel.FromSeason(JellyfinClient, Dto),`
`165`	`165`	`_ => new PlaylistViewModel()`
`166`	`166`	`};`
`167`	`167`	`}`
`@@ -174,7 +174,7 @@ private async Task InitializeForSyncPlay(PlayQueueUpdate pqu)`
`174`	`174`	`}`
`175`	`175`
`176`	`176`	`var id = pqu.Playlist[pqu.PlayingItemIndex].ItemId;`
`177`		`- Dto = await jellyfinClient.GetItem(id);`
	`177`	`+ Dto = await JellyfinClient.GetItem(id);`
`178`	`178`	`Playlist = PlaylistViewModel.FromSyncPlay(pqu.Playlist);`
`179`	`179`	`}`
`180`	`180`
`@@ -198,7 +198,7 @@ private async Task Skip()`
`198`	`198`
`199`	`199`	`if (_playQueueUpdate is not null)`
`200`	`200`	`{`
`201`		`- await jellyfinClient.SignalSeekForSyncPlay(endPosition);`
	`201`	`+ await JellyfinClient.SignalSeekForSyncPlay(endPosition);`
`202`	`202`	`}`
`203`	`203`
`204`	`204`	`MediaPlayer.SeekTo(endPosition);`
`@@ -223,7 +223,7 @@ private async void OnPlaylistPropertyChanged(object? sender, System.ComponentMod`
`223`	`223`
`224`	`224`	`MediaPlayer.Stop();`
`225`	`225`
`226`		`- var full = await jellyfinClient.GetItem(selectedItem.Dto.Id ?? Guid.Empty);`
	`226`	`+ var full = await JellyfinClient.GetItem(selectedItem.Dto.Id ?? Guid.Empty);`
`227`	`227`
`228`	`228`	`if (full is null)`
`229`	`229`	`{`
`@@ -238,7 +238,7 @@ private async void OnPlaylistPropertyChanged(object? sender, System.ComponentMod`
`238`	`238`	`}`
`239`	`239`
`240`	`240`
`241`		`- await jellyfinClient.Stop();`
	`241`	`+ await JellyfinClient.Stop();`
`242`	`242`	`TrickplayViewModel.SetItem(full);`
`243`	`243`
`244`	`244`	`var defaultSubtitleIndex = mediaResponse.MediaSourceInfo.DefaultSubtitleStreamIndex;`
`@@ -277,7 +277,7 @@ private void OpenSubtitles(IMediaPlayerController mp, MediaResponse response, Me`
`277`	`277`	`{`
`278`	`278`	`if (stream.IsExternal == true)`
`279`	`279`	`{`
`280`		`- var url = HttpUtility.UrlDecode(jellyfinClient.BaseUrl.AppendPathSegment(stream.DeliveryUrl).ToString());`
	`280`	`+ var url = HttpUtility.UrlDecode(JellyfinClient.BaseUrl.AppendPathSegment(stream.DeliveryUrl).ToString());`
`281`	`281`	`mp.OpenExternalSubtitleTrack(url);`
`282`	`282`	`}`
`283`	`283`	`else`
`@@ -297,14 +297,14 @@ private void OpenSubtitles(IMediaPlayerController mp, MediaResponse response, Me`
`297`	`297`
`298`	`298`	`private async Task<MediaResponse?> GetMediaUrl(BaseItemDto dto)`
`299`	`299`	`{`
`300`		`- var segments = await jellyfinClient.GetMediaSegments(dto, [MediaSegmentType.Intro, MediaSegmentType.Outro]);`
	`300`	`+ var segments = await JellyfinClient.GetMediaSegments(dto, [MediaSegmentType.Intro, MediaSegmentType.Outro]);`
`301`	`301`
`302`	`302`	`if (segments is { Items: not null })`
`303`	`303`	`{`
`304`	`304`	`Segments = segments.Items;`
`305`	`305`	`}`
`306`	`306`
`307`		`- return await jellyfinClient.GetMediaUrl(dto);`
	`307`	`+ return await JellyfinClient.GetMediaUrl(dto);`
`308`	`308`	`}`
`309`	`309`
`310`	`310`	`private async Task UpdateStatus()`
`@@ -348,7 +348,7 @@ private async Task UpdateStatus()`
`348`	`348`
`349`	`349`	`taskBarProgress.SetProgressPercent((int)((MediaPlayer.Position.TotalSeconds / _duration.TotalSeconds) * 100));`
`350`	`350`
`351`		`- await jellyfinClient.Progress(_playbackProgressInfo);`
	`351`	`+ await JellyfinClient.Progress(_playbackProgressInfo);`
`352`	`352`	`}`
`353`	`353`
`354`	`354`	`private void SubscribeEvents(IMediaPlayerController mp)`
`@@ -359,11 +359,11 @@ private void SubscribeEvents(IMediaPlayerController mp)`
`359`	`359`	`taskBarProgress.Clear();`
`360`	`360`	`Playlist.SelectNext();`
`361`	`361`	`});`
`362`		`- mp.Stopped.Subscribe(async _ => await jellyfinClient.Stop());`
	`362`	`+ mp.Stopped.Subscribe(async _ => await JellyfinClient.Stop());`
`363`	`363`	`mp.Errored.Subscribe(async _ =>`
`364`	`364`	`{`
`365`	`365`	`logger.LogError("An error occurred while playing media");`
`366`		`- await jellyfinClient.Stop();`
	`366`	`+ await JellyfinClient.Stop();`
`367`	`367`	`});`
`368`	`368`	`mp.PositionChanged`
`369`	`369`	`.Where(_ => MediaPlayer?.State == MediaPlayerState.Playing)`
`@@ -376,7 +376,7 @@ private void SubscribeEvents(IMediaPlayerController mp)`
`376`	`376`
`377`	`377`	`mp.MediaLoaded`
`378`	`378`	`.Where(_ => _playQueueUpdate is not null)`
`379`		`- .SelectMany(_ => jellyfinClient.SignalReadyForSyncPlay(new ReadyRequestDto`
	`379`	`+ .SelectMany(_ => JellyfinClient.SignalReadyForSyncPlay(new ReadyRequestDto`
`380`	`380`	`{`
`381`	`381`	`When = TimeProvider.System.GetUtcNow(),`
`382`	`382`	`IsPlaying = mp.IsPlaying,`
`@@ -397,7 +397,6 @@ private void SubscribeWebsocketMessage()`
`397`	`397`	`return;`
`398`	`398`	`}`
`399`	`399`
`400`		`-`
`401`	`400`	`switch (message)`
`402`	`401`	`{`
`403`	`402`	`case PlayStateMessage { Data.Command: PlaystateCommand.PlayPause }:`
`@@ -406,7 +405,7 @@ private void SubscribeWebsocketMessage()`
`406`	`405`	`break;`
`407`	`406`	`case PlayStateMessage { Data.Command: PlaystateCommand.Stop }:`
`408`	`407`	`MediaPlayer.Stop();`
`409`		`- await jellyfinClient.Stop();`
	`408`	`+ await JellyfinClient.Stop();`
`410`	`409`	`navigationService.NavigateTo<HomeViewModel>(new());`
`411`	`410`	`break;`
`412`	`411`	`case SyncPlayCommandMessage { Data: not null } syncPlay:`
`@@ -445,7 +444,7 @@ private async Task SchedulePause(SyncPlaySendCommand command, IMediaPlayerContro`
`445`	`444`	`return;`
`446`	`445`	`}`
`447`	`446`
`448`		`- var currentTime = await jellyfinClient.SyncTime();`
	`447`	`+ var currentTime = await JellyfinClient.SyncTime();`
`449`	`448`	`var commandTime = command.When;`
`450`	`449`
`451`	`450`	`mp.SeekTo(new TimeSpan(command.PositionTicks));`
`@@ -467,7 +466,7 @@ private async Task SchedulePlay(SyncPlaySendCommand command, IMediaPlayerControl`
`467`	`466`	`return;`
`468`	`467`	`}`
`469`	`468`
`470`		`- var currentTime = await jellyfinClient.SyncTime();`
	`469`	`+ var currentTime = await JellyfinClient.SyncTime();`
`471`	`470`	`var commandTime = command.When;`
`472`	`471`
`473`	`472`	`if (commandTime > currentTime)`