Add light/dark theme toggle feature

Co-authored-by: Keboo <[email protected]>

Author: Copilot

PointerStar/Client/Cookies/WellKnownCookieValues.cs

@@ -5,6 +5,7 @@ public static class WellKnownCookieValues
     private const string NameKey = "Name";
     private const string RoleKey = "RoleId";
     private const string RoomKey = "RoomId";
+    private const string ThemePreferenceKey = "ThemePreference";
 
     public static ValueTask<string> GetNameAsync(this ICookie cookie)
         => cookie.GetValueAsync(NameKey);
@@ -26,5 +27,10 @@ public static ValueTask SetRoleAsync(this ICookie cookie, Guid? value)
         => cookie.SetValueAsync(RoleKey, value?.ToString("D") ?? "");
     public static ValueTask SetRoomAsync(this ICookie cookie, string value)
         => cookie.SetValueAsync(RoomKey, value);
+
+    public static ValueTask<string> GetThemePreferenceAsync(this ICookie cookie)
+        => cookie.GetValueAsync(ThemePreferenceKey);
+    public static ValueTask SetThemePreferenceAsync(this ICookie cookie, string value)
+        => cookie.SetValueAsync(ThemePreferenceKey, value);
 }
 

PointerStar/Client/Program.cs

@@ -5,6 +5,7 @@
 using MudBlazor.Services;
 using PointerStar.Client;
 using PointerStar.Client.Cookies;
+using PointerStar.Client.Services;
 using PointerStar.Client.ViewModels;
 using PointerStar.Shared;
 using Toolbelt.Blazor.Extensions.DependencyInjection;
@@ -34,5 +35,6 @@
 builder.Services.AddScoped<UserDialogViewModel>();
 builder.Services.AddScoped<ICookie, Cookie>();
 builder.Services.AddScoped<IClipboardService, ClipboardService>();
+builder.Services.AddScoped<IThemeService, ThemeService>();
 
 await builder.Build().RunAsync();

PointerStar/Client/Services/ThemeService.cs

@@ -0,0 +1,98 @@
+namespace PointerStar.Client.Services;
+
+using PointerStar.Client.Cookies;
+
+public enum ThemePreference
+{
+    System,
+    Light,
+    Dark
+}
+
+public interface IThemeService
+{
+    ThemePreference CurrentPreference { get; }
+    bool IsDarkMode { get; }
+    event EventHandler? ThemeChanged;
+    Task InitializeAsync(Func<Task<bool>> getSystemPreference);
+    Task SetPreferenceAsync(ThemePreference preference);
+    Task CycleThemeAsync();
+}
+
+public class ThemeService : IThemeService
+{
+    private readonly ICookie _cookie;
+    private Func<Task<bool>>? _getSystemPreference;
+    private bool _systemPreference;
+
+    public ThemePreference CurrentPreference { get; private set; }
+    
+    public bool IsDarkMode => CurrentPreference switch
+    {
+        ThemePreference.Dark => true,
+        ThemePreference.Light => false,
+        ThemePreference.System => _systemPreference,
+        _ => _systemPreference
+    };
+
+    public event EventHandler? ThemeChanged;
+
+    public ThemeService(ICookie cookie)
+    {
+        _cookie = cookie ?? throw new ArgumentNullException(nameof(cookie));
+    }
+
+    public async Task InitializeAsync(Func<Task<bool>> getSystemPreference)
+    {
+        _getSystemPreference = getSystemPreference ?? throw new ArgumentNullException(nameof(getSystemPreference));
+        
+        // Get system preference
+        _systemPreference = await _getSystemPreference();
+
+        // Load saved preference from cookie
+        string preferenceValue = await _cookie.GetThemePreferenceAsync();
+        if (!string.IsNullOrEmpty(preferenceValue) && Enum.TryParse<ThemePreference>(preferenceValue, out var preference))
+        {
+            CurrentPreference = preference;
+        }
+        else
+        {
+            CurrentPreference = ThemePreference.System;
+        }
+    }
+
+    public async Task SetPreferenceAsync(ThemePreference preference)
+    {
+        if (CurrentPreference != preference)
+        {
+            CurrentPreference = preference;
+            await _cookie.SetThemePreferenceAsync(preference.ToString());
+            ThemeChanged?.Invoke(this, EventArgs.Empty);
+        }
+    }
+
+    public async Task CycleThemeAsync()
+    {
+        var nextPreference = CurrentPreference switch
+        {
+            ThemePreference.System => ThemePreference.Light,
+            ThemePreference.Light => ThemePreference.Dark,
+            ThemePreference.Dark => ThemePreference.System,
+            _ => ThemePreference.System
+        };
+        await SetPreferenceAsync(nextPreference);
+    }
+
+    public async Task UpdateSystemPreferenceAsync(bool isDark)
+    {
+        if (_systemPreference != isDark)
+        {
+            _systemPreference = isDark;
+            if (CurrentPreference == ThemePreference.System)
+            {
+                ThemeChanged?.Invoke(this, EventArgs.Empty);
+            }
+        }
+        await Task.CompletedTask;
+    }
+}

PointerStar/Client/Shared/MainLayout.razor

@@ -1,5 +1,8 @@
 @using System.Reflection;
+@using PointerStar.Client.Services
 @inherits LayoutComponentBase
+@inject IThemeService ThemeService
+@implements IDisposable
 
 <Toolbelt.Blazor.PWA.Updater.PWAUpdater />
 <MudThemeProvider @ref="@_mudThemeProvider" @bind-IsDarkMode="@_isDarkMode" />
@@ -11,6 +14,9 @@
     <MudAppBar Elevation="1">
         <MudText Typo="Typo.h5" Class="ml-3">Pointer*</MudText>
         <MudSpacer />
+        <MudTooltip Text="@GetThemeTooltip()">
+            <MudIconButton Icon="@GetThemeIcon()" Color="Color.Inherit" OnClick="@CycleThemeAsync" />
+        </MudTooltip>
         <MudText Typo="Typo.subtitle1" Align="Align.End">@Assembly.GetExecutingAssembly().GetName().Version?.ToString(3)</MudText>
     </MudAppBar>
     <MudMainContent>
@@ -26,16 +32,57 @@
     {
         if (firstRender && _mudThemeProvider is { } themeProvider)
         {
-            _isDarkMode = await themeProvider.GetSystemDarkModeAsync();
+            await ThemeService.InitializeAsync(() => themeProvider.GetSystemDarkModeAsync());
+            _isDarkMode = ThemeService.IsDarkMode;
             await themeProvider.WatchSystemDarkModeAsync(OnSystemPreferenceChanged);
+            ThemeService.ThemeChanged += OnThemeChanged;
             StateHasChanged();
         }
     }
 
-    private Task OnSystemPreferenceChanged(bool newValue)
+    private async Task OnSystemPreferenceChanged(bool newValue)
     {
-        _isDarkMode = newValue;
+        if (ThemeService is ThemeService themeService)
+        {
+            await themeService.UpdateSystemPreferenceAsync(newValue);
+        }
+    }
+
+    private void OnThemeChanged(object? sender, EventArgs e)
+    {
+        _isDarkMode = ThemeService.IsDarkMode;
         StateHasChanged();
-        return Task.CompletedTask;
+    }
+
+    private async Task CycleThemeAsync()
+    {
+        await ThemeService.CycleThemeAsync();
+    }
+
+    private string GetThemeIcon()
+    {
+        return ThemeService.CurrentPreference switch
+        {
+            ThemePreference.System => Icons.Material.Filled.Brightness4,
+            ThemePreference.Light => Icons.Material.Filled.LightMode,
+            ThemePreference.Dark => Icons.Material.Filled.DarkMode,
+            _ => Icons.Material.Filled.Brightness4
+        };
+    }
+
+    private string GetThemeTooltip()
+    {
+        return ThemeService.CurrentPreference switch
+        {
+            ThemePreference.System => "Theme: System (click to switch to Light)",
+            ThemePreference.Light => "Theme: Light (click to switch to Dark)",
+            ThemePreference.Dark => "Theme: Dark (click to switch to System)",
+            _ => "Toggle theme"
+        };
+    }
+
+    public void Dispose()
+    {
+        ThemeService.ThemeChanged -= OnThemeChanged;
     }
 }