Tab restore

src/AppCommon/FileTime.App.Core/Models/ApplicationSettings.cs

@@ -0,0 +1,54 @@
+using System.Reflection;
+
+namespace FileTime.App.Core.Models;
+
+public class ApplicationSettings : IApplicationSettings
+{
+    public string AppDataRoot { get; private set; } = null!;
+    public string EnvironmentName { get; private set; } = null!;
+
+    public ApplicationSettings()
+    {
+#if DEBUG
+        InitDebugSettings();
+#else
+        InitReleaseSettings();
+#endif
+    }
+
+    private void InitDebugSettings()
+    {
+        EnvironmentName = "Development";
+
+        AppDataRoot = Path.Combine(Environment.CurrentDirectory, "appdata");
+    }
+
+    private void InitReleaseSettings()
+    {
+        EnvironmentName = "Release";
+
+        var possibleDataRootsPaths = new List<string>()
+        {
+            Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "FileTime"),
+            Path.Combine(Assembly.GetEntryAssembly()?.Location ?? ".", "fallbackDataRoot")
+        };
+
+        string? appDataRoot = null;
+        foreach (var possibleAppDataRoot in possibleDataRootsPaths)
+        {
+            try
+            {
+                var appDataRootDirectory = new DirectoryInfo(possibleAppDataRoot);
+                if (!appDataRootDirectory.Exists) appDataRootDirectory.Create();
+
+                appDataRoot = possibleAppDataRoot;
+                break;
+            }
+            catch
+            {
+            }
+        }
+
+        AppDataRoot = appDataRoot ?? throw new UnauthorizedAccessException();
+    }
+}

src/AppCommon/FileTime.App.Core/Services/Persistence/TabPersistenceService.cs

@@ -0,0 +1,215 @@
+using System.Reactive.Linq;
+using System.Text.Json;
+using FileTime.App.Core.Models;
+using FileTime.App.Core.ViewModels;
+using FileTime.Core.Models;
+using FileTime.Core.Services;
+using FileTime.Core.Timeline;
+using FileTime.Providers.Local;
+using InitableService;
+using Microsoft.Extensions.Logging;
+
+namespace FileTime.App.Core.Services.Persistence;
+
+public class TabPersistenceService : ITabPersistenceService
+{
+    private readonly IAppState _appState;
+    private readonly ILogger<TabPersistenceService> _logger;
+
+    private class PersistenceRoot
+    {
+        public TabStates? TabStates { get; set; }
+    }
+
+    private class TabStates
+    {
+        public List<TabState>? Tabs { get; set; }
+        public int? ActiveTabNumber { get; set; }
+    }
+
+    private class TabState
+    {
+        public string? Path { get; set; }
+        public int Number { get; set; }
+
+        public TabState()
+        {
+        }
+
+        public TabState(FullName path, int number)
+        {
+            Path = path.Path;
+            Number = number;
+        }
+    }
+
+    private readonly string _settingsPath;
+    private readonly JsonSerializerOptions _jsonOptions;
+    private readonly ITimelessContentProvider _timelessContentProvider;
+    private readonly IServiceProvider _serviceProvider;
+    private readonly ILocalContentProvider _localContentProvider;
+
+    public TabPersistenceService(
+        IApplicationSettings applicationSettings,
+        IAppState appState,
+        ITimelessContentProvider timelessContentProvider,
+        IServiceProvider serviceProvider,
+        ILocalContentProvider localContentProvider,
+        ILogger<TabPersistenceService> logger)
+    {
+        _appState = appState;
+        _logger = logger;
+        _settingsPath = Path.Combine(applicationSettings.AppDataRoot, "savedState.json");
+        _timelessContentProvider = timelessContentProvider;
+        _serviceProvider = serviceProvider;
+        _localContentProvider = localContentProvider;
+
+        _jsonOptions = new JsonSerializerOptions()
+        {
+            PropertyNameCaseInsensitive = true,
+            WriteIndented = true
+        };
+    }
+
+    public Task ExitAsync()
+    {
+        SaveStates();
+
+        return Task.CompletedTask;
+    }
+
+    private async Task LoadStatesAsync()
+    {
+        if (!File.Exists(_settingsPath)) return;
+
+        try
+        {
+            await using var stateReader = File.OpenRead(_settingsPath);
+            var state = await JsonSerializer.DeserializeAsync<PersistenceRoot>(stateReader);
+            if (state != null)
+            {
+                await RestoreTabs(state.TabStates);
+            }
+        }
+        catch (Exception e)
+        {
+            _logger.LogError(e, "Unknown exception while restoring app state");
+        }
+    }
+    private async Task RestoreTabs(TabStates? tabStates)
+    {
+        if (tabStates == null
+            || tabStates.Tabs == null)
+        {
+            CreateEmptyTab();
+            return;
+        }
+
+        try
+        {
+
+            foreach (var tab in tabStates.Tabs)
+            {
+                try
+                {
+                    if (tab.Path == null) continue;
+
+                    IContainer? container = null;
+                    var path = new FullName(tab.Path);
+                    while (true)
+                    {
+                        try
+                        {
+                            var pathItem = await _timelessContentProvider.GetItemByFullNameAsync(path, PointInTime.Present);
+
+                            container = pathItem switch
+                            {
+                                IContainer c => c,
+                                IElement e => e.Parent?.ResolveAsync() as IContainer,
+                                _ => null
+                            };
+                            break;
+                        }
+                        catch
+                        {
+                            path = path.GetParent();
+                            if (path == null)
+                            {
+                                throw new Exception($"Could not find an initializable path along {tab.Path}");
+                            }
+                        }
+                    }
+
+                    if (container == null) continue;
+
+                    var tabToLoad = _serviceProvider.GetInitableResolver(container)
+                        .GetRequiredService<ITab>();
+                    var tabViewModel = _serviceProvider.GetInitableResolver(tabToLoad, tab.Number).GetRequiredService<ITabViewModel>();
+
+                    _appState.AddTab(tabViewModel);
+                }
+                catch (Exception e)
+                {
+                    _logger.LogError(e, "Unkown exception while restoring tab. {TabState}", JsonSerializer.Serialize(tab, _jsonOptions));
+                }
+            }
+        }
+        catch (Exception e)
+        {
+            _logger.LogError(e, "Unkown exception while restoring tabs.");
+        }
+
+        if (_appState.Tabs.Count == 0)
+        {
+            CreateEmptyTab();
+        }
+        else
+        {
+            var tabToActivate = _appState.Tabs.FirstOrDefault(t => t.TabNumber == tabStates.ActiveTabNumber);
+            if (tabToActivate is not null) _appState.SetSelectedTab(tabToActivate);
+        }
+
+        void CreateEmptyTab()
+        {
+            var tab = _serviceProvider.GetInitableResolver<IContainer>(_localContentProvider)
+                .GetRequiredService<ITab>();
+            var tabViewModel = _serviceProvider.GetInitableResolver(tab, 1).GetRequiredService<ITabViewModel>();
+
+            _appState.AddTab(tabViewModel);
+        }
+    }
+
+    public void SaveStates()
+    {
+        var state = new PersistenceRoot
+        {
+            TabStates = SerializeTabStates()
+        };
+        var settingsDirectory = new DirectoryInfo(string.Join(Path.DirectorySeparatorChar, _settingsPath.Split(Path.DirectorySeparatorChar)[0..^1]));
+        if (!settingsDirectory.Exists) settingsDirectory.Create();
+        var serializedData = JsonSerializer.Serialize(state, _jsonOptions);
+        File.WriteAllText(_settingsPath, serializedData);
+    }
+
+    private TabStates SerializeTabStates()
+    {
+        var tabStates = new List<TabState>();
+        foreach (var tab in _appState.Tabs)
+        {
+            var currentLocation = tab.CachedCurrentLocation;
+            if (currentLocation is null) continue;
+            tabStates.Add(new TabState(currentLocation.FullName!, tab.TabNumber));
+        }
+
+        return new TabStates()
+        {
+            Tabs = tabStates,
+            ActiveTabNumber = _appState.CurrentSelectedTab?.TabNumber
+        };
+    }
+
+    public async Task InitAsync()
+    {
+        await LoadStatesAsync();
+    }
+}

src/AppCommon/FileTime.App.Core/Startup.cs

@@ -22,9 +22,11 @@ public static class Startup
         serviceCollection.TryAddSingleton<IUserCommandHandlerService, UserCommandHandlerService>();
         serviceCollection.TryAddSingleton<IClipboardService, ClipboardService>();
         serviceCollection.TryAddSingleton<IIdentifiableUserCommandService, IdentifiableUserCommandService>();
-        serviceCollection.TryAddSingleton<IStartupHandler, DefaultIdentifiableCommandHandlerRegister>();
         serviceCollection.TryAddSingleton<IItemPreviewService, ItemPreviewService>();
-        return serviceCollection.AddCommandHandlers();
+
+        return serviceCollection
+            .AddCommandHandlers()
+            .AddSingleton<IStartupHandler, DefaultIdentifiableCommandHandlerRegister>();
     }
 
     private static IServiceCollection AddCommandHandlers(this IServiceCollection serviceCollection)

src/AppCommon/FileTime.App.Core/StartupServices/DefaultIdentifiableCommandHandlerRegister.cs

@@ -37,6 +37,8 @@ public class DefaultIdentifiableCommandHandlerRegister : IStartupHandler
         AddUserCommand(SwitchToTabCommand.SwitchToTab8);
     }
 
+    public Task InitAsync() => Task.CompletedTask;
+
     private void AddUserCommand(IIdentifiableUserCommand command)
         => _service.AddIdentifiableUserCommandFactory(command.UserCommandID, () => command);
 }

src/AppCommon/FileTime.App.Core/ViewModels/TabViewModel.cs

@@ -43,7 +43,8 @@ public partial class TabViewModel : ITabViewModel
         null!;
 
     public IObservable<IReadOnlyCollection<IItemViewModel>?>
-        SelectedsChildrenCollectionObservable { get; private set; } = null!;
+        SelectedsChildrenCollectionObservable
+    { get; private set; } = null!;
 
     [Property] private BindedCollection<IItemViewModel>? _currentItemsCollection;
 
@@ -51,6 +52,8 @@ public partial class TabViewModel : ITabViewModel
 
     [Property] private BindedCollection<IItemViewModel>? _selectedsChildrenCollection;
 
+    public IContainer? CachedCurrentLocation { get; private set; }
+
     public TabViewModel(
         IServiceProvider serviceProvider,
         IItemNameConverterService itemNameConverterService,
@@ -74,6 +77,8 @@ public partial class TabViewModel : ITabViewModel
         tab.AddToDisposables(_disposables);
 
         CurrentLocation = tab.CurrentLocation.AsObservable();
+        CurrentLocation.Subscribe(l => CachedCurrentLocation = l).AddToDisposables(_disposables);
+
         CurrentItems = tab.CurrentItems
             .Select(items => items?.Transform(i => MapItemToViewModel(i, ItemViewModelType.Main)))
             /*.ObserveOn(_rxSchedulerService.GetWorkerScheduler())