From 9cf827bc9fdce7de5c9b91b966d6aa5eef093fbe Mon Sep 17 00:00:00 2001
From: United600 <United600@users.noreply.github.com>
Date: Wed, 8 Oct 2025 18:22:24 +0100
Subject: [PATCH 1/9] move show recent setting to privacy section

---
 Screenbox/Pages/SettingsPage.xaml      | 57 ++++++++++++++------------
 Screenbox/Strings/en-US/Resources.resw |  3 ++
 2 files changed, 33 insertions(+), 27 deletions(-)

diff --git a/Screenbox/Pages/SettingsPage.xaml b/Screenbox/Pages/SettingsPage.xaml
index 72436b691..9c541fb29 100644
--- a/Screenbox/Pages/SettingsPage.xaml
+++ b/Screenbox/Pages/SettingsPage.xaml
@@ -316,33 +316,6 @@
                 <!--  General section  -->
                 <TextBlock Style="{StaticResource SettingsSectionHeaderTextBlockStyle}" Text="{strings:Resources Key=SettingsCategoryGeneral}" />
 
-                <ctc:SettingsExpander
-                    Margin="{StaticResource SettingsCardMargin}"
-                    Description="{strings:Resources Key=SettingsShowRecentDescription}"
-                    Header="{strings:Resources Key=SettingsShowRecentHeader}">
-                    <ctc:SettingsExpander.HeaderIcon>
-                        <FontIcon
-                            FontFamily="{StaticResource ScreenboxSymbolThemeFontFamily}"
-                            Glyph="{x:Bind converters:GlyphConverter.ToRecentGlyph(ViewModel.ShowRecent), Mode=OneWay}"
-                            MirroredWhenRightToLeft="True" />
-                    </ctc:SettingsExpander.HeaderIcon>
-                    <interactivity:Interaction.Behaviors>
-                        <behaviors:SettingsExpanderXYNavigationBehavior />
-                    </interactivity:Interaction.Behaviors>
-                    <ToggleSwitch
-                        x:Name="ShowRecentToggleSwitch"
-                        AutomationProperties.HelpText="{strings:Resources Key=SettingsShowRecentDescription}"
-                        IsOn="{x:Bind ViewModel.ShowRecent, Mode=TwoWay}" />
-                    <ctc:SettingsExpander.Items>
-                        <ctc:SettingsCard
-                            x:Name="SettingsClearRecentCard"
-                            AutomationProperties.Name="{x:Bind SettingsClearRecentCard.Header}"
-                            Header="{strings:Resources Key=SettingsClearRecentHeader}">
-                            <Button Command="{x:Bind ViewModel.ClearRecentHistoryCommand}" Content="{strings:Resources Key=Clear}" />
-                        </ctc:SettingsCard>
-                    </ctc:SettingsExpander.Items>
-                </ctc:SettingsExpander>
-
                 <ctc:SettingsCard
                     x:Name="SettingsEnqueueAllFilesInFolderCard"
                     Margin="{StaticResource SettingsCardMargin}"
@@ -578,6 +551,36 @@
                     </ctc:SettingsExpander.Items>
                 </ctc:SettingsExpander>
 
+                <!--  Privacy  -->
+                <TextBlock Style="{StaticResource SettingsSectionHeaderTextBlockStyle}" Text="{x:Bind strings:Resources.SettingsCategoryPrivacy}" />
+
+                <ctc:SettingsExpander
+                    Margin="{StaticResource SettingsCardMargin}"
+                    Description="{strings:Resources Key=SettingsShowRecentDescription}"
+                    Header="{strings:Resources Key=SettingsShowRecentHeader}">
+                    <ctc:SettingsExpander.HeaderIcon>
+                        <FontIcon
+                            FontFamily="{StaticResource ScreenboxSymbolThemeFontFamily}"
+                            Glyph="{x:Bind converters:GlyphConverter.ToRecentGlyph(ViewModel.ShowRecent), Mode=OneWay}"
+                            MirroredWhenRightToLeft="True" />
+                    </ctc:SettingsExpander.HeaderIcon>
+                    <interactivity:Interaction.Behaviors>
+                        <behaviors:SettingsExpanderXYNavigationBehavior />
+                    </interactivity:Interaction.Behaviors>
+                    <ToggleSwitch
+                        x:Name="ShowRecentToggleSwitch"
+                        AutomationProperties.HelpText="{strings:Resources Key=SettingsShowRecentDescription}"
+                        IsOn="{x:Bind ViewModel.ShowRecent, Mode=TwoWay}" />
+                    <ctc:SettingsExpander.Items>
+                        <ctc:SettingsCard
+                            x:Name="SettingsClearRecentCard"
+                            AutomationProperties.Name="{x:Bind SettingsClearRecentCard.Header}"
+                            Header="{strings:Resources Key=SettingsClearRecentHeader}">
+                            <Button Command="{x:Bind ViewModel.ClearRecentHistoryCommand}" Content="{strings:Resources Key=Clear}" />
+                        </ctc:SettingsCard>
+                    </ctc:SettingsExpander.Items>
+                </ctc:SettingsExpander>
+
                 <!--  About section  -->
                 <TextBlock Style="{StaticResource SettingsSectionHeaderTextBlockStyle}" Text="{strings:Resources Key=SettingsCategoryAbout}" />
 
diff --git a/Screenbox/Strings/en-US/Resources.resw b/Screenbox/Strings/en-US/Resources.resw
index 7a8f5bb6c..989d694b9 100644
--- a/Screenbox/Strings/en-US/Resources.resw
+++ b/Screenbox/Strings/en-US/Resources.resw
@@ -740,6 +740,9 @@
   <data name="SettingsCategoryAdvanced" xml:space="preserve">
     <value>Advanced</value>
   </data>
+  <data name="SettingsCategoryPrivacy" xml:space="preserve">
+    <value>Privacy</value>
+  </data>
   <data name="SettingsAdvancedModeHeader" xml:space="preserve">
     <value>Advanced mode</value>
   </data>

From d2a0ee80ee1d026bd6a62e27ee616e3e0d230b13 Mon Sep 17 00:00:00 2001
From: United600 <United600@users.noreply.github.com>
Date: Wed, 8 Oct 2025 18:35:49 +0100
Subject: [PATCH 2/9] prevent adding items to the recently used list when the
 show recent setting is disabled

---
 Screenbox.Core/Services/FilesService.cs | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/Screenbox.Core/Services/FilesService.cs b/Screenbox.Core/Services/FilesService.cs
index 59dfe4f4a..b2aa2f56f 100644
--- a/Screenbox.Core/Services/FilesService.cs
+++ b/Screenbox.Core/Services/FilesService.cs
@@ -21,6 +21,13 @@ namespace Screenbox.Core.Services
 {
     public sealed class FilesService : IFilesService
     {
+        private readonly ISettingsService _settingsService;
+
+        public FilesService(ISettingsService settingsService)
+        {
+            _settingsService = settingsService;
+        }
+
         public async Task<StorageFileQueryResult?> GetNeighboringFilesQueryAsync(StorageFile file, QueryOptions? options = null)
         {
             try
@@ -162,6 +169,9 @@ public async Task OpenFileLocationAsync(StorageFile file)
 
         public void AddToRecent(IStorageItem item)
         {
+            if (!_settingsService.ShowRecent)
+                return;
+
             string metadata = DateTimeOffset.Now.ToUnixTimeSeconds().ToString();
             try
             {

From 970d967bdc1f38cf0adb074983531ac7f59bc706 Mon Sep 17 00:00:00 2001
From: United600 <United600@users.noreply.github.com>
Date: Sat, 18 Oct 2025 20:23:23 +0100
Subject: [PATCH 3/9] add option to remember and clear playback position
 history

---
 Screenbox.Core/Helpers/LastPositionTracker.cs | 39 ++++++++++++++++---
 Screenbox.Core/Services/ISettingsService.cs   |  1 +
 Screenbox.Core/Services/SettingsService.cs    |  8 ++++
 Screenbox.Core/ViewModels/SeekBarViewModel.cs |  3 +-
 .../ViewModels/SettingsPageViewModel.cs       | 25 +++++++++++-
 Screenbox/Pages/SettingsPage.xaml             | 26 +++++++++++++
 Screenbox/Strings/en-US/Resources.resw        | 13 ++++++-
 7 files changed, 105 insertions(+), 10 deletions(-)

diff --git a/Screenbox.Core/Helpers/LastPositionTracker.cs b/Screenbox.Core/Helpers/LastPositionTracker.cs
index e612b85db..7013d1594 100644
--- a/Screenbox.Core/Helpers/LastPositionTracker.cs
+++ b/Screenbox.Core/Helpers/LastPositionTracker.cs
@@ -1,15 +1,15 @@
 #nullable enable
 
-using CommunityToolkit.Mvvm.ComponentModel;
-using CommunityToolkit.Mvvm.Messaging;
-using Screenbox.Core.Messages;
-using Screenbox.Core.Models;
-using Screenbox.Core.Services;
 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Messaging;
+using Screenbox.Core.Messages;
+using Screenbox.Core.Models;
+using Screenbox.Core.Services;
 using Windows.Storage;
 
 namespace Screenbox.Core.Helpers
@@ -98,7 +98,7 @@ public async Task SaveToDiskAsync()
         {
             try
             {
-                await _filesService.SaveToDiskAsync(ApplicationData.Current.TemporaryFolder, SaveFileName, _lastPositions.ToList());
+                await _filesService.SaveToDiskAsync(ApplicationData.Current.TemporaryFolder, SaveFileName, _lastPositions);
             }
             catch (FileLoadException)
             {
@@ -125,5 +125,32 @@ public async Task LoadFromDiskAsync()
                 // pass
             }
         }
+
+        public async Task DeleteFromDiskAsync()
+        {
+            try
+            {
+                _lastPositions.Clear();
+                _updateCache = null;
+                _removeCache = null;
+                LastUpdated = default;
+
+                //await _filesService.SaveToDiskAsync(ApplicationData.Current.TemporaryFolder, SaveFileName, _lastPositions);
+
+                var folder = ApplicationData.Current.TemporaryFolder;
+                if (await folder.TryGetItemAsync(SaveFileName) is StorageFile file)
+                {
+                    await file.DeleteAsync();
+                }
+            }
+            catch (FileNotFoundException)
+            {
+                // pass
+            }
+            catch (Exception)
+            {
+                // pass
+            }
+        }
     }
 }
diff --git a/Screenbox.Core/Services/ISettingsService.cs b/Screenbox.Core/Services/ISettingsService.cs
index beccce782..430055b8c 100644
--- a/Screenbox.Core/Services/ISettingsService.cs
+++ b/Screenbox.Core/Services/ISettingsService.cs
@@ -27,5 +27,6 @@ public interface ISettingsService
         bool UseMultipleInstances { get; set; }
         string LivelyActivePath { get; set; }
         MediaPlaybackAutoRepeatMode PersistentRepeatMode { get; set; }
+        bool SavePlaybackPosition { get; set; }
     }
 }
diff --git a/Screenbox.Core/Services/SettingsService.cs b/Screenbox.Core/Services/SettingsService.cs
index 946eb5b0e..63378387e 100644
--- a/Screenbox.Core/Services/SettingsService.cs
+++ b/Screenbox.Core/Services/SettingsService.cs
@@ -36,6 +36,7 @@ public sealed class SettingsService : ISettingsService
         private const string PersistentRepeatModeKey = "Values/RepeatMode";
         private const string PersistentSubtitleLanguageKey = "Values/SubtitleLanguage";
         private const string PlayerShowChaptersKey = "Player/ShowChapters";
+        private const string PrivacySavePlaybackPosition = "Privacy/SavePlaybackPosition";
 
         public bool UseIndexer
         {
@@ -169,6 +170,12 @@ public bool PlayerShowChapters
             set => SetValue(PlayerShowChaptersKey, value);
         }
 
+        public bool SavePlaybackPosition
+        {
+            get => GetValue<bool>(PrivacySavePlaybackPosition);
+            set => SetValue(PrivacySavePlaybackPosition, value);
+        }
+
         public SettingsService()
         {
             SetDefault(PlayerAutoResizeKey, (int)PlayerAutoResizeOption.Never);
@@ -188,6 +195,7 @@ public SettingsService()
             SetDefault(AdvancedMultipleInstancesKey, false);
             SetDefault(GlobalArgumentsKey, string.Empty);
             SetDefault(PlayerShowChaptersKey, true);
+            SetDefault(PrivacySavePlaybackPosition, true);
 
             // Device family specific overrides
             if (SystemInformation.IsXbox)
diff --git a/Screenbox.Core/ViewModels/SeekBarViewModel.cs b/Screenbox.Core/ViewModels/SeekBarViewModel.cs
index fedad0e68..6e5eba2b7 100644
--- a/Screenbox.Core/ViewModels/SeekBarViewModel.cs
+++ b/Screenbox.Core/ViewModels/SeekBarViewModel.cs
@@ -391,7 +391,8 @@ private void UpdateChapters(PlaybackChapterList? chapterList)
 
         private void UpdateLastPosition(TimeSpan position)
         {
-            if (_currentItem == null || NaturalDuration <= TimeSpan.FromMinutes(1) ||
+            if (!_settingsService.SavePlaybackPosition ||
+                _currentItem == null || NaturalDuration <= TimeSpan.FromMinutes(1) ||
                 DateTimeOffset.Now - _lastPositionTracker.LastUpdated <= TimeSpan.FromSeconds(3))
                 return;
 
diff --git a/Screenbox.Core/ViewModels/SettingsPageViewModel.cs b/Screenbox.Core/ViewModels/SettingsPageViewModel.cs
index 77b8e0e8c..21c525beb 100644
--- a/Screenbox.Core/ViewModels/SettingsPageViewModel.cs
+++ b/Screenbox.Core/ViewModels/SettingsPageViewModel.cs
@@ -43,6 +43,7 @@ public sealed partial class SettingsPageViewModel : ObservableRecipient
         [ObservableProperty] private string _globalArguments;
         [ObservableProperty] private bool _isRelaunchRequired;
         [ObservableProperty] private int _selectedLanguage;
+        [ObservableProperty] private bool _savePlaybackPosition;
 
         public ObservableCollection<StorageFolder> MusicLocations { get; }
 
@@ -59,6 +60,7 @@ public sealed partial class SettingsPageViewModel : ObservableRecipient
         private readonly DispatcherQueue _dispatcherQueue;
         private readonly DispatcherQueueTimer _storageDeviceRefreshTimer;
         private readonly DeviceWatcher? _portableStorageDeviceWatcher;
+        private readonly LastPositionTracker _lastPositionTracker;
         private static InitialValues? _initialValues;
         private StorageLibrary? _videosLibrary;
         private StorageLibrary? _musicLibrary;
@@ -71,10 +73,11 @@ private record InitialValues(string GlobalArguments, bool AdvancedMode, int Vide
             public int Language { get; } = Language;
         }
 
-        public SettingsPageViewModel(ISettingsService settingsService, ILibraryService libraryService)
+        public SettingsPageViewModel(ISettingsService settingsService, ILibraryService libraryService, LastPositionTracker lastPositionTracker)
         {
             _settingsService = settingsService;
             _libraryService = libraryService;
+            _lastPositionTracker = lastPositionTracker;
             _dispatcherQueue = DispatcherQueue.GetForCurrentThread();
             _storageDeviceRefreshTimer = _dispatcherQueue.CreateTimer();
             MusicLocations = new ObservableCollection<StorageFolder>();
@@ -105,6 +108,7 @@ public SettingsPageViewModel(ISettingsService settingsService, ILibraryService l
             _playerControlsHideDelay = _settingsService.PlayerControlsHideDelay;
             _useIndexer = _settingsService.UseIndexer;
             _showRecent = _settingsService.ShowRecent;
+            _savePlaybackPosition = _settingsService.SavePlaybackPosition;
             _theme = ((int)_settingsService.Theme + 2) % 3;
             _enqueueAllFilesInFolder = _settingsService.EnqueueAllFilesInFolder;
             _restorePlaybackPosition = _settingsService.RestorePlaybackPosition;
@@ -276,6 +280,12 @@ partial void OnGlobalArgumentsChanged(string value)
             CheckForRelaunch();
         }
 
+        partial void OnSavePlaybackPositionChanged(bool value)
+        {
+            _settingsService.SavePlaybackPosition = value;
+            Messenger.Send(new SettingsChangedMessage(nameof(SavePlaybackPosition), typeof(SettingsPageViewModel)));
+        }
+
         [RelayCommand]
         private async Task RefreshLibrariesAsync()
         {
@@ -332,6 +342,19 @@ private void ClearRecentHistory()
             StorageApplicationPermissions.MostRecentlyUsedList.Clear();
         }
 
+
+        [RelayCommand]
+        private async Task ClearPlaybackPositionsAsync()
+        {
+            try
+            {
+                await _lastPositionTracker.DeleteFromDiskAsync();
+            }
+            catch (Exception)
+            {
+                // pass
+            }
+        }
         public void OnNavigatedFrom()
         {
             if (SystemInformation.IsXbox)
diff --git a/Screenbox/Pages/SettingsPage.xaml b/Screenbox/Pages/SettingsPage.xaml
index 9c541fb29..1708eee70 100644
--- a/Screenbox/Pages/SettingsPage.xaml
+++ b/Screenbox/Pages/SettingsPage.xaml
@@ -581,6 +581,32 @@
                     </ctc:SettingsExpander.Items>
                 </ctc:SettingsExpander>
 
+                <ctc:SettingsExpander
+                    Margin="{StaticResource SettingsCardMargin}"
+                    Description="{x:Bind strings:Resources.SettingsSavePlaybackPositionDescription}"
+                    Header="{x:Bind strings:Resources.SettingsSavePlaybackPositionHeader}"
+                    HeaderIcon="{ui:FontIcon Glyph=&#xE81C;}">
+                    <ctc:SettingsExpander.Resources>
+                        <ResourceDictionary>
+                            <ResourceDictionary.MergedDictionaries>
+                                <ResourceDictionary Source="ms-appx:///CommunityToolkit.WinUI.Controls.SettingsControls/SettingsExpander/SettingsExpander.xaml" />
+                            </ResourceDictionary.MergedDictionaries>
+                        </ResourceDictionary>
+                    </ctc:SettingsExpander.Resources>
+                    <interactivity:Interaction.Behaviors>
+                        <behaviors:SettingsExpanderXYNavigationBehavior />
+                    </interactivity:Interaction.Behaviors>
+                    <ToggleSwitch AutomationProperties.HelpText="{x:Bind strings:Resources.SettingsSavePlaybackPositionDescription}" IsOn="{x:Bind ViewModel.SavePlaybackPosition, Mode=TwoWay}" />
+                    <ctc:SettingsExpander.ItemsFooter>
+                        <ctc:SettingsCard
+                            AutomationProperties.Name="{x:Bind strings:Resources.SettingsClearPlaybackPositionHeader}"
+                            Header="{x:Bind strings:Resources.SettingsClearPlaybackPositionHeader}"
+                            Style="{StaticResource DefaultSettingsExpanderItemStyle}">
+                            <Button Command="{x:Bind ViewModel.ClearPlaybackPositionsCommand}" Content="{x:Bind strings:Resources.Clear}" />
+                        </ctc:SettingsCard>
+                    </ctc:SettingsExpander.ItemsFooter>
+                </ctc:SettingsExpander>
+
                 <!--  About section  -->
                 <TextBlock Style="{StaticResource SettingsSectionHeaderTextBlockStyle}" Text="{strings:Resources Key=SettingsCategoryAbout}" />
 
diff --git a/Screenbox/Strings/en-US/Resources.resw b/Screenbox/Strings/en-US/Resources.resw
index 989d694b9..d3c43963f 100644
--- a/Screenbox/Strings/en-US/Resources.resw
+++ b/Screenbox/Strings/en-US/Resources.resw
@@ -622,7 +622,7 @@
     <value>Music library locations</value>
   </data>
   <data name="SettingsShowRecentHeader" xml:space="preserve">
-    <value>Show recent</value>
+    <value>Remember recent media</value>
   </data>
   <data name="SettingsShowControlsHeader" xml:space="preserve">
     <value>Show controls when paused</value>
@@ -634,7 +634,7 @@
     <value>Subtitles</value>
   </data>
   <data name="SettingsShowRecentDescription" xml:space="preserve">
-    <value>Display recently played media on the home page</value>
+    <value>Show recently played media on the home page</value>
   </data>
   <data name="SettingsClearRecentHeader" xml:space="preserve">
     <value>Clear recent media history</value>
@@ -981,4 +981,13 @@
   <data name="Folder" xml:space="preserve">
     <value>Folder</value>
   </data>
+  <data name="SettingsSavePlaybackPositionHeader" xml:space="preserve">
+    <value>Remember playback position</value>
+  </data>
+  <data name="SettingsSavePlaybackPositionDescription" xml:space="preserve">
+    <value>Store my playback position history on this device to resume where I left off</value>
+  </data>
+  <data name="SettingsClearPlaybackPositionHeader" xml:space="preserve">
+    <value>Clear device playback position history</value>
+  </data>
 </root>
\ No newline at end of file

From 366e94b3680151428f5c447e9c3caa77018a9a5e Mon Sep 17 00:00:00 2001
From: Tung Huynh <31434093+huynhsontung@users.noreply.github.com>
Date: Sun, 25 Jan 2026 16:05:28 -0800
Subject: [PATCH 4/9] make LastPositionTrack singleton

---
 Screenbox.Core/Common/ServiceHelpers.cs       |   5 +-
 .../Controllers/LastPositionTracker.cs        | 155 +++++
 Screenbox.Core/Helpers/LastPositionTracker.cs | 156 -----
 Screenbox.Core/Screenbox.Core.csproj          |   2 +-
 Screenbox.Core/ViewModels/SeekBarViewModel.cs | 594 +++++++++---------
 5 files changed, 454 insertions(+), 458 deletions(-)
 create mode 100644 Screenbox.Core/Controllers/LastPositionTracker.cs
 delete mode 100644 Screenbox.Core/Helpers/LastPositionTracker.cs

diff --git a/Screenbox.Core/Common/ServiceHelpers.cs b/Screenbox.Core/Common/ServiceHelpers.cs
index bd8127e2e..0a9614349 100644
--- a/Screenbox.Core/Common/ServiceHelpers.cs
+++ b/Screenbox.Core/Common/ServiceHelpers.cs
@@ -2,7 +2,6 @@
 using Screenbox.Core.Contexts;
 using Screenbox.Core.Controllers;
 using Screenbox.Core.Factories;
-using Screenbox.Core.Helpers;
 using Screenbox.Core.Services;
 using Screenbox.Core.ViewModels;
 
@@ -45,9 +44,6 @@ public static void PopulateCoreServices(ServiceCollection services)
         services.AddSingleton<VolumeViewModel>();   // Avoid thread lock
         services.AddSingleton<MediaListViewModel>(); // Global playlist
 
-        // Misc
-        services.AddTransient<LastPositionTracker>();
-
         // Factories
         services.AddSingleton<MediaViewModelFactory>();
         services.AddSingleton<StorageItemViewModelFactory>();
@@ -62,6 +58,7 @@ public static void PopulateCoreServices(ServiceCollection services)
 
         // Controllers
         services.AddSingleton<LibraryController>();
+        services.AddSingleton<LastPositionTracker>();
 
         // Services
         services.AddSingleton<IPlayerService, PlayerService>();
diff --git a/Screenbox.Core/Controllers/LastPositionTracker.cs b/Screenbox.Core/Controllers/LastPositionTracker.cs
new file mode 100644
index 000000000..3996b8a12
--- /dev/null
+++ b/Screenbox.Core/Controllers/LastPositionTracker.cs
@@ -0,0 +1,155 @@
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Messaging;
+using Screenbox.Core.Messages;
+using Screenbox.Core.Models;
+using Screenbox.Core.Services;
+using Windows.Storage;
+
+namespace Screenbox.Core.Controllers;
+
+public sealed class LastPositionTracker : ObservableRecipient,
+    IRecipient<SuspendingMessage>
+{
+    private const int Capacity = 64;
+    private const string SaveFileName = "last_positions.bin";
+
+    public bool IsLoaded => LastUpdated != default;
+
+    public DateTimeOffset LastUpdated { get; private set; }
+
+    private readonly IFilesService _filesService;
+    private List<MediaLastPosition> _lastPositions = new(Capacity + 1);
+    private MediaLastPosition? _updateCache;
+    private string? _removeCache;
+
+    public LastPositionTracker(IFilesService filesService)
+    {
+        _filesService = filesService;
+
+        IsActive = true;
+    }
+
+    public void Receive(SuspendingMessage message)
+    {
+        message.Reply(SaveToDiskAsync());
+    }
+
+    public void UpdateLastPosition(string location, TimeSpan position)
+    {
+        LastUpdated = DateTimeOffset.Now;
+        _removeCache = null;
+        MediaLastPosition? item = _updateCache;
+        if (item?.Location == location)
+        {
+            item.Position = position;
+            if (_lastPositions.FirstOrDefault() != item)
+            {
+                int index = _lastPositions.IndexOf(item);
+                if (index >= 0)
+                {
+                    _lastPositions.RemoveAt(index);
+                }
+
+                _lastPositions.Insert(0, item);
+            }
+        }
+        else
+        {
+            item = _lastPositions.Find(x => x.Location == location);
+            if (item == null)
+            {
+                item = new MediaLastPosition(location, position);
+                _lastPositions.Insert(0, item);
+                if (_lastPositions.Count > Capacity)
+                {
+                    _lastPositions.RemoveAt(Capacity);
+                }
+            }
+            else
+            {
+                item.Position = position;
+            }
+        }
+
+        _updateCache = item;
+    }
+
+    public TimeSpan GetPosition(string location)
+    {
+        return _lastPositions.Find(x => x.Location == location)?.Position ?? TimeSpan.Zero;
+    }
+
+    public void RemovePosition(string location)
+    {
+        LastUpdated = DateTimeOffset.Now;
+        if (_removeCache == location) return;
+        _lastPositions.RemoveAll(x => x.Location == location);
+        _removeCache = location;
+    }
+
+    public async Task SaveToDiskAsync()
+    {
+        try
+        {
+            await _filesService.SaveToDiskAsync(ApplicationData.Current.TemporaryFolder, SaveFileName, _lastPositions);
+        }
+        catch (FileLoadException)
+        {
+            // File in use. Skipped
+        }
+    }
+
+    public async Task LoadFromDiskAsync()
+    {
+        try
+        {
+            List<MediaLastPosition> lastPositions =
+                await _filesService.LoadFromDiskAsync<List<MediaLastPosition>>(ApplicationData.Current.TemporaryFolder, SaveFileName);
+            lastPositions.Capacity = Capacity;
+            _lastPositions = lastPositions;
+            LastUpdated = DateTimeOffset.UtcNow;
+        }
+        catch (FileNotFoundException)
+        {
+            // pass
+        }
+        catch (Exception)
+        {
+            // pass
+        }
+    }
+
+    public async Task DeleteFromDiskAsync()
+    {
+        try
+        {
+            _lastPositions.Clear();
+            _updateCache = null;
+            _removeCache = null;
+            LastUpdated = default;
+
+            //await _filesService.SaveToDiskAsync(ApplicationData.Current.TemporaryFolder, SaveFileName, _lastPositions);
+
+            var folder = ApplicationData.Current.TemporaryFolder;
+            if (await folder.TryGetItemAsync(SaveFileName) is StorageFile file)
+            {
+                await file.DeleteAsync();
+            }
+        }
+        catch (FileNotFoundException)
+        {
+            // pass
+        }
+        catch (Exception)
+        {
+            // pass
+        }
+    }
+}
diff --git a/Screenbox.Core/Helpers/LastPositionTracker.cs b/Screenbox.Core/Helpers/LastPositionTracker.cs
deleted file mode 100644
index 7013d1594..000000000
--- a/Screenbox.Core/Helpers/LastPositionTracker.cs
+++ /dev/null
@@ -1,156 +0,0 @@
-#nullable enable
-
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading.Tasks;
-using CommunityToolkit.Mvvm.ComponentModel;
-using CommunityToolkit.Mvvm.Messaging;
-using Screenbox.Core.Messages;
-using Screenbox.Core.Models;
-using Screenbox.Core.Services;
-using Windows.Storage;
-
-namespace Screenbox.Core.Helpers
-{
-    public sealed class LastPositionTracker : ObservableRecipient,
-        IRecipient<SuspendingMessage>
-    {
-        private const int Capacity = 64;
-        private const string SaveFileName = "last_positions.bin";
-
-        public bool IsLoaded => LastUpdated != default;
-
-        public DateTimeOffset LastUpdated { get; private set; }
-
-        private readonly IFilesService _filesService;
-        private List<MediaLastPosition> _lastPositions = new(Capacity + 1);
-        private MediaLastPosition? _updateCache;
-        private string? _removeCache;
-
-        public LastPositionTracker(IFilesService filesService)
-        {
-            _filesService = filesService;
-
-            IsActive = true;
-        }
-
-        public void Receive(SuspendingMessage message)
-        {
-            message.Reply(SaveToDiskAsync());
-        }
-
-        public void UpdateLastPosition(string location, TimeSpan position)
-        {
-            LastUpdated = DateTimeOffset.Now;
-            _removeCache = null;
-            MediaLastPosition? item = _updateCache;
-            if (item?.Location == location)
-            {
-                item.Position = position;
-                if (_lastPositions.FirstOrDefault() != item)
-                {
-                    int index = _lastPositions.IndexOf(item);
-                    if (index >= 0)
-                    {
-                        _lastPositions.RemoveAt(index);
-                    }
-
-                    _lastPositions.Insert(0, item);
-                }
-            }
-            else
-            {
-                item = _lastPositions.Find(x => x.Location == location);
-                if (item == null)
-                {
-                    item = new MediaLastPosition(location, position);
-                    _lastPositions.Insert(0, item);
-                    if (_lastPositions.Count > Capacity)
-                    {
-                        _lastPositions.RemoveAt(Capacity);
-                    }
-                }
-                else
-                {
-                    item.Position = position;
-                }
-            }
-
-            _updateCache = item;
-        }
-
-        public TimeSpan GetPosition(string location)
-        {
-            return _lastPositions.Find(x => x.Location == location)?.Position ?? TimeSpan.Zero;
-        }
-
-        public void RemovePosition(string location)
-        {
-            LastUpdated = DateTimeOffset.Now;
-            if (_removeCache == location) return;
-            _lastPositions.RemoveAll(x => x.Location == location);
-            _removeCache = location;
-        }
-
-        public async Task SaveToDiskAsync()
-        {
-            try
-            {
-                await _filesService.SaveToDiskAsync(ApplicationData.Current.TemporaryFolder, SaveFileName, _lastPositions);
-            }
-            catch (FileLoadException)
-            {
-                // File in use. Skipped
-            }
-        }
-
-        public async Task LoadFromDiskAsync()
-        {
-            try
-            {
-                List<MediaLastPosition> lastPositions =
-                    await _filesService.LoadFromDiskAsync<List<MediaLastPosition>>(ApplicationData.Current.TemporaryFolder, SaveFileName);
-                lastPositions.Capacity = Capacity;
-                _lastPositions = lastPositions;
-                LastUpdated = DateTimeOffset.UtcNow;
-            }
-            catch (FileNotFoundException)
-            {
-                // pass
-            }
-            catch (Exception)
-            {
-                // pass
-            }
-        }
-
-        public async Task DeleteFromDiskAsync()
-        {
-            try
-            {
-                _lastPositions.Clear();
-                _updateCache = null;
-                _removeCache = null;
-                LastUpdated = default;
-
-                //await _filesService.SaveToDiskAsync(ApplicationData.Current.TemporaryFolder, SaveFileName, _lastPositions);
-
-                var folder = ApplicationData.Current.TemporaryFolder;
-                if (await folder.TryGetItemAsync(SaveFileName) is StorageFile file)
-                {
-                    await file.DeleteAsync();
-                }
-            }
-            catch (FileNotFoundException)
-            {
-                // pass
-            }
-            catch (Exception)
-            {
-                // pass
-            }
-        }
-    }
-}
diff --git a/Screenbox.Core/Screenbox.Core.csproj b/Screenbox.Core/Screenbox.Core.csproj
index c51129997..c8ecdb631 100644
--- a/Screenbox.Core/Screenbox.Core.csproj
+++ b/Screenbox.Core/Screenbox.Core.csproj
@@ -152,7 +152,7 @@
     <Compile Include="Helpers\EnumExtensions.cs" />
     <Compile Include="Helpers\FilesHelpers.cs" />
     <Compile Include="Helpers\LanguageHelper.cs" />
-    <Compile Include="Helpers\LastPositionTracker.cs" />
+    <Compile Include="Controllers\LastPositionTracker.cs" />
     <Compile Include="Helpers\ListGrouping.cs" />
     <Compile Include="Helpers\LivelyWallpaperUtil.cs" />
     <Compile Include="Helpers\MediaGroupingHelpers.cs" />
diff --git a/Screenbox.Core/ViewModels/SeekBarViewModel.cs b/Screenbox.Core/ViewModels/SeekBarViewModel.cs
index 6e5eba2b7..afbebeb48 100644
--- a/Screenbox.Core/ViewModels/SeekBarViewModel.cs
+++ b/Screenbox.Core/ViewModels/SeekBarViewModel.cs
@@ -7,6 +7,7 @@
 using CommunityToolkit.Mvvm.Messaging.Messages;
 using CommunityToolkit.WinUI;
 using Screenbox.Core.Contexts;
+using Screenbox.Core.Controllers;
 using Screenbox.Core.Enums;
 using Screenbox.Core.Events;
 using Screenbox.Core.Helpers;
@@ -21,389 +22,388 @@
 using Windows.UI.Xaml;
 using Windows.UI.Xaml.Controls.Primitives;
 
-namespace Screenbox.Core.ViewModels
+namespace Screenbox.Core.ViewModels;
+
+public sealed partial class SeekBarViewModel :
+    ObservableRecipient,
+    IRecipient<TimeChangeOverrideMessage>,
+    IRecipient<ChangeTimeRequestMessage>,
+    IRecipient<PlayerControlsVisibilityChangedMessage>,
+    IRecipient<PlaylistCurrentItemChangedMessage>,
+    IRecipient<PropertyChangedMessage<PlayerVisibilityState>>,
+    IRecipient<PropertyChangedMessage<IMediaPlayer?>>
 {
-    public sealed partial class SeekBarViewModel :
-        ObservableRecipient,
-        IRecipient<TimeChangeOverrideMessage>,
-        IRecipient<ChangeTimeRequestMessage>,
-        IRecipient<PlayerControlsVisibilityChangedMessage>,
-        IRecipient<PlaylistCurrentItemChangedMessage>,
-        IRecipient<PropertyChangedMessage<PlayerVisibilityState>>,
-        IRecipient<PropertyChangedMessage<IMediaPlayer?>>
-    {
-        [ObservableProperty] private double _length;
+    [ObservableProperty] private double _length;
 
-        [ObservableProperty] private double _time;
+    [ObservableProperty] private double _time;
 
-        [ObservableProperty] private bool _isSeekable;
+    [ObservableProperty] private bool _isSeekable;
 
-        [ObservableProperty] private bool _bufferingVisible;
+    [ObservableProperty] private bool _bufferingVisible;
 
-        [ObservableProperty] private double _previewTime;
+    [ObservableProperty] private double _previewTime;
 
-        [ObservableProperty] private bool _shouldShowPreview;
+    [ObservableProperty] private bool _shouldShowPreview;
 
-        [ObservableProperty] private bool _shouldHandleKeyDown;
+    [ObservableProperty] private bool _shouldHandleKeyDown;
 
-        public ObservableCollection<ChapterCue> Chapters { get; }
+    public ObservableCollection<ChapterCue> Chapters { get; }
 
-        private TimeSpan NaturalDuration => TimeSpan.FromMilliseconds(Length);
+    private TimeSpan NaturalDuration => TimeSpan.FromMilliseconds(Length);
 
-        private TimeSpan Position
-        {
-            get => TimeSpan.FromMilliseconds(Time);
-            set => Time = value.TotalMilliseconds;
-        }
+    private TimeSpan Position
+    {
+        get => TimeSpan.FromMilliseconds(Time);
+        set => Time = value.TotalMilliseconds;
+    }
 
-        private IMediaPlayer? MediaPlayer => _playerContext.MediaPlayer;
-
-        private readonly ISettingsService _settingsService;
-        private readonly PlayerContext _playerContext;
-        private readonly DispatcherQueue _dispatcherQueue;
-        private readonly DispatcherQueueTimer _bufferingTimer;
-        private readonly DispatcherQueueTimer _seekTimer;
-        private readonly DispatcherQueueTimer _originalPositionTimer;
-        private readonly LastPositionTracker _lastPositionTracker;
-        private TimeSpan _originalPosition;
-        private TimeSpan _lastTrackedPosition;
-        private bool _timeChangeOverride;
-        private MediaViewModel? _currentItem;
-
-        public SeekBarViewModel(ISettingsService settingsService, LastPositionTracker lastPositionTracker,
-            PlayerContext playerContext)
+    private IMediaPlayer? MediaPlayer => _playerContext.MediaPlayer;
+
+    private readonly ISettingsService _settingsService;
+    private readonly PlayerContext _playerContext;
+    private readonly DispatcherQueue _dispatcherQueue;
+    private readonly DispatcherQueueTimer _bufferingTimer;
+    private readonly DispatcherQueueTimer _seekTimer;
+    private readonly DispatcherQueueTimer _originalPositionTimer;
+    private readonly LastPositionTracker _lastPositionTracker;
+    private TimeSpan _originalPosition;
+    private TimeSpan _lastTrackedPosition;
+    private bool _timeChangeOverride;
+    private MediaViewModel? _currentItem;
+
+    public SeekBarViewModel(ISettingsService settingsService, LastPositionTracker lastPositionTracker,
+        PlayerContext playerContext)
+    {
+        _settingsService = settingsService;
+        _lastPositionTracker = lastPositionTracker;
+        _playerContext = playerContext;
+        _dispatcherQueue = DispatcherQueue.GetForCurrentThread();
+        _bufferingTimer = _dispatcherQueue.CreateTimer();
+        _seekTimer = _dispatcherQueue.CreateTimer();
+        _originalPositionTimer = _dispatcherQueue.CreateTimer();
+        _originalPositionTimer.IsRepeating = false;
+        _shouldShowPreview = true;
+        _shouldHandleKeyDown = true;
+        Chapters = new ObservableCollection<ChapterCue>();
+
+        if (MediaPlayer != null)
         {
-            _settingsService = settingsService;
-            _lastPositionTracker = lastPositionTracker;
-            _playerContext = playerContext;
-            _dispatcherQueue = DispatcherQueue.GetForCurrentThread();
-            _bufferingTimer = _dispatcherQueue.CreateTimer();
-            _seekTimer = _dispatcherQueue.CreateTimer();
-            _originalPositionTimer = _dispatcherQueue.CreateTimer();
-            _originalPositionTimer.IsRepeating = false;
-            _shouldShowPreview = true;
-            _shouldHandleKeyDown = true;
-            Chapters = new ObservableCollection<ChapterCue>();
-
-            if (MediaPlayer != null)
-            {
-                MediaPlayer.PlaybackStateChanged += OnPlaybackStateChanged;
-                MediaPlayer.NaturalDurationChanged += OnNaturalDurationChanged;
-                MediaPlayer.PositionChanged += OnPositionChanged;
-                MediaPlayer.MediaEnded += OnEndReached;
-                MediaPlayer.BufferingStarted += OnBufferingStarted;
-                MediaPlayer.BufferingEnded += OnBufferingEnded;
-                MediaPlayer.PlaybackItemChanged += OnPlaybackItemChanged;
-                MediaPlayer.CanSeekChanged += OnCanSeekChanged;
-            }
-
-            // Activate the view model's messenger
-            IsActive = true;
+            MediaPlayer.PlaybackStateChanged += OnPlaybackStateChanged;
+            MediaPlayer.NaturalDurationChanged += OnNaturalDurationChanged;
+            MediaPlayer.PositionChanged += OnPositionChanged;
+            MediaPlayer.MediaEnded += OnEndReached;
+            MediaPlayer.BufferingStarted += OnBufferingStarted;
+            MediaPlayer.BufferingEnded += OnBufferingEnded;
+            MediaPlayer.PlaybackItemChanged += OnPlaybackItemChanged;
+            MediaPlayer.CanSeekChanged += OnCanSeekChanged;
         }
 
-        public void Receive(PlaylistCurrentItemChangedMessage message)
+        // Activate the view model's messenger
+        IsActive = true;
+    }
+
+    public void Receive(PlaylistCurrentItemChangedMessage message)
+    {
+        _lastTrackedPosition = TimeSpan.Zero;
+        _currentItem = message.Value;
+        if (message.Value != null && _lastPositionTracker.IsLoaded)
         {
-            _lastTrackedPosition = TimeSpan.Zero;
-            _currentItem = message.Value;
-            if (message.Value != null && _lastPositionTracker.IsLoaded)
-            {
-                RestoreLastPosition(message.Value);
-            }
+            RestoreLastPosition(message.Value);
         }
+    }
 
-        public void Receive(PropertyChangedMessage<PlayerVisibilityState> message)
+    public void Receive(PropertyChangedMessage<PlayerVisibilityState> message)
+    {
+        ShouldHandleKeyDown = message.NewValue != PlayerVisibilityState.Visible;
+    }
+
+    public void Receive(PlayerControlsVisibilityChangedMessage message)
+    {
+        if (!message.Value && ShouldShowPreview)
         {
-            ShouldHandleKeyDown = message.NewValue != PlayerVisibilityState.Visible;
+            ShouldShowPreview = false;
         }
+    }
+
+    public async void Receive(PropertyChangedMessage<IMediaPlayer?> message)
+    {
+        if (message.Sender is not PlayerContext) return;
 
-        public void Receive(PlayerControlsVisibilityChangedMessage message)
+        if (message.OldValue is { } oldPlayer)
         {
-            if (!message.Value && ShouldShowPreview)
-            {
-                ShouldShowPreview = false;
-            }
+            oldPlayer.PlaybackStateChanged -= OnPlaybackStateChanged;
+            oldPlayer.NaturalDurationChanged -= OnNaturalDurationChanged;
+            oldPlayer.PositionChanged -= OnPositionChanged;
+            oldPlayer.MediaEnded -= OnEndReached;
+            oldPlayer.BufferingStarted -= OnBufferingStarted;
+            oldPlayer.BufferingEnded -= OnBufferingEnded;
+            oldPlayer.PlaybackItemChanged -= OnPlaybackItemChanged;
+            oldPlayer.CanSeekChanged -= OnCanSeekChanged;
         }
 
-        public async void Receive(PropertyChangedMessage<IMediaPlayer?> message)
+        if (MediaPlayer != null)
         {
-            if (message.Sender is not PlayerContext) return;
-
-            if (message.OldValue is { } oldPlayer)
+            MediaPlayer.PlaybackStateChanged += OnPlaybackStateChanged;
+            MediaPlayer.NaturalDurationChanged += OnNaturalDurationChanged;
+            MediaPlayer.PositionChanged += OnPositionChanged;
+            MediaPlayer.MediaEnded += OnEndReached;
+            MediaPlayer.BufferingStarted += OnBufferingStarted;
+            MediaPlayer.BufferingEnded += OnBufferingEnded;
+            MediaPlayer.PlaybackItemChanged += OnPlaybackItemChanged;
+            MediaPlayer.CanSeekChanged += OnCanSeekChanged;
+
+            if (!_lastPositionTracker.IsLoaded)
             {
-                oldPlayer.PlaybackStateChanged -= OnPlaybackStateChanged;
-                oldPlayer.NaturalDurationChanged -= OnNaturalDurationChanged;
-                oldPlayer.PositionChanged -= OnPositionChanged;
-                oldPlayer.MediaEnded -= OnEndReached;
-                oldPlayer.BufferingStarted -= OnBufferingStarted;
-                oldPlayer.BufferingEnded -= OnBufferingEnded;
-                oldPlayer.PlaybackItemChanged -= OnPlaybackItemChanged;
-                oldPlayer.CanSeekChanged -= OnCanSeekChanged;
-            }
-
-            if (MediaPlayer != null)
-            {
-                MediaPlayer.PlaybackStateChanged += OnPlaybackStateChanged;
-                MediaPlayer.NaturalDurationChanged += OnNaturalDurationChanged;
-                MediaPlayer.PositionChanged += OnPositionChanged;
-                MediaPlayer.MediaEnded += OnEndReached;
-                MediaPlayer.BufferingStarted += OnBufferingStarted;
-                MediaPlayer.BufferingEnded += OnBufferingEnded;
-                MediaPlayer.PlaybackItemChanged += OnPlaybackItemChanged;
-                MediaPlayer.CanSeekChanged += OnCanSeekChanged;
-
-                if (!_lastPositionTracker.IsLoaded)
+                await _lastPositionTracker.LoadFromDiskAsync();
+                if (_currentItem != null)
                 {
-                    await _lastPositionTracker.LoadFromDiskAsync();
-                    if (_currentItem != null)
-                    {
-                        RestoreLastPosition(_currentItem);
-                    }
+                    RestoreLastPosition(_currentItem);
                 }
             }
         }
+    }
 
-        public void Receive(TimeChangeOverrideMessage message)
-        {
-            _timeChangeOverride = message.Value;
-        }
+    public void Receive(TimeChangeOverrideMessage message)
+    {
+        _timeChangeOverride = message.Value;
+    }
 
-        public void Receive(ChangeTimeRequestMessage message)
-        {
-            var result = UpdatePosition(message.Value, message.IsOffset, message.Debounce);
-            message.Reply(result);
-        }
+    public void Receive(ChangeTimeRequestMessage message)
+    {
+        var result = UpdatePosition(message.Value, message.IsOffset, message.Debounce);
+        message.Reply(result);
+    }
 
-        public void OnSeekBarPointerEvent(bool pressed)
-        {
-            _timeChangeOverride = pressed;
-        }
+    public void OnSeekBarPointerEvent(bool pressed)
+    {
+        _timeChangeOverride = pressed;
+    }
 
-        public void UpdatePreviewTime(double normalizedPosition)
-        {
-            normalizedPosition = Math.Clamp(normalizedPosition, 0, 1);
-            PreviewTime = (long)(normalizedPosition * Length);
-        }
+    public void UpdatePreviewTime(double normalizedPosition)
+    {
+        normalizedPosition = Math.Clamp(normalizedPosition, 0, 1);
+        PreviewTime = (long)(normalizedPosition * Length);
+    }
 
-        public void OnSeekBarPointerWheelChanged(double pointerWheelDelta)
-        {
-            if (!IsSeekable || MediaPlayer == null) return;
-            var controlPressed = Window.Current.CoreWindow.GetKeyState(VirtualKey.Control) == CoreVirtualKeyStates.Down;
-            var shiftPressed = Window.Current.CoreWindow.GetKeyState(VirtualKey.Shift) == CoreVirtualKeyStates.Down;
-            var delta = 5000;
-            if (controlPressed) delta = 10000;
-            if (shiftPressed) delta = 2000;
-            var result = UpdatePosition(TimeSpan.FromMilliseconds(pointerWheelDelta > 0 ? delta : -delta), true, true);
-            TimeSpan offset = result.NewPosition - result.OriginalPosition;
-            string extra = $"{(offset > TimeSpan.Zero ? '+' : string.Empty)}{Humanizer.ToDuration(offset)}";
-            Messenger.SendPositionStatus(result.NewPosition, result.NaturalDuration, extra);
-        }
+    public void OnSeekBarPointerWheelChanged(double pointerWheelDelta)
+    {
+        if (!IsSeekable || MediaPlayer == null) return;
+        var controlPressed = Window.Current.CoreWindow.GetKeyState(VirtualKey.Control) == CoreVirtualKeyStates.Down;
+        var shiftPressed = Window.Current.CoreWindow.GetKeyState(VirtualKey.Shift) == CoreVirtualKeyStates.Down;
+        var delta = 5000;
+        if (controlPressed) delta = 10000;
+        if (shiftPressed) delta = 2000;
+        var result = UpdatePosition(TimeSpan.FromMilliseconds(pointerWheelDelta > 0 ? delta : -delta), true, true);
+        TimeSpan offset = result.NewPosition - result.OriginalPosition;
+        string extra = $"{(offset > TimeSpan.Zero ? '+' : string.Empty)}{Humanizer.ToDuration(offset)}";
+        Messenger.SendPositionStatus(result.NewPosition, result.NaturalDuration, extra);
+    }
 
-        public void OnSeekBarValueChanged(object sender, RangeBaseValueChangedEventArgs args)
+    public void OnSeekBarValueChanged(object sender, RangeBaseValueChangedEventArgs args)
+    {
+        var newPosition = TimeSpan.FromMilliseconds(args.NewValue);
+        // Only update player position when there is a user interaction.
+        // SeekBar should have OneWay binding to Time, so when Time changes and invokes
+        // this handler, Time = args.NewValue. The only exception is when the change is
+        // coming from user.
+        // We can detect user interaction by checking if Time != args.NewValue
+        if (IsSeekable && MediaPlayer != null && Math.Abs(Time - args.NewValue) > 50)
         {
-            var newPosition = TimeSpan.FromMilliseconds(args.NewValue);
-            // Only update player position when there is a user interaction.
-            // SeekBar should have OneWay binding to Time, so when Time changes and invokes
-            // this handler, Time = args.NewValue. The only exception is when the change is
-            // coming from user.
-            // We can detect user interaction by checking if Time != args.NewValue
-            if (IsSeekable && MediaPlayer != null && Math.Abs(Time - args.NewValue) > 50)
+            Time = args.NewValue;
+            double currentMs = MediaPlayer.Position.TotalMilliseconds;
+            double newDiffMs = Math.Abs(args.NewValue - currentMs);
+            bool shouldUpdate = newDiffMs > 400;
+            bool shouldOverride = _timeChangeOverride && newDiffMs > 100;
+            bool paused = MediaPlayer.PlaybackState is MediaPlaybackState.Paused or MediaPlaybackState.Buffering;
+            if (shouldUpdate || paused || shouldOverride)
             {
-                Time = args.NewValue;
-                double currentMs = MediaPlayer.Position.TotalMilliseconds;
-                double newDiffMs = Math.Abs(args.NewValue - currentMs);
-                bool shouldUpdate = newDiffMs > 400;
-                bool shouldOverride = _timeChangeOverride && newDiffMs > 100;
-                bool paused = MediaPlayer.PlaybackState is MediaPlaybackState.Paused or MediaPlaybackState.Buffering;
-                if (shouldUpdate || paused || shouldOverride)
-                {
-                    SetPlayerPosition(newPosition, true);
-                }
+                SetPlayerPosition(newPosition, true);
             }
-
-            UpdateLastPosition(newPosition);
         }
 
-        private void RestoreLastPosition(MediaViewModel media)
+        UpdateLastPosition(newPosition);
+    }
+
+    private void RestoreLastPosition(MediaViewModel media)
+    {
+        TimeSpan lastPosition = _lastPositionTracker.GetPosition(media.Location);
+        if (lastPosition <= TimeSpan.Zero) return;
+        if (_settingsService.RestorePlaybackPosition)
         {
-            TimeSpan lastPosition = _lastPositionTracker.GetPosition(media.Location);
-            if (lastPosition <= TimeSpan.Zero) return;
-            if (_settingsService.RestorePlaybackPosition)
+            if (media.IsPlaying ?? false)
             {
-                if (media.IsPlaying ?? false)
-                {
-                    _dispatcherQueue.TryEnqueue(DispatcherQueuePriority.Low, () => SetPlayerPosition(lastPosition, false));
-                    _lastTrackedPosition = TimeSpan.Zero;
-                }
-                else
-                {
-                    // Media is not seekable yet, so we need to wait for the PlaybackStateChanged event
-                    _lastTrackedPosition = lastPosition;
-                }
+                _dispatcherQueue.TryEnqueue(DispatcherQueuePriority.Low, () => SetPlayerPosition(lastPosition, false));
+                _lastTrackedPosition = TimeSpan.Zero;
             }
             else
             {
-                Messenger.Send(new RaiseResumePositionNotificationMessage(lastPosition));
+                // Media is not seekable yet, so we need to wait for the PlaybackStateChanged event
+                _lastTrackedPosition = lastPosition;
             }
         }
+        else
+        {
+            Messenger.Send(new RaiseResumePositionNotificationMessage(lastPosition));
+        }
+    }
+
+    private PositionChangedResult UpdatePosition(TimeSpan position, bool isOffset, bool debounce)
+    {
+        TimeSpan currentPosition = Position;
+        _originalPositionTimer.Debounce(() => _originalPosition = currentPosition, TimeSpan.FromSeconds(1), true);
 
-        private PositionChangedResult UpdatePosition(TimeSpan position, bool isOffset, bool debounce)
+        // Assume UI thread
+        Position = isOffset ? (currentPosition + position) switch
         {
-            TimeSpan currentPosition = Position;
-            _originalPositionTimer.Debounce(() => _originalPosition = currentPosition, TimeSpan.FromSeconds(1), true);
+            var newPosition when newPosition < TimeSpan.Zero => TimeSpan.Zero,
+            var newPosition when newPosition > NaturalDuration => NaturalDuration,
+            var newPosition => newPosition
+        } : position;
+        SetPlayerPosition(Position, debounce);
 
-            // Assume UI thread
-            Position = isOffset ? (currentPosition + position) switch
-            {
-                var newPosition when newPosition < TimeSpan.Zero => TimeSpan.Zero,
-                var newPosition when newPosition > NaturalDuration => NaturalDuration,
-                var newPosition => newPosition
-            } : position;
-            SetPlayerPosition(Position, debounce);
+        return new PositionChangedResult(currentPosition, Position, _originalPosition, NaturalDuration);
+    }
 
-            return new PositionChangedResult(currentPosition, Position, _originalPosition, NaturalDuration);
+    private void SetPlayerPosition(TimeSpan position, bool debounce)
+    {
+        if (!IsSeekable || MediaPlayer == null) return;
+        if (debounce)
+        {
+            _seekTimer.Debounce(() => MediaPlayer.Position = position, TimeSpan.FromMilliseconds(50));
         }
-
-        private void SetPlayerPosition(TimeSpan position, bool debounce)
+        else
         {
-            if (!IsSeekable || MediaPlayer == null) return;
-            if (debounce)
-            {
-                _seekTimer.Debounce(() => MediaPlayer.Position = position, TimeSpan.FromMilliseconds(50));
-            }
-            else
-            {
-                _seekTimer.Stop();
-                MediaPlayer.Position = position;
-            }
+            _seekTimer.Stop();
+            MediaPlayer.Position = position;
         }
+    }
+
+    private void OnCanSeekChanged(IMediaPlayer sender, EventArgs args)
+    {
+        _dispatcherQueue.TryEnqueue(() =>
+        {
+            IsSeekable = sender.CanSeek;
+        });
+    }
 
-        private void OnCanSeekChanged(IMediaPlayer sender, EventArgs args)
+    private void OnPlaybackStateChanged(IMediaPlayer sender, ValueChangedEventArgs<MediaPlaybackState> args)
+    {
+        if (args.NewValue is not (MediaPlaybackState.None or MediaPlaybackState.Opening) &&
+            _lastTrackedPosition > TimeSpan.Zero)
         {
-            _dispatcherQueue.TryEnqueue(() =>
+            _dispatcherQueue.TryEnqueue(DispatcherQueuePriority.Low, () =>
             {
-                IsSeekable = sender.CanSeek;
+                SetPlayerPosition(_lastTrackedPosition, false);
+                _lastTrackedPosition = TimeSpan.Zero;
             });
         }
+    }
 
-        private void OnPlaybackStateChanged(IMediaPlayer sender, ValueChangedEventArgs<MediaPlaybackState> args)
+    private void OnPlaybackItemChanged(IMediaPlayer sender, object? args)
+    {
+        _seekTimer.Stop();
+        if (sender.PlaybackItem == null)
         {
-            if (args.NewValue is not (MediaPlaybackState.None or MediaPlaybackState.Opening) &&
-                _lastTrackedPosition > TimeSpan.Zero)
+            _dispatcherQueue.TryEnqueue(() =>
             {
-                _dispatcherQueue.TryEnqueue(DispatcherQueuePriority.Low, () =>
-                {
-                    SetPlayerPosition(_lastTrackedPosition, false);
-                    _lastTrackedPosition = TimeSpan.Zero;
-                });
-            }
+                IsSeekable = false;
+                Time = 0;
+                Chapters.Clear();
+            });
         }
-
-        private void OnPlaybackItemChanged(IMediaPlayer sender, object? args)
+        else
         {
-            _seekTimer.Stop();
-            if (sender.PlaybackItem == null)
-            {
-                _dispatcherQueue.TryEnqueue(() =>
-                {
-                    IsSeekable = false;
-                    Time = 0;
-                    Chapters.Clear();
-                });
-            }
-            else
+            _dispatcherQueue.TryEnqueue(() =>
             {
-                _dispatcherQueue.TryEnqueue(() =>
-                {
-                    Time = 0;
-                    Chapters.Clear();
-                });
-            }
+                Time = 0;
+                Chapters.Clear();
+            });
         }
+    }
 
-        private void OnBufferingEnded(IMediaPlayer sender, object? args)
-        {
-            _bufferingTimer.Stop();
-            _dispatcherQueue.TryEnqueue(() => BufferingVisible = false);
-        }
+    private void OnBufferingEnded(IMediaPlayer sender, object? args)
+    {
+        _bufferingTimer.Stop();
+        _dispatcherQueue.TryEnqueue(() => BufferingVisible = false);
+    }
 
-        private void OnBufferingStarted(IMediaPlayer sender, object? args)
+    private void OnBufferingStarted(IMediaPlayer sender, object? args)
+    {
+        // When the player is paused, the following still triggers a buffering
+        if (sender.Position == sender.NaturalDuration)
+            return;
+
+        // Only show buffering if it takes more than 0.5s
+        _bufferingTimer.Debounce(() => BufferingVisible = true, TimeSpan.FromSeconds(0.5));
+    }
+
+    private void OnPositionChanged(IMediaPlayer sender, object? args)
+    {
+        if (_seekTimer.IsRunning || _timeChangeOverride) return;
+        _dispatcherQueue.TryEnqueue(() =>
         {
-            // When the player is paused, the following still triggers a buffering
-            if (sender.Position == sender.NaturalDuration)
-                return;
+            Time = sender.Position.TotalMilliseconds;
+        });
+    }
 
-            // Only show buffering if it takes more than 0.5s
-            _bufferingTimer.Debounce(() => BufferingVisible = true, TimeSpan.FromSeconds(0.5));
-        }
+    private void OnNaturalDurationChanged(IMediaPlayer sender, object? args)
+    {
+        // Natural duration can fluctuate during playback
+        // Do not rely on this event to detect media changes
+        _dispatcherQueue.TryEnqueue(() =>
+        {
+            Length = sender.NaturalDuration.TotalMilliseconds;
+            IsSeekable = sender.CanSeek;
+            UpdateChapters(sender.PlaybackItem?.Chapters);
+        });
+    }
 
-        private void OnPositionChanged(IMediaPlayer sender, object? args)
+    private void OnEndReached(IMediaPlayer sender, object? args)
+    {
+        if (!_timeChangeOverride)
         {
-            if (_seekTimer.IsRunning || _timeChangeOverride) return;
             _dispatcherQueue.TryEnqueue(() =>
             {
-                Time = sender.Position.TotalMilliseconds;
+                // Check if Time is close enough to Length. Sometimes a new file is already loaded at this point.
+                if (Length - Time is > 0 and < 400)
+                {
+                    // Round Time to Length to avoid gap at the end
+                    Time = Length;
+                }
             });
         }
+    }
 
-        private void OnNaturalDurationChanged(IMediaPlayer sender, object? args)
+    private void UpdateChapters(PlaybackChapterList? chapterList)
+    {
+        Chapters.Clear();
+        if (chapterList == null) return;
+        if (MediaPlayer != null)
         {
-            // Natural duration can fluctuate during playback
-            // Do not rely on this event to detect media changes
-            _dispatcherQueue.TryEnqueue(() =>
-            {
-                Length = sender.NaturalDuration.TotalMilliseconds;
-                IsSeekable = sender.CanSeek;
-                UpdateChapters(sender.PlaybackItem?.Chapters);
-            });
+            chapterList.Load(MediaPlayer);
         }
 
-        private void OnEndReached(IMediaPlayer sender, object? args)
+        foreach (ChapterCue chapterCue in chapterList)
         {
-            if (!_timeChangeOverride)
-            {
-                _dispatcherQueue.TryEnqueue(() =>
-                {
-                    // Check if Time is close enough to Length. Sometimes a new file is already loaded at this point.
-                    if (Length - Time is > 0 and < 400)
-                    {
-                        // Round Time to Length to avoid gap at the end
-                        Time = Length;
-                    }
-                });
-            }
+            Chapters.Add(chapterCue);
         }
+        // Chapters.SyncItems(chapterList);
+    }
 
-        private void UpdateChapters(PlaybackChapterList? chapterList)
-        {
-            Chapters.Clear();
-            if (chapterList == null) return;
-            if (MediaPlayer != null)
-            {
-                chapterList.Load(MediaPlayer);
-            }
+    private void UpdateLastPosition(TimeSpan position)
+    {
+        if (!_settingsService.SavePlaybackPosition ||
+            _currentItem == null || NaturalDuration <= TimeSpan.FromMinutes(1) ||
+            DateTimeOffset.Now - _lastPositionTracker.LastUpdated <= TimeSpan.FromSeconds(3))
+            return;
 
-            foreach (ChapterCue chapterCue in chapterList)
-            {
-                Chapters.Add(chapterCue);
-            }
-            // Chapters.SyncItems(chapterList);
+        if (position > TimeSpan.FromSeconds(30) && position + TimeSpan.FromSeconds(10) < NaturalDuration)
+        {
+            _lastPositionTracker.UpdateLastPosition(_currentItem.Location, position);
         }
-
-        private void UpdateLastPosition(TimeSpan position)
+        else if (position > TimeSpan.FromSeconds(5))
         {
-            if (!_settingsService.SavePlaybackPosition ||
-                _currentItem == null || NaturalDuration <= TimeSpan.FromMinutes(1) ||
-                DateTimeOffset.Now - _lastPositionTracker.LastUpdated <= TimeSpan.FromSeconds(3))
-                return;
-
-            if (position > TimeSpan.FromSeconds(30) && position + TimeSpan.FromSeconds(10) < NaturalDuration)
-            {
-                _lastPositionTracker.UpdateLastPosition(_currentItem.Location, position);
-            }
-            else if (position > TimeSpan.FromSeconds(5))
-            {
-                _lastPositionTracker.RemovePosition(_currentItem.Location);
-            }
+            _lastPositionTracker.RemovePosition(_currentItem.Location);
         }
     }
 }

From 06c50cd256dcb912ed6fe98c52a01679cc8d3c1c Mon Sep 17 00:00:00 2001
From: Tung Huynh <31434093+huynhsontung@users.noreply.github.com>
Date: Sun, 25 Jan 2026 16:19:24 -0800
Subject: [PATCH 5/9] format SettingsService

---
 Screenbox.Core/Services/ISettingsService.cs |  53 ++-
 Screenbox.Core/Services/SettingsService.cs  | 391 ++++++++++----------
 2 files changed, 221 insertions(+), 223 deletions(-)

diff --git a/Screenbox.Core/Services/ISettingsService.cs b/Screenbox.Core/Services/ISettingsService.cs
index 430055b8c..1d9a8ba99 100644
--- a/Screenbox.Core/Services/ISettingsService.cs
+++ b/Screenbox.Core/Services/ISettingsService.cs
@@ -1,32 +1,31 @@
 using Screenbox.Core.Enums;
 using Windows.Media;
 
-namespace Screenbox.Core.Services
+namespace Screenbox.Core.Services;
+
+public interface ISettingsService
 {
-    public interface ISettingsService
-    {
-        PlayerAutoResizeOption PlayerAutoResize { get; set; }
-        bool UseIndexer { get; set; }
-        bool PlayerVolumeGesture { get; set; }
-        bool PlayerSeekGesture { get; set; }
-        bool PlayerTapGesture { get; set; }
-        bool PlayerShowControls { get; set; }
-        bool PlayerShowChapters { get; set; }
-        int PlayerControlsHideDelay { get; set; }
-        int PersistentVolume { get; set; }
-        string PersistentSubtitleLanguage { get; set; }
-        bool ShowRecent { get; set; }
-        ThemeOption Theme { get; set; }
-        bool EnqueueAllFilesInFolder { get; set; }
-        bool RestorePlaybackPosition { get; set; }
-        bool SearchRemovableStorage { get; set; }
-        int MaxVolume { get; set; }
-        string GlobalArguments { get; set; }
-        bool AdvancedMode { get; set; }
-        VideoUpscaleOption VideoUpscale { get; set; }
-        bool UseMultipleInstances { get; set; }
-        string LivelyActivePath { get; set; }
-        MediaPlaybackAutoRepeatMode PersistentRepeatMode { get; set; }
-        bool SavePlaybackPosition { get; set; }
-    }
+    PlayerAutoResizeOption PlayerAutoResize { get; set; }
+    bool UseIndexer { get; set; }
+    bool PlayerVolumeGesture { get; set; }
+    bool PlayerSeekGesture { get; set; }
+    bool PlayerTapGesture { get; set; }
+    bool PlayerShowControls { get; set; }
+    bool PlayerShowChapters { get; set; }
+    int PlayerControlsHideDelay { get; set; }
+    int PersistentVolume { get; set; }
+    string PersistentSubtitleLanguage { get; set; }
+    bool ShowRecent { get; set; }
+    ThemeOption Theme { get; set; }
+    bool EnqueueAllFilesInFolder { get; set; }
+    bool RestorePlaybackPosition { get; set; }
+    bool SearchRemovableStorage { get; set; }
+    int MaxVolume { get; set; }
+    string GlobalArguments { get; set; }
+    bool AdvancedMode { get; set; }
+    VideoUpscaleOption VideoUpscale { get; set; }
+    bool UseMultipleInstances { get; set; }
+    string LivelyActivePath { get; set; }
+    MediaPlaybackAutoRepeatMode PersistentRepeatMode { get; set; }
+    bool SavePlaybackPosition { get; set; }
 }
diff --git a/Screenbox.Core/Services/SettingsService.cs b/Screenbox.Core/Services/SettingsService.cs
index 63378387e..9a791c844 100644
--- a/Screenbox.Core/Services/SettingsService.cs
+++ b/Screenbox.Core/Services/SettingsService.cs
@@ -8,232 +8,231 @@
 using Windows.Media;
 using Windows.Storage;
 
-namespace Screenbox.Core.Services
+namespace Screenbox.Core.Services;
+
+public sealed class SettingsService : ISettingsService
 {
-    public sealed class SettingsService : ISettingsService
-    {
-        private static IPropertySet SettingsStorage => ApplicationData.Current.LocalSettings.Values;
-
-        private const string GeneralThemeKey = "General/Theme";
-        private const string PlayerAutoResizeKey = "Player/AutoResize";
-        private const string PlayerVolumeGestureKey = "Player/Gesture/Volume";
-        private const string PlayerSeekGestureKey = "Player/Gesture/Seek";
-        private const string PlayerTapGestureKey = "Player/Gesture/Tap";
-        private const string PlayerShowControlsKey = "Player/ShowControls";
-        private const string PlayerControlsHideDelayKey = "Player/ControlsHideDelay";
-        private const string PlayerLivelyPathKey = "Player/Lively/Path";
-        private const string LibrariesUseIndexerKey = "Libraries/UseIndexer";
-        private const string LibrariesSearchRemovableStorageKey = "Libraries/SearchRemovableStorage";
-        private const string GeneralShowRecent = "General/ShowRecent";
-        private const string GeneralEnqueueAllInFolder = "General/EnqueueAllInFolder";
-        private const string GeneralRestorePlaybackPosition = "General/RestorePlaybackPosition";
-        private const string AdvancedModeKey = "Advanced/IsEnabled";
-        private const string AdvancedVideoUpscaleKey = "Advanced/VideoUpscale";
-        private const string AdvancedMultipleInstancesKey = "Advanced/MultipleInstances";
-        private const string GlobalArgumentsKey = "Values/GlobalArguments";
-        private const string PersistentVolumeKey = "Values/Volume";
-        private const string MaxVolumeKey = "Values/MaxVolume";
-        private const string PersistentRepeatModeKey = "Values/RepeatMode";
-        private const string PersistentSubtitleLanguageKey = "Values/SubtitleLanguage";
-        private const string PlayerShowChaptersKey = "Player/ShowChapters";
-        private const string PrivacySavePlaybackPosition = "Privacy/SavePlaybackPosition";
-
-        public bool UseIndexer
-        {
-            get => GetValue<bool>(LibrariesUseIndexerKey);
-            set => SetValue(LibrariesUseIndexerKey, value);
-        }
+    private static IPropertySet SettingsStorage => ApplicationData.Current.LocalSettings.Values;
+
+    private const string GeneralThemeKey = "General/Theme";
+    private const string PlayerAutoResizeKey = "Player/AutoResize";
+    private const string PlayerVolumeGestureKey = "Player/Gesture/Volume";
+    private const string PlayerSeekGestureKey = "Player/Gesture/Seek";
+    private const string PlayerTapGestureKey = "Player/Gesture/Tap";
+    private const string PlayerShowControlsKey = "Player/ShowControls";
+    private const string PlayerControlsHideDelayKey = "Player/ControlsHideDelay";
+    private const string PlayerLivelyPathKey = "Player/Lively/Path";
+    private const string LibrariesUseIndexerKey = "Libraries/UseIndexer";
+    private const string LibrariesSearchRemovableStorageKey = "Libraries/SearchRemovableStorage";
+    private const string GeneralShowRecent = "General/ShowRecent";
+    private const string GeneralEnqueueAllInFolder = "General/EnqueueAllInFolder";
+    private const string GeneralRestorePlaybackPosition = "General/RestorePlaybackPosition";
+    private const string AdvancedModeKey = "Advanced/IsEnabled";
+    private const string AdvancedVideoUpscaleKey = "Advanced/VideoUpscale";
+    private const string AdvancedMultipleInstancesKey = "Advanced/MultipleInstances";
+    private const string GlobalArgumentsKey = "Values/GlobalArguments";
+    private const string PersistentVolumeKey = "Values/Volume";
+    private const string MaxVolumeKey = "Values/MaxVolume";
+    private const string PersistentRepeatModeKey = "Values/RepeatMode";
+    private const string PersistentSubtitleLanguageKey = "Values/SubtitleLanguage";
+    private const string PlayerShowChaptersKey = "Player/ShowChapters";
+    private const string PrivacySavePlaybackPosition = "Privacy/SavePlaybackPosition";
+
+    public bool UseIndexer
+    {
+        get => GetValue<bool>(LibrariesUseIndexerKey);
+        set => SetValue(LibrariesUseIndexerKey, value);
+    }
 
-        public ThemeOption Theme
-        {
-            get => (ThemeOption)GetValue<int>(GeneralThemeKey);
-            set => SetValue(GeneralThemeKey, (int)value);
-        }
+    public ThemeOption Theme
+    {
+        get => (ThemeOption)GetValue<int>(GeneralThemeKey);
+        set => SetValue(GeneralThemeKey, (int)value);
+    }
 
-        public PlayerAutoResizeOption PlayerAutoResize
-        {
-            get => (PlayerAutoResizeOption)GetValue<int>(PlayerAutoResizeKey);
-            set => SetValue(PlayerAutoResizeKey, (int)value);
-        }
+    public PlayerAutoResizeOption PlayerAutoResize
+    {
+        get => (PlayerAutoResizeOption)GetValue<int>(PlayerAutoResizeKey);
+        set => SetValue(PlayerAutoResizeKey, (int)value);
+    }
 
-        public bool PlayerVolumeGesture
-        {
-            get => GetValue<bool>(PlayerVolumeGestureKey);
-            set => SetValue(PlayerVolumeGestureKey, value);
-        }
+    public bool PlayerVolumeGesture
+    {
+        get => GetValue<bool>(PlayerVolumeGestureKey);
+        set => SetValue(PlayerVolumeGestureKey, value);
+    }
 
-        public bool PlayerSeekGesture
-        {
-            get => GetValue<bool>(PlayerSeekGestureKey);
-            set => SetValue(PlayerSeekGestureKey, value);
-        }
+    public bool PlayerSeekGesture
+    {
+        get => GetValue<bool>(PlayerSeekGestureKey);
+        set => SetValue(PlayerSeekGestureKey, value);
+    }
 
-        public bool PlayerTapGesture
-        {
-            get => GetValue<bool>(PlayerTapGestureKey);
-            set => SetValue(PlayerTapGestureKey, value);
-        }
+    public bool PlayerTapGesture
+    {
+        get => GetValue<bool>(PlayerTapGestureKey);
+        set => SetValue(PlayerTapGestureKey, value);
+    }
 
-        public int PersistentVolume
-        {
-            get => GetValue<int>(PersistentVolumeKey);
-            set => SetValue(PersistentVolumeKey, value);
-        }
+    public int PersistentVolume
+    {
+        get => GetValue<int>(PersistentVolumeKey);
+        set => SetValue(PersistentVolumeKey, value);
+    }
 
-        public string PersistentSubtitleLanguage
-        {
-            get => GetValue<string>(PersistentSubtitleLanguageKey) ?? string.Empty;
-            set => SetValue(PersistentSubtitleLanguageKey, value);
-        }
+    public string PersistentSubtitleLanguage
+    {
+        get => GetValue<string>(PersistentSubtitleLanguageKey) ?? string.Empty;
+        set => SetValue(PersistentSubtitleLanguageKey, value);
+    }
 
-        public int MaxVolume
-        {
-            get => GetValue<int>(MaxVolumeKey);
-            set => SetValue(MaxVolumeKey, value);
-        }
+    public int MaxVolume
+    {
+        get => GetValue<int>(MaxVolumeKey);
+        set => SetValue(MaxVolumeKey, value);
+    }
 
-        public bool ShowRecent
-        {
-            get => GetValue<bool>(GeneralShowRecent);
-            set => SetValue(GeneralShowRecent, value);
-        }
+    public bool ShowRecent
+    {
+        get => GetValue<bool>(GeneralShowRecent);
+        set => SetValue(GeneralShowRecent, value);
+    }
 
-        public bool EnqueueAllFilesInFolder
-        {
-            get => GetValue<bool>(GeneralEnqueueAllInFolder);
-            set => SetValue(GeneralEnqueueAllInFolder, value);
-        }
+    public bool EnqueueAllFilesInFolder
+    {
+        get => GetValue<bool>(GeneralEnqueueAllInFolder);
+        set => SetValue(GeneralEnqueueAllInFolder, value);
+    }
 
-        public bool RestorePlaybackPosition
-        {
-            get => GetValue<bool>(GeneralRestorePlaybackPosition);
-            set => SetValue(GeneralRestorePlaybackPosition, value);
-        }
+    public bool RestorePlaybackPosition
+    {
+        get => GetValue<bool>(GeneralRestorePlaybackPosition);
+        set => SetValue(GeneralRestorePlaybackPosition, value);
+    }
 
-        public bool PlayerShowControls
-        {
-            get => GetValue<bool>(PlayerShowControlsKey);
-            set => SetValue(PlayerShowControlsKey, value);
-        }
+    public bool PlayerShowControls
+    {
+        get => GetValue<bool>(PlayerShowControlsKey);
+        set => SetValue(PlayerShowControlsKey, value);
+    }
 
-        public int PlayerControlsHideDelay
-        {
-            get => GetValue<int>(PlayerControlsHideDelayKey);
-            set => SetValue(PlayerControlsHideDelayKey, value);
-        }
+    public int PlayerControlsHideDelay
+    {
+        get => GetValue<int>(PlayerControlsHideDelayKey);
+        set => SetValue(PlayerControlsHideDelayKey, value);
+    }
 
-        public bool SearchRemovableStorage
-        {
-            get => GetValue<bool>(LibrariesSearchRemovableStorageKey);
-            set => SetValue(LibrariesSearchRemovableStorageKey, value);
-        }
+    public bool SearchRemovableStorage
+    {
+        get => GetValue<bool>(LibrariesSearchRemovableStorageKey);
+        set => SetValue(LibrariesSearchRemovableStorageKey, value);
+    }
 
-        public MediaPlaybackAutoRepeatMode PersistentRepeatMode
-        {
-            get => (MediaPlaybackAutoRepeatMode)GetValue<int>(PersistentRepeatModeKey);
-            set => SetValue(PersistentRepeatModeKey, (int)value);
-        }
+    public MediaPlaybackAutoRepeatMode PersistentRepeatMode
+    {
+        get => (MediaPlaybackAutoRepeatMode)GetValue<int>(PersistentRepeatModeKey);
+        set => SetValue(PersistentRepeatModeKey, (int)value);
+    }
 
-        public string GlobalArguments
-        {
-            get => GetValue<string>(GlobalArgumentsKey) ?? string.Empty;
-            set => SetValue(GlobalArgumentsKey, SanitizeArguments(value));
-        }
+    public string GlobalArguments
+    {
+        get => GetValue<string>(GlobalArgumentsKey) ?? string.Empty;
+        set => SetValue(GlobalArgumentsKey, SanitizeArguments(value));
+    }
 
-        public bool AdvancedMode
-        {
-            get => GetValue<bool>(AdvancedModeKey);
-            set => SetValue(AdvancedModeKey, value);
-        }
+    public bool AdvancedMode
+    {
+        get => GetValue<bool>(AdvancedModeKey);
+        set => SetValue(AdvancedModeKey, value);
+    }
 
-        public VideoUpscaleOption VideoUpscale
-        {
-            get => (VideoUpscaleOption)GetValue<int>(AdvancedVideoUpscaleKey);
-            set => SetValue(AdvancedVideoUpscaleKey, (int)value);
-        }
+    public VideoUpscaleOption VideoUpscale
+    {
+        get => (VideoUpscaleOption)GetValue<int>(AdvancedVideoUpscaleKey);
+        set => SetValue(AdvancedVideoUpscaleKey, (int)value);
+    }
 
-        public bool UseMultipleInstances
-        {
-            get => GetValue<bool>(AdvancedMultipleInstancesKey);
-            set => SetValue(AdvancedMultipleInstancesKey, value);
-        }
+    public bool UseMultipleInstances
+    {
+        get => GetValue<bool>(AdvancedMultipleInstancesKey);
+        set => SetValue(AdvancedMultipleInstancesKey, value);
+    }
 
-        public string LivelyActivePath
-        {
-            get => GetValue<string>(PlayerLivelyPathKey) ?? string.Empty;
-            set => SetValue(PlayerLivelyPathKey, value);
-        }
+    public string LivelyActivePath
+    {
+        get => GetValue<string>(PlayerLivelyPathKey) ?? string.Empty;
+        set => SetValue(PlayerLivelyPathKey, value);
+    }
 
-        public bool PlayerShowChapters
-        {
-            get => GetValue<bool>(PlayerShowChaptersKey);
-            set => SetValue(PlayerShowChaptersKey, value);
-        }
+    public bool PlayerShowChapters
+    {
+        get => GetValue<bool>(PlayerShowChaptersKey);
+        set => SetValue(PlayerShowChaptersKey, value);
+    }
 
-        public bool SavePlaybackPosition
-        {
-            get => GetValue<bool>(PrivacySavePlaybackPosition);
-            set => SetValue(PrivacySavePlaybackPosition, value);
-        }
+    public bool SavePlaybackPosition
+    {
+        get => GetValue<bool>(PrivacySavePlaybackPosition);
+        set => SetValue(PrivacySavePlaybackPosition, value);
+    }
 
-        public SettingsService()
-        {
-            SetDefault(PlayerAutoResizeKey, (int)PlayerAutoResizeOption.Never);
-            SetDefault(PlayerVolumeGestureKey, true);
-            SetDefault(PlayerSeekGestureKey, true);
-            SetDefault(PlayerTapGestureKey, true);
-            SetDefault(PlayerShowControlsKey, true);
-            SetDefault(PlayerControlsHideDelayKey, 3);
-            SetDefault(PersistentVolumeKey, 100);
-            SetDefault(MaxVolumeKey, 100);
-            SetDefault(LibrariesUseIndexerKey, true);
-            SetDefault(LibrariesSearchRemovableStorageKey, true);
-            SetDefault(GeneralShowRecent, true);
-            SetDefault(PersistentRepeatModeKey, (int)MediaPlaybackAutoRepeatMode.None);
-            SetDefault(AdvancedModeKey, false);
-            SetDefault(AdvancedVideoUpscaleKey, (int)VideoUpscaleOption.Linear);
-            SetDefault(AdvancedMultipleInstancesKey, false);
-            SetDefault(GlobalArgumentsKey, string.Empty);
-            SetDefault(PlayerShowChaptersKey, true);
-            SetDefault(PrivacySavePlaybackPosition, true);
-
-            // Device family specific overrides
-            if (SystemInformation.IsXbox)
-            {
-                SetValue(PlayerTapGestureKey, false);
-                SetValue(PlayerSeekGestureKey, false);
-                SetValue(PlayerVolumeGestureKey, false);
-                SetValue(PlayerAutoResizeKey, (int)PlayerAutoResizeOption.Never);
-                SetValue(PlayerShowControlsKey, true);
-            }
+    public SettingsService()
+    {
+        SetDefault(PlayerAutoResizeKey, (int)PlayerAutoResizeOption.Never);
+        SetDefault(PlayerVolumeGestureKey, true);
+        SetDefault(PlayerSeekGestureKey, true);
+        SetDefault(PlayerTapGestureKey, true);
+        SetDefault(PlayerShowControlsKey, true);
+        SetDefault(PlayerControlsHideDelayKey, 3);
+        SetDefault(PersistentVolumeKey, 100);
+        SetDefault(MaxVolumeKey, 100);
+        SetDefault(LibrariesUseIndexerKey, true);
+        SetDefault(LibrariesSearchRemovableStorageKey, true);
+        SetDefault(GeneralShowRecent, true);
+        SetDefault(PersistentRepeatModeKey, (int)MediaPlaybackAutoRepeatMode.None);
+        SetDefault(AdvancedModeKey, false);
+        SetDefault(AdvancedVideoUpscaleKey, (int)VideoUpscaleOption.Linear);
+        SetDefault(AdvancedMultipleInstancesKey, false);
+        SetDefault(GlobalArgumentsKey, string.Empty);
+        SetDefault(PlayerShowChaptersKey, true);
+        SetDefault(PrivacySavePlaybackPosition, true);
+
+        // Device family specific overrides
+        if (SystemInformation.IsXbox)
+        {
+            SetValue(PlayerTapGestureKey, false);
+            SetValue(PlayerSeekGestureKey, false);
+            SetValue(PlayerVolumeGestureKey, false);
+            SetValue(PlayerAutoResizeKey, (int)PlayerAutoResizeOption.Never);
+            SetValue(PlayerShowControlsKey, true);
         }
+    }
 
-        private static T? GetValue<T>(string key)
+    private static T? GetValue<T>(string key)
+    {
+        if (SettingsStorage.TryGetValue(key, out object value))
         {
-            if (SettingsStorage.TryGetValue(key, out object value))
-            {
-                return (T)value;
-            }
-
-            return default;
+            return (T)value;
         }
 
-        private static void SetValue<T>(string key, T value)
-        {
-            SettingsStorage[key] = value;
-        }
+        return default;
+    }
 
-        private static void SetDefault<T>(string key, T value)
-        {
-            if (SettingsStorage.ContainsKey(key) && SettingsStorage[key] is T) return;
-            SettingsStorage[key] = value;
-        }
+    private static void SetValue<T>(string key, T value)
+    {
+        SettingsStorage[key] = value;
+    }
 
-        private static string SanitizeArguments(string raw)
-        {
-            string[] args = raw.Trim().Split(' ', StringSplitOptions.RemoveEmptyEntries)
-                .Where(s => s.StartsWith('-') && s != "--").ToArray();
-            return string.Join(' ', args);
-        }
+    private static void SetDefault<T>(string key, T value)
+    {
+        if (SettingsStorage.ContainsKey(key) && SettingsStorage[key] is T) return;
+        SettingsStorage[key] = value;
+    }
+
+    private static string SanitizeArguments(string raw)
+    {
+        string[] args = raw.Trim().Split(' ', StringSplitOptions.RemoveEmptyEntries)
+            .Where(s => s.StartsWith('-') && s != "--").ToArray();
+        return string.Join(' ', args);
     }
 }

From 5c212a0cca9e238a5db06a57708bd2f74211d843 Mon Sep 17 00:00:00 2001
From: Tung Huynh <31434093+huynhsontung@users.noreply.github.com>
Date: Sun, 25 Jan 2026 16:21:57 -0800
Subject: [PATCH 6/9] offload adding to recent to MediaListViewModel

---
 Screenbox.Core/Services/FilesService.cs       | 345 +++++++++---------
 .../ViewModels/MediaListViewModel.cs          |   2 +-
 2 files changed, 168 insertions(+), 179 deletions(-)

diff --git a/Screenbox.Core/Services/FilesService.cs b/Screenbox.Core/Services/FilesService.cs
index b2aa2f56f..be6e487a0 100644
--- a/Screenbox.Core/Services/FilesService.cs
+++ b/Screenbox.Core/Services/FilesService.cs
@@ -1,14 +1,14 @@
 #nullable enable
 
-using ProtoBuf;
-using Screenbox.Core.Enums;
-using Screenbox.Core.Helpers;
-using Screenbox.Core.Models;
 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
+using ProtoBuf;
+using Screenbox.Core.Enums;
+using Screenbox.Core.Helpers;
+using Screenbox.Core.Models;
 using Windows.Foundation;
 using Windows.Storage;
 using Windows.Storage.AccessCache;
@@ -17,222 +17,211 @@
 using Windows.Storage.Search;
 using Windows.System;
 
-namespace Screenbox.Core.Services
+namespace Screenbox.Core.Services;
+
+public sealed class FilesService : IFilesService
 {
-    public sealed class FilesService : IFilesService
+    public async Task<StorageFileQueryResult?> GetNeighboringFilesQueryAsync(StorageFile file, QueryOptions? options = null)
     {
-        private readonly ISettingsService _settingsService;
-
-        public FilesService(ISettingsService settingsService)
+        try
         {
-            _settingsService = settingsService;
+            StorageFolder? parent = await file.GetParentAsync();
+            options ??= new QueryOptions(CommonFileQuery.DefaultQuery, FilesHelpers.SupportedFormats);
+            StorageFileQueryResult? queryResult = parent?.CreateFileQueryWithOptions(options);
+            return queryResult;
         }
-
-        public async Task<StorageFileQueryResult?> GetNeighboringFilesQueryAsync(StorageFile file, QueryOptions? options = null)
+        catch (Exception)
         {
-            try
-            {
-                StorageFolder? parent = await file.GetParentAsync();
-                options ??= new QueryOptions(CommonFileQuery.DefaultQuery, FilesHelpers.SupportedFormats);
-                StorageFileQueryResult? queryResult = parent?.CreateFileQueryWithOptions(options);
-                return queryResult;
-            }
-            catch (Exception)
-            {
-                return null;
-            }
+            return null;
         }
+    }
 
-        public async Task<StorageFile?> GetNextFileAsync(IStorageFile currentFile, StorageFileQueryResult neighboringFilesQuery)
-        {
-            // Due to limitations with NeighboringFilesQuery, manually find the next supported file
-            uint startIndex = await neighboringFilesQuery.FindStartIndexAsync(currentFile);
-            if (startIndex == uint.MaxValue) return null;
-            startIndex += 1;
-
-            // The following line return a native vector view.
-            // It does not fetch all the files in the directory at once.
-            // No need for manual paging!
-            IReadOnlyList<StorageFile> files = await neighboringFilesQuery.GetFilesAsync(startIndex, uint.MaxValue);
-            return files.FirstOrDefault(x => x.IsSupported());
-        }
+    public async Task<StorageFile?> GetNextFileAsync(IStorageFile currentFile, StorageFileQueryResult neighboringFilesQuery)
+    {
+        // Due to limitations with NeighboringFilesQuery, manually find the next supported file
+        uint startIndex = await neighboringFilesQuery.FindStartIndexAsync(currentFile);
+        if (startIndex == uint.MaxValue) return null;
+        startIndex += 1;
+
+        // The following line return a native vector view.
+        // It does not fetch all the files in the directory at once.
+        // No need for manual paging!
+        IReadOnlyList<StorageFile> files = await neighboringFilesQuery.GetFilesAsync(startIndex, uint.MaxValue);
+        return files.FirstOrDefault(x => x.IsSupported());
+    }
 
-        public async Task<StorageFile?> GetPreviousFileAsync(IStorageFile currentFile, StorageFileQueryResult neighboringFilesQuery)
-        {
-            // Due to limitations with NeighboringFilesQuery, manually find the previous supported file
-            uint startIndex = await neighboringFilesQuery.FindStartIndexAsync(currentFile);
-            if (startIndex == uint.MaxValue) return null;
-
-            // The following line return a native vector view.
-            // It does not fetch all the files in the directory at once.
-            // No need for manual paging!
-            IReadOnlyList<StorageFile> files = await neighboringFilesQuery.GetFilesAsync(0, startIndex);
-            return files.LastOrDefault(x => x.IsSupported());
-        }
+    public async Task<StorageFile?> GetPreviousFileAsync(IStorageFile currentFile, StorageFileQueryResult neighboringFilesQuery)
+    {
+        // Due to limitations with NeighboringFilesQuery, manually find the previous supported file
+        uint startIndex = await neighboringFilesQuery.FindStartIndexAsync(currentFile);
+        if (startIndex == uint.MaxValue) return null;
+
+        // The following line return a native vector view.
+        // It does not fetch all the files in the directory at once.
+        // No need for manual paging!
+        IReadOnlyList<StorageFile> files = await neighboringFilesQuery.GetFilesAsync(0, startIndex);
+        return files.LastOrDefault(x => x.IsSupported());
+    }
 
-        public StorageItemQueryResult GetSupportedItems(StorageFolder folder)
-        {
-            // Don't use indexer when querying. Potential incomplete result.
-            QueryOptions queryOptions = new(CommonFileQuery.DefaultQuery, FilesHelpers.SupportedFormats);
-            return folder.CreateItemQueryWithOptions(queryOptions);
-        }
+    public StorageItemQueryResult GetSupportedItems(StorageFolder folder)
+    {
+        // Don't use indexer when querying. Potential incomplete result.
+        QueryOptions queryOptions = new(CommonFileQuery.DefaultQuery, FilesHelpers.SupportedFormats);
+        return folder.CreateItemQueryWithOptions(queryOptions);
+    }
 
-        public IAsyncOperation<uint> GetSupportedItemCountAsync(StorageFolder folder)
-        {
-            QueryOptions queryOptions = new(CommonFileQuery.DefaultQuery, FilesHelpers.SupportedFormats);
-            return folder.CreateItemQueryWithOptions(queryOptions).GetItemCountAsync();
-        }
+    public IAsyncOperation<uint> GetSupportedItemCountAsync(StorageFolder folder)
+    {
+        QueryOptions queryOptions = new(CommonFileQuery.DefaultQuery, FilesHelpers.SupportedFormats);
+        return folder.CreateItemQueryWithOptions(queryOptions).GetItemCountAsync();
+    }
+
+    public IAsyncOperation<StorageFile> PickFileAsync(params string[] formats)
+    {
+        FileOpenPicker picker = GetFilePickerForFormats(formats);
+        return picker.PickSingleFileAsync();
+    }
 
-        public IAsyncOperation<StorageFile> PickFileAsync(params string[] formats)
+    public IAsyncOperation<IReadOnlyList<StorageFile>> PickMultipleFilesAsync(params string[] formats)
+    {
+        FileOpenPicker picker = GetFilePickerForFormats(formats);
+        return picker.PickMultipleFilesAsync();
+    }
+
+    public IAsyncOperation<StorageFolder> PickFolderAsync()
+    {
+        FolderPicker picker = new()
         {
-            FileOpenPicker picker = GetFilePickerForFormats(formats);
-            return picker.PickSingleFileAsync();
-        }
+            SuggestedStartLocation = PickerLocationId.ComputerFolder
+        };
 
-        public IAsyncOperation<IReadOnlyList<StorageFile>> PickMultipleFilesAsync(params string[] formats)
+        foreach (string supportedFormat in FilesHelpers.SupportedFormats)
         {
-            FileOpenPicker picker = GetFilePickerForFormats(formats);
-            return picker.PickMultipleFilesAsync();
+            picker.FileTypeFilter.Add(supportedFormat);
         }
 
-        public IAsyncOperation<StorageFolder> PickFolderAsync()
-        {
-            FolderPicker picker = new()
-            {
-                SuggestedStartLocation = PickerLocationId.ComputerFolder
-            };
+        return picker.PickSingleFolderAsync();
+    }
 
-            foreach (string supportedFormat in FilesHelpers.SupportedFormats)
-            {
-                picker.FileTypeFilter.Add(supportedFormat);
-            }
+    public async Task<StorageFile> SaveToDiskAsync<T>(StorageFolder folder, string fileName, T source)
+    {
+        StorageFile file = await folder.CreateFileAsync(fileName, CreationCollisionOption.OpenIfExists);
+        await SaveToDiskAsync(file, source);
+        return file;
+    }
 
-            return picker.PickSingleFolderAsync();
-        }
+    public async Task SaveToDiskAsync<T>(StorageFile file, T source)
+    {
+        using var stream = await file.OpenStreamForWriteAsync();
+        // using var dataWriter = new StreamWriter(stream);
+        // using var jsonWriter = new JsonTextWriter(dataWriter);
+        // var serializer = JsonSerializer.Create();
+        // serializer.Serialize(jsonWriter, source);
+        Serializer.Serialize(stream, source);
+        stream.SetLength(stream.Position);  // A weird quirk of protobuf-net
+        await stream.FlushAsync();
+    }
 
-        public async Task<StorageFile> SaveToDiskAsync<T>(StorageFolder folder, string fileName, T source)
-        {
-            StorageFile file = await folder.CreateFileAsync(fileName, CreationCollisionOption.OpenIfExists);
-            await SaveToDiskAsync(file, source);
-            return file;
-        }
+    public async Task<T> LoadFromDiskAsync<T>(StorageFolder folder, string fileName)
+    {
+        StorageFile file = await folder.GetFileAsync(fileName);
+        return await LoadFromDiskAsync<T>(file);
+    }
+
+    public async Task<T> LoadFromDiskAsync<T>(StorageFile file)
+    {
+        using Stream readStream = await file.OpenStreamForReadAsync();
+        return Serializer.Deserialize<T>(readStream);
+        // using var dataReader = new StreamReader(readStream);
+        // using var jsonReader = new JsonTextReader(dataReader);
+        // var serializer = JsonSerializer.Create();
+        // return serializer.Deserialize<T>(jsonReader) ?? throw new NullReferenceException();
+    }
+
+    public async Task OpenFileLocationAsync(string path)
+    {
+        string? folderPath = Path.GetDirectoryName(path);
+        if (!string.IsNullOrEmpty(folderPath))
+            await Launcher.LaunchFolderPathAsync(folderPath);
+    }
 
-        public async Task SaveToDiskAsync<T>(StorageFile file, T source)
+    public async Task OpenFileLocationAsync(StorageFile file)
+    {
+        StorageFolder? folder = await file.GetParentAsync();
+        if (folder == null)
         {
-            using var stream = await file.OpenStreamForWriteAsync();
-            // using var dataWriter = new StreamWriter(stream);
-            // using var jsonWriter = new JsonTextWriter(dataWriter);
-            // var serializer = JsonSerializer.Create();
-            // serializer.Serialize(jsonWriter, source);
-            Serializer.Serialize(stream, source);
-            stream.SetLength(stream.Position);  // A weird quirk of protobuf-net
-            await stream.FlushAsync();
+            await OpenFileLocationAsync(file.Path);
         }
-
-        public async Task<T> LoadFromDiskAsync<T>(StorageFolder folder, string fileName)
+        else
         {
-            StorageFile file = await folder.GetFileAsync(fileName);
-            return await LoadFromDiskAsync<T>(file);
+            FolderLauncherOptions options = new();
+            options.ItemsToSelect.Add(file);
+            await Launcher.LaunchFolderAsync(folder, options);
         }
+    }
 
-        public async Task<T> LoadFromDiskAsync<T>(StorageFile file)
+    public void AddToRecent(IStorageItem item)
+    {
+        string metadata = DateTimeOffset.Now.ToUnixTimeSeconds().ToString();
+        try
         {
-            using Stream readStream = await file.OpenStreamForReadAsync();
-            return Serializer.Deserialize<T>(readStream);
-            // using var dataReader = new StreamReader(readStream);
-            // using var jsonReader = new JsonTextReader(dataReader);
-            // var serializer = JsonSerializer.Create();
-            // return serializer.Deserialize<T>(jsonReader) ?? throw new NullReferenceException();
+            StorageApplicationPermissions.MostRecentlyUsedList.Add(item, metadata);
         }
-
-        public async Task OpenFileLocationAsync(string path)
+        catch (Exception)
         {
-            string? folderPath = Path.GetDirectoryName(path);
-            if (!string.IsNullOrEmpty(folderPath))
-                await Launcher.LaunchFolderPathAsync(folderPath);
+            // System.Exception: Element not found. (Exception from HRESULT: 0x80070490)
+            // Ownership issue?
         }
+    }
+
+    public async Task<MediaInfo> GetMediaInfoAsync(StorageFile file)
+    {
+        MediaPlaybackType mediaType = FilesHelpers.GetMediaTypeForFile(file);
+        if (!file.IsAvailable) return new MediaInfo(mediaType);
 
-        public async Task OpenFileLocationAsync(StorageFile file)
+        try
         {
-            StorageFolder? folder = await file.GetParentAsync();
-            if (folder == null)
+            BasicProperties basicProperties = await file.GetBasicPropertiesAsync();
+            switch (mediaType)
             {
-                await OpenFileLocationAsync(file.Path);
-            }
-            else
-            {
-                FolderLauncherOptions options = new();
-                options.ItemsToSelect.Add(file);
-                await Launcher.LaunchFolderAsync(folder, options);
+                case MediaPlaybackType.Video:
+                    VideoProperties videoProperties = await file.Properties.GetVideoPropertiesAsync();
+                    return new MediaInfo(basicProperties, videoProperties);
+                case MediaPlaybackType.Music:
+                    MusicProperties musicProperties = await file.Properties.GetMusicPropertiesAsync();
+                    return new MediaInfo(basicProperties, musicProperties);
             }
         }
-
-        public void AddToRecent(IStorageItem item)
+        catch (Exception e)
         {
-            if (!_settingsService.ShowRecent)
-                return;
-
-            string metadata = DateTimeOffset.Now.ToUnixTimeSeconds().ToString();
-            try
-            {
-                StorageApplicationPermissions.MostRecentlyUsedList.Add(item, metadata);
-            }
-            catch (Exception)
-            {
-                // System.Exception: Element not found. (Exception from HRESULT: 0x80070490)
-                // Ownership issue?
-            }
+            // System.Exception: The RPC server is unavailable.
+            if (e.HResult != unchecked((int)0x800706BA))
+                LogService.Log(e);
         }
 
-        public async Task<MediaInfo> GetMediaInfoAsync(StorageFile file)
-        {
-            MediaPlaybackType mediaType = FilesHelpers.GetMediaTypeForFile(file);
-            if (!file.IsAvailable) return new MediaInfo(mediaType);
+        return new MediaInfo(mediaType);
+    }
 
-            try
-            {
-                BasicProperties basicProperties = await file.GetBasicPropertiesAsync();
-                switch (mediaType)
-                {
-                    case MediaPlaybackType.Video:
-                        VideoProperties videoProperties = await file.Properties.GetVideoPropertiesAsync();
-                        return new MediaInfo(basicProperties, videoProperties);
-                    case MediaPlaybackType.Music:
-                        MusicProperties musicProperties = await file.Properties.GetMusicPropertiesAsync();
-                        return new MediaInfo(basicProperties, musicProperties);
-                }
-            }
-            catch (Exception e)
-            {
-                // System.Exception: The RPC server is unavailable.
-                if (e.HResult != unchecked((int)0x800706BA))
-                    LogService.Log(e);
-            }
+    private FileOpenPicker GetFilePickerForFormats(IReadOnlyCollection<string> formats)
+    {
+        FileOpenPicker picker = new()
+        {
+            ViewMode = PickerViewMode.Thumbnail,
+            SuggestedStartLocation = PickerLocationId.ComputerFolder
+        };
 
-            return new MediaInfo(mediaType);
+        IEnumerable<string> fileTypes = formats;
+        if (formats.Count == 0)
+        {
+            fileTypes = FilesHelpers.SupportedFormats;
+            picker.FileTypeFilter.Add("*");
         }
 
-        private FileOpenPicker GetFilePickerForFormats(IReadOnlyCollection<string> formats)
+        foreach (string? fileType in fileTypes)
         {
-            FileOpenPicker picker = new()
-            {
-                ViewMode = PickerViewMode.Thumbnail,
-                SuggestedStartLocation = PickerLocationId.ComputerFolder
-            };
-
-            IEnumerable<string> fileTypes = formats;
-            if (formats.Count == 0)
-            {
-                fileTypes = FilesHelpers.SupportedFormats;
-                picker.FileTypeFilter.Add("*");
-            }
-
-            foreach (string? fileType in fileTypes)
-            {
-                picker.FileTypeFilter.Add(fileType);
-            }
-
-            return picker;
+            picker.FileTypeFilter.Add(fileType);
         }
+
+        return picker;
     }
 }
diff --git a/Screenbox.Core/ViewModels/MediaListViewModel.cs b/Screenbox.Core/ViewModels/MediaListViewModel.cs
index 365e12c0e..7a0f4f363 100644
--- a/Screenbox.Core/ViewModels/MediaListViewModel.cs
+++ b/Screenbox.Core/ViewModels/MediaListViewModel.cs
@@ -288,7 +288,7 @@ async partial void OnCurrentItemChanged(MediaViewModel? value)
 
         // Async updates
         await Task.WhenAll(
-            AddToRecent(value?.Source),
+            _settingsService.ShowRecent ? AddToRecent(value?.Source) : Task.CompletedTask,
             _transportControlsService.UpdateTransportControlsDisplayAsync(value),
             UpdateMediaBufferAsync()
         );

From 14f1474ec654caa002edbf0275d5553eaa75112d Mon Sep 17 00:00:00 2001
From: United600 <United600@users.noreply.github.com>
Date: Mon, 26 Jan 2026 18:37:44 +0000
Subject: [PATCH 7/9] refactor playback position persistence setting

---
 .../Controllers/LastPositionTracker.cs        | 35 +++++--------------
 Screenbox.Core/Services/ISettingsService.cs   |  7 +++-
 Screenbox.Core/Services/SettingsService.cs    | 10 +++---
 Screenbox.Core/ViewModels/SeekBarViewModel.cs |  4 ++-
 .../ViewModels/SettingsPageViewModel.cs       | 15 ++++----
 Screenbox/Pages/SettingsPage.xaml             | 20 +++--------
 6 files changed, 35 insertions(+), 56 deletions(-)

diff --git a/Screenbox.Core/Controllers/LastPositionTracker.cs b/Screenbox.Core/Controllers/LastPositionTracker.cs
index 3996b8a12..a52b5cb78 100644
--- a/Screenbox.Core/Controllers/LastPositionTracker.cs
+++ b/Screenbox.Core/Controllers/LastPositionTracker.cs
@@ -94,6 +94,14 @@ public void RemovePosition(string location)
         _removeCache = location;
     }
 
+    public void ClearAll()
+    {
+        LastUpdated = DateTimeOffset.Now;
+        _lastPositions.Clear();
+        _updateCache = null;
+        _removeCache = null;
+    }
+
     public async Task SaveToDiskAsync()
     {
         try
@@ -125,31 +133,4 @@ public async Task LoadFromDiskAsync()
             // pass
         }
     }
-
-    public async Task DeleteFromDiskAsync()
-    {
-        try
-        {
-            _lastPositions.Clear();
-            _updateCache = null;
-            _removeCache = null;
-            LastUpdated = default;
-
-            //await _filesService.SaveToDiskAsync(ApplicationData.Current.TemporaryFolder, SaveFileName, _lastPositions);
-
-            var folder = ApplicationData.Current.TemporaryFolder;
-            if (await folder.TryGetItemAsync(SaveFileName) is StorageFile file)
-            {
-                await file.DeleteAsync();
-            }
-        }
-        catch (FileNotFoundException)
-        {
-            // pass
-        }
-        catch (Exception)
-        {
-            // pass
-        }
-    }
 }
diff --git a/Screenbox.Core/Services/ISettingsService.cs b/Screenbox.Core/Services/ISettingsService.cs
index 1d9a8ba99..942cac4b4 100644
--- a/Screenbox.Core/Services/ISettingsService.cs
+++ b/Screenbox.Core/Services/ISettingsService.cs
@@ -27,5 +27,10 @@ public interface ISettingsService
     bool UseMultipleInstances { get; set; }
     string LivelyActivePath { get; set; }
     MediaPlaybackAutoRepeatMode PersistentRepeatMode { get; set; }
-    bool SavePlaybackPosition { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value that indicates whether the playback position should be saved
+    /// and restored between sessions.
+    /// </summary>
+    bool PersistPlaybackPosition { get; set; }
 }
diff --git a/Screenbox.Core/Services/SettingsService.cs b/Screenbox.Core/Services/SettingsService.cs
index 9a791c844..e19a55561 100644
--- a/Screenbox.Core/Services/SettingsService.cs
+++ b/Screenbox.Core/Services/SettingsService.cs
@@ -36,7 +36,7 @@ public sealed class SettingsService : ISettingsService
     private const string PersistentRepeatModeKey = "Values/RepeatMode";
     private const string PersistentSubtitleLanguageKey = "Values/SubtitleLanguage";
     private const string PlayerShowChaptersKey = "Player/ShowChapters";
-    private const string PrivacySavePlaybackPosition = "Privacy/SavePlaybackPosition";
+    private const string PrivacyPersistPlaybackPosition = "Privacy/PersistPlaybackPosition";
 
     public bool UseIndexer
     {
@@ -170,10 +170,10 @@ public bool PlayerShowChapters
         set => SetValue(PlayerShowChaptersKey, value);
     }
 
-    public bool SavePlaybackPosition
+    public bool PersistPlaybackPosition
     {
-        get => GetValue<bool>(PrivacySavePlaybackPosition);
-        set => SetValue(PrivacySavePlaybackPosition, value);
+        get => GetValue<bool>(PrivacyPersistPlaybackPosition);
+        set => SetValue(PrivacyPersistPlaybackPosition, value);
     }
 
     public SettingsService()
@@ -195,7 +195,7 @@ public SettingsService()
         SetDefault(AdvancedMultipleInstancesKey, false);
         SetDefault(GlobalArgumentsKey, string.Empty);
         SetDefault(PlayerShowChaptersKey, true);
-        SetDefault(PrivacySavePlaybackPosition, true);
+        SetDefault(PrivacyPersistPlaybackPosition, true);
 
         // Device family specific overrides
         if (SystemInformation.IsXbox)
diff --git a/Screenbox.Core/ViewModels/SeekBarViewModel.cs b/Screenbox.Core/ViewModels/SeekBarViewModel.cs
index afbebeb48..30fabe2e9 100644
--- a/Screenbox.Core/ViewModels/SeekBarViewModel.cs
+++ b/Screenbox.Core/ViewModels/SeekBarViewModel.cs
@@ -226,6 +226,8 @@ public void OnSeekBarValueChanged(object sender, RangeBaseValueChangedEventArgs
 
     private void RestoreLastPosition(MediaViewModel media)
     {
+        if (!_settingsService.PersistPlaybackPosition) return;
+
         TimeSpan lastPosition = _lastPositionTracker.GetPosition(media.Location);
         if (lastPosition <= TimeSpan.Zero) return;
         if (_settingsService.RestorePlaybackPosition)
@@ -392,7 +394,7 @@ private void UpdateChapters(PlaybackChapterList? chapterList)
 
     private void UpdateLastPosition(TimeSpan position)
     {
-        if (!_settingsService.SavePlaybackPosition ||
+        if (!_settingsService.PersistPlaybackPosition ||
             _currentItem == null || NaturalDuration <= TimeSpan.FromMinutes(1) ||
             DateTimeOffset.Now - _lastPositionTracker.LastUpdated <= TimeSpan.FromSeconds(3))
             return;
diff --git a/Screenbox.Core/ViewModels/SettingsPageViewModel.cs b/Screenbox.Core/ViewModels/SettingsPageViewModel.cs
index 292974865..9399c2b33 100644
--- a/Screenbox.Core/ViewModels/SettingsPageViewModel.cs
+++ b/Screenbox.Core/ViewModels/SettingsPageViewModel.cs
@@ -45,7 +45,7 @@ public sealed partial class SettingsPageViewModel : ObservableRecipient
     [ObservableProperty] private string _globalArguments;
     [ObservableProperty] private bool _isRelaunchRequired;
     [ObservableProperty] private int _selectedLanguage;
-    [ObservableProperty] private bool _savePlaybackPosition;
+    [ObservableProperty] private bool _persistPlaybackPosition;
 
     public ObservableCollection<StorageFolder> MusicLocations { get; }
 
@@ -119,7 +119,7 @@ public SettingsPageViewModel(
         _playerControlsHideDelay = _settingsService.PlayerControlsHideDelay;
         _useIndexer = _settingsService.UseIndexer;
         _showRecent = _settingsService.ShowRecent;
-        _savePlaybackPosition = _settingsService.SavePlaybackPosition;
+        _persistPlaybackPosition = _settingsService.PersistPlaybackPosition;
         _theme = ((int)_settingsService.Theme + 2) % 3;
         _enqueueAllFilesInFolder = _settingsService.EnqueueAllFilesInFolder;
         _restorePlaybackPosition = _settingsService.RestorePlaybackPosition;
@@ -300,10 +300,10 @@ partial void OnGlobalArgumentsChanged(string value)
         CheckForRelaunch();
     }
 
-    partial void OnSavePlaybackPositionChanged(bool value)
+    partial void OnPersistPlaybackPositionChanged(bool value)
     {
-        _settingsService.SavePlaybackPosition = value;
-        Messenger.Send(new SettingsChangedMessage(nameof(SavePlaybackPosition), typeof(SettingsPageViewModel)));
+        _settingsService.PersistPlaybackPosition = value;
+        Messenger.Send(new SettingsChangedMessage(nameof(PersistPlaybackPosition), typeof(SettingsPageViewModel)));
     }
 
     [RelayCommand]
@@ -363,11 +363,12 @@ private void ClearRecentHistory()
     }
 
     [RelayCommand]
-    private async Task ClearPlaybackPositionsAsync()
+    private async Task ClearPlaybackPositionHistoryAsync()
     {
         try
         {
-            await _lastPositionTracker.DeleteFromDiskAsync();
+            _lastPositionTracker.ClearAll();
+            await _lastPositionTracker.SaveToDiskAsync();
         }
         catch (Exception)
         {
diff --git a/Screenbox/Pages/SettingsPage.xaml b/Screenbox/Pages/SettingsPage.xaml
index 1708eee70..b18ffb114 100644
--- a/Screenbox/Pages/SettingsPage.xaml
+++ b/Screenbox/Pages/SettingsPage.xaml
@@ -586,25 +586,15 @@
                     Description="{x:Bind strings:Resources.SettingsSavePlaybackPositionDescription}"
                     Header="{x:Bind strings:Resources.SettingsSavePlaybackPositionHeader}"
                     HeaderIcon="{ui:FontIcon Glyph=&#xE81C;}">
-                    <ctc:SettingsExpander.Resources>
-                        <ResourceDictionary>
-                            <ResourceDictionary.MergedDictionaries>
-                                <ResourceDictionary Source="ms-appx:///CommunityToolkit.WinUI.Controls.SettingsControls/SettingsExpander/SettingsExpander.xaml" />
-                            </ResourceDictionary.MergedDictionaries>
-                        </ResourceDictionary>
-                    </ctc:SettingsExpander.Resources>
                     <interactivity:Interaction.Behaviors>
                         <behaviors:SettingsExpanderXYNavigationBehavior />
                     </interactivity:Interaction.Behaviors>
-                    <ToggleSwitch AutomationProperties.HelpText="{x:Bind strings:Resources.SettingsSavePlaybackPositionDescription}" IsOn="{x:Bind ViewModel.SavePlaybackPosition, Mode=TwoWay}" />
-                    <ctc:SettingsExpander.ItemsFooter>
-                        <ctc:SettingsCard
-                            AutomationProperties.Name="{x:Bind strings:Resources.SettingsClearPlaybackPositionHeader}"
-                            Header="{x:Bind strings:Resources.SettingsClearPlaybackPositionHeader}"
-                            Style="{StaticResource DefaultSettingsExpanderItemStyle}">
-                            <Button Command="{x:Bind ViewModel.ClearPlaybackPositionsCommand}" Content="{x:Bind strings:Resources.Clear}" />
+                    <ToggleSwitch AutomationProperties.HelpText="{x:Bind strings:Resources.SettingsSavePlaybackPositionDescription}" IsOn="{x:Bind ViewModel.PersistPlaybackPosition, Mode=TwoWay}" />
+                    <ctc:SettingsExpander.Items>
+                        <ctc:SettingsCard AutomationProperties.Name="{x:Bind strings:Resources.SettingsClearPlaybackPositionHeader}" Header="{x:Bind strings:Resources.SettingsClearPlaybackPositionHeader}">
+                            <Button Command="{x:Bind ViewModel.ClearPlaybackPositionHistoryCommand}" Content="{x:Bind strings:Resources.Clear}" />
                         </ctc:SettingsCard>
-                    </ctc:SettingsExpander.ItemsFooter>
+                    </ctc:SettingsExpander.Items>
                 </ctc:SettingsExpander>
 
                 <!--  About section  -->

From dbef5a8a8883aa0c62066f7fd1849fa0e9ce492e Mon Sep 17 00:00:00 2001
From: United600 <United600@users.noreply.github.com>
Date: Wed, 4 Feb 2026 20:22:37 +0000
Subject: [PATCH 8/9] minor strings update

---
 Screenbox/Strings/en-US/Resources.resw | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Screenbox/Strings/en-US/Resources.resw b/Screenbox/Strings/en-US/Resources.resw
index d3c43963f..ed761f371 100644
--- a/Screenbox/Strings/en-US/Resources.resw
+++ b/Screenbox/Strings/en-US/Resources.resw
@@ -622,7 +622,7 @@
     <value>Music library locations</value>
   </data>
   <data name="SettingsShowRecentHeader" xml:space="preserve">
-    <value>Remember recent media</value>
+    <value>Show recent media</value>
   </data>
   <data name="SettingsShowControlsHeader" xml:space="preserve">
     <value>Show controls when paused</value>
@@ -982,10 +982,10 @@
     <value>Folder</value>
   </data>
   <data name="SettingsSavePlaybackPositionHeader" xml:space="preserve">
-    <value>Remember playback position</value>
+    <value>Playback position history</value>
   </data>
   <data name="SettingsSavePlaybackPositionDescription" xml:space="preserve">
-    <value>Store my playback position history on this device to resume where I left off</value>
+    <value>Store my playback position history on this device to resume where you left off</value>
   </data>
   <data name="SettingsClearPlaybackPositionHeader" xml:space="preserve">
     <value>Clear device playback position history</value>

From 1424cdd84cd96f3464fe8647f9db484790126591 Mon Sep 17 00:00:00 2001
From: United600 <United600@users.noreply.github.com>
Date: Wed, 4 Feb 2026 20:25:30 +0000
Subject: [PATCH 9/9] refactor and reorganize playback position settings ui and
 update strings

---
 Screenbox/Pages/SettingsPage.xaml      | 27 +++++++++++++++-----------
 Screenbox/Strings/en-US/Resources.resw |  6 +++---
 2 files changed, 19 insertions(+), 14 deletions(-)

diff --git a/Screenbox/Pages/SettingsPage.xaml b/Screenbox/Pages/SettingsPage.xaml
index b18ffb114..a0d88deff 100644
--- a/Screenbox/Pages/SettingsPage.xaml
+++ b/Screenbox/Pages/SettingsPage.xaml
@@ -28,6 +28,7 @@
     <Page.Resources>
         <!--<x:Double x:Key="SettingsCardActionIconMaxSize">14</x:Double>-->
         <Thickness x:Key="SettingsCardMargin">0,0,0,4</Thickness>
+        <x:Double x:Key="SettingsCardButtonMinWidth">120</x:Double>
 
         <converters:ResourceNameToResourceStringConverter x:Key="ResourceNameToResourceStringConverter" />
 
@@ -326,14 +327,6 @@
                     <ToggleSwitch AutomationProperties.HelpText="{strings:Resources Key=SettingsEnqueueAllFilesInFolderDescription}" IsOn="{x:Bind ViewModel.EnqueueAllFilesInFolder, Mode=TwoWay}" />
                 </ctc:SettingsCard>
 
-                <ctc:SettingsCard
-                    Margin="{StaticResource SettingsCardMargin}"
-                    Description="{strings:Resources Key=SettingsRestorePlaybackPositionDescription}"
-                    Header="{strings:Resources Key=SettingsRestorePlaybackPositionHeader}"
-                    HeaderIcon="{ui:FontIcon Glyph=&#xEF3B;}">
-                    <ToggleSwitch AutomationProperties.HelpText="{strings:Resources Key=SettingsRestorePlaybackPositionDescription}" IsOn="{x:Bind ViewModel.RestorePlaybackPosition, Mode=TwoWay}" />
-                </ctc:SettingsCard>
-
                 <!--  Player section  -->
                 <TextBlock Style="{StaticResource SettingsSectionHeaderTextBlockStyle}" Text="{strings:Resources Key=SettingsCategoryPlayer}" />
 
@@ -576,7 +569,10 @@
                             x:Name="SettingsClearRecentCard"
                             AutomationProperties.Name="{x:Bind SettingsClearRecentCard.Header}"
                             Header="{strings:Resources Key=SettingsClearRecentHeader}">
-                            <Button Command="{x:Bind ViewModel.ClearRecentHistoryCommand}" Content="{strings:Resources Key=Clear}" />
+                            <Button
+                                MinWidth="{StaticResource SettingsCardButtonMinWidth}"
+                                Command="{x:Bind ViewModel.ClearRecentHistoryCommand}"
+                                Content="{strings:Resources Key=Clear}" />
                         </ctc:SettingsCard>
                     </ctc:SettingsExpander.Items>
                 </ctc:SettingsExpander>
@@ -585,14 +581,23 @@
                     Margin="{StaticResource SettingsCardMargin}"
                     Description="{x:Bind strings:Resources.SettingsSavePlaybackPositionDescription}"
                     Header="{x:Bind strings:Resources.SettingsSavePlaybackPositionHeader}"
-                    HeaderIcon="{ui:FontIcon Glyph=&#xE81C;}">
+                    HeaderIcon="{ui:FontIcon Glyph=&#xEF3B;}">
                     <interactivity:Interaction.Behaviors>
                         <behaviors:SettingsExpanderXYNavigationBehavior />
                     </interactivity:Interaction.Behaviors>
                     <ToggleSwitch AutomationProperties.HelpText="{x:Bind strings:Resources.SettingsSavePlaybackPositionDescription}" IsOn="{x:Bind ViewModel.PersistPlaybackPosition, Mode=TwoWay}" />
                     <ctc:SettingsExpander.Items>
+                        <ctc:SettingsCard
+                            Description="{x:Bind strings:Resources.SettingsRestorePlaybackPositionDescription}"
+                            Header="{x:Bind strings:Resources.SettingsRestorePlaybackPositionHeader}"
+                            IsEnabled="{x:Bind ViewModel.PersistPlaybackPosition, Mode=OneWay}">
+                            <ToggleSwitch AutomationProperties.HelpText="{x:Bind strings:Resources.SettingsRestorePlaybackPositionDescription}" IsOn="{x:Bind ViewModel.RestorePlaybackPosition, Mode=TwoWay}" />
+                        </ctc:SettingsCard>
                         <ctc:SettingsCard AutomationProperties.Name="{x:Bind strings:Resources.SettingsClearPlaybackPositionHeader}" Header="{x:Bind strings:Resources.SettingsClearPlaybackPositionHeader}">
-                            <Button Command="{x:Bind ViewModel.ClearPlaybackPositionHistoryCommand}" Content="{x:Bind strings:Resources.Clear}" />
+                            <Button
+                                MinWidth="{StaticResource SettingsCardButtonMinWidth}"
+                                Command="{x:Bind ViewModel.ClearPlaybackPositionHistoryCommand}"
+                                Content="{x:Bind strings:Resources.Clear}" />
                         </ctc:SettingsCard>
                     </ctc:SettingsExpander.Items>
                 </ctc:SettingsExpander>
diff --git a/Screenbox/Strings/en-US/Resources.resw b/Screenbox/Strings/en-US/Resources.resw
index ed761f371..bef19810c 100644
--- a/Screenbox/Strings/en-US/Resources.resw
+++ b/Screenbox/Strings/en-US/Resources.resw
@@ -634,7 +634,7 @@
     <value>Subtitles</value>
   </data>
   <data name="SettingsShowRecentDescription" xml:space="preserve">
-    <value>Show recently played media on the home page</value>
+    <value>See recently played media on the home page</value>
   </data>
   <data name="SettingsClearRecentHeader" xml:space="preserve">
     <value>Clear recent media history</value>
@@ -931,10 +931,10 @@
     <value>Personalization</value>
   </data>
   <data name="SettingsRestorePlaybackPositionHeader" xml:space="preserve">
-    <value>Always resume from last position</value>
+    <value>Resume previous session</value>
   </data>
   <data name="SettingsRestorePlaybackPositionDescription" xml:space="preserve">
-    <value>Continue playing from where you last stopped when opening a file</value>
+    <value>Automatically resume media playback from your last stopped position when opening a file</value>
   </data>
   <data name="SettingsVideoUpscalingHeader" xml:space="preserve">
     <value>Video upscaling method</value>