Merge pull request #19 from jayfunc/dev

github actions

.github/workflows/pages.yml

@@ -0,0 +1,69 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+
+# Sample workflow for building and deploying a Jekyll site to GitHub Pages
+name: Deploy Jekyll site to Pages
+
+on:
+  push:
+    branches: ["dev", "stable"]
+    paths:
+      - "docs/**"
+
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+# Allow one concurrent deployment
+concurrency:
+  group: "pages"
+  cancel-in-progress: true
+
+jobs:
+  # Build job
+  build:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: docs
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Setup Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: "3.3"
+          bundler-cache: true
+          cache-version: 0
+          working-directory: "${{ github.workspace }}/docs"
+      - name: Setup Pages
+        id: pages
+        uses: actions/configure-pages@v5
+      - name: Build with Jekyll
+        # Outputs to the './_site' directory by default
+        run: bundle exec jekyll build --baseurl "${{ steps.pages.outputs.base_path }}"
+        env:
+          JEKYLL_ENV: production
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: docs/_site/
+
+  # Deployment job
+  deploy:
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+    needs: build
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4

.github/workflows/releases-to-discord.yml

@@ -0,0 +1,20 @@
+on:
+  release:
+    types: [published, edited]
+
+jobs:
+  github-releases-to-discord:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: GitHub Releases to Discord
+        uses: SethCohen/github-releases-to-discord@v1
+        with:
+          webhook_url: ${{ secrets.WEBHOOK_URL }}
+          color: "2105893"
+          username: "Release Changelog"
+          avatar_url: "https://cdn.discordapp.com/avatars/487431320314576937/bd64361e4ba6313d561d54e78c9e7171.png"
+          content: "||@everyone||"
+          footer_title: "Changelog"
+          reduce_headings: true

.gitignore

@@ -404,4 +404,5 @@ FodyWeavers.xsd
 *.msp
 
 # JetBrains Rider
-*.sln.iml
+*.sln.iml
+/BetterLyrics.WinUI3/BetterLyrics.WinUI3 (Package)/BetterLyrics.WinUI3 (Package)_TemporaryKey.pfx

BetterLyrics.WinUI3/BetterLyrics.WinUI3 (Package)/BetterLyrics.WinUI3 (Package).wapproj

@@ -40,15 +40,16 @@
     <TargetPlatformMinVersion>10.0.17763.0</TargetPlatformMinVersion>
     <AssetTargetFallback>net8.0-windows$(TargetPlatformVersion);$(AssetTargetFallback)</AssetTargetFallback>
     <DefaultLanguage>zh-CN</DefaultLanguage>
-    <AppxPackageSigningEnabled>false</AppxPackageSigningEnabled>
+    <AppxPackageSigningEnabled>True</AppxPackageSigningEnabled>
     <EntryPointProjectUniqueName>..\BetterLyrics.WinUI3\BetterLyrics.WinUI3.csproj</EntryPointProjectUniqueName>
     <GenerateAppInstallerFile>False</GenerateAppInstallerFile>
     <AppxPackageSigningTimestampDigestAlgorithm>SHA256</AppxPackageSigningTimestampDigestAlgorithm>
-    <AppxAutoIncrementPackageRevision>True</AppxAutoIncrementPackageRevision>
+    <AppxAutoIncrementPackageRevision>False</AppxAutoIncrementPackageRevision>
     <GenerateTestArtifacts>True</GenerateTestArtifacts>
-    <AppxBundlePlatforms>x86|x64|arm64</AppxBundlePlatforms>
+    <AppxBundlePlatforms>x86|x64</AppxBundlePlatforms>
     <GenerateTemporaryStoreCertificate>True</GenerateTemporaryStoreCertificate>
     <HoursBetweenUpdateChecks>0</HoursBetweenUpdateChecks>
+    <PackageCertificateKeyFile>BetterLyrics.WinUI3 %28Package%29_TemporaryKey.pfx</PackageCertificateKeyFile>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <AppxBundle>Always</AppxBundle>
@@ -80,6 +81,7 @@
     </AppxManifest>
   </ItemGroup>
   <ItemGroup>
+    <None Include="BetterLyrics.WinUI3 %28Package%29_TemporaryKey.pfx" />
     <Content Include="Images\LargeTile.scale-100.png" />
     <Content Include="Images\LargeTile.scale-125.png" />
     <Content Include="Images\LargeTile.scale-150.png" />

BetterLyrics.WinUI3/BetterLyrics.WinUI3 (Package)/Package.appxmanifest

@@ -5,47 +5,62 @@
   xmlns:mp="http://schemas.microsoft.com/appx/2014/phone/manifest"
   xmlns:uap="http://schemas.microsoft.com/appx/manifest/uap/windows10"
   xmlns:rescap="http://schemas.microsoft.com/appx/manifest/foundation/windows10/restrictedcapabilities"
-  IgnorableNamespaces="uap rescap">
+  xmlns:uap5="http://schemas.microsoft.com/appx/manifest/uap/windows10/5"
+  xmlns:uap18="http://schemas.microsoft.com/appx/manifest/uap/windows10/18"
+  IgnorableNamespaces="uap rescap uap18">
 
-  <Identity
-    Name="37412.BetterLyrics"
-    Publisher="CN=E1428B0E-DC1D-4EA4-ACB1-4556569D5BA9"
-    Version="1.0.1.0" />
+	<Identity
+	  Name="37412.BetterLyrics"
+	  Publisher="CN=E1428B0E-DC1D-4EA4-ACB1-4556569D5BA9"
+	  Version="1.0.11.0" />
 
-  <mp:PhoneIdentity PhoneProductId="ca4a4830-fc19-40d9-b823-53e2bff3d816" PhonePublisherId="00000000-0000-0000-0000-000000000000"/>
+	<mp:PhoneIdentity PhoneProductId="ca4a4830-fc19-40d9-b823-53e2bff3d816" PhonePublisherId="00000000-0000-0000-0000-000000000000"/>
 
-  <Properties>
-    <DisplayName>BetterLyrics</DisplayName>
-    <PublisherDisplayName>founchoo</PublisherDisplayName>
-    <Logo>Images\StoreLogo.png</Logo>
-  </Properties>
+	<Properties>
+		<DisplayName>BetterLyrics</DisplayName>
+		<PublisherDisplayName>founchoo</PublisherDisplayName>
+		<Logo>Images\StoreLogo.png</Logo>
+	</Properties>
 
-  <Dependencies>
-    <TargetDeviceFamily Name="Windows.Universal" MinVersion="10.0.19041.0" MaxVersionTested="10.0.26100.0" />
-    <TargetDeviceFamily Name="Windows.Desktop" MinVersion="10.0.19041.0" MaxVersionTested="10.0.26100.0" />
-  </Dependencies>
+	<Dependencies>
+		<TargetDeviceFamily Name="Windows.Universal" MinVersion="10.0.19041.0" MaxVersionTested="10.0.26100.0" />
+		<TargetDeviceFamily Name="Windows.Desktop" MinVersion="10.0.19041.0" MaxVersionTested="10.0.26100.0" />
+	</Dependencies>
 
-  <Resources>
-    <Resource Language="x-generate"/>
-  </Resources>
+	<Resources>
+		<Resource Language="en-US"/>
+		<Resource Language="zh-CN"/>
+		<Resource Language="zh-TW"/>
+		<Resource Language="ja-JP"/>
+		<Resource Language="ko-KR"/>
+	</Resources>
 
-  <Applications>
-    <Application Id="App"
-      Executable="$targetnametoken$.exe"
-      EntryPoint="$targetentrypoint$">
-      <uap:VisualElements
-        DisplayName="BetterLyrics"
-        Description="BetterLyrics.WinUI3 (Package)"
-        BackgroundColor="transparent"
-        Square150x150Logo="Images\Square150x150Logo.png"
-        Square44x44Logo="Images\Square44x44Logo.png">
-        <uap:DefaultTile Wide310x150Logo="Images\Wide310x150Logo.png"  Square71x71Logo="Images\SmallTile.png" Square310x310Logo="Images\LargeTile.png"/>
-        <uap:SplashScreen Image="Images\SplashScreen.png" />
-      </uap:VisualElements>
-    </Application>
-  </Applications>
+	<Applications>
+		<Application Id="App"
+		  Executable="$targetnametoken$.exe"
+		  EntryPoint="$targetentrypoint$">
+			<uap:VisualElements
+			  DisplayName="BetterLyrics"
+			  Description="BetterLyrics.WinUI3 (Package)"
+			  BackgroundColor="transparent"
+			  Square150x150Logo="Images\Square150x150Logo.png"
+			  Square44x44Logo="Images\Square44x44Logo.png">
+				<uap:DefaultTile Wide310x150Logo="Images\Wide310x150Logo.png"  Square71x71Logo="Images\SmallTile.png" Square310x310Logo="Images\LargeTile.png"/>
+				<uap:SplashScreen Image="Images\SplashScreen.png" />
+			</uap:VisualElements>
+			<Extensions>
+				<uap5:Extension
+				  Category="windows.startupTask">
+					<uap5:StartupTask
+					  TaskId="AutoStartup"
+					  Enabled="false"
+					  DisplayName="BetterLyrics" />
+				</uap5:Extension>
+			</Extensions>
+		</Application>
+	</Applications>
 
-  <Capabilities>
-    <rescap:Capability Name="runFullTrust" />
-  </Capabilities>
+	<Capabilities>
+		<rescap:Capability Name="runFullTrust" />
+	</Capabilities>
 </Package>

BetterLyrics.WinUI3/BetterLyrics.WinUI3/App.xaml

@@ -5,7 +5,8 @@
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
     xmlns:converter="using:BetterLyrics.WinUI3.Converter"
     xmlns:converters="using:CommunityToolkit.WinUI.Converters"
-    xmlns:local="using:BetterLyrics.WinUI3">
+    xmlns:local="using:BetterLyrics.WinUI3"
+    xmlns:media="using:CommunityToolkit.WinUI.Media">
     <Application.Resources>
         <ResourceDictionary>
             <ResourceDictionary.MergedDictionaries>
@@ -16,12 +17,8 @@
 
             <!--  Theme  -->
             <ResourceDictionary.ThemeDictionaries>
-                <ResourceDictionary x:Key="Light">
-                    <Color x:Key="SemiTransparentSystemBaseHighColor">#80000000</Color>
-                </ResourceDictionary>
-                <ResourceDictionary x:Key="Dark">
-                    <Color x:Key="SemiTransparentSystemBaseHighColor">#80FFFFFF</Color>
-                </ResourceDictionary>
+                <ResourceDictionary x:Key="Light" />
+                <ResourceDictionary x:Key="Dark" />
             </ResourceDictionary.ThemeDictionaries>
 
             <!--  Brush  -->
@@ -44,14 +41,20 @@
             <ExponentialEase x:Key="EaseIn" EasingMode="EaseIn" />
 
             <!--  Converter  -->
-            <converter:ThemeTypeToElementThemeConverter x:Key="ThemeTypeToElementThemeConverter" />
+            <converter:EnumToIntConverter x:Key="EnumToIntConverter" />
             <converter:ColorToBrushConverter x:Key="ColorToBrushConverter" />
+            <converter:MatchedLocalFilesPathToVisibilityConverter x:Key="MatchedLocalFilesPathToVisibilityConverter" />
+            <converter:IntToCornerRadius x:Key="IntToCornerRadius" />
+            <converter:CornerRadiusToDoubleConverter x:Key="CornerRadiusToDoubleConverter" />
+            <converter:LyricsSearchProviderToDisplayNameConverter x:Key="LyricsSearchProviderToDisplayNameConverter" />
+            <converter:AlbumArtSearchProviderToDisplayNameConverter x:Key="AlbumArtSearchProviderToDisplayNameConverter" />
             <converters:BoolToVisibilityConverter x:Key="BoolToVisibilityConverter" />
             <converters:BoolNegationConverter x:Key="BoolNegationConverter" />
+            <converters:ColorToDisplayNameConverter x:Key="ColorToDisplayNameConverter" />
 
             <x:Double x:Key="SettingsCardSpacing">4</x:Double>
 
-            <!--  Style (inc. the correct spacing) of a section header  -->
+            <!--  Style  -->
             <Style
                 x:Key="SettingsSectionHeaderTextBlockStyle"
                 BasedOn="{StaticResource BodyStrongTextBlockStyle}"
@@ -60,7 +63,40 @@
                     <Setter Property="Margin" Value="1,30,0,6" />
                 </Style.Setters>
             </Style>
+            <Style x:Key="TitleBarButtonStyle" TargetType="Button">
+                <Setter Property="VerticalAlignment" Value="Top" />
+                <Setter Property="CornerRadius" Value="4" />
+                <Setter Property="BorderThickness" Value="0" />
+                <Setter Property="Padding" Value="16,9,16,11" />
+                <Setter Property="Margin" Value="0" />
+                <Setter Property="Background" Value="Transparent" />
+            </Style>
+            <Style x:Key="GhostButtonStyle" TargetType="Button">
+                <Setter Property="VerticalAlignment" Value="Stretch" />
+                <Setter Property="Padding" Value="8" />
+                <Setter Property="CornerRadius" Value="4" />
+                <Setter Property="BorderThickness" Value="0" />
+                <Setter Property="Background" Value="Transparent" />
+            </Style>
+            <Style x:Key="TitleBarToggleButtonStyle" TargetType="ToggleButton">
+                <Setter Property="CornerRadius" Value="4" />
+                <Setter Property="VerticalAlignment" Value="Stretch" />
+                <Setter Property="BorderThickness" Value="0" />
+                <Setter Property="Padding" Value="16,0" />
+                <Setter Property="Background" Value="Transparent" />
+            </Style>
+            <Style x:Key="GhostToggleButtonStyle" TargetType="ToggleButton">
+                <Setter Property="CornerRadius" Value="4" />
+                <Setter Property="VerticalAlignment" Value="Stretch" />
+                <Setter Property="BorderThickness" Value="0" />
+                <Setter Property="Padding" Value="8" />
+                <Setter Property="Background" Value="Transparent" />
+            </Style>
 
+            <!--  Dimensions  -->
+
+            <!--  Fonts  -->
+            <FontFamily x:Key="IconFontFamily">Segoe Fluent Icons, Segoe MDL2 Assets</FontFamily>
         </ResourceDictionary>
     </Application.Resources>
 </Application>

BetterLyrics.WinUI3/BetterLyrics.WinUI3/App.xaml.cs

@@ -1,63 +1,119 @@
-using BetterLyrics.WinUI3.Services.Database;
-using BetterLyrics.WinUI3.Services.Settings;
+// 2025/6/23 by Zhe Fang
+
+using BetterLyrics.WinUI3.Enums;
+using BetterLyrics.WinUI3.Helper;
+using BetterLyrics.WinUI3.Services;
 using BetterLyrics.WinUI3.ViewModels;
 using BetterLyrics.WinUI3.Views;
 using CommunityToolkit.Mvvm.DependencyInjection;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
 using Microsoft.UI.Dispatching;
 using Microsoft.UI.Xaml;
 using Microsoft.Windows.ApplicationModel.Resources;
+using Serilog;
+using ShadowViewer.Controls;
+using System;
+using System.Linq;
 using System.Text;
+using System.Threading.Tasks;
 
-// To learn more about WinUI, the WinUI project structure,
-// and more about our project templates, see: http://aka.ms/winui-project-info.
+namespace BetterLyrics.WinUI3
+{
+    public partial class App : Application
+    {
 
-namespace BetterLyrics.WinUI3 {
-    /// <summary>
-    /// Provides application-specific behavior to supplement the default Application class.
-    /// </summary>
-    public partial class App : Application {
-        public static App Current => (App)Application.Current;
-        public MainWindow? MainWindow { get; private set; }
-        public MainWindow? SettingsWindow { get; set; }
+        private readonly ILogger<App> _logger;
 
-        public static ResourceLoader ResourceLoader = new();
+        public static new App Current => (App)Application.Current;
+        public static DispatcherQueue? DispatcherQueue { get; private set; }
+        public static DispatcherQueueTimer? DispatcherQueueTimer { get; private set; }
+        public static ResourceLoader? ResourceLoader { get; private set; }
 
-        public static DispatcherQueue DispatcherQueue => DispatcherQueue.GetForCurrentThread();
+        public NotificationPanel? LyricsWindowNotificationPanel { get; set; }
+        public NotificationPanel? SettingsWindowNotificationPanel { get; set; }
 
-        /// <summary>
-        /// Initializes the singleton application object.  This is the first line of authored code
-        /// executed, and as such is the logical equivalent of main() or WinMain().
-        /// </summary>
-        public App() {
+        public App()
+        {
             this.InitializeComponent();
+
+            DispatcherQueue = DispatcherQueue.GetForCurrentThread();
+            DispatcherQueueTimer = DispatcherQueue.CreateTimer();
+            ResourceLoader = new ResourceLoader();
+
+            Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
+            PathHelper.EnsureDirectories();
+            ConfigureServices();
+
+            _logger = Ioc.Default.GetRequiredService<ILogger<App>>();
+
+            UnhandledException += App_UnhandledException;
+            AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
+            AppDomain.CurrentDomain.FirstChanceException += CurrentDomain_FirstChanceException;
+            TaskScheduler.UnobservedTaskException += TaskScheduler_UnobservedTaskException;
         }
 
-        /// <summary>
-        /// Invoked when the application is launched.
-        /// </summary>
-        /// <param name="args">Details about the launch request and process.</param>
-        protected override void OnLaunched(Microsoft.UI.Xaml.LaunchActivatedEventArgs args) {
+        protected override void OnLaunched(LaunchActivatedEventArgs args)
+        {
+            WindowHelper.OpenOrShowWindow<LyricsWindow>();
+            var lyricsWindow = WindowHelper.GetWindowByWindowType<LyricsWindow>();
+            if (lyricsWindow == null) return;
+
+            lyricsWindow.AutoSelectLyricsMode();
+        }
+
+        private static void ConfigureServices()
+        {
+            Log.Logger = new LoggerConfiguration()
+                .MinimumLevel.Is(Serilog.Events.LogEventLevel.Verbose)
+                .WriteTo.File(PathHelper.LogFilePattern, rollingInterval: RollingInterval.Day)
+                .CreateLogger();
 
             // Register services
             Ioc.Default.ConfigureServices(
                 new ServiceCollection()
-                .AddSingleton(DispatcherQueue.GetForCurrentThread())
-                // Services
-                .AddSingleton<SettingsService>()
-                .AddSingleton<DatabaseService>()
-                // ViewModels
-                .AddSingleton<MainViewModel>()
-                .AddSingleton<SettingsViewModel>()
-                .BuildServiceProvider());
-
-            Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
-
-            // Activate the window
-            MainWindow = new MainWindow();
-            MainWindow!.Navigate(typeof(MainPage));
-            MainWindow.Activate();
+                    .AddLogging(loggingBuilder =>
+                    {
+                        loggingBuilder.ClearProviders();
+                        loggingBuilder.AddSerilog();
+                    })
+                    // Services
+                    .AddSingleton<ISettingsService, SettingsService>()
+                    .AddSingleton<IPlaybackService, PlaybackService>()
+                    .AddSingleton<IAlbumArtSearchService, AlbumArtSearchService>()
+                    .AddSingleton<ILyricsSearchService, LyricsSearchService>()
+                    .AddSingleton<ILibWatcherService, LibWatcherService>()
+                    .AddSingleton<ITranslateService, TranslateService>()
+                    // ViewModels
+                    .AddSingleton<LyricsWindowViewModel>()
+                    .AddSingleton<SettingsWindowViewModel>()
+                    .AddSingleton<SystemTrayViewModel>()
+                    .AddSingleton<SettingsPageViewModel>()
+                    .AddSingleton<LyricsPageViewModel>()
+                    .AddSingleton<LyricsRendererViewModel>()
+                    .BuildServiceProvider()
+            );
         }
 
+        private void App_UnhandledException(object sender, Microsoft.UI.Xaml.UnhandledExceptionEventArgs e)
+        {
+            _logger.LogError(e.Exception, "App_UnhandledException");
+            e.Handled = true;
+        }
+
+        private void CurrentDomain_FirstChanceException(object? sender, System.Runtime.ExceptionServices.FirstChanceExceptionEventArgs e)
+        {
+            _logger.LogError(e.Exception, "CurrentDomain_FirstChanceException");
+        }
+
+        private void CurrentDomain_UnhandledException(object sender, System.UnhandledExceptionEventArgs e)
+        {
+            _logger.LogError(e.ExceptionObject.ToString(), "CurrentDomain_UnhandledException");
+        }
+
+        private void TaskScheduler_UnobservedTaskException(object? sender, UnobservedTaskExceptionEventArgs e)
+        {
+            _logger.LogError(e.Exception, "TaskScheduler_UnobservedTaskException");
+        }
     }
 }

BetterLyrics.WinUI3/BetterLyrics.WinUI3/BetterLyrics.WinUI3.csproj

@@ -2,42 +2,94 @@
   <PropertyGroup>
     <OutputType>WinExe</OutputType>
     <TargetFramework>net8.0-windows10.0.26100.0</TargetFramework>
-    <TargetPlatformMinVersion>10.0.17763.0</TargetPlatformMinVersion>
+    <TargetPlatformMinVersion>10.0.19041.0</TargetPlatformMinVersion>
     <RootNamespace>BetterLyrics.WinUI3</RootNamespace>
-    <ApplicationManifest>app.manifest</ApplicationManifest>
     <Platforms>x86;x64;ARM64</Platforms>
     <RuntimeIdentifiers>win-x86;win-x64;win-arm64</RuntimeIdentifiers>
     <UseWinUI>true</UseWinUI>
     <Nullable>enable</Nullable>
+    <LangVersion>preview</LangVersion>
   </PropertyGroup>
-
+  <ItemGroup>
+    <Compile Remove="ViewModels\Lyrics\**" />
+    <Content Remove="ViewModels\Lyrics\**" />
+    <EmbeddedResource Remove="ViewModels\Lyrics\**" />
+    <None Remove="ViewModels\Lyrics\**" />
+    <Page Remove="ViewModels\Lyrics\**" />
+    <PRIResource Remove="ViewModels\Lyrics\**" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Remove="Assets\Core14.profile.xml" />
+    <None Remove="Controls\SystemTray.xaml" />
+    <None Remove="Views\SettingsWindow.xaml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Logo.ico" />
+  </ItemGroup>
   <ItemGroup>
     <Manifest Include="$(ApplicationManifest)" />
   </ItemGroup>
-
   <ItemGroup>
     <PackageReference Include="CommunityToolkit.Labs.WinUI.MarqueeText" Version="0.1.230830" />
     <PackageReference Include="CommunityToolkit.Labs.WinUI.OpacityMaskView" Version="0.1.250513-build.2126" />
     <PackageReference Include="CommunityToolkit.Mvvm" Version="8.4.0" />
     <PackageReference Include="CommunityToolkit.WinUI.Behaviors" Version="8.2.250402" />
+    <PackageReference Include="CommunityToolkit.WinUI.Controls.Primitives" Version="8.2.250402" />
+    <PackageReference Include="CommunityToolkit.WinUI.Controls.Segmented" Version="8.2.250402" />
     <PackageReference Include="CommunityToolkit.WinUI.Controls.SettingsControls" Version="8.2.250402" />
     <PackageReference Include="CommunityToolkit.WinUI.Converters" Version="8.2.250402" />
     <PackageReference Include="CommunityToolkit.WinUI.Extensions" Version="8.2.250402" />
+    <PackageReference Include="CommunityToolkit.WinUI.Helpers" Version="8.2.250402" />
     <PackageReference Include="CommunityToolkit.WinUI.Media" Version="8.2.250402" />
-    <PackageReference Include="DevWinUI" Version="8.2.0" />
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="9.0.5" />
+    <PackageReference Include="Dubya.WindowsMediaController" Version="2.5.5" />
+    <PackageReference Include="H.NotifyIcon.WinUI" Version="2.3.0" />
+    <PackageReference Include="Lyricify.Lyrics.Helper-NativeAot" Version="0.1.4-alpha.5" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="9.0.6" />
+    <PackageReference Include="Microsoft.Extensions.Logging" Version="9.0.6" />
     <PackageReference Include="Microsoft.Graphics.Win2D" Version="1.3.2" />
     <PackageReference Include="Microsoft.Windows.SDK.BuildTools" Version="10.0.26100.4188" />
-    <PackageReference Include="Microsoft.WindowsAppSDK" Version="1.7.250513003" />
-    <PackageReference Include="Microsoft.Xaml.Behaviors.WinUI.Managed" Version="3.0.0" />
-    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
-    <PackageReference Include="sqlite-net-pcl" Version="1.9.172" />
-    <PackageReference Include="System.Text.Encoding.CodePages" Version="9.0.5" />
+    <PackageReference Include="Microsoft.WindowsAppSDK" Version="1.7.250606001" />
+    <PackageReference Include="Nito.AsyncEx.Tasks" Version="5.1.2" />
+    <PackageReference Include="NTextCat" Version="0.3.65" />
+    <PackageReference Include="Serilog.Extensions.Logging" Version="9.0.2" />
+    <PackageReference Include="Serilog.Sinks.File" Version="7.0.0" />
+    <PackageReference Include="ShadowViewer.Controls.Notification" Version="1.2.1" />
+    <PackageReference Include="SixLabors.ImageSharp" Version="3.1.10" />
+    <PackageReference Include="System.Drawing.Common" Version="9.0.6" />
+    <PackageReference Include="System.Text.Encoding.CodePages" Version="9.0.6" />
+    <PackageReference Include="TagLibSharp" Version="2.3.0" />
     <PackageReference Include="Ude.NetStandard" Version="1.2.0" />
-    <PackageReference Include="z440.atl.core" Version="6.24.0" />
+    <PackageReference Include="Vanara.PInvoke.Gdi32" Version="4.1.6" />
+    <PackageReference Include="Vanara.PInvoke.Shell32" Version="4.1.6" />
+    <PackageReference Include="Vanara.PInvoke.User32" Version="4.1.6" />
+    <PackageReference Include="WinUIEx" Version="2.6.0" />
+    <PackageReference Include="z440.atl.core" Version="7.0.0" />
   </ItemGroup>
-
-    <!-- Publish Properties -->
+  <ItemGroup>
+    <Page Update="Rendering\InAppLyricsRenderer.xaml">
+      <Generator>MSBuild:Compile</Generator>
+    </Page>
+  </ItemGroup>
+  <ItemGroup>
+    <Page Update="Rendering\DesktopLyricsRenderer.xaml">
+      <Generator>MSBuild:Compile</Generator>
+    </Page>
+  </ItemGroup>
+  <!--Disable Trimming for Specific Packages-->
+  <ItemGroup>
+    <TrimmerRootAssembly Include="TagLibSharp" />
+  </ItemGroup>
+  <ItemGroup>
+    <Page Update="Views\SettingsWindow.xaml">
+      <Generator>MSBuild:Compile</Generator>
+    </Page>
+  </ItemGroup>
+  <ItemGroup>
+    <Page Update="Controls\SystemTray.xaml">
+      <Generator>MSBuild:Compile</Generator>
+    </Page>
+  </ItemGroup>
+  <!-- Publish Properties -->
   <PropertyGroup>
     <PublishReadyToRun Condition="'$(Configuration)' == 'Debug'">False</PublishReadyToRun>
     <PublishReadyToRun Condition="'$(Configuration)' != 'Debug'">True</PublishReadyToRun>
@@ -45,4 +97,22 @@
     <PublishTrimmed Condition="'$(Configuration)' != 'Debug'">True</PublishTrimmed>
     <SupportedOSPlatformVersion>10.0.19041.0</SupportedOSPlatformVersion>
   </PropertyGroup>
-</Project>
+  <PropertyGroup>
+    <DefineConstants>$(DefineConstants)</DefineConstants>
+    <ApplicationManifest>app.manifest</ApplicationManifest>
+    <ApplicationIcon>Logo.ico</ApplicationIcon>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <ShouldCreateLogs>True</ShouldCreateLogs>
+    <AdvancedSettingsExpanded>True</AdvancedSettingsExpanded>
+    <UpdateAssemblyVersion>False</UpdateAssemblyVersion>
+    <UpdateAssemblyFileVersion>False</UpdateAssemblyFileVersion>
+    <UpdateAssemblyInfoVersion>False</UpdateAssemblyInfoVersion>
+    <UpdatePackageVersion>True</UpdatePackageVersion>
+    <AssemblyInfoVersionType>SettingsVersion</AssemblyInfoVersionType>
+    <InheritWinAppVersionFrom>AssemblyVersion</InheritWinAppVersionFrom>
+    <PackageVersionSettings>AssemblyVersion.None.None</PackageVersionSettings>
+    <Version>2025.6.0</Version>
+    <AssemblyVersion>2025.6.18.0110</AssemblyVersion>
+    <FileVersion>2025.6.18.0110</FileVersion>
+  </PropertyGroup>
+</Project>

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Controls/SystemTray.xaml

@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<UserControl
+    x:Class="BetterLyrics.WinUI3.Controls.SystemTray"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+    xmlns:local="using:BetterLyrics.WinUI3.Controls"
+    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+    xmlns:tb="using:H.NotifyIcon"
+    xmlns:ui="using:CommunityToolkit.WinUI"
+    mc:Ignorable="d">
+
+    <tb:TaskbarIcon
+        x:Name="TrayIcon"
+        x:FieldModifier="public"
+        ContextMenuMode="SecondWindow"
+        IconSource="ms-appx:///Assets/Logo.ico"
+        NoLeftClickDelay="True"
+        ToolTipText="{x:Bind ViewModel.ToolTipText, Mode=OneWay}">
+        <tb:TaskbarIcon.ContextFlyout>
+            <MenuFlyout
+                AreOpenCloseAnimationsEnabled="True"
+                LightDismissOverlayMode="On"
+                ShowMode="TransientWithDismissOnPointerMoveAway">
+                <MenuFlyoutItem x:Uid="SystemTraySettings" Command="{x:Bind ViewModel.OpenSettingsCommand}" />
+                <MenuFlyoutItem x:Uid="SystemTrayExit" Command="{x:Bind ViewModel.ExitAppCommand}" />
+                <MenuFlyoutItem
+                    x:Uid="SystemTrayUnlock"
+                    Command="{x:Bind ViewModel.UnlockWindowCommand}"
+                    Visibility="{x:Bind ViewModel.IsLyricsWindowLocked, Mode=OneWay, Converter={StaticResource BoolToVisibilityConverter}}" />
+            </MenuFlyout>
+        </tb:TaskbarIcon.ContextFlyout>
+    </tb:TaskbarIcon>
+</UserControl>

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Controls/SystemTray.xaml.cs

@@ -0,0 +1,17 @@
+using BetterLyrics.WinUI3.ViewModels;
+using CommunityToolkit.Mvvm.DependencyInjection;
+using Microsoft.UI.Xaml.Controls;
+
+namespace BetterLyrics.WinUI3.Controls
+{
+    public sealed partial class SystemTray : UserControl
+    {
+        public SystemTrayViewModel ViewModel => (SystemTrayViewModel)DataContext;
+
+        public SystemTray()
+        {
+            InitializeComponent();
+            DataContext = Ioc.Default.GetService<SystemTrayViewModel>();
+        }
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Converter/AlbumArtSearchProviderToDisplayNameConverter.cs

@@ -0,0 +1,33 @@
+using BetterLyrics.WinUI3.Enums;
+using Microsoft.UI.Xaml.Data;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BetterLyrics.WinUI3.Converter
+{
+    public class AlbumArtSearchProviderToDisplayNameConverter : IValueConverter
+    {
+        public object Convert(object value, Type targetType, object parameter, string language)
+        {
+            if (value is AlbumArtSearchProvider provider)
+            {
+                return provider switch
+                {
+                    AlbumArtSearchProvider.Local => App.ResourceLoader!.GetString("AlbumArtSearchLocalProvider"),
+                    AlbumArtSearchProvider.SMTC => App.ResourceLoader!.GetString("AlbumArtSearchSMTCProvider"),
+                    AlbumArtSearchProvider.iTunes => "iTunes",
+                    _ => throw new Exception($"Unknown AlbumArtSearchProvider: {provider}"),
+                };
+            }
+            throw new ArgumentException("Value must be of type AlbumArtSearchProvider", nameof(value));
+        }
+
+        public object ConvertBack(object value, Type targetType, object parameter, string language)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Converter/ColorToBrushConverter.cs

@@ -1,22 +1,25 @@
-using Microsoft.UI.Xaml.Data;
-using Microsoft.UI.Xaml.Media;
+// 2025/6/23 by Zhe Fang
+
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+using Microsoft.UI.Xaml.Data;
+using Microsoft.UI.Xaml.Media;
 using Windows.UI;
 
-namespace BetterLyrics.WinUI3.Converter {
-    public class ColorToBrushConverter : IValueConverter {
-        public object Convert(object value, Type targetType, object parameter, string language) {
-            if (value is Color color) {
+namespace BetterLyrics.WinUI3.Converter
+{
+    public partial class ColorToBrushConverter : IValueConverter
+    {
+        public object Convert(object value, Type targetType, object parameter, string language)
+        {
+            if (value is Color color)
+            {
                 return new SolidColorBrush(color);
             }
             return new SolidColorBrush();
         }
 
-        public object ConvertBack(object value, Type targetType, object parameter, string language) {
+        public object ConvertBack(object value, Type targetType, object parameter, string language)
+        {
             throw new NotImplementedException();
         }
     }

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Converter/CornerRadiusToDoubleConverter.cs

@@ -0,0 +1,22 @@
+using System;
+using Microsoft.UI.Xaml.Data;
+
+namespace BetterLyrics.WinUI3.Converter
+{
+    internal partial class CornerRadiusToDoubleConverter : IValueConverter
+    {
+        public object Convert(object value, Type targetType, object parameter, string language)
+        {
+            if (value is Microsoft.UI.Xaml.CornerRadius cornerRadius)
+            {
+                return (double)cornerRadius.TopLeft;
+            }
+            return .0;
+        }
+
+        public object ConvertBack(object value, Type targetType, object parameter, string language)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Converter/EnumToIntConverter.cs

@@ -0,0 +1,28 @@
+// 2025/6/23 by Zhe Fang
+
+using System;
+using Microsoft.UI.Xaml.Data;
+
+namespace BetterLyrics.WinUI3.Converter
+{
+    internal partial class EnumToIntConverter : IValueConverter
+    {
+        public object Convert(object value, Type targetType, object parameter, string language)
+        {
+            if (value is Enum)
+            {
+                return System.Convert.ToInt32(value);
+            }
+            return 0;
+        }
+
+        public object ConvertBack(object value, Type targetType, object parameter, string language)
+        {
+            if (value is int && targetType.IsEnum)
+            {
+                return Enum.ToObject(targetType, value);
+            }
+            return Enum.ToObject(targetType, 0);
+        }
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Converter/IntToCornerRadius.cs

@@ -0,0 +1,24 @@
+// 2025/6/23 by Zhe Fang
+
+using System;
+using Microsoft.UI.Xaml.Data;
+
+namespace BetterLyrics.WinUI3.Converter
+{
+    public partial class IntToCornerRadius : IValueConverter
+    {
+        public object Convert(object value, Type targetType, object parameter, string language)
+        {
+            if (value is int intValue && parameter is double controlHeight)
+            {
+                return new Microsoft.UI.Xaml.CornerRadius(intValue / 100f * controlHeight / 2);
+            }
+            return new Microsoft.UI.Xaml.CornerRadius(0);
+        }
+
+        public object ConvertBack(object value, Type targetType, object parameter, string language)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Converter/LyricsSearchProviderToDisplayNameConverter.cs

@@ -0,0 +1,37 @@
+// 2025/6/23 by Zhe Fang
+
+using System;
+using BetterLyrics.WinUI3.Enums;
+using Microsoft.UI.Xaml.Data;
+
+namespace BetterLyrics.WinUI3.Converter
+{
+    public partial class LyricsSearchProviderToDisplayNameConverter : IValueConverter
+    {
+        public object Convert(object value, Type targetType, object parameter, string language)
+        {
+            if (value is LyricsSearchProvider provider)
+            {
+                return provider switch
+                {
+                    LyricsSearchProvider.LrcLib => App.ResourceLoader!.GetString("LyricsSearchProviderLrcLib"),
+                    LyricsSearchProvider.QQ => App.ResourceLoader!.GetString("LyricsSearchProviderQQ"),
+                    LyricsSearchProvider.Netease => App.ResourceLoader!.GetString("LyricsSearchProviderNetease"),
+                    LyricsSearchProvider.Kugou => App.ResourceLoader!.GetString("LyricsSearchProviderKugou"),
+                    LyricsSearchProvider.AmllTtmlDb => App.ResourceLoader!.GetString("LyricsSearchProviderAmllTtmlDb"),
+                    LyricsSearchProvider.LocalLrcFile => App.ResourceLoader!.GetString("LyricsSearchProviderLocalLrcFile"),
+                    LyricsSearchProvider.LocalMusicFile => App.ResourceLoader!.GetString("LyricsSearchProviderLocalMusicFile"),
+                    LyricsSearchProvider.LocalEslrcFile => App.ResourceLoader!.GetString("LyricsSearchProviderEslrcFile"),
+                    LyricsSearchProvider.LocalTtmlFile => App.ResourceLoader!.GetString("LyricsSearchProviderTtmlFile"),
+                    _ => "",
+                };
+            }
+            return "";
+        }
+
+        public object ConvertBack(object value, Type targetType, object parameter, string language)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Converter/MatchedLocalFilesPathToVisibilityConverter.cs

@@ -0,0 +1,32 @@
+// 2025/6/23 by Zhe Fang
+
+using System;
+using Microsoft.UI.Xaml;
+using Microsoft.UI.Xaml.Data;
+
+namespace BetterLyrics.WinUI3.Converter
+{
+    public partial class MatchedLocalFilesPathToVisibilityConverter : IValueConverter
+    {
+        public object Convert(object value, Type targetType, object parameter, string language)
+        {
+            if (value is string path)
+            {
+                if (path == App.ResourceLoader!.GetString("MainPageNoLocalFilesMatched"))
+                {
+                    return Visibility.Collapsed;
+                }
+                else
+                {
+                    return Visibility.Visible;
+                }
+            }
+            return Visibility.Collapsed;
+        }
+
+        public object ConvertBack(object value, Type targetType, object parameter, string language)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Converter/ThemeTypeToElementThemeConverter.cs

@@ -1,22 +0,0 @@
-using Microsoft.UI.Xaml;
-using Microsoft.UI.Xaml.Data;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace BetterLyrics.WinUI3.Converter {
-    internal class ThemeTypeToElementThemeConverter : IValueConverter {
-        public object Convert(object value, Type targetType, object parameter, string language) {
-            if (value is int themeType) {
-                return (ElementTheme)themeType;
-            }
-            return ElementTheme.Default;
-        }
-
-        public object ConvertBack(object value, Type targetType, object parameter, string language) {
-            return 0;
-        }
-    }
-}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Enums/AlbumArtSearchProvider.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BetterLyrics.WinUI3.Enums
+{
+    public enum AlbumArtSearchProvider
+    {
+        Local,
+        SMTC,
+        iTunes,
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Enums/AutoStartWindowType.cs

@@ -0,0 +1,11 @@
+// 2025/6/23 by Zhe Fang
+
+namespace BetterLyrics.WinUI3.Enums
+{
+    public enum AutoStartWindowType
+    {
+        StandardMode,
+        DockMode,
+        DesktopMode,
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Enums/BackdropType.cs

@@ -0,0 +1,13 @@
+// 2025/6/23 by Zhe Fang
+
+namespace BetterLyrics.WinUI3.Enums
+{
+    public enum BackdropType
+    {
+        None = 0,
+        Mica = 1,
+        MicaAlt = 2,
+        DesktopAcrylic = 3,
+        Transparent = 4,
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Enums/EasingType.cs

@@ -0,0 +1,20 @@
+// 2025/6/23 by Zhe Fang
+
+namespace BetterLyrics.WinUI3.Enums
+{
+    public enum EasingType
+    {
+        Linear,
+        SmoothStep,
+        EaseInOutSine,
+        EaseInOutQuad,
+        EaseInOutCubic,
+        EaseInOutQuart,
+        EaseInOutQuint,
+        EaseInOutExpo,
+        EaseInOutCirc,
+        EaseInOutBack,
+        EaseInOutElastic,
+        EaseInOutBounce,
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Enums/Language.cs

@@ -1,14 +1,20 @@
-using System;
+// 2025/6/23 by Zhe Fang
+
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace BetterLyrics.WinUI3.Models {
-    public enum Language {
+namespace BetterLyrics.WinUI3.Enums
+{
+    public enum Language
+    {
         FollowSystem,
         English,
         SimplifiedChinese,
         TraditionalChinese,
+        Japanese,
+        Korean,
     }
 }

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Enums/LineMaskType.cs

@@ -4,10 +4,11 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace BetterLyrics.WinUI3.Models {
-    public enum LyricsAlignmentType {
-        Left,
-        Center,
-        Right,
+namespace BetterLyrics.WinUI3.Enums
+{
+    public enum LineMaskType
+    {
+        Glow,
+        Highlight,
     }
 }

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Enums/LineRenderingType.cs

@@ -0,0 +1,11 @@
+// 2025/6/23 by Zhe Fang
+
+namespace BetterLyrics.WinUI3.Enums
+{
+    public enum LineRenderingType
+    {
+        CurrentChar,
+        LineStartToCurrentChar,
+        CurrentLine
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Enums/LocalSearchTargetProps.cs

@@ -0,0 +1,10 @@
+// 2025/6/23 by Zhe Fang
+
+namespace BetterLyrics.WinUI3.Enums
+{
+    public enum LocalSearchTargetProps
+    {
+        LyricsOnly,
+        LyricsAndAlbumArt,
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Enums/LyricsDisplayType.cs

@@ -0,0 +1,12 @@
+// 2025/6/23 by Zhe Fang
+
+namespace BetterLyrics.WinUI3.Enums
+{
+    public enum LyricsDisplayType
+    {
+        AlbumArtOnly,
+        LyricsOnly,
+        SplitView,
+        PlaceholderOnly,
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Enums/LyricsFontColorType.cs

@@ -0,0 +1,11 @@
+// 2025/6/23 by Zhe Fang
+
+namespace BetterLyrics.WinUI3.Enums
+{
+    public enum LyricsFontColorType
+    {
+        AdaptiveColored,
+        AdaptiveGrayed,
+        Custom,
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Enums/LyricsFontWeight.cs

@@ -0,0 +1,45 @@
+// 2025/6/23 by Zhe Fang
+
+using System;
+using Microsoft.UI.Text;
+using Windows.UI.Text;
+
+namespace BetterLyrics.WinUI3.Enums
+{
+    public enum LyricsFontWeight
+    {
+        Thin,
+        ExtraLight,
+        Light,
+        SemiLight,
+        Normal,
+        Medium,
+        SemiBold,
+        Bold,
+        ExtraBold,
+        Black,
+        ExtraBlack,
+    }
+
+    public static class LyricsFontWeightExtensions
+    {
+        public static FontWeight ToFontWeight(this LyricsFontWeight weight)
+        {
+            return weight switch
+            {
+                LyricsFontWeight.Thin => FontWeights.Thin,
+                LyricsFontWeight.ExtraLight => FontWeights.ExtraLight,
+                LyricsFontWeight.Light => FontWeights.Light,
+                LyricsFontWeight.SemiLight => FontWeights.SemiLight,
+                LyricsFontWeight.Normal => FontWeights.Normal,
+                LyricsFontWeight.Medium => FontWeights.Medium,
+                LyricsFontWeight.SemiBold => FontWeights.SemiBold,
+                LyricsFontWeight.Bold => FontWeights.Bold,
+                LyricsFontWeight.ExtraBold => FontWeights.ExtraBold,
+                LyricsFontWeight.Black => FontWeights.Black,
+                LyricsFontWeight.ExtraBlack => FontWeights.ExtraBlack,
+                LyricsFontWeight _ => throw new ArgumentOutOfRangeException(nameof(weight), weight, null),
+            };
+        }
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Enums/LyricsFormat.cs

@@ -0,0 +1,71 @@
+// 2025/6/23 by Zhe Fang
+
+namespace BetterLyrics.WinUI3.Enums
+{
+    public enum LyricsFormat
+    {
+        Lrc,
+        Eslrc,
+        Ttml,
+        Qrc,
+        Krc,
+        NotSpecified,
+    }
+
+    public static class LyricsFormatExtensions
+    {
+        public static LyricsFormat? DetectFormat(this string content)
+        {
+            if (string.IsNullOrWhiteSpace(content))
+                return null;
+
+            // TTML: 检查 <tt ... xmlns="http://www.w3.org/ns/ttml"
+            if (System.Text.RegularExpressions.Regex.IsMatch(
+                    content,
+                    @"<tt\b[^>]*\bxmlns\s*=\s*[""']http://www\.w3\.org/ns/ttml[""']",
+                    System.Text.RegularExpressions.RegexOptions.IgnoreCase))
+            {
+                return LyricsFormat.Ttml;
+            }
+            // KRC: 检测主内容格式 [start,duration]<offset,duration,0>字...
+            else if (System.Text.RegularExpressions.Regex.IsMatch(
+                         content,
+                         @"^\[\d+,\d+\](<\d+,\d+,0>.+)+",
+                         System.Text.RegularExpressions.RegexOptions.Multiline))
+            {
+                return LyricsFormat.Krc;
+            }
+            // QRC: 检测主内容格式 [start,duration]字(offset,duration)
+            else if (System.Text.RegularExpressions.Regex.IsMatch(
+                         content,
+                         @"^\[\d+,\d+\].*?\(\d+,\d+\)",
+                         System.Text.RegularExpressions.RegexOptions.Multiline))
+            {
+                return LyricsFormat.Qrc;
+            }
+            // 标准LRC和增强型LRC
+            else if (System.Text.RegularExpressions.Regex.IsMatch(content, @"\[\d{1,2}:\d{2}") ||
+                     System.Text.RegularExpressions.Regex.IsMatch(content, @"<\d{1,2}:\d{2}\.\d{2,3}>"))
+            {
+                return LyricsFormat.Lrc;
+            }
+            else
+            {
+                return null;
+            }
+        }
+
+        public static string ToFileExtension(this LyricsFormat format)
+        {
+            return format switch
+            {
+                LyricsFormat.Lrc => ".lrc",
+                LyricsFormat.Qrc => ".qrc",
+                LyricsFormat.Krc => ".krc",
+                LyricsFormat.Eslrc => ".eslrc",
+                LyricsFormat.Ttml => ".ttml",
+                _ => ".*",
+            };
+        }
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Enums/LyricsSearchProvider.cs

@@ -0,0 +1,65 @@
+// 2025/6/23 by Zhe Fang
+
+using BetterLyrics.WinUI3.Helper;
+
+namespace BetterLyrics.WinUI3.Enums
+{
+    public enum LyricsSearchProvider
+    {
+        QQ,
+        Kugou,
+        Netease,
+        LrcLib,
+        AmllTtmlDb,
+        LocalMusicFile,
+        LocalLrcFile,
+        LocalEslrcFile,
+        LocalTtmlFile,
+    }
+
+    public static class LyricsSearchProviderExtensions
+    {
+        public static string GetCacheDirectory(this LyricsSearchProvider provider)
+        {
+            return provider switch
+            {
+                LyricsSearchProvider.LrcLib => PathHelper.LrcLibLyricsCacheDirectory,
+                LyricsSearchProvider.QQ => PathHelper.QQLyricsCacheDirectory,
+                LyricsSearchProvider.Netease => PathHelper.NeteaseLyricsCacheDirectory,
+                LyricsSearchProvider.Kugou => PathHelper.KugouLyricsCacheDirectory,
+                LyricsSearchProvider.AmllTtmlDb => PathHelper.AmllTtmlDbLyricsCacheDirectory,
+                _ => throw new System.ArgumentOutOfRangeException(nameof(provider)),
+            };
+        }
+
+        public static LyricsFormat GetLyricsFormat(this LyricsSearchProvider provider)
+        {
+            return provider switch
+            {
+                LyricsSearchProvider.LrcLib => LyricsFormat.Lrc,
+                LyricsSearchProvider.QQ => LyricsFormat.Qrc,
+                LyricsSearchProvider.Kugou => LyricsFormat.Krc,
+                LyricsSearchProvider.Netease => LyricsFormat.Lrc,
+                LyricsSearchProvider.AmllTtmlDb => LyricsFormat.Ttml,
+                LyricsSearchProvider.LocalLrcFile => LyricsFormat.Lrc,
+                LyricsSearchProvider.LocalEslrcFile => LyricsFormat.Eslrc,
+                LyricsSearchProvider.LocalTtmlFile => LyricsFormat.Ttml,
+                _ => LyricsFormat.NotSpecified,
+            };
+        }
+
+        public static bool IsLocal(this LyricsSearchProvider provider)
+        {
+            return provider
+                is LyricsSearchProvider.LocalMusicFile
+                    or LyricsSearchProvider.LocalLrcFile
+                    or LyricsSearchProvider.LocalEslrcFile
+                    or LyricsSearchProvider.LocalTtmlFile;
+        }
+
+        public static bool IsRemote(this LyricsSearchProvider provider)
+        {
+            return !provider.IsLocal();
+        }
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Enums/TextAlignmentType.cs

@@ -0,0 +1,28 @@
+// 2025/6/23 by Zhe Fang
+
+using Microsoft.Graphics.Canvas.Text;
+using System;
+
+namespace BetterLyrics.WinUI3.Enums
+{
+    public enum TextAlignmentType
+    {
+        Left,
+        Center,
+        Right,
+    }
+
+    public static class LyricsAlignmentTypeExtensions
+    {
+        public static CanvasHorizontalAlignment ToCanvasHorizontalAlignment(this TextAlignmentType alignmentType)
+        {
+            return alignmentType switch
+            {
+                TextAlignmentType.Left => CanvasHorizontalAlignment.Left,
+                TextAlignmentType.Center => CanvasHorizontalAlignment.Center,
+                TextAlignmentType.Right => CanvasHorizontalAlignment.Right,
+                _ => throw new ArgumentOutOfRangeException(nameof(alignmentType), alignmentType, null),
+            };
+        }
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Enums/WindowPixelSampleMode.cs

@@ -0,0 +1,9 @@
+namespace BetterLyrics.WinUI3.Enums
+{
+    public enum WindowPixelSampleMode
+    {
+        BelowWindow,
+        WindowArea,
+        WindowEdge,
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Events/AlbumArtChangedEventArgs.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Windows.Graphics.Imaging;
+using Windows.UI;
+
+namespace BetterLyrics.WinUI3.Events
+{
+    public class AlbumArtChangedEventArgs : EventArgs
+    {
+        public SoftwareBitmap? AlbumArtSwBitmap { get; set; } = null;
+        public Color? AlbumArtAccentColor { get; set; } = null;
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Events/IsPlayingChangedEventArgs.cs

@@ -0,0 +1,11 @@
+// 2025/6/23 by Zhe Fang
+
+using System;
+
+namespace BetterLyrics.WinUI3.Events
+{
+    public class IsPlayingChangedEventArgs(bool isPlaying) : EventArgs
+    {
+        public bool IsPlaying { get; set; } = isPlaying;
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Events/LibChangedEventArgs.cs

@@ -0,0 +1,18 @@
+// 2025/6/23 by Zhe Fang
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BetterLyrics.WinUI3.Events
+{
+    public class LibChangedEventArgs(string folder, string filePath, WatcherChangeTypes changeType) : EventArgs
+    {
+        public WatcherChangeTypes ChangeType { get; } = changeType;
+        public string FilePath { get; } = filePath;
+        public string Folder { get; } = folder;
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Events/MediaSourceProvidersInfoEventArgs.cs

@@ -0,0 +1,14 @@
+using BetterLyrics.WinUI3.Models;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BetterLyrics.WinUI3.Events
+{
+    public class MediaSourceProvidersInfoEventArgs(List<MediaSourceProviderInfo> sessionIds):EventArgs
+    {
+        public List<MediaSourceProviderInfo> MediaSourceProviersInfo { get; set; } = sessionIds;
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Events/PositionChangedEventArgs.cs

@@ -0,0 +1,11 @@
+// 2025/6/23 by Zhe Fang
+
+using System;
+
+namespace BetterLyrics.WinUI3.Events
+{
+    public class PositionChangedEventArgs(TimeSpan position) : EventArgs()
+    {
+        public TimeSpan Position { get; set; } = position;
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Events/SongInfoChangedEventArgs.cs

@@ -0,0 +1,12 @@
+// 2025/6/23 by Zhe Fang
+
+using System;
+using BetterLyrics.WinUI3.Models;
+
+namespace BetterLyrics.WinUI3.Events
+{
+    public class SongInfoChangedEventArgs(SongInfo? songInfo) : EventArgs
+    {
+        public SongInfo? SongInfo { get; set; } = songInfo;
+    }
+}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Helper/AnimationHelper.cs

@@ -1,44 +0,0 @@
-using Microsoft.UI.Xaml;
-using Microsoft.UI.Xaml.Media.Animation;
-using System;
-
-namespace BetterLyrics.WinUI3.Helper {
-
-    /// <summary>
-    /// Edited based on: https://stackoverflow.com/a/25236507/11048731
-    /// </summary>
-    public class AnimationHelper : DependencyObject {
-        public static int GetAnimationDuration(DependencyObject obj) {
-            return (int)obj.GetValue(AnimationDurationProperty);
-        }
-
-        public static void SetAnimationDuration(DependencyObject obj, int value) {
-            obj.SetValue(AnimationDurationProperty, value);
-        }
-
-        // Using a DependencyProperty as the backing store for AnimationDuration.
-        // This enables animation, styling, binding, etc...
-        public static readonly DependencyProperty AnimationDurationProperty =
-            DependencyProperty.RegisterAttached("AnimationDuration", typeof(int),
-            typeof(AnimationHelper), new PropertyMetadata(0,
-            OnAnimationDurationChanged));
-
-        private static void OnAnimationDurationChanged(DependencyObject d,
-            DependencyPropertyChangedEventArgs e) {
-            FrameworkElement element = d as FrameworkElement;
-
-            var ms = (int)e.NewValue;
-
-            if (ms < 0) return;
-
-            var key = "LyricsLineCharGradientInTextBlock";
-            foreach (var timeline in (element.Resources[key] as Storyboard).Children) {
-                foreach (var keyFrame in (timeline as DoubleAnimationUsingKeyFrames).KeyFrames) {
-                    (keyFrame as LinearDoubleKeyFrame).KeyTime =
-                        KeyTime.FromTimeSpan(TimeSpan.FromMilliseconds(ms));
-                }
-            }
-        }
-    }
-
-}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Helper/CollectionHelper.cs

@@ -1,15 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace BetterLyrics.WinUI3.Helper {
-    public static class CollectionHelper {
-        public static T? SafeGet<T>(this IList<T> list, int index) {
-            if (list == null || index < 0 || index >= list.Count)
-                return default;
-            return list[index];
-        }
-    }
-}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Helper/ColorHelper.cs

@@ -1,11 +1,243 @@
-namespace BetterLyrics.WinUI3.Helper {
-    public class ColorHelper {
-        public static Windows.UI.Color LerpColor(Windows.UI.Color a, Windows.UI.Color b, double t) {
-            byte A = (byte)(a.A + (b.A - a.A) * t);
-            byte R = (byte)(a.R + (b.R - a.R) * t);
-            byte G = (byte)(a.G + (b.G - a.G) * t);
-            byte B = (byte)(a.B + (b.B - a.B) * t);
-            return Windows.UI.Color.FromArgb(A, R, G, B);
+// 2025/6/23 by Zhe Fang
+
+using BetterLyrics.WinUI3.Enums;
+using Microsoft.UI;
+using Microsoft.UI.Xaml;
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Drawing.Imaging;
+using Vanara.PInvoke;
+using Windows.UI;
+
+using Color = Windows.UI.Color;
+
+namespace BetterLyrics.WinUI3.Helper
+{
+    public static class ColorHelper
+    {
+        public static ElementTheme GetElementThemeFromBackgroundColor(Color backgroundColor)
+        {
+            // 计算亮度（YIQ公式）
+            double yiq =
+                ((backgroundColor.R * 299) + (backgroundColor.G * 587) + (backgroundColor.B * 114))
+                / 1000.0;
+            return yiq >= 128 ? ElementTheme.Light : ElementTheme.Dark;
+        }
+
+        public static Color GetForegroundColor(Color background)
+        {
+            // 转为 HSL
+            var hsl = CommunityToolkit.WinUI.Helpers.ColorHelper.ToHsl(background);
+            double h = hsl.H;
+            double s = hsl.S;
+            double l = hsl.L;
+
+            // 目标亮度与背景错开，但不极端
+            double targetL;
+            if (l >= 0.7)
+                targetL = 0.35; // 背景很亮，前景适中偏暗
+            else if (l <= 0.3)
+                targetL = 0.75; // 背景很暗，前景适中偏亮
+            else
+                targetL = l > 0.5 ? l - 0.35 : l + 0.35; // 其余情况适度错开
+
+            // 保持色相，适当提升饱和度
+            double targetS = Math.Min(1.0, s + 0.2);
+
+            // 转回 Color
+            var fg = CommunityToolkit.WinUI.Helpers.ColorHelper.FromHsl(h, targetS, targetL);
+
+            // 保持不透明
+            return Color.FromArgb(255, fg.R, fg.G, fg.B);
+        }
+
+        public static Color GetInterpolatedColor(float progress, Color startColor, Color targetColor)
+        {
+            byte Lerp(byte a, byte b) => (byte)(a + (progress * (b - a)));
+            return Color.FromArgb(
+                Lerp(startColor.A, targetColor.A),
+                Lerp(startColor.R, targetColor.R),
+                Lerp(startColor.G, targetColor.G),
+                Lerp(startColor.B, targetColor.B)
+            );
+        }
+
+        public static Color ToColor(this int argb)
+        {
+            byte a = (byte)(argb >> 24);
+            byte r = (byte)(argb >> 16);
+            byte g = (byte)(argb >> 8);
+            byte b = (byte)argb;
+
+            // 还原非预乘分量
+            if (a == 0)
+                return Color.FromArgb(0, 0, 0, 0);
+
+            // 预乘解码
+            // 这里 a+1 是编码时的分母
+            int ap1 = a + 1;
+            r = (byte)Math.Min(255, (r * 255 + (ap1 / 2)) / ap1);
+            g = (byte)Math.Min(255, (g * 255 + (ap1 / 2)) / ap1);
+            b = (byte)Math.Min(255, (b * 255 + (ap1 / 2)) / ap1);
+
+            return Color.FromArgb(a, r, g, b);
+        }
+
+        public static Color ToColor(this System.Drawing.Color color)
+        {
+            return Color.FromArgb(color.A, color.R, color.G, color.B);
+        }
+
+        public static Color WithAlpha(this Color color, byte alpha)
+        {
+            return Color.FromArgb(alpha, color.R, color.G, color.B);
+        }
+
+        public static Color WithBrightness(this Color color, double brightness)
+        {
+            // 确保亮度因子在合理范围内
+            brightness = Math.Max(0, Math.Min(1, brightness));
+
+            var hsl = CommunityToolkit.WinUI.Helpers.ColorHelper.ToHsl(color);
+            double h = hsl.H;
+            double s = hsl.S;
+
+            return CommunityToolkit.WinUI.Helpers.ColorHelper.FromHsl(h, s, brightness);
+        }
+
+        public static System.Drawing.Color GetAccentColor(IntPtr myHwnd, WindowPixelSampleMode mode)
+        {
+            if (!User32.GetWindowRect(myHwnd, out RECT myRect)) return System.Drawing.Color.Transparent;
+
+            switch (mode)
+            {
+                case WindowPixelSampleMode.BelowWindow:
+                    {
+                        int screenWidth = User32.GetSystemMetrics(User32.SystemMetric.SM_CXSCREEN);
+                        int sampleHeight = 1;
+                        int sampleY = myRect.Bottom + 1;
+                        return GetAverageColorFromScreenRegion(0, sampleY, screenWidth, sampleHeight);
+                    }
+                case WindowPixelSampleMode.WindowArea:
+                    {
+                        int width = myRect.Right - myRect.Left;
+                        int height = myRect.Bottom - myRect.Top;
+                        if (width <= 0 || height <= 0)
+                            return System.Drawing.Color.Transparent;
+                        // 采集窗口区域的平均色
+                        return GetAverageColorFromScreenRegion(myRect.Left, myRect.Top, width, height);
+                    }
+                case WindowPixelSampleMode.WindowEdge:
+                    {
+                        int width = myRect.Right - myRect.Left;
+                        int height = myRect.Bottom - myRect.Top;
+                        if (width <= 0 || height <= 0)
+                            return System.Drawing.Color.Transparent;
+
+                        var edgeThickness = new Thickness(36, 0, 36, 0);
+                        List<System.Drawing.Color> edgeColors = [];
+
+                        // Top edge
+                        if (edgeThickness.Top > 0 && edgeThickness.Top < height)
+                            edgeColors.Add(
+                                GetAverageColorFromScreenRegion(
+                                    myRect.Left,
+                                    myRect.Top,
+                                    width,
+                                    (int)edgeThickness.Top
+                                )
+                            );
+                        // Bottom edge
+                        if (edgeThickness.Bottom > 0 && edgeThickness.Bottom < height)
+                            edgeColors.Add(
+                                GetAverageColorFromScreenRegion(
+                                    myRect.Left,
+                                    myRect.Bottom - (int)edgeThickness.Bottom,
+                                    width,
+                                    (int)edgeThickness.Bottom
+                                )
+                            );
+                        // Left edge
+                        if (edgeThickness.Left > 0 && edgeThickness.Left < width)
+                            edgeColors.Add(
+                                GetAverageColorFromScreenRegion(
+                                    myRect.Left,
+                                    myRect.Top + (int)edgeThickness.Top,
+                                    (int)edgeThickness.Left,
+                                    height - (int)edgeThickness.Top - (int)edgeThickness.Bottom
+                                )
+                            );
+                        // Right edge
+                        if (edgeThickness.Right > 0 && edgeThickness.Right < width)
+                            edgeColors.Add(
+                                GetAverageColorFromScreenRegion(
+                                    myRect.Right - (int)edgeThickness.Right,
+                                    myRect.Top + (int)edgeThickness.Top,
+                                    (int)edgeThickness.Right,
+                                    height - (int)edgeThickness.Top - (int)edgeThickness.Bottom
+                                )
+                            );
+
+                        // 合并四边平均色
+                        if (edgeColors.Count == 0)
+                            return System.Drawing.Color.Transparent;
+                        long r = 0,
+                            g = 0,
+                            b = 0;
+                        foreach (var c in edgeColors)
+                        {
+                            r += c.R;
+                            g += c.G;
+                            b += c.B;
+                        }
+                        return System.Drawing.Color.FromArgb(
+                            255,
+                            (int)(r / edgeColors.Count),
+                            (int)(g / edgeColors.Count),
+                            (int)(b / edgeColors.Count)
+                        );
+                    }
+                default:
+                    return System.Drawing.Color.Transparent;
+            }
+        }
+
+        private static System.Drawing.Color GetAverageColorFromScreenRegion(int x, int y, int width, int height)
+        {
+            using Bitmap bmp = new(width, height, PixelFormat.Format32bppArgb);
+            using Graphics gDest = Graphics.FromImage(bmp);
+
+            IntPtr hdcDest = gDest.GetHdc();
+            IntPtr hdcSrc = (nint)User32.GetDC(IntPtr.Zero); // Entire screen
+
+            Gdi32.BitBlt(hdcDest, 0, 0, width, height, hdcSrc, x, y, Gdi32.RasterOperationMode.SRCCOPY);
+
+            gDest.ReleaseHdc(hdcDest);
+            User32.ReleaseDC(IntPtr.Zero, hdcSrc);
+
+            return ComputeAverageColor(bmp);
+        }
+
+        private static System.Drawing.Color ComputeAverageColor(Bitmap bmp)
+        {
+            long r = 0, g = 0, b = 0;
+            int count = 0;
+
+            for (int y = 0; y < bmp.Height; y++)
+            {
+                for (int x = 0; x < bmp.Width; x++)
+                {
+                    System.Drawing.Color pixel = bmp.GetPixel(x, y);
+                    r += pixel.R;
+                    g += pixel.G;
+                    b += pixel.B;
+                    count++;
+                }
+            }
+
+            if (count == 0) return System.Drawing.Color.Transparent;
+            return System.Drawing.Color.FromArgb((int)(r / count), (int)(g / count), (int)(b / count));
         }
 
     }

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Helper/ColorThief.cs

@@ -1,928 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using Windows.Graphics.Imaging;
-
-namespace BetterLyrics.WinUI3.Helper
-{
-    /// <summary>
-    ///     Color map
-    /// </summary>
-    internal class CMap
-    {
-        private readonly List<VBox> vboxes = new List<VBox>();
-        private List<QuantizedColor> palette;
-
-        public void Push(VBox box)
-        {
-            palette = null;
-            vboxes.Add(box);
-        }
-
-        public List<QuantizedColor> GeneratePalette()
-        {
-            if (palette == null)
-            {
-                palette = (from vBox in vboxes
-                           let rgb = vBox.Avg(false)
-                           let color = FromRgb(rgb[0], rgb[1], rgb[2])
-                           select new QuantizedColor(color, vBox.Count(false))).ToList();
-            }
-
-            return palette;
-        }
-
-        public int Size()
-        {
-            return vboxes.Count;
-        }
-
-        public int[] Map(int[] color)
-        {
-            foreach (var vbox in vboxes.Where(vbox => vbox.Contains(color)))
-            {
-                return vbox.Avg(false);
-            }
-            return Nearest(color);
-        }
-
-        public int[] Nearest(int[] color)
-        {
-            var d1 = double.MaxValue;
-            int[] pColor = null;
-
-            foreach (var t in vboxes)
-            {
-                var vbColor = t.Avg(false);
-                var d2 = Math.Sqrt(Math.Pow(color[0] - vbColor[0], 2)
-                                   + Math.Pow(color[1] - vbColor[1], 2)
-                                   + Math.Pow(color[2] - vbColor[2], 2));
-                if (d2 < d1)
-                {
-                    d1 = d2;
-                    pColor = vbColor;
-                }
-            }
-            return pColor;
-        }
-
-        public VBox FindColor(double targetLuma, double minLuma, double maxLuma, double targetSaturation, double minSaturation, double maxSaturation)
-        {
-            VBox max = null;
-            double maxValue = 0;
-            var highestPopulation = vboxes.Select(p => p.Count(false)).Max();
-
-            foreach (var swatch in vboxes)
-            {
-                var avg = swatch.Avg(false);
-                var hsl = FromRgb(avg[0], avg[1], avg[2]).ToHsl();
-                var sat = hsl.S;
-                var luma = hsl.L;
-
-                if (sat >= minSaturation && sat <= maxSaturation &&
-                   luma >= minLuma && luma <= maxLuma)
-                {
-                    var thisValue = Mmcq.CreateComparisonValue(sat, targetSaturation, luma, targetLuma,
-                        swatch.Count(false), highestPopulation);
-
-                    if (max == null || thisValue > maxValue)
-                    {
-                        max = swatch;
-                        maxValue = thisValue;
-                    }
-                }
-            }
-
-            return max;
-        }
-
-        public Color FromRgb(int red, int green, int blue)
-        {
-            var color = new Color
-            {
-                A = 255,
-                R = (byte)red,
-                G = (byte)green,
-                B = (byte)blue
-            };
-
-            return color;
-        }
-    }
-
-    /// <summary>
-    ///     Defines a color in RGB space.
-    /// </summary>
-    public struct Color
-    {
-        /// <summary>
-        ///     Get or Set the Alpha component value for sRGB.
-        /// </summary>
-        public byte A;
-
-        /// <summary>
-        ///     Get or Set the Blue component value for sRGB.
-        /// </summary>
-        public byte B;
-
-        /// <summary>
-        ///     Get or Set the Green component value for sRGB.
-        /// </summary>
-        public byte G;
-
-        /// <summary>
-        ///     Get or Set the Red component value for sRGB.
-        /// </summary>
-        public byte R;
-
-        /// <summary>
-        ///     Get HSL color.
-        /// </summary>
-        /// <returns></returns>
-        public HslColor ToHsl()
-        {
-            const double toDouble = 1.0 / 255;
-            var r = toDouble * R;
-            var g = toDouble * G;
-            var b = toDouble * B;
-            var max = Math.Max(Math.Max(r, g), b);
-            var min = Math.Min(Math.Min(r, g), b);
-            var chroma = max - min;
-            double h1;
-
-            // ReSharper disable CompareOfFloatsByEqualityOperator
-            if (chroma == 0)
-            {
-                h1 = 0;
-            }
-            else if (max == r)
-            {
-                h1 = (g - b) / chroma % 6;
-            }
-            else if (max == g)
-            {
-                h1 = 2 + (b - r) / chroma;
-            }
-            else //if (max == b)
-            {
-                h1 = 4 + (r - g) / chroma;
-            }
-
-            var lightness = 0.5 * (max - min);
-            var saturation = chroma == 0 ? 0 : chroma / (1 - Math.Abs(2 * lightness - 1));
-            HslColor ret;
-            ret.H = 60 * h1;
-            ret.S = saturation;
-            ret.L = lightness;
-            ret.A = toDouble * A;
-            return ret;
-            // ReSharper restore CompareOfFloatsByEqualityOperator
-        }
-
-        public string ToHexString()
-        {
-            return "#" + R.ToString("X2") + G.ToString("X2") + B.ToString("X2");
-        }
-
-        public string ToHexAlphaString()
-        {
-            return "#" + A.ToString("X2") + R.ToString("X2") + G.ToString("X2") + B.ToString("X2");
-        }
-
-        public override string ToString()
-        {
-            if (A == 255)
-            {
-                return ToHexString();
-            }
-
-            return ToHexAlphaString();
-        }
-    }
-
-    /// <summary>
-    ///     Defines a color in Hue/Saturation/Lightness (HSL) space.
-    /// </summary>
-    public struct HslColor
-    {
-        /// <summary>
-        ///     The Alpha/opacity in 0..1 range.
-        /// </summary>
-        public double A;
-
-        /// <summary>
-        ///     The Hue in 0..360 range.
-        /// </summary>
-        public double H;
-
-        /// <summary>
-        ///     The Lightness in 0..1 range.
-        /// </summary>
-        public double L;
-
-        /// <summary>
-        ///     The Saturation in 0..1 range.
-        /// </summary>
-        public double S;
-    }
-
-    internal static class Mmcq
-    {
-        public const int Sigbits = 5;
-        public const int Rshift = 8 - Sigbits;
-        public const int Mult = 1 << Rshift;
-        public const int Histosize = 1 << (3 * Sigbits);
-        public const int VboxLength = 1 << Sigbits;
-        public const double FractByPopulation = 0.75;
-        public const int MaxIterations = 1000;
-        public const double WeightSaturation = 3d;
-        public const double WeightLuma = 6d;
-        public const double WeightPopulation = 1d;
-        private static readonly VBoxComparer ComparatorProduct = new VBoxComparer();
-        private static readonly VBoxCountComparer ComparatorCount = new VBoxCountComparer();
-
-        public static int GetColorIndex(int r, int g, int b)
-        {
-            return (r << (2 * Sigbits)) + (g << Sigbits) + b;
-        }
-
-        /// <summary>
-        ///     Gets the histo.
-        /// </summary>
-        /// <param name="pixels">The pixels.</param>
-        /// <returns>Histo (1-d array, giving the number of pixels in each quantized region of color space), or null on error.</returns>
-        private static int[] GetHisto(IEnumerable<byte[]> pixels)
-        {
-            var histo = new int[Histosize];
-
-            foreach (var pixel in pixels)
-            {
-                var rval = pixel[0] >> Rshift;
-                var gval = pixel[1] >> Rshift;
-                var bval = pixel[2] >> Rshift;
-                var index = GetColorIndex(rval, gval, bval);
-                histo[index]++;
-            }
-            return histo;
-        }
-
-        private static VBox VboxFromPixels(IList<byte[]> pixels, int[] histo)
-        {
-            int rmin = 1000000, rmax = 0;
-            int gmin = 1000000, gmax = 0;
-            int bmin = 1000000, bmax = 0;
-
-            // find min/max
-            var numPixels = pixels.Count;
-            for (var i = 0; i < numPixels; i++)
-            {
-                var pixel = pixels[i];
-                var rval = pixel[0] >> Rshift;
-                var gval = pixel[1] >> Rshift;
-                var bval = pixel[2] >> Rshift;
-
-                if (rval < rmin)
-                {
-                    rmin = rval;
-                }
-                else if (rval > rmax)
-                {
-                    rmax = rval;
-                }
-
-                if (gval < gmin)
-                {
-                    gmin = gval;
-                }
-                else if (gval > gmax)
-                {
-                    gmax = gval;
-                }
-
-                if (bval < bmin)
-                {
-                    bmin = bval;
-                }
-                else if (bval > bmax)
-                {
-                    bmax = bval;
-                }
-            }
-
-            return new VBox(rmin, rmax, gmin, gmax, bmin, bmax, histo);
-        }
-
-        private static VBox[] DoCut(char color, VBox vbox, IList<int> partialsum, IList<int> lookaheadsum, int total)
-        {
-            int vboxDim1;
-            int vboxDim2;
-
-            switch (color)
-            {
-                case 'r':
-                    vboxDim1 = vbox.R1;
-                    vboxDim2 = vbox.R2;
-                    break;
-                case 'g':
-                    vboxDim1 = vbox.G1;
-                    vboxDim2 = vbox.G2;
-                    break;
-                default:
-                    vboxDim1 = vbox.B1;
-                    vboxDim2 = vbox.B2;
-                    break;
-            }
-
-            for (var i = vboxDim1; i <= vboxDim2; i++)
-            {
-                if (partialsum[i] > total / 2)
-                {
-                    var vbox1 = vbox.Clone();
-                    var vbox2 = vbox.Clone();
-
-                    var left = i - vboxDim1;
-                    var right = vboxDim2 - i;
-
-                    var d2 = left <= right
-                        ? Math.Min(vboxDim2 - 1, Math.Abs(i + right / 2))
-                        : Math.Max(vboxDim1, Math.Abs(Convert.ToInt32(i - 1 - left / 2.0)));
-
-                    // avoid 0-count boxes
-                    while (d2 < 0 || partialsum[d2] <= 0)
-                    {
-                        d2++;
-                    }
-                    var count2 = lookaheadsum[d2];
-                    while (count2 == 0 && d2 > 0 && partialsum[d2 - 1] > 0)
-                    {
-                        count2 = lookaheadsum[--d2];
-                    }
-
-                    // set dimensions
-                    switch (color)
-                    {
-                        case 'r':
-                            vbox1.R2 = d2;
-                            vbox2.R1 = d2 + 1;
-                            break;
-                        case 'g':
-                            vbox1.G2 = d2;
-                            vbox2.G1 = d2 + 1;
-                            break;
-                        default:
-                            vbox1.B2 = d2;
-                            vbox2.B1 = d2 + 1;
-                            break;
-                    }
-
-                    return new[] { vbox1, vbox2 };
-                }
-            }
-
-            throw new Exception("VBox can't be cut");
-        }
-
-        private static VBox[] MedianCutApply(IList<int> histo, VBox vbox)
-        {
-            if (vbox.Count(false) == 0)
-            {
-                return null;
-            }
-            if (vbox.Count(false) == 1)
-            {
-                return new[] { vbox.Clone(), null };
-            }
-
-            // only one pixel, no split
-
-            var rw = vbox.R2 - vbox.R1 + 1;
-            var gw = vbox.G2 - vbox.G1 + 1;
-            var bw = vbox.B2 - vbox.B1 + 1;
-            var maxw = Math.Max(Math.Max(rw, gw), bw);
-
-            // Find the partial sum arrays along the selected axis.
-            var total = 0;
-            var partialsum = new int[VboxLength];
-            // -1 = not set / 0 = 0
-            for (var l = 0; l < partialsum.Length; l++)
-            {
-                partialsum[l] = -1;
-            }
-
-            // -1 = not set / 0 = 0
-            var lookaheadsum = new int[VboxLength];
-            for (var l = 0; l < lookaheadsum.Length; l++)
-            {
-                lookaheadsum[l] = -1;
-            }
-
-            int i, j, k, sum, index;
-
-            if (maxw == rw)
-            {
-                for (i = vbox.R1; i <= vbox.R2; i++)
-                {
-                    sum = 0;
-                    for (j = vbox.G1; j <= vbox.G2; j++)
-                    {
-                        for (k = vbox.B1; k <= vbox.B2; k++)
-                        {
-                            index = GetColorIndex(i, j, k);
-                            sum += histo[index];
-                        }
-                    }
-                    total += sum;
-                    partialsum[i] = total;
-                }
-            }
-            else if (maxw == gw)
-            {
-                for (i = vbox.G1; i <= vbox.G2; i++)
-                {
-                    sum = 0;
-                    for (j = vbox.R1; j <= vbox.R2; j++)
-                    {
-                        for (k = vbox.B1; k <= vbox.B2; k++)
-                        {
-                            index = GetColorIndex(j, i, k);
-                            sum += histo[index];
-                        }
-                    }
-                    total += sum;
-                    partialsum[i] = total;
-                }
-            }
-            else /* maxw == bw */
-            {
-                for (i = vbox.B1; i <= vbox.B2; i++)
-                {
-                    sum = 0;
-                    for (j = vbox.R1; j <= vbox.R2; j++)
-                    {
-                        for (k = vbox.G1; k <= vbox.G2; k++)
-                        {
-                            index = GetColorIndex(j, k, i);
-                            sum += histo[index];
-                        }
-                    }
-                    total += sum;
-                    partialsum[i] = total;
-                }
-            }
-
-            for (i = 0; i < VboxLength; i++)
-            {
-                if (partialsum[i] != -1)
-                {
-                    lookaheadsum[i] = total - partialsum[i];
-                }
-            }
-
-            // determine the cut planes
-            return maxw == rw ? DoCut('r', vbox, partialsum, lookaheadsum, total) : maxw == gw
-                    ? DoCut('g', vbox, partialsum, lookaheadsum, total) : DoCut('b', vbox, partialsum, lookaheadsum, total);
-        }
-
-        /// <summary>
-        ///     Inner function to do the iteration.
-        /// </summary>
-        /// <param name="lh">The lh.</param>
-        /// <param name="comparator">The comparator.</param>
-        /// <param name="target">The target.</param>
-        /// <param name="histo">The histo.</param>
-        /// <exception cref="System.Exception">vbox1 not defined; shouldn't happen!</exception>
-        private static void Iter(List<VBox> lh, IComparer<VBox> comparator, int target, IList<int> histo)
-        {
-            var ncolors = 1;
-            var niters = 0;
-
-            while (niters < MaxIterations)
-            {
-                var vbox = lh[lh.Count - 1];
-                if (vbox.Count(false) == 0)
-                {
-                    lh.Sort(comparator);
-                    niters++;
-                    continue;
-                }
-
-                lh.RemoveAt(lh.Count - 1);
-
-                // do the cut
-                var vboxes = MedianCutApply(histo, vbox);
-                var vbox1 = vboxes[0];
-                var vbox2 = vboxes[1];
-
-                if (vbox1 == null)
-                {
-                    throw new Exception(
-                        "vbox1 not defined; shouldn't happen!");
-                }
-
-                lh.Add(vbox1);
-                if (vbox2 != null)
-                {
-                    lh.Add(vbox2);
-                    ncolors++;
-                }
-                lh.Sort(comparator);
-
-                if (ncolors >= target)
-                {
-                    return;
-                }
-                if (niters++ > MaxIterations)
-                {
-                    return;
-                }
-            }
-        }
-
-        public static CMap Quantize(byte[][] pixels, int maxcolors)
-        {
-            // short-circuit
-            if (pixels.Length == 0 || maxcolors < 2 || maxcolors > 256)
-            {
-                return null;
-            }
-
-            var histo = GetHisto(pixels);
-
-            // get the beginning vbox from the colors
-            var vbox = VboxFromPixels(pixels, histo);
-            var pq = new List<VBox> { vbox };
-
-            // Round up to have the same behaviour as in JavaScript
-            var target = (int)Math.Ceiling(FractByPopulation * maxcolors);
-
-            // first set of colors, sorted by population
-            Iter(pq, ComparatorCount, target, histo);
-
-            // Re-sort by the product of pixel occupancy times the size in color
-            // space.
-            pq.Sort(ComparatorProduct);
-
-            // next set - generate the median cuts using the (npix * vol) sorting.
-            Iter(pq, ComparatorProduct, maxcolors - pq.Count, histo);
-
-            // Reverse to put the highest elements first into the color map
-            pq.Reverse();
-
-            // calculate the actual colors
-            var cmap = new CMap();
-            foreach (var vb in pq)
-            {
-                cmap.Push(vb);
-            }
-
-            return cmap;
-        }
-
-        public static double CreateComparisonValue(double saturation, double targetSaturation, double luma, double targetLuma, int population, int highestPopulation)
-        {
-            return WeightedMean(InvertDiff(saturation, targetSaturation), WeightSaturation,
-                InvertDiff(luma, targetLuma), WeightLuma,
-                population / (double)highestPopulation, WeightPopulation);
-        }
-
-        private static double WeightedMean(params double[] values)
-        {
-            double sum = 0;
-            double sumWeight = 0;
-
-            for (var i = 0; i < values.Length; i += 2)
-            {
-                var value = values[i];
-                var weight = values[i + 1];
-
-                sum += value * weight;
-                sumWeight += weight;
-            }
-
-            return sum / sumWeight;
-        }
-
-        private static double InvertDiff(double value, double targetValue)
-        {
-            return 1 - Math.Abs(value - targetValue);
-        }
-    }
-
-    public class QuantizedColor
-    {
-        public QuantizedColor(Color color, int population)
-        {
-            Color = color;
-            Population = population;
-            IsDark = CalculateYiqLuma(color) < 128;
-        }
-
-        public Color Color { get; private set; }
-        public int Population { get; private set; }
-        public bool IsDark { get; private set; }
-
-        public int CalculateYiqLuma(Color color)
-        {
-            return Convert.ToInt32(Math.Round((299 * color.R + 587 * color.G + 114 * color.B) / 1000f));
-        }
-    }
-
-    /// <summary>
-    ///     3D color space box.
-    /// </summary>
-    internal class VBox
-    {
-        private readonly int[] histo;
-        private int[] avg;
-        public int B1;
-        public int B2;
-        private int? count;
-        public int G1;
-        public int G2;
-        public int R1;
-        public int R2;
-        private int? volume;
-
-        public VBox(int r1, int r2, int g1, int g2, int b1, int b2, int[] histo)
-        {
-            R1 = r1;
-            R2 = r2;
-            G1 = g1;
-            G2 = g2;
-            B1 = b1;
-            B2 = b2;
-
-            this.histo = histo;
-        }
-
-        public int Volume(bool force)
-        {
-            if (volume == null || force)
-            {
-                volume = (R2 - R1 + 1) * (G2 - G1 + 1) * (B2 - B1 + 1);
-            }
-
-            return volume.Value;
-        }
-
-        public int Count(bool force)
-        {
-            if (count == null || force)
-            {
-                var npix = 0;
-                int i;
-
-                for (i = R1; i <= R2; i++)
-                {
-                    int j;
-                    for (j = G1; j <= G2; j++)
-                    {
-                        int k;
-                        for (k = B1; k <= B2; k++)
-                        {
-                            var index = Mmcq.GetColorIndex(i, j, k);
-                            npix += histo[index];
-                        }
-                    }
-                }
-
-                count = npix;
-            }
-
-            return count.Value;
-        }
-
-        public VBox Clone()
-        {
-            return new VBox(R1, R2, G1, G2, B1, B2, histo);
-        }
-
-        public int[] Avg(bool force)
-        {
-            if (avg == null || force)
-            {
-                var ntot = 0;
-
-                var rsum = 0;
-                var gsum = 0;
-                var bsum = 0;
-
-                int i;
-
-                for (i = R1; i <= R2; i++)
-                {
-                    int j;
-                    for (j = G1; j <= G2; j++)
-                    {
-                        int k;
-                        for (k = B1; k <= B2; k++)
-                        {
-                            var histoindex = Mmcq.GetColorIndex(i, j, k);
-                            var hval = histo[histoindex];
-                            ntot += hval;
-                            rsum += Convert.ToInt32((hval * (i + 0.5) * Mmcq.Mult));
-                            gsum += Convert.ToInt32((hval * (j + 0.5) * Mmcq.Mult));
-                            bsum += Convert.ToInt32((hval * (k + 0.5) * Mmcq.Mult));
-                        }
-                    }
-                }
-
-                if (ntot > 0)
-                {
-                    avg = new[]
-                    {
-                        Math.Abs(rsum / ntot), Math.Abs(gsum / ntot),
-                        Math.Abs(bsum / ntot)
-                    };
-                }
-                else
-                {
-                    avg = new[]
-                    {
-                        Math.Abs(Mmcq.Mult * (R1 + R2 + 1) / 2),
-                        Math.Abs(Mmcq.Mult * (G1 + G2 + 1) / 2),
-                        Math.Abs(Mmcq.Mult * (B1 + B2 + 1) / 2)
-                    };
-                }
-            }
-
-            return avg;
-        }
-
-        public bool Contains(int[] pixel)
-        {
-            var rval = pixel[0] >> Mmcq.Rshift;
-            var gval = pixel[1] >> Mmcq.Rshift;
-            var bval = pixel[2] >> Mmcq.Rshift;
-
-            return rval >= R1 && rval <= R2 && gval >= G1 && gval <= G2 && bval >= B1 && bval <= B2;
-        }
-    }
-
-    internal class VBoxCountComparer : IComparer<VBox>
-    {
-        public int Compare(VBox x, VBox y)
-        {
-            var a = x.Count(false);
-            var b = y.Count(false);
-            return a < b ? -1 : (a > b ? 1 : 0);
-        }
-    }
-
-    internal class VBoxComparer : IComparer<VBox>
-    {
-        public int Compare(VBox x, VBox y)
-        {
-            var aCount = x.Count(false);
-            var bCount = y.Count(false);
-            var aVolume = x.Volume(false);
-            var bVolume = y.Volume(false);
-
-            // Otherwise sort by products
-            var a = aCount * aVolume;
-            var b = bCount * bVolume;
-            return a < b ? -1 : (a > b ? 1 : 0);
-        }
-    }
-
-    public class ColorThief
-    {
-        public const int DefaultColorCount = 5;
-        public const int DefaultQuality = 10;
-        public const bool DefaultIgnoreWhite = true;
-        public const int ColorDepth = 4;
-
-        private CMap GetColorMap(byte[][] pixelArray, int colorCount)
-        {
-            // Send array to quantize function which clusters values using median
-            // cut algorithm
-
-            if (colorCount > 0)
-            {
-                --colorCount;
-            }
-
-            var cmap = Mmcq.Quantize(pixelArray, colorCount);
-            return cmap;
-        }
-
-        private byte[][] ConvertPixels(byte[] pixels, int pixelCount, int quality, bool ignoreWhite)
-        {
-
-
-            var expectedDataLength = pixelCount * ColorDepth;
-            if (expectedDataLength != pixels.Length)
-            {
-                throw new ArgumentException("(expectedDataLength = "
-                                            + expectedDataLength + ") != (pixels.length = "
-                                            + pixels.Length + ")");
-            }
-
-            // Store the RGB values in an array format suitable for quantize
-            // function
-
-            // numRegardedPixels must be rounded up to avoid an
-            // ArrayIndexOutOfBoundsException if all pixels are good.
-
-            var numRegardedPixels = (pixelCount + quality - 1) / quality;
-
-            var numUsedPixels = 0;
-            var pixelArray = new byte[numRegardedPixels][];
-
-            for (var i = 0; i < pixelCount; i += quality)
-            {
-                var offset = i * ColorDepth;
-                var b = pixels[offset];
-                var g = pixels[offset + 1];
-                var r = pixels[offset + 2];
-                var a = pixels[offset + 3];
-
-                // If pixel is mostly opaque and not white
-                if (a >= 125 && !(ignoreWhite && r > 250 && g > 250 && b > 250))
-                {
-                    pixelArray[numUsedPixels] = new[] { r, g, b };
-                    numUsedPixels++;
-                }
-            }
-
-            // Remove unused pixels from the array
-            var copy = new byte[numUsedPixels][];
-            Array.Copy(pixelArray, copy, numUsedPixels);
-            return copy;
-        }
-
-        /// <summary>
-        ///     Use the median cut algorithm to cluster similar colors and return the base color from the largest cluster.
-        /// </summary>
-        /// <param name="sourceImage">The source image.</param>
-        /// <param name="quality">
-        ///     1 is the highest quality settings. 10 is the default. There is
-        ///     a trade-off between quality and speed. The bigger the number,
-        ///     the faster a color will be returned but the greater the
-        ///     likelihood that it will not be the visually most dominant color.
-        /// </param>
-        /// <param name="ignoreWhite">if set to <c>true</c> [ignore white].</param>
-        /// <returns></returns>
-        public async Task<QuantizedColor> GetColor(BitmapDecoder sourceImage, int quality = DefaultQuality, bool ignoreWhite = DefaultIgnoreWhite)
-        {
-            var palette = await GetPalette(sourceImage, 3, quality, ignoreWhite);
-
-            var dominantColor = new QuantizedColor(new Color
-            {
-                A = Convert.ToByte(palette.Average(a => a.Color.A)),
-                R = Convert.ToByte(palette.Average(a => a.Color.R)),
-                G = Convert.ToByte(palette.Average(a => a.Color.G)),
-                B = Convert.ToByte(palette.Average(a => a.Color.B))
-            }, Convert.ToInt32(palette.Average(a => a.Population)));
-
-            return dominantColor;
-        }
-
-        /// <summary>
-        ///     Use the median cut algorithm to cluster similar colors.
-        /// </summary>
-        /// <param name="sourceImage">The source image.</param>
-        /// <param name="colorCount">The color count.</param>
-        /// <param name="quality">
-        ///     1 is the highest quality settings. 10 is the default. There is
-        ///     a trade-off between quality and speed. The bigger the number,
-        ///     the faster a color will be returned but the greater the
-        ///     likelihood that it will not be the visually most dominant color.
-        /// </param>
-        /// <param name="ignoreWhite">if set to <c>true</c> [ignore white].</param>
-        /// <returns></returns>
-        /// <code>true</code>
-        public async Task<List<QuantizedColor>> GetPalette(BitmapDecoder sourceImage, int colorCount = DefaultColorCount, int quality = DefaultQuality, bool ignoreWhite = DefaultIgnoreWhite)
-        {
-            var pixelArray = await GetPixelsFast(sourceImage, quality, ignoreWhite);
-            var cmap = GetColorMap(pixelArray, colorCount);
-            if (cmap != null)
-            {
-                var colors = cmap.GeneratePalette();
-                return colors;
-            }
-            return new List<QuantizedColor>();
-        }
-
-        private async Task<byte[]> GetIntFromPixel(BitmapDecoder decoder)
-        {
-            var pixelsData = await decoder.GetPixelDataAsync();
-            var pixels = pixelsData.DetachPixelData();
-            return pixels;
-        }
-
-        private async Task<byte[][]> GetPixelsFast(BitmapDecoder sourceImage, int quality, bool ignoreWhite)
-        {
-            if (quality < 1)
-            {
-                quality = DefaultQuality;
-            }
-
-            var pixels = await GetIntFromPixel(sourceImage);
-            var pixelCount = sourceImage.PixelWidth * sourceImage.PixelHeight;
-
-            return ConvertPixels(pixels, Convert.ToInt32(pixelCount), quality, ignoreWhite);
-        }
-    }
-}

BetterLyrics.WinUI3/BetterLyrics.WinUI3/Helper/DatabaseHelper.cs

@@ -1,21 +0,0 @@
-using BetterLyrics.WinUI3.Models;
-using SQLite;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace BetterLyrics.WinUI3.Helper {
-    public class DatabaseHelper {
-        private static SQLiteConnection _database;
-
-        public static SQLiteConnection InitializeDatabase() {
-            string dbPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "MusicMetadataIndex.db");
-            _database = new SQLiteConnection(dbPath);
-            _database.CreateTable<MetadataIndex>(); // Create table if it doesn't exist
-            return _database;
-        }
-    }
-}