completing

Bumps the packages group in /src/Snap.Hutao with 2 updates: [MSTest.TestAdapter](https://github.com/microsoft/testfx) and [MSTest.TestFramework](https://github.com/microsoft/testfx).


Updates `MSTest.TestAdapter` from 3.4.3 to 3.5.0
- [Release notes](https://github.com/microsoft/testfx/releases)
- [Changelog](https://github.com/microsoft/testfx/blob/main/docs/Changelog.md)
- [Commits](https://github.com/microsoft/testfx/compare/v3.4.3...v3.5.0)

Updates `MSTest.TestFramework` from 3.4.3 to 3.5.0
- [Release notes](https://github.com/microsoft/testfx/releases)
- [Changelog](https://github.com/microsoft/testfx/blob/main/docs/Changelog.md)
- [Commits](https://github.com/microsoft/testfx/compare/v3.4.3...v3.5.0)

---
updated-dependencies:
- dependency-name: MSTest.TestAdapter
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: packages
- dependency-name: MSTest.TestFramework
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: packages
...

Signed-off-by: dependabot[bot] <support@github.com>

.github/ISSUE_TEMPLATE/CHS-bug-report.yml

@@ -19,7 +19,7 @@ body:
         - label: 我已阅读 Snap Hutao 文档中的[常见问题](https://hut.ao/advanced/FAQ.html)和[常见程序异常](https://hut.ao/advanced/exceptions.html)，我的问题没有在文档中得到解答
           required: true
 
-        - label: 我知道文档站的导航栏中有**搜索功能**，且已经搜索过相关关键词
+        - label: 我知道[文档站](https://hut.ao/zh/menu.html)的导航栏中有**搜索功能**，且已经搜索过相关关键词
           required: true
 
         - label: 我的问题不是[已完成](https://github.com/DGP-Studio/Snap.Hutao/issues?q=is%3Aopen+is%3Aissue+label%3A%E5%B7%B2%E5%AE%8C%E6%88%90)的问题也不是一个别人已发布的**重复的**问题
@@ -40,7 +40,7 @@ body:
     attributes:
       label: Snap Hutao 版本
       description: 在应用标题，应用程序的反馈中心界面中可以找到
-      placeholder: 例：1.4.15.0
+      placeholder: 例：1.9.9.0
     validations:
       required: true
 
@@ -62,20 +62,19 @@ body:
       description: 请设置一个你认为合适的分类，这将帮助我们快速定位问题
       options:
         - 安装和环境
-        - 成就管理
-        - 角色信息面板
         - 游戏启动器
+        - 祈愿记录
+        - 成就管理
+        - 我的角色
         - 实时便笺
         - 养成计算
-        - 文件缓存
-        - 祈愿记录
-        - 玩家查询
-        - 胡桃数据库
-        - 用户界面
-        - 胡桃云
-        - 胡桃帐号
-        - 签到
+        - 深境螺旋/胡桃数据库
         - Wiki
+        - 米游社账号面板
+        - 每日签到奖励
+        - 胡桃通行证/胡桃云
+        - 用户界面
+        - 文件缓存
         - 公告
         - 其它
     validations:

.github/ISSUE_TEMPLATE/CHS-feature-request.yml

@@ -1,9 +1,7 @@
-name: 功能请求 
+name: 功能请求
 description: 通过这个议题来向开发团队分享你的想法
 title: "[Feat]: 在这里填写一个合适的标题"
-labels: ["功能", "needs-triage", "priority:none"]
-assignees:
-  - Lightczx
+labels: ["feature request", "needs-triage", "priority:none"]
 body:
   - type: markdown
     attributes:
@@ -24,4 +22,4 @@ body:
       label: 想要实现或优化的功能
       description: 详细的描述一下你想要的功能，描述的越具体，采纳的可能性越高
     validations:
-      required: true
+      required: true

.github/ISSUE_TEMPLATE/ENG-bug-report.yml

@@ -40,7 +40,7 @@ body:
     attributes:
       label: Snap Hutao Version
       description: You can find the version in application's title bar
-      placeholder: e.g. 1.4.15.0
+      placeholder: e.g. 1.9.9.0
     validations:
       required: true
 
@@ -62,20 +62,19 @@ body:
       description: Please select the most associated category of your issue
       options:
         - Installation and Environment
+        - Game Launcher
+        - Wish Export
         - Achievement
         - My Character
-        - Game Launcher
         - Realtime Note
         - Develop Plan
-        - File Cache
-        - Wish Export
-        - Game Record
-        - Hutao Database
-        - User Interface
-        - Snap Hutao Cloud
-        - Snap Hutao Account
-        - Checkin
+        - Spiral Abyss
         - Wiki
+        - MiHoYo Account Panel
+        - Daily Checkin Reward
+        - Hutao Passport/Hutao Cloud
+        - User Interface
+        - File Cache
         - Announcement
         - Other
     validations:

.github/ISSUE_TEMPLATE/ENG-feature-request.yml

@@ -1,9 +1,7 @@
 name: Feature Request [English Form]
 description: Tell us about your thought
 title: "[Feat]: Place your title here"
-labels: ["功能", "needs-triage", "priority:none"]
-assignees:
-  - Lightczx
+labels: ["feature request", "needs-triage", "priority:none"]
 body:
   - type: markdown
     attributes:
@@ -22,6 +20,6 @@ body:
     id: req
     attributes:
       label: Detail of the Feature
-      description: Descripbe the feaure in detail. The more detailed and convincing the desciprtion the more likyly feature will be accepted. 
+      description: Descripbe the feaure in detail. The more detailed and convincing the desciprtion the more likyly feature will be accepted.
     validations:
-      required: true
+      required: true

.github/pull_request_template.md

@@ -0,0 +1,15 @@
+<!--- Hi, thanks for considering make a PR contribution to Snap Hutao, we appreciate your work. -->
+<!--- Before you create this PR, please check our contribution guide (https://hut.ao/en/development/contribute.html) and fill out the following form and checklist -->
+
+## Description
+
+<!--- Describe your changes -->
+
+## Related Issue
+
+<!--- If there's an associated issue, please use [GitHub Keyword](https://docs.github.com/en/get-started/writing-on-github/working-with-advanced-formatting/using-keywords-in-issues-and-pull-requests) to link it -->
+<!-- e.g. fix #999, resolve #999, close #999 -->
+
+## Checklist
+
+- [ ] The target PR branch is `develop` branch

.github/workflows/alpha.yml

@@ -5,6 +5,7 @@ on:
     branches:
       - main
       - develop
+      - 'feat/*'
     paths-ignore:
       - '.gitattributes'
       - '.github/**'
@@ -44,13 +45,8 @@ jobs:
         run: dotnet tool restore && dotnet cake
         env:
           VERSION_API_TOKEN: ${{ secrets.VERSION_API_TOKEN }}
-
-      - name: Sign Msix
-        if: success() && github.event_name != 'pull_request'
-        shell: pwsh
-        run: |
-          [System.Convert]::FromBase64String("${{ secrets.CERTIFICATE }}") | Set-Content -AsByteStream temp.pfx
-          signtool.exe sign /debug /v /a /fd SHA256 /f temp.pfx /p ${{ secrets.PW }} ${{ github.workspace }}\src\output\Snap.Hutao.Alpha-${{ steps.cake.outputs.version }}.msix
+          CERTIFICATE: ${{ secrets.CERTIFICATE }}
+          PW: ${{ secrets.PW }}
 
       - name: Upload signed msix
         if: success() && github.event_name != 'pull_request'
@@ -68,12 +64,55 @@ jobs:
           > 该版本是由 CI 程序自动打包生成的 `Alpha` 测试版本，**仅供开发者测试使用**
 
           > [!TIP]
-          > 普通用户请[点击这里](https://github.com/DGP-Studio/Snap.Hutao/releases/latest/)下载最新的稳定版本
+          > 普通用户请 [点击这里](https://github.com/DGP-Studio/Snap.Hutao/releases/latest/) 下载最新的稳定版本
 
           > [!IMPORTANT]
-          > 请注意，从 Snap Hutao Alpha 2023.12.21.3 开始，我们将使用全新的 CI 证书，原有的 Snap.Hutao.CI.cer 将在几天后过期停止使用。
-          >
-          > 请安装 [DGP_Studio_CA.crt](https://github.com/DGP-Automation/Hutao-Auto-Release/releases/download/certificate-ca/DGP_Studio_CA.crt) 以安装测试版安装包
+          > 请先安装 **[DGP_Studio_CA.crt](https://github.com/DGP-Automation/Hutao-Auto-Release/releases/download/certificate-ca/DGP_Studio_CA.crt)** 到 **受信任的根证书颁发机构** 以安装测试版安装包
+          "
+
+          echo $summary >> $Env:GITHUB_STEP_SUMMARY
+  fallback_build:
+    runs-on: windows-latest
+    needs: build
+    if: failure()
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup .NET
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: 8.0
+
+      - name: Cake
+        id: cake
+        shell: pwsh
+        run: dotnet tool restore && dotnet cake
+        env:
+          VERSION_API_TOKEN: ${{ secrets.VERSION_API_TOKEN }}
+          CERTIFICATE: ${{ secrets.CERTIFICATE }}
+          PW: ${{ secrets.PW }}
+
+      - name: Upload signed msix
+        if: success() && github.event_name != 'pull_request'
+        uses: actions/upload-artifact@v4
+        with:
+          name: Snap.Hutao.Alpha-${{ steps.cake.outputs.version }}
+          path: ${{ github.workspace }}/src/output/Snap.Hutao.Alpha-${{ steps.cake.outputs.version }}.msix
+
+      - name: Add summary
+        if: success() && github.event_name != 'pull_request'
+        shell: pwsh
+        run: |
+          $summary = "
+          > [!WARNING]
+          > 该版本是由 CI 程序自动打包生成的 `Alpha` 测试版本，**仅供开发者测试使用**
+
+          > [!TIP]
+          > 普通用户请 [点击这里](https://github.com/DGP-Studio/Snap.Hutao/releases/latest/) 下载最新的稳定版本
+
+          > [!IMPORTANT]
+          > 请先安装 **[DGP_Studio_CA.crt](https://github.com/DGP-Automation/Hutao-Auto-Release/releases/download/certificate-ca/DGP_Studio_CA.crt)** 到 **受信任的根证书颁发机构** 以安装测试版安装包
           "
 
           echo $summary >> $Env:GITHUB_STEP_SUMMARY

.github/workflows/close_stale.yml

@@ -10,7 +10,7 @@ jobs:
       - uses: actions/stale@v9
         with:
           any-of-labels: 'needs-more-info,需要更多信息'
-          stale-issue-message: 'This issue is stale because it has been open 30 days with no activity. Remove stale label or comment or this will be closed in 3 days.'
+          stale-issue-message: 'This issue is stale because it has been open 7 days with no activity. Remove stale label or comment or this will be closed in 3 days.'
           days-before-stale: 7
           days-before-close: 3
           close-issue-reason: not_planned

README.md

@@ -1,42 +1,44 @@
-![HutaoRepoBanner2-20231222](https://github.com/DGP-Studio/Snap.Hutao/assets/10614984/2d178de1-95bc-44a1-a95e-20c5f11a8628)
+![HutaoRepoBanner3-en](https://github.com/DGP-Studio/Snap.Hutao/assets/10614984/7289da68-59cf-409b-bd85-4b5a01d0c091)
 
 
-胡桃工具箱是一款以 MIT 协议开源的原神工具箱，专为现代化 Windows 平台设计，旨在改善桌面端玩家的游戏体验。通过将既有的官方资源与开发团队设计的全新 功能相结合，它提供了一套完整且实用的工具集，且无需依赖任何移动设备。它不对游戏客户端进行任何破坏性修改以确保工具箱的安全性
+胡桃工具箱是一款以 MIT 协议开源的原神工具箱，专为现代化 Windows 平台设计，旨在改善桌面端玩家的游戏体验。通过将既有的官方资源与开发团队设计的全新功能相结合，提供了一套完整且实用的工具集，且无需依赖任何移动设备。它不对游戏客户端进行任何破坏性修改以确保工具箱的安全性
 
 Snap Hutao is an open-source Genshin Impact toolkit under MIT license, designed for modern Windows platform to improve the gaming experience for desktop players. By combining existing official resources with new features designed by the development team, it provides a complete and useful set of tools without the need to rely on mobile devices. Snap Hutao does not take any destructive modification to the game client to ensure the security of the toolkit.
 
-## 下载使用 / Download
+## 安装 / Installation
 
 ![](https://ci.appveyor.com/api/projects/status/n4s40t9llru4si9y?svg=true) [![GitHub Release](https://img.shields.io/github/release/DGP-Studio/Snap.Hutao?style=flat)](https://github.com/DGP-Studio/Snap.Hutao/releases/latest) [![Github All Releases](https://img.shields.io/github/downloads/DGP-Studio/Snap.Hutao/total.svg?style=flat)]() 
 
 ---
 
-#### 使用安装器安装 / Install with Snap.Hutao.Depolyment Installer
+你可以按照[快速开始](https://hut.ao/zh/quick-start.html)文档中提供的流程安装并设置 Snap Hutao。
 
-Snap.Hutao.Depolyment 是一个由 DGP-Studio 重新包装的 Windows 应用安装器，适用于缺少专业计算机知识的一般用户，可以在安装时同时解决缺少必要系统环境的问题。
+You can follow the instructions in the [Quick Start](https://hut.ao/en/quick-start.html) document to install and set up Snap Hutao.
 
-Snap.Hutao.Depolyment is a Windows application installer repackaged by DGP-Studio for the users who lacks computer knowledge and can solve the problem of missing necessary system environment at the same time as the installation.
+## 本地化翻译 / Localization
 
-[从 GitHub 发布页获取 / Download from GitHub release](https://github.com/DGP-Studio/Snap.Hutao.Deployment/releases/latest) 
+[![zh-TW translation](https://img.shields.io/badge/dynamic/json?color=blue&label=zh-TW&style=flat&logo=crowdin&query=%24.progress[?(@.data.languageId==%27zh-TW%27)].data.translationProgress&url=https%3A%2F%2Fbadges.awesome-crowdin.com%2Fstats-15670597-565845.json)](https://crowdin.com/project/snap-hutao)
+[![en translation](https://img.shields.io/badge/dynamic/json?color=blue&label=en&style=flat&logo=crowdin&query=%24.progress[?(@.data.languageId==%27en%27)].data.translationProgress&url=https%3A%2F%2Fbadges.awesome-crowdin.com%2Fstats-15670597-565845.json)](https://crowdin.com/project/snap-hutao)
+[![fr translation](https://img.shields.io/badge/dynamic/json?color=blue&label=fr&style=flat&logo=crowdin&query=%24.progress[?(@.data.languageId==%27fr%27)].data.translationProgress&url=https%3A%2F%2Fbadges.awesome-crowdin.com%2Fstats-15670597-565845.json)](https://crowdin.com/project/snap-hutao)
+[![id translation](https://img.shields.io/badge/dynamic/json?color=blue&label=id&style=flat&logo=crowdin&query=%24.progress[?(@.data.languageId==%27id%27)].data.translationProgress&url=https%3A%2F%2Fbadges.awesome-crowdin.com%2Fstats-15670597-565845.json)](https://crowdin.com/project/snap-hutao)
+[![ja translation](https://img.shields.io/badge/dynamic/json?color=blue&label=ja&style=flat&logo=crowdin&query=%24.progress[?(@.data.languageId==%27ja%27)].data.translationProgress&url=https%3A%2F%2Fbadges.awesome-crowdin.com%2Fstats-15670597-565845.json)](https://crowdin.com/project/snap-hutao)
+[![ko translation](https://img.shields.io/badge/dynamic/json?color=blue&label=ko&style=flat&logo=crowdin&query=%24.progress[?(@.data.languageId==%27ko%27)].data.translationProgress&url=https%3A%2F%2Fbadges.awesome-crowdin.com%2Fstats-15670597-565845.json)](https://crowdin.com/project/snap-hutao)
+[![pt-PT translation](https://img.shields.io/badge/dynamic/json?color=blue&label=pt-PT&style=flat&logo=crowdin&query=%24.progress[?(@.data.languageId==%27pt-PT%27)].data.translationProgress&url=https%3A%2F%2Fbadges.awesome-crowdin.com%2Fstats-15670597-565845.json)](https://crowdin.com/project/snap-hutao)
+[![ru translation](https://img.shields.io/badge/dynamic/json?color=blue&label=ru&style=flat&logo=crowdin&query=%24.progress[?(@.data.languageId==%27ru%27)].data.translationProgress&url=https%3A%2F%2Fbadges.awesome-crowdin.com%2Fstats-15670597-565845.json)](https://crowdin.com/project/snap-hutao)
+[![vi translation](https://img.shields.io/badge/dynamic/json?color=blue&label=vi&style=flat&logo=crowdin&query=%24.progress[?(@.data.languageId==%27vi%27)].data.translationProgress&url=https%3A%2F%2Fbadges.awesome-crowdin.com%2Fstats-15670597-565845.json)](https://crowdin.com/project/snap-hutao)
 
-[从极狐Lab 发布页获取 / Download from Jihu Gitlab release](https://jihulab.com/DGP-Studio/Snap.Hutao.Deployment/-/releases)
+Snap Hutao 使用 [Crowdin](https://translate.hut.ao/) 作为客户端文本翻译平台，在该平台上你可以为你熟悉的语言提交翻译文本。我们感谢每一个为 Snap Hutao 做出贡献的社区成员，并且欢迎更多的朋友能参与到这个项目中。
 
-#### 使用 MSIX 包安装 / Install with MSIX Package
+Snap Hutao uses [Crowdin](https://translate.hut.ao/) as a client text translation platform where you can submit translated text for languages you are familiar with. We are grateful to every community member who has contributed to Snap Hutao and welcome more friends to participate in this project.
 
-直接使用 Snap Hutao MSIX 安装包，使用 Windows 内置的 App Installer 即可安装。如在安装中出现问题，请查阅我们的[常见问题](https://hut.ao/zh/advanced/FAQ.html)文档
+## 社区 / Community
 
-Install with Snap Hutao MSIX package, can be installed with Windows built-in App Installer. If you faced any issue, please check our [FAQ](https://hut.ao/en/advanced/FAQ.html) document.
-
-[从 GitHub 发布页获取 / Download from GitHub release](https://github.com/DGP-Studio/Snap.Hutao/releases/latest) 
-
-[从极狐Lab 发布页获取 / Download from Jihu Gitlab release](https://jihulab.com/DGP-Studio/Snap.Hutao/-/releases)
+[![Discord](https://img.shields.io/discord/952488447753465916?color=5865f2&label=%20Discord)](https://discord.gg/CcH5XtDtvR) [![QQ](https://img.shields.io/badge/QQ-EB1923?logo=tencent-qq&logoColor=white&label=567908135)](https://qm.qq.com/q/WJKykrY9W)
 
 ## 贡献 / Contribute
 
-* [向我们提交 PR / Make Pull Requests](https://github.com/DGP-Studio/Snap.Hutao/pulls)
-* [在 Crowdin 上进行本地化 / Translate Project on Crowdin](https://translate.hut.ao/)
+* [向我们提交 PR / Make Pull Requests](https://hut.ao/development/contribute.html)
 * [为我们更新文档 / Enhance our Document](https://github.com/DGP-Studio/Snap.Hutao.Docs)
-* [帮助我们测试程序 / Test Binary Package](https://hut.ao/development/contribute.html)
 
 ## 特别感谢 / Special Thanks
 
@@ -52,13 +54,13 @@ Install with Snap Hutao MSIX package, can be installed with Windows built-in App
 * [CommunityToolkit/dotnet](https://github.com/CommunityToolkit/dotnet)
 * [CommunityToolkit/Labs-Windows](https://github.com/CommunityToolkit/Labs-Windows)
 * [CommunityToolkit/Windows](https://github.com/CommunityToolkit/Windows)
-* [dahall/taskscheduler](https://github.com/dahall/taskscheduler)
 * [dotnet/efcore](https://github.com/dotnet/efcore)
 * [dotnet/runtime](https://github.com/dotnet/runtime)
 * [DotNetAnalyzers/StyleCopAnalyzers](https://github.com/DotNetAnalyzers/StyleCopAnalyzers)
 * [microsoft/vs-validation](https://github.com/microsoft/vs-validation)
 * [microsoft/WindowsAppSDK](https://github.com/microsoft/WindowsAppSDK)
 * [microsoft/microsoft-ui-xaml](https://github.com/microsoft/microsoft-ui-xaml)
+* [quartznet/quartznet](https://github.com/quartznet/quartznet)
 
 ### 支撑项目 / Supporter Project
 
@@ -70,9 +72,9 @@ Install with Snap Hutao MSIX package, can be installed with Windows built-in App
 Snap Hutao is currently using sponsored software from the following service providers.
 
 | [![](https://www.netlify.com/v3/img/components/netlify-light.svg)](https://www.netlify.com/) | [![](https://support.crowdin.com/assets/logos/core-logo/svg/crowdin-core-logo-cDark.svg)](https://crowdin.com/) | [![](https://gitlab.cn/images/icons/logos/logo-121-75.svg)](https://gitlab.cn/) |
-|:----------------------------------------------------------------------------------------------------:|:-----------------------------------------------------------------------------------------------------------------------:|:---------------------------------------------------------------------------------------:|
-|              [![](https://github.com/DGP-Studio/Snap.Hutao/assets/10614984/73ae8b90-f3c7-4033-b2b7-f4126331ce66)](https://about.signpath.io)              |                        [![](https://github.com/DGP-Studio/Snap.Hutao/assets/10614984/49aed8ee-9f19-4a8a-998c-7b93ee286d65)](https://1password.com/)                         |  [![](https://github.com/DGP-Studio/Snap.Hutao/assets/10614984/ad121220-d2d3-4f49-b215-b6d063dc229d)](https://about.signpath.io)   |
-
+| :----------------------------------------------------------: | :----------------------------------------------------------: | :----------------------------------------------------------: |
+| [![](https://github.com/DGP-Studio/Snap.Hutao/assets/10614984/73ae8b90-f3c7-4033-b2b7-f4126331ce66)](https://about.signpath.io) | [![](https://github.com/DGP-Studio/Snap.Hutao/assets/10614984/49aed8ee-9f19-4a8a-998c-7b93ee286d65)](https://1password.com/) | [![](https://github.com/DGP-Studio/Snap.Hutao/assets/10614984/ad121220-d2d3-4f49-b215-b6d063dc229d)](https://www.digitalocean.com) |
+| [![ducalis](https://raw.githubusercontent.com/DGP-Studio/Snap.Hutao.Docs/main/docs/.vuepress/public/svg/ducalis.svg)](https://hi.ducalis.io/) | [![jetbrains](https://github.com/DGP-Studio/Snap.Hutao/assets/36357191/4105772a-728a-4a84-9c6e-d713a5698a20)](https://www.jetbrains.com/opensource/) |                                                              |
 
 - Netlify provides document and home page hosting service for Snap Hutao
 
@@ -86,6 +88,10 @@ Snap Hutao is currently using sponsored software from the following service prov
   
 - DigitalOcean provides reliable cloud database for Snap Hutao database backup
 
+- [Ducalis.io](https://hi.ducalis.io/) provides Snap Hutao project with a complete decision-making toolkit for project management
+
+- Jetbrains provides powerful IDE for Snap Hutao infrastructure services coding
+
 ## 开发 / Development
 
 ![Snap.Hutao](https://repobeats.axiom.co/api/embed/f029553fbe0c60689b1710476ec8512452163fc9.svg)

SECURITY.md

@@ -4,8 +4,8 @@
 
 | Version | Supported          |
 | ------- | ------------------ |
-| >=1.6.0   | :white_check_mark: |
-| <1.6.0   | :x:                |
+| >=1.9.0   | :white_check_mark: |
+| <1.9.0   | :x:                |
 
 ## Reporting a Vulnerability
 

build.cake

@@ -11,6 +11,18 @@ var version = "version";
 var repoDir = "repoDir";
 var outputPath = "outputPath";
 
+var pfxPath = "pfxPath";
+var pw = "pw";
+
+// Extension
+
+static ProcessArgumentBuilder AppendIf(this ProcessArgumentBuilder builder, string text, bool condition)
+{
+    return condition ? builder.Append(text) : builder;
+}
+
+// Properties
+
 string solution
 {
     get => System.IO.Path.Combine(repoDir, "src", "Snap.Hutao", "Snap.Hutao.sln");
@@ -53,6 +65,11 @@ if (GitHubActions.IsRunningOnGitHubActions)
             }
         );
 
+        var certificateBase64 = HasEnvironmentVariable("CERTIFICATE") ? EnvironmentVariable("CERTIFICATE") : throw new Exception("Cannot find CERTIFICATE");
+        pw = HasEnvironmentVariable("PW") ? EnvironmentVariable("PW") : throw new Exception("Cannot find PW");
+        pfxPath = System.IO.Path.Combine(repoDir, "temp.pfx");
+        System.IO.File.WriteAllBytes(pfxPath, System.Convert.FromBase64String(certificateBase64));
+
         Information($"Version: {version}");
     }
 
@@ -69,11 +86,29 @@ else if (AppVeyor.IsRunningOnAppVeyor)
     })[..^2];
     Information($"Version: {version}");
 }
+else // Local
+{
+    repoDir = System.Environment.CurrentDirectory;
+    outputPath = System.IO.Path.Combine(repoDir, "src", "output");
+
+    version = System.DateTime.Now.ToString("yyyy.M.d.") + ((int)((System.DateTime.Now - System.DateTime.Today).TotalSeconds / 86400 * 65535)).ToString();
+
+    Information($"Version: {version}");
+}
+
+// Windows SDK
+var registry = new WindowsRegistry();
+var winsdkRegistry = registry.LocalMachine.OpenKey(@"SOFTWARE\Microsoft\Windows Kits\Installed Roots");
+var winsdkVersion = winsdkRegistry.GetSubKeyNames().MaxBy(key => int.Parse(key.Split(".")[2]));
+var winsdkPath = (string)winsdkRegistry.GetValue("KitsRoot10");
+var winsdkBinPath = System.IO.Path.Combine(winsdkPath, "bin", winsdkVersion, "x64");
+Information($"Windows SDK: {winsdkPath}");
 
 Task("Build")
     .IsDependentOn("Build binary package")
     .IsDependentOn("Copy files")
-    .IsDependentOn("Build MSIX");
+    .IsDependentOn("Build MSIX")
+    .IsDependentOn("Sign");
 
 Task("NuGet Restore")
     .Does(() =>
@@ -112,6 +147,17 @@ Task("Generate AppxManifest")
         Information("Using Release configuration");
         content = System.Text.RegularExpressions.Regex.Replace(content, "  Publisher=\"([^\"]*)\"", "  Publisher=\"CN=SignPath Foundation, O=SignPath Foundation, L=Lewes, S=Delaware, C=US\"");
     }
+    else
+    {
+        Information("Using Local configuration.");
+        content = content
+            .Replace("Snap Hutao", "Snap Hutao Local")
+            .Replace("胡桃", "胡桃 Local")
+            .Replace("DGP Studio", "DGP Studio CI");
+        content = System.Text.RegularExpressions.Regex.Replace(content, "  Name=\"([^\"]*)\"", "  Name=\"E8B6E2B3-D2A0-4435-A81D-2A16AAF405C7\"");
+        content = System.Text.RegularExpressions.Regex.Replace(content, "  Publisher=\"([^\"]*)\"", "  Publisher=\"E=admin@dgp-studio.cn, CN=DGP Studio CI, OU=CI, O=DGP-Studio, L=San Jose, S=CA, C=US\"");
+        content = System.Text.RegularExpressions.Regex.Replace(content, "  Version=\"([0-9\\.]+)\"", $"  Version=\"{version}\"");
+    }
 
     System.IO.File.WriteAllText(manifest, content);
 
@@ -137,6 +183,7 @@ Task("Build binary package")
                                             .Append("/p:AppxPackageSigningEnabled=false")
                                             .Append("/p:AppxBundle=Never")
                                             .Append("/p:AppxPackageOutput=" + outputPath)
+                                            .AppendIf("/p:AlphaConstants=IS_ALPHA_BUILD", !AppVeyor.IsRunningOnAppVeyor)
     };
 
     DotNetBuild(project, settings);
@@ -173,8 +220,15 @@ Task("Build MSIX")
     {
         arguments = "pack /d " + binPath + " /p " + System.IO.Path.Combine(outputPath, $"Snap.Hutao-{version}.msix");
     }
+    else
+    {
+        arguments = "pack /d " + binPath + " /p " + System.IO.Path.Combine(outputPath, $"Snap.Hutao.Local-{version}.msix");
+    }
+
+    var makeappxPath = System.IO.Path.Combine(winsdkBinPath, "makeappx.exe");
+
     var p = StartProcess(
-        "makeappx.exe",
+        makeappxPath,
         new ProcessSettings
         {
             Arguments = arguments
@@ -182,7 +236,46 @@ Task("Build MSIX")
     );
     if (p != 0)
     {
-        throw new InvalidOperationException("Build failed with exit code " + p);
+        throw new InvalidOperationException("Build MSIX failed with exit code " + p);
+    }
+});
+
+Task("Sign")
+    .IsDependentOn("Build MSIX")
+    .Does(() =>
+{
+    if (AppVeyor.IsRunningOnAppVeyor)
+    {
+        Information("Move to SignPath. Skip signing.");
+        return;
+    }
+    else if (GitHubActions.IsRunningOnGitHubActions)
+    {
+        if (GitHubActions.Environment.PullRequest.IsPullRequest)
+        {
+            Information("Is Pull Request. Skip signing.");
+            return;
+        }
+
+        var signPath = System.IO.Path.Combine(winsdkBinPath, "signtool.exe");
+        var arguments = $"sign /debug /v /a /fd SHA256 /f {pfxPath} /p {pw} {System.IO.Path.Combine(outputPath, $"Snap.Hutao.Alpha-{version}.msix")}";
+
+        var p = StartProcess(
+            signPath,
+            new ProcessSettings
+            {
+                Arguments = arguments
+            }
+        );
+        if (p != 0)
+        {
+            throw new InvalidOperationException("Sign failed with exit code " + p);
+        }
+    }
+    else
+    {
+        Information("Local configuration. Skip signing.");
+        return;
     }
 });
 

crowdin.yml

@@ -1,3 +1,5 @@
 files:
   - source: /src/Snap.Hutao/Snap.Hutao/Resource/Localization/SH.resx
     translation: /src/Snap.Hutao/Snap.Hutao/Resource/Localization/SH.%osx_locale%.resx
+  - source: /src/Snap.Hutao/Snap.Hutao/Resource/Localization/SHRegex.resx
+    translation: /src/Snap.Hutao/Snap.Hutao/Resource/Localization/SHRegex.%osx_locale%.resx

src/Snap.Hutao/.editorconfig

@@ -110,7 +110,6 @@ dotnet_diagnostic.SA1642.severity = none
 
 dotnet_diagnostic.IDE0005.severity = warning
 dotnet_diagnostic.IDE0060.severity = none
-dotnet_diagnostic.IDE0290.severity = none
 
 # SA1208: System using directives should be placed before other using directives
 dotnet_diagnostic.SA1208.severity = none
@@ -321,7 +320,9 @@ dotnet_diagnostic.CA2227.severity = suggestion
 
 # CA2251: 使用 “string.Equals”
 dotnet_diagnostic.CA2251.severity = suggestion
-csharp_style_prefer_primary_constructors = true:suggestion
+
+csharp_style_prefer_primary_constructors = false:none
+dotnet_diagnostic.SA1124.severity = none
 
 [*.vb]
 #### 命名样式 ####

src/Snap.Hutao/Snap.Hutao.Test/BaseClassLibrary/HttpClientTest.cs

@@ -0,0 +1,31 @@
+using System.Net.Http;
+
+namespace Snap.Hutao.Test.BaseClassLibrary;
+
+[TestClass]
+public sealed class HttpClientTest
+{
+    [TestMethod]
+    public void RedirectionHeaderTest()
+    {
+        HttpClientHandler handler = new()
+        {
+            UseCookies = false,
+            AllowAutoRedirect = false,
+        };
+
+        using (handler)
+        {
+            using (HttpClient httpClient = new(handler))
+            {
+                using (HttpRequestMessage request = new(HttpMethod.Get, "https://api.snapgenshin.com/patch/hutao/download"))
+                {
+                    using (HttpResponseMessage response = httpClient.Send(request))
+                    {
+                        _ = 1;
+                    }
+                }
+            }
+        }
+    }
+}

src/Snap.Hutao/Snap.Hutao.Test/BaseClassLibrary/JsonSerializeTest.cs

@@ -13,19 +13,19 @@ public sealed class JsonSerializeTest
         NumberHandling = JsonNumberHandling.AllowReadingFromString,
     };
 
-    private const string SmapleObjectJson = """
+    private const string SampleObjectJson = """
         {
             "A" :1
         }
         """;
 
-    private const string SmapleEmptyStringObjectJson = """
+    private const string SampleEmptyStringObjectJson = """
         {
             "A" : ""
         }
         """;
 
-    private const string SmapleNumberKeyDictionaryJson = """
+    private const string SampleNumberKeyDictionaryJson = """
         {
             "111" : "12",
             "222" : "34"
@@ -35,7 +35,7 @@ public sealed class JsonSerializeTest
     [TestMethod]
     public void DelegatePropertyCanSerialize()
     {
-        SampleDelegatePropertyClass sample = JsonSerializer.Deserialize<SampleDelegatePropertyClass>(SmapleObjectJson)!;
+        SampleDelegatePropertyClass sample = JsonSerializer.Deserialize<SampleDelegatePropertyClass>(SampleObjectJson)!;
         Assert.AreEqual(sample.B, 1);
     }
 
@@ -43,14 +43,23 @@ public sealed class JsonSerializeTest
     [ExpectedException(typeof(JsonException))]
     public void EmptyStringCannotSerializeAsNumber()
     {
-        SampleStringReadWriteNumberPropertyClass sample = JsonSerializer.Deserialize<SampleStringReadWriteNumberPropertyClass>(SmapleEmptyStringObjectJson)!;
+        SampleStringReadWriteNumberPropertyClass sample = JsonSerializer.Deserialize<SampleStringReadWriteNumberPropertyClass>(SampleEmptyStringObjectJson)!;
         Assert.AreEqual(sample.A, 0);
     }
 
+    [TestMethod]
+    public void EmptyStringCanSerializeAsUri()
+    {
+        SampleEmptyUriClass sample = JsonSerializer.Deserialize<SampleEmptyUriClass>(SampleEmptyStringObjectJson)!;
+        Uri.TryCreate("", UriKind.RelativeOrAbsolute, out Uri? value);
+        Console.WriteLine(value);
+        Assert.AreEqual(sample.A, value);
+    }
+
     [TestMethod]
     public void NumberStringKeyCanSerializeAsKey()
     {
-        Dictionary<int, string> sample = JsonSerializer.Deserialize<Dictionary<int, string>>(SmapleNumberKeyDictionaryJson, AlowStringNumberOptions)!;
+        Dictionary<int, string> sample = JsonSerializer.Deserialize<Dictionary<int, string>>(SampleNumberKeyDictionaryJson, AlowStringNumberOptions)!;
         Assert.AreEqual(sample[111], "12");
     }
 
@@ -80,6 +89,19 @@ public sealed class JsonSerializeTest
         Assert.AreEqual(result, """{"A":1,"B":2}""");
     }
 
+    [TestMethod]
+    public void LowercaseStringCanDeserializeAsEnum()
+    {
+        string source = """
+            {
+              "Value": "a"
+            }
+            """;
+
+        SampleClassHoldEnum sample = JsonSerializer.Deserialize<SampleClassHoldEnum>(source)!;
+        Assert.AreEqual(sample.Value, SampleEnum.A);
+    }
+
     private sealed class SampleDelegatePropertyClass
     {
         public int A { get => B; set => B = value; }
@@ -92,6 +114,11 @@ public sealed class JsonSerializeTest
         public int A { get; set; }
     }
 
+    private sealed class SampleEmptyUriClass
+    {
+        public Uri A { get; set; } = default!;
+    }
+
     private sealed class SampleByteArrayPropertyClass
     {
         public byte[]? Array { get; set; }
@@ -104,6 +131,18 @@ public sealed class JsonSerializeTest
         public int B { get; set; }
     }
 
+    [JsonConverter(typeof(JsonStringEnumConverter))]
+    private enum SampleEnum
+    {
+        A,
+        B,
+    }
+
+    private sealed class SampleClassHoldEnum
+    {
+        public SampleEnum Value { get; set; }
+    }
+
     [JsonDerivedType(typeof(SampleClassImplementedInterface))]
     private interface ISampleInterface
     {

src/Snap.Hutao/Snap.Hutao.Test/BaseClassLibrary/ListTest.cs

@@ -0,0 +1,14 @@
+using System.Collections.Generic;
+
+namespace Snap.Hutao.Test.BaseClassLibrary;
+
+[TestClass]
+public sealed class ListTest
+{
+    [TestMethod]
+    public void IndexOfNullIsNegativeOne()
+    {
+        List<object> list = [new()];
+        Assert.AreEqual(-1, list.IndexOf(default!));
+    }
+}

src/Snap.Hutao/Snap.Hutao.Test/BaseClassLibrary/UnsafeAccessorTest.cs

@@ -0,0 +1,28 @@
+using System.Runtime.CompilerServices;
+
+namespace Snap.Hutao.Test.BaseClassLibrary;
+
+[TestClass]
+public class UnsafeAccessorTest
+{
+    [TestMethod]
+    public void UnsafeAccessorCanGetInterfaceProperty()
+    {
+        TestClass test = new();
+        int value = InternalGetInterfaceProperty(test);
+        Assert.AreEqual(3, value);
+    }
+
+    [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "get_TestProperty")]
+    private static extern int InternalGetInterfaceProperty(ITestInterface instance);
+
+    internal interface ITestInterface
+    {
+        internal int TestProperty { get; }
+    }
+
+    internal sealed class TestClass : ITestInterface
+    {
+        public int TestProperty { get; } = 3;
+    }
+}

src/Snap.Hutao/Snap.Hutao.Test/IncomingFeature/SpiralAbyssScheduleIdTest.cs

@@ -6,14 +6,25 @@ namespace Snap.Hutao.Test.IncomingFeature;
 public class SpiralAbyssScheduleIdTest
 {
     private static readonly TimeSpan Utc8 = new(8, 0, 0);
+    private static readonly DateTimeOffset AcrobaticsBattleIntroducedTime = new(2024, 7, 1, 4, 0, 0, Utc8);
 
     [TestMethod]
     public void Test()
     {
         Console.WriteLine($"当前第 {GetForDateTimeOffset(DateTimeOffset.Now)} 期");
 
-        DateTimeOffset dateTimeOffset = new(2020, 7, 1, 4, 0, 0, Utc8);
-        Console.WriteLine($"2020-07-01 04:00:00 为第 {GetForDateTimeOffset(dateTimeOffset)} 期");
+        // 2020-07-01 04:00:00 为第 1 期
+        // 2024-06-16 04:00:00 为第 96 期
+        // 2024-07-01 04:00:00 为第 97 期
+        // 2024-07-16 04:00:00 为第 98 期
+        // 2024-08-01 04:00:00 为第 99 期
+        Console.WriteLine($"2020-07-01 04:00:00 为第 {GetForDateTimeOffset(new(2020, 07, 01, 4, 0, 0, Utc8))} 期");
+        Console.WriteLine($"2024-06-16 04:00:00 为第 {GetForDateTimeOffset(new(2024, 06, 16, 4, 0, 0, Utc8))} 期");
+        Console.WriteLine($"2024-07-01 04:00:00 为第 {GetForDateTimeOffset(new(2024, 07, 01, 4, 0, 0, Utc8))} 期");
+        Console.WriteLine($"2024-07-16 04:00:00 为第 {GetForDateTimeOffset(new(2024, 07, 16, 4, 0, 0, Utc8))} 期");
+        Console.WriteLine($"2024-08-01 04:00:00 为第 {GetForDateTimeOffset(new(2024, 08, 01, 4, 0, 0, Utc8))} 期");
+        Console.WriteLine($"2024-08-16 04:00:00 为第 {GetForDateTimeOffset(new(2024, 08, 16, 4, 0, 0, Utc8))} 期");
+        Console.WriteLine($"2024-09-01 04:00:00 为第 {GetForDateTimeOffset(new(2024, 09, 01, 4, 0, 0, Utc8))} 期");
     }
 
     public static int GetForDateTimeOffset(DateTimeOffset dateTimeOffset)
@@ -38,6 +49,12 @@ public class SpiralAbyssScheduleIdTest
             periodNum--;
         }
 
+        if (dateTimeOffset >= AcrobaticsBattleIntroducedTime)
+        {
+            // 当超过 96 期时，每一个月一期
+            periodNum = (4 * 12 * 2) + ((periodNum - (4 * 12 * 2)) / 2);
+        }
+
         return periodNum;
     }
 }

src/Snap.Hutao/Snap.Hutao.Test/IncomingFeature/UnlockerIslandFunctionOffsetTest.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Text.Json;
+
+namespace Snap.Hutao.Test.IncomingFeature;
+
+[TestClass]
+public class UnlockerIslandFunctionOffsetTest
+{
+    private static readonly JsonSerializerOptions Options = new()
+    {
+        WriteIndented = true,
+    };
+
+    [TestMethod]
+    public void GenerateJson()
+    {
+        UnlockerIslandConfigurationWrapper wrapper = new()
+        {
+            Oversea = new()
+            {
+                FunctionOffsetFieldOfView = 0x00000000_01688E60,
+                FunctionOffsetTargetFrameRate = 0x00000000_018834D0,
+                FunctionOffsetFog = 0x00000000_00FB2AD0,
+            },
+            Chinese = new()
+            {
+                FunctionOffsetFieldOfView = 0x00000000_01684560,
+                FunctionOffsetTargetFrameRate = 0x00000000_0187EBD0,
+                FunctionOffsetFog = 0x00000000_00FAE1D0,
+            },
+        };
+
+        Console.WriteLine(JsonSerializer.Serialize(wrapper, Options));
+    }
+
+    private sealed class UnlockerIslandConfigurationWrapper
+    {
+        public required UnlockerIslandConfiguration Oversea { get; set; }
+
+        public required UnlockerIslandConfiguration Chinese { get; set; }
+    }
+
+    private sealed class UnlockerIslandConfiguration
+    {
+        public required uint FunctionOffsetFieldOfView { get; set; }
+
+        public required uint FunctionOffsetTargetFrameRate { get; set; }
+
+        public required uint FunctionOffsetFog { get; set; }
+    }
+}

src/Snap.Hutao/Snap.Hutao.Test/PlatformExtensions/DependencyInjectionTest.cs

@@ -1,5 +1,7 @@
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
 using System;
+using System.Linq;
 
 namespace Snap.Hutao.Test.PlatformExtensions;
 
@@ -10,7 +12,10 @@ public sealed class DependencyInjectionTest
         .AddSingleton<IService, ServiceA>()
         .AddSingleton<IService, ServiceB>()
         .AddScoped<IScopedService, ServiceA>()
+        .AddKeyedTransient<IKeyedService, KeyedServiceA>("A")
+        .AddKeyedTransient<IKeyedService, KeyedServiceB>("B")
         .AddTransient(typeof(IGenericService<>), typeof(GenericService<>))
+        .AddLogging(builder => builder.AddConsole())
         .BuildServiceProvider();
 
     [TestMethod]
@@ -41,6 +46,22 @@ public sealed class DependencyInjectionTest
         }
     }
 
+    [TestMethod]
+    public void LoggerWithInterfaceTypeCanBeResolved()
+    {
+        Assert.IsNotNull(services.GetService<ILogger<IScopedService>>());
+        Assert.IsNotNull(services.GetRequiredService<ILoggerFactory>().CreateLogger(nameof(IScopedService)));
+    }
+
+    [TestMethod]
+    public void KeyedServicesCanBeResolvedAsEnumerable()
+    {
+        Assert.IsNotNull(services.GetRequiredKeyedService<IKeyedService>("A"));
+        Assert.IsNotNull(services.GetRequiredKeyedService<IKeyedService>("B"));
+
+        Assert.AreEqual(0, services.GetServices<IKeyedService>().Count());
+    }
+
     private interface IService
     {
         Guid Id { get; }
@@ -86,4 +107,14 @@ public sealed class DependencyInjectionTest
         {
         }
     }
+
+    private interface IKeyedService;
+
+    private sealed class KeyedServiceA : IKeyedService
+    {
+    }
+
+    private sealed class KeyedServiceB : IKeyedService
+    {
+    }
 }

src/Snap.Hutao/Snap.Hutao.Test/RuntimeBehavior/HttpClientBehaviorTest.cs

@@ -0,0 +1,45 @@
+using System.Drawing;
+using System.Net.Http;
+using System.Net.Http.Json;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Snap.Hutao.Test.RuntimeBehavior;
+
+[TestClass]
+public sealed class HttpClientBehaviorTest
+{
+    private const int MessageNotYetSent = 0;
+
+    [TestMethod]
+    public async Task RetrySendHttpRequestMessage()
+    {
+        using (HttpClient httpClient = new())
+        {
+            HttpRequestMessage requestMessage = new(HttpMethod.Post, "https://jsonplaceholder.typicode.com/posts");
+            JsonContent content = JsonContent.Create(new Point(12, 34));
+            requestMessage.Content = content;
+            using (requestMessage)
+            {
+                await httpClient.SendAsync(requestMessage).ConfigureAwait(false);
+            }
+
+            Interlocked.Exchange(ref GetPrivateSendStatus(requestMessage), MessageNotYetSent);
+            Volatile.Write(ref GetPrivateDisposed(content), false);
+            await httpClient.SendAsync(requestMessage).ConfigureAwait(false);
+        }
+    }
+
+    // private int _sendStatus
+    [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "_sendStatus")]
+    private static extern ref int GetPrivateSendStatus(HttpRequestMessage message);
+
+    // private bool _disposed
+    [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "_disposed")]
+    private static extern ref bool GetPrivateDisposed(HttpRequestMessage message);
+
+    // private bool _disposed
+    [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "_disposed")]
+    private static extern ref bool GetPrivateDisposed(HttpContent content);
+}

src/Snap.Hutao/Snap.Hutao.Test/RuntimeBehavior/UnsafeRuntimeBehaviorTest.cs

@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
@@ -46,7 +47,59 @@ public sealed class UnsafeRuntimeBehaviorTest
         Assert.AreEqual(1212, testStruct.Value4);
     }
 
+    [TestMethod]
+    public unsafe void UnsafeUtf8StringReference()
+    {
+        void* ptr = Unsafe.AsPointer(ref MemoryMarshal.GetReference("test"u8));
+        GC.Collect(GC.MaxGeneration);
+        ReadOnlySpan<byte> bytes = MemoryMarshal.CreateReadOnlySpanFromNullTerminated((byte*)ptr);
+        Console.WriteLine(System.Text.Encoding.UTF8.GetString(bytes));
+    }
 
+    [TestMethod]
+    public unsafe void UnsafeSizeInt32ToRectInt32Test()
+    {
+        RectInt32 rectInt32 = ToRectInt32(new(100, 200));
+        Assert.AreEqual(rectInt32.X, 0);
+        Assert.AreEqual(rectInt32.Y, 0);
+        Assert.AreEqual(rectInt32.Width, 100);
+        Assert.AreEqual(rectInt32.Height, 200);
+
+        unsafe RectInt32 ToRectInt32(SizeInt32 sizeInt32)
+        {
+            byte* pBytes = stackalloc byte[sizeof(RectInt32)];
+            *(SizeInt32*)(pBytes + 8) = sizeInt32;
+            return *(RectInt32*)pBytes;
+        }
+    }
+
+    private struct RectInt32
+    {
+        public int X;
+        public int Y;
+        public int Width;
+        public int Height;
+
+        public RectInt32(int x, int y, int width, int height)
+        {
+            X = x;
+            Y = y;
+            Width = width;
+            Height = height;
+        }
+    }
+
+    private struct SizeInt32
+    {
+        public int Width;
+        public int Height;
+
+        public SizeInt32(int width, int height)
+        {
+            Width = width;
+            Height = height;
+        }
+    }
 
     private readonly struct TestStruct
     {

src/Snap.Hutao/Snap.Hutao.Test/Snap.Hutao.Test.csproj

@@ -12,10 +12,11 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="8.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.9.0" />
-    <PackageReference Include="MSTest.TestAdapter" Version="3.2.1" />
-    <PackageReference Include="MSTest.TestFramework" Version="3.2.2" />
-    <PackageReference Include="coverlet.collector" Version="6.0.1">
+    <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="8.0.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.10.0" />
+    <PackageReference Include="MSTest.TestAdapter" Version="3.5.0" />
+    <PackageReference Include="MSTest.TestFramework" Version="3.5.0" />
+    <PackageReference Include="coverlet.collector" Version="6.0.2">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>

src/Snap.Hutao/Snap.Hutao/App.xaml

@@ -6,29 +6,39 @@
         <ResourceDictionary>
             <ResourceDictionary.MergedDictionaries>
                 <XamlControlsResources/>
-                <ResourceDictionary Source="ms-appx:///CommunityToolkit.WinUI.Controls.TokenizingTextBox/TokenizingTextBox.xaml"/>
-                <ResourceDictionary Source="ms-appx:///Control/Loading.xaml"/>
-                <ResourceDictionary Source="ms-appx:///Control/Image/CachedImage.xaml"/>
-                <ResourceDictionary Source="ms-appx:///Control/Theme/Card.xaml"/>
-                <ResourceDictionary Source="ms-appx:///Control/Theme/Color.xaml"/>
-                <ResourceDictionary Source="ms-appx:///Control/Theme/ComboBox.xaml"/>
-                <ResourceDictionary Source="ms-appx:///Control/Theme/Converter.xaml"/>
-                <ResourceDictionary Source="ms-appx:///Control/Theme/CornerRadius.xaml"/>
-                <ResourceDictionary Source="ms-appx:///Control/Theme/FlyoutStyle.xaml"/>
-                <ResourceDictionary Source="ms-appx:///Control/Theme/FontStyle.xaml"/>
-                <ResourceDictionary Source="ms-appx:///Control/Theme/Glyph.xaml"/>
-                <ResourceDictionary Source="ms-appx:///Control/Theme/InfoBarOverride.xaml"/>
-                <ResourceDictionary Source="ms-appx:///Control/Theme/ItemsPanelTemplate.xaml"/>
-                <ResourceDictionary Source="ms-appx:///Control/Theme/NumericValue.xaml"/>
-                <ResourceDictionary Source="ms-appx:///Control/Theme/PageOverride.xaml"/>
-                <ResourceDictionary Source="ms-appx:///Control/Theme/PivotOverride.xaml"/>
-                <ResourceDictionary Source="ms-appx:///Control/Theme/ScrollViewer.xaml"/>
-                <ResourceDictionary Source="ms-appx:///Control/Theme/SegmentedOverride.xaml"/>
-                <ResourceDictionary Source="ms-appx:///Control/Theme/SettingsStyle.xaml"/>
-                <ResourceDictionary Source="ms-appx:///Control/Theme/Thickness.xaml"/>
-                <ResourceDictionary Source="ms-appx:///Control/Theme/TransitionCollection.xaml"/>
-                <ResourceDictionary Source="ms-appx:///Control/Theme/Uri.xaml"/>
-                <ResourceDictionary Source="ms-appx:///Control/Theme/WindowOverride.xaml"/>
+                <ResourceDictionary Source="ms-appx:///CommunityToolkit.WinUI.Controls.SettingsControls/SettingsCard/SettingsCard.xaml"/>
+                <ResourceDictionary Source="ms-appx:///CommunityToolkit.Labs.WinUI.TokenView/TokenItem/TokenItem.xaml"/>
+                <ResourceDictionary Source="ms-appx:///UI/Xaml/Control/Elevation.xaml"/>
+                <ResourceDictionary Source="ms-appx:///UI/Xaml/Control/ItemIcon.xaml"/>
+                <ResourceDictionary Source="ms-appx:///UI/Xaml/Control/Loading.xaml"/>
+                <ResourceDictionary Source="ms-appx:///UI/Xaml/Control/StandardView.xaml"/>
+                <ResourceDictionary Source="ms-appx:///UI/Xaml/Control/AutoSuggestBox/AutoSuggestTokenBox.xaml"/>
+                <ResourceDictionary Source="ms-appx:///UI/Xaml/Control/Card/CardBlock.xaml"/>
+                <ResourceDictionary Source="ms-appx:///UI/Xaml/Control/Card/CardProgressBar.xaml"/>
+                <ResourceDictionary Source="ms-appx:///UI/Xaml/Control/Card/HorizontalCard.xaml"/>
+                <ResourceDictionary Source="ms-appx:///UI/Xaml/Control/Card/VerticalCard.xaml"/>
+                <ResourceDictionary Source="ms-appx:///UI/Xaml/Control/Image/CachedImage.xaml"/>
+                <ResourceDictionary Source="ms-appx:///UI/Xaml/Control/TextBlock/RateDeltaTextBlock.xaml"/>
+                <ResourceDictionary Source="ms-appx:///UI/Xaml/Control/Theme/Card.xaml"/>
+                <ResourceDictionary Source="ms-appx:///UI/Xaml/Control/Theme/Color.xaml"/>
+                <ResourceDictionary Source="ms-appx:///UI/Xaml/Control/Theme/ComboBox.xaml"/>
+                <ResourceDictionary Source="ms-appx:///UI/Xaml/Control/Theme/Converter.xaml"/>
+                <ResourceDictionary Source="ms-appx:///UI/Xaml/Control/Theme/CornerRadius.xaml"/>
+                <ResourceDictionary Source="ms-appx:///UI/Xaml/Control/Theme/FlyoutStyle.xaml"/>
+                <ResourceDictionary Source="ms-appx:///UI/Xaml/Control/Theme/FontStyle.xaml"/>
+                <ResourceDictionary Source="ms-appx:///UI/Xaml/Control/Theme/Glyph.xaml"/>
+                <ResourceDictionary Source="ms-appx:///UI/Xaml/Control/Theme/InfoBarOverride.xaml"/>
+                <ResourceDictionary Source="ms-appx:///UI/Xaml/Control/Theme/ItemsPanelTemplate.xaml"/>
+                <ResourceDictionary Source="ms-appx:///UI/Xaml/Control/Theme/NumericValue.xaml"/>
+                <ResourceDictionary Source="ms-appx:///UI/Xaml/Control/Theme/PageOverride.xaml"/>
+                <ResourceDictionary Source="ms-appx:///UI/Xaml/Control/Theme/PivotOverride.xaml"/>
+                <ResourceDictionary Source="ms-appx:///UI/Xaml/Control/Theme/ScrollViewer.xaml"/>
+                <ResourceDictionary Source="ms-appx:///UI/Xaml/Control/Theme/SegmentedOverride.xaml"/>
+                <ResourceDictionary Source="ms-appx:///UI/Xaml/Control/Theme/SettingsStyle.xaml"/>
+                <ResourceDictionary Source="ms-appx:///UI/Xaml/Control/Theme/Thickness.xaml"/>
+                <ResourceDictionary Source="ms-appx:///UI/Xaml/Control/Theme/TransitionCollection.xaml"/>
+                <ResourceDictionary Source="ms-appx:///UI/Xaml/Control/Theme/Uri.xaml"/>
+                <ResourceDictionary Source="ms-appx:///UI/Xaml/Control/Theme/WindowOverride.xaml"/>
             </ResourceDictionary.MergedDictionaries>
 
             <Style
@@ -42,15 +52,15 @@
                 x:Name="NoneSelectionListViewItemStyle"
                 BasedOn="{StaticResource DefaultListViewItemStyle}"
                 TargetType="ListViewItem">
-                <Setter Property="Padding" Value="0"/>
                 <Setter Property="Margin" Value="0,4,0,0"/>
+                <Setter Property="Padding" Value="0"/>
             </Style>
             <Style
                 x:Name="NoneSelectionGridViewItemStyle"
                 BasedOn="{StaticResource DefaultGridViewItemStyle}"
                 TargetType="GridViewItem">
-                <Setter Property="Padding" Value="0"/>
                 <Setter Property="Margin" Value="0,0,2,4"/>
+                <Setter Property="Padding" Value="0"/>
             </Style>
         </ResourceDictionary>
     </Application.Resources>

src/Snap.Hutao/Snap.Hutao/App.xaml.cs

@@ -3,11 +3,12 @@
 
 using Microsoft.UI.Xaml;
 using Microsoft.Windows.AppLifecycle;
+using Microsoft.Windows.AppNotifications;
 using Snap.Hutao.Core;
 using Snap.Hutao.Core.ExceptionService;
 using Snap.Hutao.Core.LifeCycle;
 using Snap.Hutao.Core.LifeCycle.InterProcess;
-using Snap.Hutao.Core.Shell;
+using Snap.Hutao.Core.Logging;
 using System.Diagnostics;
 
 namespace Snap.Hutao;
@@ -21,24 +22,24 @@ namespace Snap.Hutao;
 [SuppressMessage("", "SH001")]
 public sealed partial class App : Application
 {
-    private const string ConsoleBanner = """
+    private const string ConsoleBanner = $"""
         ----------------------------------------------------------------
-          _____                         _    _         _                
-         / ____|                       | |  | |       | |               
-        | (___   _ __    __ _  _ __    | |__| | _   _ | |_  __ _   ___  
-         \___ \ | '_ \  / _` || '_ \   |  __  || | | || __|/ _` | / _ \ 
+          _____                         _    _         _ 
+         / ____|                       | |  | |       | |
+        | (___   _ __    __ _  _ __    | |__| | _   _ | |_  __ _   ___
+         \___ \ | '_ \  / _` || '_ \   |  __  || | | || __|/ _` | / _ \
          ____) || | | || (_| || |_) |_ | |  | || |_| || |_| (_| || (_) |
-        |_____/ |_| |_| \__,_|| .__/(_)|_|  |_| \__,_| \__|\__,_| \___/ 
-                              | |                                       
-                              |_| 
-                              
+        |_____/ |_| |_| \__,_|| .__/(_)|_|  |_| \__,_| \__|\__,_| \___/
+                              | |
+                              |_|
+        
         Snap.Hutao is a open source software developed by DGP Studio.
         Copyright (C) 2022 - 2024 DGP Studio, All Rights Reserved.
         ----------------------------------------------------------------
         """;
 
     private readonly IServiceProvider serviceProvider;
-    private readonly IActivation activation;
+    private readonly IAppActivation activation;
     private readonly ILogger<App> logger;
 
     /// <summary>
@@ -49,38 +50,47 @@ public sealed partial class App : Application
     {
         // Load app resource
         InitializeComponent();
-        activation = serviceProvider.GetRequiredService<IActivation>();
+        activation = serviceProvider.GetRequiredService<IAppActivation>();
         logger = serviceProvider.GetRequiredService<ILogger<App>>();
         serviceProvider.GetRequiredService<ExceptionRecorder>().Record(this);
 
         this.serviceProvider = serviceProvider;
     }
 
+    public new void Exit()
+    {
+        XamlApplicationLifetime.Exiting = true;
+        base.Exit();
+    }
+
     /// <inheritdoc/>
     protected override void OnLaunched(LaunchActivatedEventArgs args)
     {
         try
         {
+            // Important: You must call AppNotificationManager::Default().Register
+            // before calling AppInstance.GetCurrent.GetActivatedEventArgs.
+            AppNotificationManager.Default.NotificationInvoked += activation.NotificationInvoked;
+            AppNotificationManager.Default.Register();
             AppActivationArguments activatedEventArgs = AppInstance.GetCurrent().GetActivatedEventArgs();
 
             if (serviceProvider.GetRequiredService<PrivateNamedPipeClient>().TryRedirectActivationTo(activatedEventArgs))
             {
+                logger.LogDebug("Application exiting on RedirectActivationTo");
                 Exit();
                 return;
             }
 
-            logger.LogInformation(ConsoleBanner);
+            logger.LogColorizedInformation((ConsoleBanner, ConsoleColor.DarkYellow));
             LogDiagnosticInformation();
 
-            // manually invoke
+            // Manually invoke
             activation.Activate(HutaoActivationArguments.FromAppActivationArguments(activatedEventArgs));
-            activation.Initialize();
-
-            serviceProvider.GetRequiredService<IJumpListInterop>().ConfigureAsync().SafeForget();
+            activation.PostInitialization();
         }
-        catch
+        catch (Exception ex)
         {
-            // AppInstance.GetCurrent() calls failed
+            logger.LogError(ex, "Application failed in App.OnLaunched");
             Process.GetCurrentProcess().Kill();
         }
     }
@@ -89,8 +99,8 @@ public sealed partial class App : Application
     {
         RuntimeOptions runtimeOptions = serviceProvider.GetRequiredService<RuntimeOptions>();
 
-        logger.LogInformation("FamilyName: {name}", runtimeOptions.FamilyName);
-        logger.LogInformation("Version: {version}", runtimeOptions.Version);
-        logger.LogInformation("LocalCache: {folder}", runtimeOptions.LocalCache);
+        logger.LogColorizedInformation(("FamilyName: {Name}", ConsoleColor.Blue), (runtimeOptions.FamilyName, ConsoleColor.Cyan));
+        logger.LogColorizedInformation(("Version: {Version}", ConsoleColor.Blue), (runtimeOptions.Version, ConsoleColor.Cyan));
+        logger.LogColorizedInformation(("LocalCache: {Path}", ConsoleColor.Blue), (runtimeOptions.LocalCache, ConsoleColor.Cyan));
     }
 }

src/Snap.Hutao/Snap.Hutao/AppResourceProvider.cs

@@ -1,28 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-namespace Snap.Hutao;
-
-/// <summary>
-/// 应用程序资源提供器
-/// </summary>
-[Injection(InjectAs.Transient, typeof(IAppResourceProvider))]
-internal sealed class AppResourceProvider : IAppResourceProvider
-{
-    private readonly App app;
-
-    /// <summary>
-    /// 构造一个新的应用程序资源提供器
-    /// </summary>
-    /// <param name="app">应用</param>
-    public AppResourceProvider(App app)
-    {
-        this.app = app;
-    }
-
-    /// <inheritdoc/>
-    public T GetResource<T>(string name)
-    {
-        return (T)app.Resources[name];
-    }
-}

src/Snap.Hutao/Snap.Hutao/Control/AutoSuggestBox/AutoSuggestTokenBox.cs

@@ -1,65 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-using CommunityToolkit.WinUI.Controls;
-using Microsoft.UI.Xaml.Controls;
-using Snap.Hutao.Control.Extension;
-
-namespace Snap.Hutao.Control.AutoSuggestBox;
-
-[DependencyProperty("FilterCommand", typeof(ICommand))]
-[DependencyProperty("FilterCommandParameter", typeof(object))]
-[DependencyProperty("AvailableTokens", typeof(IReadOnlyDictionary<string, SearchToken>))]
-internal sealed partial class AutoSuggestTokenBox : TokenizingTextBox
-{
-    public AutoSuggestTokenBox()
-    {
-        DefaultStyleKey = typeof(TokenizingTextBox);
-        TextChanged += OnFilterSuggestionRequested;
-        QuerySubmitted += OnQuerySubmitted;
-        TokenItemAdding += OnTokenItemAdding;
-        TokenItemAdded += OnTokenItemModified;
-        TokenItemRemoved += OnTokenItemModified;
-    }
-
-    private void OnFilterSuggestionRequested(Microsoft.UI.Xaml.Controls.AutoSuggestBox sender, AutoSuggestBoxTextChangedEventArgs args)
-    {
-        if (string.IsNullOrWhiteSpace(Text))
-        {
-            return;
-        }
-
-        if (args.Reason == AutoSuggestionBoxTextChangeReason.UserInput)
-        {
-            sender.ItemsSource = AvailableTokens.Values.Where(q => q.Value.Contains(Text, StringComparison.OrdinalIgnoreCase));
-
-            // TODO: CornerRadius
-            // Popup? popup = this.FindDescendant("SuggestionsPopup") as Popup;
-        }
-    }
-
-    private void OnQuerySubmitted(Microsoft.UI.Xaml.Controls.AutoSuggestBox sender, AutoSuggestBoxQuerySubmittedEventArgs args)
-    {
-        if (args.ChosenSuggestion is not null)
-        {
-            return;
-        }
-
-        CommandExtension.TryExecute(FilterCommand, FilterCommandParameter);
-    }
-
-    private void OnTokenItemAdding(TokenizingTextBox sender, TokenItemAddingEventArgs args)
-    {
-        if (string.IsNullOrWhiteSpace(args.TokenText))
-        {
-            return;
-        }
-
-        args.Item = AvailableTokens.GetValueOrDefault(args.TokenText) ?? new SearchToken(SearchTokenKind.None, args.TokenText);
-    }
-
-    private void OnTokenItemModified(TokenizingTextBox sender, object args)
-    {
-        CommandExtension.TryExecute(FilterCommand, FilterCommandParameter);
-    }
-}

src/Snap.Hutao/Snap.Hutao/Control/Behavior/MarqueeTextBehavior.cs

@@ -1,46 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-using CommunityToolkit.Labs.WinUI.MarqueeTextRns;
-using CommunityToolkit.WinUI.Behaviors;
-using Microsoft.UI.Xaml.Input;
-
-namespace Snap.Hutao.Control.Behavior;
-
-internal sealed class MarqueeTextBehavior : BehaviorBase<MarqueeText>
-{
-    private readonly PointerEventHandler pointerEnteredEventHandler;
-    private readonly PointerEventHandler pointerExitedEventHandler;
-
-    public MarqueeTextBehavior()
-    {
-        pointerEnteredEventHandler = OnPointerEntered;
-        pointerExitedEventHandler = OnPointerExited;
-    }
-
-    protected override bool Initialize()
-    {
-        AssociatedObject.PointerEntered += pointerEnteredEventHandler;
-        AssociatedObject.PointerExited += pointerExitedEventHandler;
-
-        return true;
-    }
-
-    protected override bool Uninitialize()
-    {
-        AssociatedObject.PointerEntered -= pointerEnteredEventHandler;
-        AssociatedObject.PointerExited -= pointerExitedEventHandler;
-
-        return true;
-    }
-
-    private void OnPointerEntered(object sender, PointerRoutedEventArgs e)
-    {
-        AssociatedObject.StartMarquee();
-    }
-
-    private void OnPointerExited(object sender, PointerRoutedEventArgs e)
-    {
-        AssociatedObject.StopMarquee();
-    }
-}

src/Snap.Hutao/Snap.Hutao/Control/Brush/ColorSegment.cs

@@ -1,19 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-using Windows.UI;
-
-namespace Snap.Hutao.Control.Brush;
-
-internal sealed class ColorSegment : IColorSegment
-{
-    public ColorSegment(Color color, double value)
-    {
-        Color = color;
-        Value = value;
-    }
-
-    public Color Color { get; set; }
-
-    public double Value { get; set; }
-}

src/Snap.Hutao/Snap.Hutao/Control/Brush/ColorSegmentCollection.cs

@@ -1,8 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-namespace Snap.Hutao.Control.Brush;
-
-internal sealed class ColorSegmentCollection : List<IColorSegment>
-{
-}

src/Snap.Hutao/Snap.Hutao/Control/Brush/IColorSegment.cs

@@ -1,13 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-using Windows.UI;
-
-namespace Snap.Hutao.Control.Brush;
-
-internal interface IColorSegment
-{
-    Color Color { get; }
-
-    double Value { get; set; }
-}

src/Snap.Hutao/Snap.Hutao/Control/Brush/SegmentedBar.cs

@@ -1,56 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-using Microsoft.UI.Xaml;
-using Microsoft.UI.Xaml.Controls;
-using Microsoft.UI.Xaml.Media;
-using Microsoft.UI.Xaml.Shapes;
-using System.Runtime.InteropServices;
-
-namespace Snap.Hutao.Control.Brush;
-
-[DependencyProperty("Source", typeof(ColorSegmentCollection), default!, nameof(OnSourceChanged))]
-internal sealed partial class SegmentedBar : ContentControl
-{
-    private readonly LinearGradientBrush brush = new() { StartPoint = new(0, 0), EndPoint = new(1, 0), };
-
-    public SegmentedBar()
-    {
-        HorizontalContentAlignment = HorizontalAlignment.Stretch;
-        VerticalContentAlignment = VerticalAlignment.Stretch;
-
-        Content = new Rectangle()
-        {
-            Fill = brush,
-            HorizontalAlignment = HorizontalAlignment.Stretch,
-            VerticalAlignment = VerticalAlignment.Stretch,
-        };
-    }
-
-    private static void OnSourceChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
-    {
-        UpdateLinearGradientBrush((SegmentedBar)obj);
-    }
-
-    private static void UpdateLinearGradientBrush(SegmentedBar segmentedBar)
-    {
-        GradientStopCollection collection = segmentedBar.brush.GradientStops;
-        collection.Clear();
-
-        ColorSegmentCollection segmentCollection = segmentedBar.Source;
-
-        double total = segmentCollection.Sum(seg => seg.Value);
-        if (total is 0D)
-        {
-            return;
-        }
-
-        double offset = 0;
-        foreach (ref readonly IColorSegment segment in CollectionsMarshal.AsSpan(segmentCollection))
-        {
-            collection.Add(new() { Color = segment.Color, Offset = offset, });
-            offset += segment.Value / total;
-            collection.Add(new() { Color = segment.Color, Offset = offset, });
-        }
-    }
-}

src/Snap.Hutao/Snap.Hutao/Control/Collection/Alternating/AlternatingItemsControl.cs

@@ -1,38 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-using Microsoft.UI.Xaml.Controls;
-using Windows.Foundation.Collections;
-
-namespace Snap.Hutao.Control.Collection.Alternating;
-
-[DependencyProperty("ItemAlternateBackground", typeof(Microsoft.UI.Xaml.Media.Brush))]
-internal sealed partial class AlternatingItemsControl : ItemsControl
-{
-    private readonly VectorChangedEventHandler<object> itemsVectorChangedEventHandler;
-
-    public AlternatingItemsControl()
-    {
-        itemsVectorChangedEventHandler = OnItemsVectorChanged;
-        Items.VectorChanged += itemsVectorChangedEventHandler;
-    }
-
-    private void OnItemsVectorChanged(IObservableVector<object> items, IVectorChangedEventArgs args)
-    {
-        if (args.CollectionChange is CollectionChange.Reset)
-        {
-            int index = (int)args.Index;
-            for (int i = index; i < items.Count; i++)
-            {
-                if (items[i] is IAlternatingItem item)
-                {
-                    item.Background = i % 2 is 0 ? default : ItemAlternateBackground;
-                }
-                else
-                {
-                    break;
-                }
-            }
-        }
-    }
-}

src/Snap.Hutao/Snap.Hutao/Control/Collection/Alternating/IAlternatingItem.cs

@@ -1,9 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-namespace Snap.Hutao.Control.Collection.Alternating;
-
-internal interface IAlternatingItem
-{
-    public Microsoft.UI.Xaml.Media.Brush? Background { get; set; }
-}

src/Snap.Hutao/Snap.Hutao/Control/Image/CachedImage.cs

@@ -1,46 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-using Microsoft.UI.Xaml.Media;
-using Microsoft.UI.Xaml.Media.Imaging;
-using Snap.Hutao.Core.Caching;
-using System.Runtime.InteropServices;
-
-namespace Snap.Hutao.Control.Image;
-
-/// <summary>
-/// 缓存图像
-/// </summary>
-[HighQuality]
-internal sealed class CachedImage : Implementation.ImageEx
-{
-    /// <summary>
-    /// 构造一个新的缓存图像
-    /// </summary>
-    public CachedImage()
-    {
-        IsCacheEnabled = true;
-        EnableLazyLoading = false;
-    }
-
-    /// <inheritdoc/>
-    protected override async Task<ImageSource?> ProvideCachedResourceAsync(Uri imageUri, CancellationToken token)
-    {
-        // We can only use Ioc to retrieve IImageCache, no IServiceProvider is available.
-        IImageCache imageCache = Ioc.Default.GetRequiredService<IImageCache>();
-
-        try
-        {
-            Verify.Operation(!string.IsNullOrEmpty(imageUri.Host), SH.ControlImageCachedImageInvalidResourceUri);
-            string file = await imageCache.GetFileFromCacheAsync(imageUri).ConfigureAwait(true); // BitmapImage need to be created by main thread.
-            token.ThrowIfCancellationRequested(); // check token state to determine whether the operation should be canceled.
-            return new BitmapImage(file.ToUri()); // BitmapImage initialize with a uri will increase image quality and loading speed.
-        }
-        catch (COMException)
-        {
-            // The image is corrupted, remove it.
-            imageCache.Remove(imageUri);
-            return default;
-        }
-    }
-}

src/Snap.Hutao/Snap.Hutao/Control/Image/Implementation/ImageEx.cs

@@ -1,44 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-using Microsoft.UI.Composition;
-using Microsoft.UI.Xaml;
-using Windows.Media.Casting;
-
-namespace Snap.Hutao.Control.Image.Implementation;
-
-internal class ImageEx : ImageExBase
-{
-    private static readonly DependencyProperty NineGridProperty = DependencyProperty.Register(nameof(NineGrid), typeof(Thickness), typeof(ImageEx), new PropertyMetadata(default(Thickness)));
-
-    public ImageEx()
-        : base()
-    {
-    }
-
-    public Thickness NineGrid
-    {
-        get => (Thickness)GetValue(NineGridProperty);
-        set => SetValue(NineGridProperty, value);
-    }
-
-    public override CompositionBrush GetAlphaMask()
-    {
-        if (IsInitialized && Image is Microsoft.UI.Xaml.Controls.Image image)
-        {
-            return image.GetAlphaMask();
-        }
-
-        return default!;
-    }
-
-    public CastingSource GetAsCastingSource()
-    {
-        if (IsInitialized && Image is Microsoft.UI.Xaml.Controls.Image image)
-        {
-            return image.GetAsCastingSource();
-        }
-
-        return default!;
-    }
-}

src/Snap.Hutao/Snap.Hutao/Control/Image/Implementation/ImageExBase.cs

@@ -1,471 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-using CommunityToolkit.WinUI;
-using Microsoft.UI.Composition;
-using Microsoft.UI.Xaml;
-using Microsoft.UI.Xaml.Media;
-using Microsoft.UI.Xaml.Media.Imaging;
-using System.IO;
-using Windows.Foundation;
-
-namespace Snap.Hutao.Control.Image.Implementation;
-
-[SuppressMessage("", "CA1001")]
-[SuppressMessage("", "SH003")]
-[TemplateVisualState(Name = LoadingState, GroupName = CommonGroup)]
-[TemplateVisualState(Name = LoadedState, GroupName = CommonGroup)]
-[TemplateVisualState(Name = UnloadedState, GroupName = CommonGroup)]
-[TemplateVisualState(Name = FailedState, GroupName = CommonGroup)]
-[TemplatePart(Name = PartImage, Type = typeof(object))]
-[TemplatePart(Name = PartPlaceholderImage, Type = typeof(object))]
-[DependencyProperty("Stretch", typeof(Stretch), Stretch.Uniform)]
-[DependencyProperty("DecodePixelHeight", typeof(int), 0)]
-[DependencyProperty("DecodePixelWidth", typeof(int), 0)]
-[DependencyProperty("DecodePixelType", typeof(DecodePixelType), DecodePixelType.Physical)]
-[DependencyProperty("IsCacheEnabled", typeof(bool), false)]
-[DependencyProperty("EnableLazyLoading", typeof(bool), false, nameof(EnableLazyLoadingChanged))]
-[DependencyProperty("LazyLoadingThreshold", typeof(double), default(double), nameof(LazyLoadingThresholdChanged))]
-[DependencyProperty("PlaceholderSource", typeof(object), default(object))]
-[DependencyProperty("PlaceholderStretch", typeof(Stretch), Stretch.Uniform)]
-[DependencyProperty("PlaceholderMargin", typeof(Thickness))]
-[DependencyProperty("Source", typeof(object), default(object), nameof(SourceChanged))]
-internal abstract partial class ImageExBase : Microsoft.UI.Xaml.Controls.Control, IAlphaMaskProvider
-{
-    protected const string PartImage = "Image";
-    protected const string PartPlaceholderImage = "PlaceholderImage";
-    protected const string CommonGroup = "CommonStates";
-    protected const string LoadingState = "Loading";
-    protected const string LoadedState = "Loaded";
-    protected const string UnloadedState = "Unloaded";
-    protected const string FailedState = "Failed";
-
-    private CancellationTokenSource? tokenSource;
-    private object? lazyLoadingSource;
-    private bool isInViewport;
-
-    public bool IsInitialized { get; private set; }
-
-    public bool WaitUntilLoaded
-    {
-        get => true;
-    }
-
-    protected object? Image { get; private set; }
-
-    protected object? PlaceholderImage { get; private set; }
-
-    public abstract CompositionBrush GetAlphaMask();
-
-    protected virtual Task<ImageSource?> ProvideCachedResourceAsync(Uri imageUri, CancellationToken token)
-    {
-        // By default we just use the built-in UWP image cache provided within the Image control.
-        return Task.FromResult<ImageSource?>(new BitmapImage(imageUri));
-    }
-
-    protected virtual void OnImageOpened(object sender, RoutedEventArgs e)
-    {
-        VisualStateManager.GoToState(this, LoadedState, true);
-    }
-
-    protected virtual void OnImageFailed(object sender, ExceptionRoutedEventArgs e)
-    {
-        VisualStateManager.GoToState(this, FailedState, true);
-    }
-
-    protected override void OnApplyTemplate()
-    {
-        RemoveImageOpened(OnImageOpened);
-        RemoveImageFailed(OnImageFailed);
-
-        Image = GetTemplateChild(PartImage);
-        PlaceholderImage = GetTemplateChild(PartPlaceholderImage);
-
-        IsInitialized = true;
-
-        if (Source is null || !EnableLazyLoading || isInViewport)
-        {
-            lazyLoadingSource = null;
-            SetSource(Source);
-        }
-        else
-        {
-            lazyLoadingSource = Source;
-        }
-
-        AttachImageOpened(OnImageOpened);
-        AttachImageFailed(OnImageFailed);
-
-        base.OnApplyTemplate();
-
-        void AttachImageOpened(RoutedEventHandler handler)
-        {
-            if (Image is Microsoft.UI.Xaml.Controls.Image image)
-            {
-                image.ImageOpened += handler;
-            }
-            else if (Image is ImageBrush brush)
-            {
-                brush.ImageOpened += handler;
-            }
-        }
-
-        void AttachImageFailed(ExceptionRoutedEventHandler handler)
-        {
-            if (Image is Microsoft.UI.Xaml.Controls.Image image)
-            {
-                image.ImageFailed += handler;
-            }
-            else if (Image is ImageBrush brush)
-            {
-                brush.ImageFailed += handler;
-            }
-        }
-
-        void RemoveImageOpened(RoutedEventHandler handler)
-        {
-            if (Image is Microsoft.UI.Xaml.Controls.Image image)
-            {
-                image.ImageOpened -= handler;
-            }
-            else if (Image is ImageBrush brush)
-            {
-                brush.ImageOpened -= handler;
-            }
-        }
-
-        void RemoveImageFailed(ExceptionRoutedEventHandler handler)
-        {
-            if (Image is Microsoft.UI.Xaml.Controls.Image image)
-            {
-                image.ImageFailed -= handler;
-            }
-            else if (Image is ImageBrush brush)
-            {
-                brush.ImageFailed -= handler;
-            }
-        }
-    }
-
-    private static void EnableLazyLoadingChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
-    {
-        if (d is not ImageExBase control)
-        {
-            return;
-        }
-
-        bool value = (bool)e.NewValue;
-        if (value)
-        {
-            control.LayoutUpdated += control.OnImageExBaseLayoutUpdated;
-
-            control.InvalidateLazyLoading();
-        }
-        else
-        {
-            control.LayoutUpdated -= control.OnImageExBaseLayoutUpdated;
-        }
-    }
-
-    private static void LazyLoadingThresholdChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
-    {
-        if (d is ImageExBase control && control.EnableLazyLoading)
-        {
-            control.InvalidateLazyLoading();
-        }
-    }
-
-    private static void SourceChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
-    {
-        if (d is not ImageExBase control)
-        {
-            return;
-        }
-
-        if (e.OldValue is not null && e.NewValue is not null && e.OldValue.Equals(e.NewValue))
-        {
-            return;
-        }
-
-        if (e.NewValue is null || !control.EnableLazyLoading || control.isInViewport)
-        {
-            control.lazyLoadingSource = null;
-            control.SetSource(e.NewValue);
-        }
-        else
-        {
-            control.lazyLoadingSource = e.NewValue;
-        }
-    }
-
-    private static bool IsHttpUri(Uri uri)
-    {
-        return uri.IsAbsoluteUri && (uri.Scheme == "http" || uri.Scheme == "https");
-    }
-
-    private void AttachSource(ImageSource? source)
-    {
-        // Setting the source at this point should call ImageExOpened/VisualStateManager.GoToState
-        // as we register to both the ImageOpened/ImageFailed events of the underlying control.
-        // We only need to call those methods if we fail in other cases before we get here.
-        if (Image is Microsoft.UI.Xaml.Controls.Image image)
-        {
-            image.Source = source;
-        }
-        else if (Image is ImageBrush brush)
-        {
-            brush.ImageSource = source;
-        }
-
-        if (source is null)
-        {
-            VisualStateManager.GoToState(this, UnloadedState, true);
-        }
-        else if (source is BitmapSource { PixelHeight: > 0, PixelWidth: > 0 })
-        {
-            VisualStateManager.GoToState(this, LoadedState, true);
-        }
-    }
-
-    private void AttachPlaceholderSource(ImageSource? source)
-    {
-        // Setting the source at this point should call ImageExOpened/VisualStateManager.GoToState
-        // as we register to both the ImageOpened/ImageFailed events of the underlying control.
-        // We only need to call those methods if we fail in other cases before we get here.
-        if (PlaceholderImage is Microsoft.UI.Xaml.Controls.Image image)
-        {
-            image.Source = source;
-        }
-        else if (PlaceholderImage is ImageBrush brush)
-        {
-            brush.ImageSource = source;
-        }
-    }
-
-    private async void SetSource(object? source)
-    {
-        if (!IsInitialized)
-        {
-            return;
-        }
-
-        tokenSource?.Cancel();
-
-        tokenSource = new CancellationTokenSource();
-
-        AttachSource(null);
-
-        if (source is null)
-        {
-            return;
-        }
-
-        VisualStateManager.GoToState(this, LoadingState, true);
-
-        if (source as ImageSource is { } imageSource)
-        {
-            AttachSource(imageSource);
-
-            return;
-        }
-
-        if (source as Uri is not { } uri)
-        {
-            string? url = source as string ?? source.ToString();
-            if (!Uri.TryCreate(url, UriKind.RelativeOrAbsolute, out uri))
-            {
-                VisualStateManager.GoToState(this, FailedState, true);
-                return;
-            }
-        }
-
-        if (!IsHttpUri(uri) && !uri.IsAbsoluteUri)
-        {
-            uri = new Uri("ms-appx:///" + uri.OriginalString.TrimStart('/'));
-        }
-
-        try
-        {
-            await LoadImageAsync(uri, tokenSource.Token).ConfigureAwait(true);
-        }
-        catch (Exception ex)
-        {
-            SetPlaceholderSource(PlaceholderSource);
-
-            if (ex is OperationCanceledException)
-            {
-                // nothing to do as cancellation has been requested.
-            }
-            else
-            {
-                VisualStateManager.GoToState(this, FailedState, true);
-            }
-        }
-    }
-
-    private async void SetPlaceholderSource(object? source)
-    {
-        if (!IsInitialized)
-        {
-            return;
-        }
-
-        tokenSource?.Cancel();
-
-        tokenSource = new CancellationTokenSource();
-
-        AttachPlaceholderSource(null);
-
-        if (source is null)
-        {
-            return;
-        }
-
-        if (source as ImageSource is { } imageSource)
-        {
-            AttachPlaceholderSource(imageSource);
-
-            return;
-        }
-
-        if (source as Uri is not { } uri)
-        {
-            string? url = source as string ?? source.ToString();
-            if (!Uri.TryCreate(url, UriKind.RelativeOrAbsolute, out uri))
-            {
-                return;
-            }
-        }
-
-        if (!IsHttpUri(uri) && !uri.IsAbsoluteUri)
-        {
-            uri = new Uri("ms-appx:///" + uri.OriginalString.TrimStart('/'));
-        }
-
-        try
-        {
-            if (uri is null)
-            {
-                return;
-            }
-
-            ImageSource? img = await ProvideCachedResourceAsync(uri, tokenSource.Token).ConfigureAwait(true);
-
-            ArgumentNullException.ThrowIfNull(tokenSource);
-            if (!tokenSource.IsCancellationRequested)
-            {
-                // Only attach our image if we still have a valid request.
-                AttachPlaceholderSource(img);
-            }
-        }
-        catch (OperationCanceledException)
-        {
-            // nothing to do as cancellation has been requested.
-        }
-        catch
-        {
-        }
-    }
-
-    private async Task LoadImageAsync(Uri imageUri, CancellationToken token)
-    {
-        if (imageUri is null)
-        {
-            return;
-        }
-
-        if (IsCacheEnabled)
-        {
-            ImageSource? img = await ProvideCachedResourceAsync(imageUri, token).ConfigureAwait(true);
-
-            ArgumentNullException.ThrowIfNull(tokenSource);
-            if (!tokenSource.IsCancellationRequested)
-            {
-                // Only attach our image if we still have a valid request.
-                AttachSource(img);
-            }
-        }
-        else if (string.Equals(imageUri.Scheme, "data", StringComparison.OrdinalIgnoreCase))
-        {
-            string source = imageUri.OriginalString;
-            const string base64Head = "base64,";
-            int index = source.IndexOf(base64Head, StringComparison.Ordinal);
-            if (index >= 0)
-            {
-                byte[] bytes = Convert.FromBase64String(source[(index + base64Head.Length)..]);
-                BitmapImage bitmap = new();
-                await bitmap.SetSourceAsync(new MemoryStream(bytes).AsRandomAccessStream());
-
-                ArgumentNullException.ThrowIfNull(tokenSource);
-                if (!tokenSource.IsCancellationRequested)
-                {
-                    AttachSource(bitmap);
-                }
-            }
-        }
-        else
-        {
-            AttachSource(new BitmapImage(imageUri)
-            {
-                CreateOptions = BitmapCreateOptions.IgnoreImageCache,
-            });
-        }
-    }
-
-    private void OnImageExBaseLayoutUpdated(object? sender, object e)
-    {
-        InvalidateLazyLoading();
-    }
-
-    private void InvalidateLazyLoading()
-    {
-        if (!IsLoaded)
-        {
-            isInViewport = false;
-            return;
-        }
-
-        // Find the first ascendant ScrollViewer, if not found, use the root element.
-        FrameworkElement? hostElement = default;
-        IEnumerable<FrameworkElement> ascendants = this.FindAscendants().OfType<FrameworkElement>();
-        foreach (FrameworkElement ascendant in ascendants)
-        {
-            hostElement = ascendant;
-            if (hostElement is Microsoft.UI.Xaml.Controls.ScrollViewer)
-            {
-                break;
-            }
-        }
-
-        if (hostElement is null)
-        {
-            isInViewport = false;
-            return;
-        }
-
-        Rect controlRect = TransformToVisual(hostElement)
-            .TransformBounds(new Rect(0, 0, ActualWidth, ActualHeight));
-        double lazyLoadingThreshold = LazyLoadingThreshold;
-        Rect hostRect = new(
-            0 - lazyLoadingThreshold,
-            0 - lazyLoadingThreshold,
-            hostElement.ActualWidth + (2 * lazyLoadingThreshold),
-            hostElement.ActualHeight + (2 * lazyLoadingThreshold));
-
-        if (controlRect.IntersectsWith(hostRect))
-        {
-            isInViewport = true;
-
-            if (lazyLoadingSource is not null)
-            {
-                object source = lazyLoadingSource;
-                lazyLoadingSource = null;
-                SetSource(source);
-            }
-        }
-        else
-        {
-            isInViewport = false;
-        }
-    }
-}

src/Snap.Hutao/Snap.Hutao/Control/Image/MonoChrome.cs

@@ -1,67 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-using Microsoft.Graphics.Canvas.Effects;
-using Microsoft.UI;
-using Microsoft.UI.Composition;
-using Microsoft.UI.Xaml;
-using Microsoft.UI.Xaml.Media;
-using Snap.Hutao.Control.Theme;
-using Windows.Foundation;
-
-namespace Snap.Hutao.Control.Image;
-
-/// <summary>
-/// 支持单色的图像
-/// </summary>
-[HighQuality]
-internal sealed class MonoChrome : CompositionImage
-{
-    private readonly TypedEventHandler<FrameworkElement, object> actualThemeChangedEventHandler;
-
-    private CompositionColorBrush? backgroundBrush;
-
-    /// <summary>
-    /// 构造一个新的单色图像
-    /// </summary>
-    public MonoChrome()
-    {
-        actualThemeChangedEventHandler = OnActualThemeChanged;
-        ActualThemeChanged += actualThemeChangedEventHandler;
-    }
-
-    /// <inheritdoc/>
-    protected override SpriteVisual CompositeSpriteVisual(Compositor compositor, LoadedImageSurface imageSurface)
-    {
-        CompositionColorBrush blackLayerBrush = compositor.CreateColorBrush(Colors.Black);
-        CompositionSurfaceBrush imageSurfaceBrush = compositor.CompositeSurfaceBrush(imageSurface, stretch: CompositionStretch.Uniform, vRatio: 0f);
-        CompositionEffectBrush overlayBrush = compositor.CompositeBlendEffectBrush(blackLayerBrush, imageSurfaceBrush, BlendEffectMode.Overlay);
-        CompositionEffectBrush opacityBrush = compositor.CompositeLuminanceToAlphaEffectBrush(overlayBrush);
-
-        backgroundBrush = compositor.CreateColorBrush();
-        SetBackgroundColor(backgroundBrush);
-        CompositionEffectBrush alphaMaskEffectBrush = compositor.CompositeAlphaMaskEffectBrush(backgroundBrush, opacityBrush);
-
-        return compositor.CompositeSpriteVisual(alphaMaskEffectBrush);
-    }
-
-    private void OnActualThemeChanged(FrameworkElement sender, object args)
-    {
-        if (backgroundBrush is not null)
-        {
-            SetBackgroundColor(backgroundBrush);
-        }
-    }
-
-    private void SetBackgroundColor(CompositionColorBrush backgroundBrush)
-    {
-        ApplicationTheme theme = ThemeHelper.ElementToApplication(ActualTheme);
-
-        backgroundBrush.Color = theme switch
-        {
-            ApplicationTheme.Light => Colors.Black,
-            ApplicationTheme.Dark => Colors.White,
-            _ => Colors.Transparent,
-        };
-    }
-}

src/Snap.Hutao/Snap.Hutao/Control/Layout/DefaultItemCollectionTransitionProvider.cs

@@ -1,151 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-using Microsoft.UI.Composition;
-using Microsoft.UI.Xaml.Controls;
-using Microsoft.UI.Xaml.Hosting;
-using System.Numerics;
-using Windows.Foundation;
-
-namespace Snap.Hutao.Control.Layout;
-
-internal sealed class DefaultItemCollectionTransitionProvider : ItemCollectionTransitionProvider
-{
-    private const double DefaultAnimationDurationInMs = 300.0;
-
-    static DefaultItemCollectionTransitionProvider()
-    {
-        AnimationSlowdownFactor = 1.0;
-    }
-
-    public static double AnimationSlowdownFactor { get; set; }
-
-    protected override bool ShouldAnimateCore(ItemCollectionTransition transition)
-    {
-        return true;
-    }
-
-    protected override void StartTransitions(IList<ItemCollectionTransition> transitions)
-    {
-        List<ItemCollectionTransition> addTransitions = [];
-        List<ItemCollectionTransition> removeTransitions = [];
-        List<ItemCollectionTransition> moveTransitions = [];
-
-        foreach (ItemCollectionTransition transition in addTransitions)
-        {
-            switch (transition.Operation)
-            {
-                case ItemCollectionTransitionOperation.Add:
-                    addTransitions.Add(transition);
-                    break;
-                case ItemCollectionTransitionOperation.Remove:
-                    removeTransitions.Add(transition);
-                    break;
-                case ItemCollectionTransitionOperation.Move:
-                    moveTransitions.Add(transition);
-                    break;
-            }
-        }
-
-        StartAddTransitions(addTransitions, removeTransitions.Count > 0, moveTransitions.Count > 0);
-        StartRemoveTransitions(removeTransitions);
-        StartMoveTransitions(moveTransitions, removeTransitions.Count > 0);
-    }
-
-    private static void StartAddTransitions(IList<ItemCollectionTransition> transitions, bool hasRemoveTransitions, bool hasMoveTransitions)
-    {
-        foreach (ItemCollectionTransition transition in transitions)
-        {
-            ItemCollectionTransitionProgress progress = transition.Start();
-            Visual visual = ElementCompositionPreview.GetElementVisual(progress.Element);
-            Compositor compositor = visual.Compositor;
-
-            ScalarKeyFrameAnimation fadeInAnimation = compositor.CreateScalarKeyFrameAnimation();
-            fadeInAnimation.InsertKeyFrame(0.0f, 0.0f);
-
-            if (hasMoveTransitions && hasRemoveTransitions)
-            {
-                fadeInAnimation.InsertKeyFrame(0.66f, 0.0f);
-            }
-            else if (hasMoveTransitions || hasRemoveTransitions)
-            {
-                fadeInAnimation.InsertKeyFrame(0.5f, 0.0f);
-            }
-
-            fadeInAnimation.InsertKeyFrame(1.0f, 1.0f);
-            fadeInAnimation.Duration = TimeSpan.FromMilliseconds(
-                DefaultAnimationDurationInMs * ((hasRemoveTransitions ? 1 : 0) + (hasMoveTransitions ? 1 : 0) + 1) * AnimationSlowdownFactor);
-
-            CompositionScopedBatch batch = compositor.CreateScopedBatch(CompositionBatchTypes.Animation);
-            visual.StartAnimation("Opacity", fadeInAnimation);
-            batch.End();
-            batch.Completed += (_, _) => progress.Complete();
-        }
-    }
-
-    private static void StartRemoveTransitions(IList<ItemCollectionTransition> transitions)
-    {
-        foreach (ItemCollectionTransition transition in transitions)
-        {
-            ItemCollectionTransitionProgress progress = transition.Start();
-            Visual visual = ElementCompositionPreview.GetElementVisual(progress.Element);
-            Compositor compositor = visual.Compositor;
-
-            ScalarKeyFrameAnimation fadeOutAnimation = compositor.CreateScalarKeyFrameAnimation();
-            fadeOutAnimation.InsertExpressionKeyFrame(0.0f, "this.CurrentValue");
-            fadeOutAnimation.InsertKeyFrame(1.0f, 0.0f);
-            fadeOutAnimation.Duration = TimeSpan.FromMilliseconds(DefaultAnimationDurationInMs * AnimationSlowdownFactor);
-
-            CompositionScopedBatch batch = compositor.CreateScopedBatch(CompositionBatchTypes.Animation);
-            visual.StartAnimation(nameof(Visual.Opacity), fadeOutAnimation);
-            batch.End();
-            batch.Completed += (_, _) =>
-            {
-                visual.Opacity = 1.0f;
-                progress.Complete();
-            };
-        }
-    }
-
-    private static void StartMoveTransitions(IList<ItemCollectionTransition> transitions, bool hasRemoveAnimations)
-    {
-        foreach (ItemCollectionTransition transition in transitions)
-        {
-            ItemCollectionTransitionProgress progress = transition.Start();
-            Visual visual = ElementCompositionPreview.GetElementVisual(progress.Element);
-            Compositor compositor = visual.Compositor;
-            CompositionScopedBatch batch = compositor.CreateScopedBatch(CompositionBatchTypes.Animation);
-
-            // Animate offset.
-            if (transition.OldBounds.X != transition.NewBounds.X ||
-                transition.OldBounds.Y != transition.NewBounds.Y)
-            {
-                AnimateOffset(visual, compositor, transition.OldBounds, transition.NewBounds, hasRemoveAnimations);
-            }
-
-            batch.End();
-            batch.Completed += (_, _) => progress.Complete();
-        }
-    }
-
-    private static void AnimateOffset(Visual visual, Compositor compositor, Rect oldBounds, Rect newBounds, bool hasRemoveAnimations)
-    {
-        Vector2KeyFrameAnimation offsetAnimation = compositor.CreateVector2KeyFrameAnimation();
-
-        offsetAnimation.SetVector2Parameter("delta", new Vector2(
-            (float)(oldBounds.X - newBounds.X),
-            (float)(oldBounds.Y - newBounds.Y)));
-        offsetAnimation.SetVector2Parameter("final", default);
-        offsetAnimation.InsertExpressionKeyFrame(0.0f, "this.CurrentValue + delta");
-        if (hasRemoveAnimations)
-        {
-            offsetAnimation.InsertExpressionKeyFrame(0.5f, "delta");
-        }
-
-        offsetAnimation.InsertExpressionKeyFrame(1.0f, "final");
-        offsetAnimation.Duration = TimeSpan.FromMilliseconds(
-            DefaultAnimationDurationInMs * ((hasRemoveAnimations ? 1 : 0) + 1) * AnimationSlowdownFactor);
-
-        visual.StartAnimation("TransformMatrix._41_42", offsetAnimation);
-    }
-}

src/Snap.Hutao/Snap.Hutao/Control/Media/Bgra32.cs

@@ -1,64 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-using System.Buffers.Binary;
-using System.Runtime.CompilerServices;
-using Windows.UI;
-
-namespace Snap.Hutao.Control.Media;
-
-/// <summary>
-/// BGRA 结构
-/// </summary>
-[HighQuality]
-internal struct Bgra32
-{
-    /// <summary>
-    /// B
-    /// </summary>
-    public byte B;
-
-    /// <summary>
-    /// G
-    /// </summary>
-    public byte G;
-
-    /// <summary>
-    /// R
-    /// </summary>
-    public byte R;
-
-    /// <summary>
-    /// A
-    /// </summary>
-    public byte A;
-
-    public Bgra32(byte b, byte g, byte r, byte a)
-    {
-        B = b;
-        G = g;
-        R = r;
-        A = a;
-    }
-
-    public readonly double Luminance { get => ((0.299 * R) + (0.587 * G) + (0.114 * B)) / 255; }
-
-    /// <summary>
-    /// 从 Color 转换
-    /// </summary>
-    /// <param name="color">颜色</param>
-    /// <returns>新的 BGRA8 结构</returns>
-    public static unsafe implicit operator Bgra32(Color color)
-    {
-        Unsafe.SkipInit(out Bgra32 bgra8);
-        *(uint*)&bgra8 = BinaryPrimitives.ReverseEndianness(*(uint*)&color);
-        return bgra8;
-    }
-
-    public static unsafe implicit operator Color(Bgra32 bgra8)
-    {
-        Unsafe.SkipInit(out Color color);
-        *(uint*)&color = BinaryPrimitives.ReverseEndianness(*(uint*)&bgra8);
-        return color;
-    }
-}

src/Snap.Hutao/Snap.Hutao/Control/Media/Hsla32.cs

@@ -1,32 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-// Some part of this file came from:
-// https://github.com/xunkong/desktop/tree/main/src/Desktop/Desktop/Pages/CharacterInfoPage.xaml.cs
-
-namespace Snap.Hutao.Control.Media;
-
-/// <summary>
-/// Defines a color in Hue/Saturation/Lightness (HSL) space.
-/// </summary>
-internal struct Hsla32
-{
-    /// <summary>
-    /// The Hue in 0..360 range.
-    /// </summary>
-    public double H;
-
-    /// <summary>
-    /// The Saturation in 0..1 range.
-    /// </summary>
-    public double S;
-
-    /// <summary>
-    /// The Lightness in 0..1 range.
-    /// </summary>
-    public double L;
-
-    /// <summary>
-    /// The Alpha/opacity in 0..1 range.
-    /// </summary>
-    public double A;
-}

src/Snap.Hutao/Snap.Hutao/Control/Media/Rgba32.cs

@@ -1,185 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-// Some part of this file came from:
-// https://github.com/xunkong/desktop/tree/main/src/Desktop/Desktop/Pages/CharacterInfoPage.xaml.cs
-
-using System.Buffers.Binary;
-using Windows.UI;
-
-namespace Snap.Hutao.Control.Media;
-
-/// <summary>
-/// RGBA 颜色
-/// </summary>
-[HighQuality]
-internal struct Rgba32
-{
-    /// <summary>
-    /// R
-    /// </summary>
-    public byte R;
-
-    /// <summary>
-    /// G
-    /// </summary>
-    public byte G;
-
-    /// <summary>
-    /// B
-    /// </summary>
-    public byte B;
-
-    /// <summary>
-    /// A
-    /// </summary>
-    public byte A;
-
-    /// <summary>
-    /// 构造一个新的 RGBA8 颜色
-    /// </summary>
-    /// <param name="hex">色值字符串</param>
-    public Rgba32(string hex)
-        : this(hex.Length == 6 ? Convert.ToUInt32($"{hex}FF", 16) : Convert.ToUInt32(hex, 16))
-    {
-    }
-
-    /// <summary>
-    /// 使用 RGBA 代码初始化新的结构
-    /// </summary>
-    /// <param name="xrgbaCode">RGBA 代码</param>
-    public unsafe Rgba32(uint xrgbaCode)
-    {
-        // uint layout: 0xRRGGBBAA is AABBGGRR
-        // AABBGGRR -> RRGGBBAA
-        fixed (Rgba32* pSelf = &this)
-        {
-            *(uint*)pSelf = BinaryPrimitives.ReverseEndianness(xrgbaCode);
-        }
-    }
-
-    private Rgba32(byte r, byte g, byte b, byte a)
-    {
-        R = r;
-        G = g;
-        B = b;
-        A = a;
-    }
-
-    public static unsafe implicit operator Color(Rgba32 hexColor)
-    {
-        // Goal : Rgba32:RRGGBBAA(0xAABBGGRR) -> Color: AARRGGBB(0xBBGGRRAA)
-        // Step1: Rgba32:RRGGBBAA(0xAABBGGRR) -> UInt32:AA000000(0x000000AA)
-        uint a = ((*(uint*)&hexColor) >> 24) & 0x000000FF;
-
-        // Step2: Rgba32:RRGGBBAA(0xAABBGGRR) -> UInt32:00RRGGBB(0xRRGGBB00)
-        uint rgb = ((*(uint*)&hexColor) << 8) & 0xFFFFFF00;
-
-        // Step2: UInt32:00RRGGBB(0xRRGGBB00) + UInt32:AA000000(0x000000AA) -> UInt32:AARRGGBB(0xRRGGBBAA)
-        uint rgba = rgb + a;
-
-        return *(Color*)&rgba;
-    }
-
-    /// <summary>
-    /// 从 HSL 颜色转换
-    /// </summary>
-    /// <param name="hsl">HSL 颜色</param>
-    /// <returns>RGBA8颜色</returns>
-    public static Rgba32 FromHsl(Hsla32 hsl)
-    {
-        double chroma = (1 - Math.Abs((2 * hsl.L) - 1)) * hsl.S;
-        double h1 = hsl.H / 60;
-        double x = chroma * (1 - Math.Abs((h1 % 2) - 1));
-        double m = hsl.L - (0.5 * chroma);
-        double r1, g1, b1;
-
-        if (h1 < 1)
-        {
-            r1 = chroma;
-            g1 = x;
-            b1 = 0;
-        }
-        else if (h1 < 2)
-        {
-            r1 = x;
-            g1 = chroma;
-            b1 = 0;
-        }
-        else if (h1 < 3)
-        {
-            r1 = 0;
-            g1 = chroma;
-            b1 = x;
-        }
-        else if (h1 < 4)
-        {
-            r1 = 0;
-            g1 = x;
-            b1 = chroma;
-        }
-        else if (h1 < 5)
-        {
-            r1 = x;
-            g1 = 0;
-            b1 = chroma;
-        }
-        else
-        {
-            r1 = chroma;
-            g1 = 0;
-            b1 = x;
-        }
-
-        byte r = (byte)(255 * (r1 + m));
-        byte g = (byte)(255 * (g1 + m));
-        byte b = (byte)(255 * (b1 + m));
-        byte a = (byte)(255 * hsl.A);
-
-        return new(r, g, b, a);
-    }
-
-    /// <summary>
-    /// 转换到 HSL 颜色
-    /// </summary>
-    /// <returns>HSL 颜色</returns>
-    public readonly Hsla32 ToHsl()
-    {
-        const double toDouble = 1.0 / 255;
-        double r = toDouble * R;
-        double g = toDouble * G;
-        double b = toDouble * B;
-        double max = Math.Max(Math.Max(r, g), b);
-        double min = Math.Min(Math.Min(r, g), b);
-        double chroma = max - min;
-        double h1;
-
-        if (chroma == 0)
-        {
-            h1 = 0;
-        }
-        else if (max == r)
-        {
-            // The % operator doesn't do proper modulo on negative
-            // numbers, so we'll add 6 before using it
-            h1 = (((g - b) / chroma) + 6) % 6;
-        }
-        else if (max == g)
-        {
-            h1 = 2 + ((b - r) / chroma);
-        }
-        else
-        {
-            h1 = 4 + ((r - g) / chroma);
-        }
-
-        double lightness = 0.5 * (max + min);
-        double saturation = chroma == 0 ? 0 : chroma / (1 - Math.Abs((2 * lightness) - 1));
-
-        Hsla32 ret;
-        ret.H = 60 * h1;
-        ret.S = saturation;
-        ret.L = lightness;
-        ret.A = toDouble * A;
-        return ret;
-    }
-}

src/Snap.Hutao/Snap.Hutao/Control/Panel/UniformPanel.cs

@@ -1,21 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-using CommunityToolkit.WinUI.Controls;
-
-namespace Snap.Hutao.Control.Panel;
-
-[DependencyProperty("MinItemWidth", typeof(double))]
-internal sealed partial class UniformPanel : UniformGrid
-{
-    public UniformPanel()
-    {
-        Columns = 1;
-        SizeChanged += OnSizeChanged;
-    }
-
-    private void OnSizeChanged(object sender, Microsoft.UI.Xaml.SizeChangedEventArgs e)
-    {
-        Columns = (int)((e.NewSize.Width + ColumnSpacing) / (MinItemWidth + ColumnSpacing));
-    }
-}

src/Snap.Hutao/Snap.Hutao/Control/Theme/KnownColors.cs

@@ -1,16 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-using Snap.Hutao.Win32;
-using Windows.UI;
-
-namespace Snap.Hutao.Control.Theme;
-
-internal static class KnownColors
-{
-    public static readonly Color Orange = StructMarshal.Color(0xFFBC6932);
-    public static readonly Color Purple = StructMarshal.Color(0xFFA156E0);
-    public static readonly Color Blue = StructMarshal.Color(0xFF5180CB);
-    public static readonly Color Green = StructMarshal.Color(0xFF2A8F72);
-    public static readonly Color White = StructMarshal.Color(0xFF72778B);
-}

src/Snap.Hutao/Snap.Hutao/Control/ValueConverter.cs

@@ -1,44 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-using Microsoft.UI.Xaml.Data;
-
-namespace Snap.Hutao.Control;
-
-/// <summary>
-/// 值转换器
-/// </summary>
-/// <typeparam name="TFrom">源类型</typeparam>
-/// <typeparam name="TTo">目标类型</typeparam>
-internal abstract class ValueConverter<TFrom, TTo> : IValueConverter
-{
-    /// <inheritdoc/>
-    public object? Convert(object value, Type targetType, object parameter, string language)
-    {
-        return Convert((TFrom)value);
-    }
-
-    /// <inheritdoc/>
-    public object? ConvertBack(object value, Type targetType, object parameter, string language)
-    {
-        return ConvertBack((TTo)value);
-    }
-
-    /// <summary>
-    /// 从源类型转换到目标类型
-    /// </summary>
-    /// <param name="from">源</param>
-    /// <returns>目标</returns>
-    public abstract TTo Convert(TFrom from);
-
-    /// <summary>
-    /// 从目标类型转换到源类型
-    /// 重写时请勿调用基类方法
-    /// </summary>
-    /// <param name="to">目标</param>
-    /// <returns>源</returns>
-    public virtual TFrom ConvertBack(TTo to)
-    {
-        throw Must.NeverHappen();
-    }
-}

src/Snap.Hutao/Snap.Hutao/Core/Abstraction/BuilderExtension.cs

@@ -1,10 +1,9 @@
 // Copyright (c) DGP Studio. All rights reserved.
 // Licensed under the MIT license.
 
-using Snap.Hutao.Web.Request.Builder.Abstraction;
 using System.Diagnostics;
 
-namespace Snap.Hutao.Web.Request.Builder;
+namespace Snap.Hutao.Core.Abstraction;
 
 internal static class BuilderExtension
 {

src/Snap.Hutao/Snap.Hutao/Core/Abstraction/IBuilder.cs

@@ -1,6 +1,6 @@
 // Copyright (c) DGP Studio. All rights reserved.
 // Licensed under the MIT license.
 
-namespace Snap.Hutao.Web.Request.Builder.Abstraction;
+namespace Snap.Hutao.Core.Abstraction;
 
 internal interface IBuilder;

src/Snap.Hutao/Snap.Hutao/Core/Abstraction/ICloneable.cs

@@ -1,18 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-namespace Snap.Hutao.Core.Abstraction;
-
-/// <summary>
-/// 可克隆
-/// </summary>
-/// <typeparam name="TSelf">自身类型</typeparam>
-[HighQuality]
-internal interface ICloneable<out TSelf>
-{
-    /// <summary>
-    /// 克隆
-    /// </summary>
-    /// <returns>新的克隆</returns>
-    TSelf Clone();
-}

src/Snap.Hutao/Snap.Hutao/Core/Abstraction/IPinnable.cs

@@ -5,5 +5,5 @@ namespace Snap.Hutao.Core.Abstraction;
 
 internal interface IPinnable<TData>
 {
-    ref readonly TData GetPinnableReference();
+    ref TData GetPinnableReference();
 }

src/Snap.Hutao/Snap.Hutao/Core/Abstraction/IResurrectable.cs

@@ -0,0 +1,9 @@
+// Copyright (c) DGP Studio. All rights reserved.
+// Licensed under the MIT license.
+
+namespace Snap.Hutao.Core.Abstraction;
+
+internal interface IResurrectable
+{
+    void Resurrect();
+}

src/Snap.Hutao/Snap.Hutao/Core/Caching/IImageCache.cs

@@ -1,6 +1,7 @@
 // Copyright (c) DGP Studio. All rights reserved.
 // Licensed under the MIT license.
 
+using Microsoft.UI.Xaml;
 using Snap.Hutao.Core.IO;
 
 namespace Snap.Hutao.Core.Caching;
@@ -11,27 +12,11 @@ namespace Snap.Hutao.Core.Caching;
 [HighQuality]
 internal interface IImageCache
 {
-    /// <summary>
-    /// Gets the file path containing cached item for given Uri
-    /// </summary>
-    /// <param name="uri">Uri of the item.</param>
-    /// <returns>a string path</returns>
     ValueTask<ValueFile> GetFileFromCacheAsync(Uri uri);
 
-    /// <summary>
-    /// Removed items based on uri list passed
-    /// </summary>
-    /// <param name="uriForCachedItems">Enumerable uri list</param>
+    ValueTask<ValueFile> GetFileFromCacheAsync(Uri uri, ElementTheme theme);
+
     void Remove(in ReadOnlySpan<Uri> uriForCachedItems);
 
-    /// <summary>
-    /// Removed item based on uri passed
-    /// </summary>
-    /// <param name="uriForCachedItem">uri</param>
     void Remove(Uri uriForCachedItem);
-
-    /// <summary>
-    /// Removes invalid cached files
-    /// </summary>
-    void RemoveInvalid();
 }

src/Snap.Hutao/Snap.Hutao/Core/Caching/ImageCache.cs

@@ -1,22 +1,31 @@
 // Copyright (c) DGP Studio. All rights reserved.
 // Licensed under the MIT license.
 
+using Microsoft.Extensions.Caching.Memory;
+using Microsoft.UI.Xaml;
 using Snap.Hutao.Core.DependencyInjection.Annotation.HttpClient;
+using Snap.Hutao.Core.ExceptionService;
 using Snap.Hutao.Core.IO;
+using Snap.Hutao.Core.IO.Hashing;
+using Snap.Hutao.Core.Logging;
+using Snap.Hutao.UI;
+using Snap.Hutao.ViewModel.Guide;
+using Snap.Hutao.Web;
+using Snap.Hutao.Web.Request.Builder;
+using Snap.Hutao.Web.Request.Builder.Abstraction;
+using Snap.Hutao.Win32.System.WinRT;
 using System.Collections.Concurrent;
 using System.Collections.Frozen;
+using System.Diagnostics;
 using System.IO;
 using System.Net;
 using System.Net.Http;
-using System.Security.Cryptography;
-using System.Text;
+using Windows.Foundation;
+using Windows.Graphics.Imaging;
+using WinRT;
 
 namespace Snap.Hutao.Core.Caching;
 
-/// <summary>
-/// Provides methods and tools to cache files in a folder
-/// The class's name will become the cache folder's name
-/// </summary>
 [HighQuality]
 [ConstructorGenerated]
 [Injection(InjectAs.Singleton, typeof(IImageCache))]
@@ -24,47 +33,42 @@ namespace Snap.Hutao.Core.Caching;
 [PrimaryHttpMessageHandler(MaxConnectionsPerServer = 8)]
 internal sealed partial class ImageCache : IImageCache, IImageCacheFilePathOperation
 {
-    private const string CacheFolderName = nameof(ImageCache);
+    private const string CacheFailedDownloadTasksName = $"{nameof(ImageCache)}.FailedDownloadTasks";
 
-    private readonly FrozenDictionary<int, TimeSpan> retryCountToDelay = FrozenDictionary.ToFrozenDictionary(
+    private static readonly FrozenDictionary<int, TimeSpan> DelayFromRetryCount = FrozenDictionary.ToFrozenDictionary(
     [
         KeyValuePair.Create(0, TimeSpan.FromSeconds(4)),
         KeyValuePair.Create(1, TimeSpan.FromSeconds(16)),
         KeyValuePair.Create(2, TimeSpan.FromSeconds(64)),
     ]);
 
-    private readonly ConcurrentDictionary<string, Task> concurrentTasks = new();
+    private readonly ConcurrentDictionary<ElementThemeValueFile, Task> themefileTasks = [];
+    private readonly ConcurrentDictionary<string, Task> downloadTasks = [];
 
+    private readonly IHttpRequestMessageBuilderFactory httpRequestMessageBuilderFactory;
     private readonly IHttpClientFactory httpClientFactory;
     private readonly IServiceProvider serviceProvider;
     private readonly ILogger<ImageCache> logger;
+    private readonly IMemoryCache memoryCache;
 
-    private string? baseFolder;
     private string? cacheFolder;
 
     private string CacheFolder
     {
         get => LazyInitializer.EnsureInitialized(ref cacheFolder, () =>
         {
-            baseFolder ??= serviceProvider.GetRequiredService<RuntimeOptions>().LocalCache;
-            DirectoryInfo info = Directory.CreateDirectory(Path.Combine(baseFolder, CacheFolderName));
-            return info.FullName;
+            string folder = serviceProvider.GetRequiredService<RuntimeOptions>().GetLocalCacheImageCacheFolder();
+            Directory.CreateDirectory(Path.Combine(folder, "Light"));
+            Directory.CreateDirectory(Path.Combine(folder, "Dark"));
+            return folder;
         });
     }
 
-    /// <inheritdoc/>
-    public void RemoveInvalid()
-    {
-        RemoveCore(Directory.GetFiles(CacheFolder).Where(file => IsFileInvalid(file, false)));
-    }
-
-    /// <inheritdoc/>
     public void Remove(Uri uriForCachedItem)
     {
         Remove([uriForCachedItem]);
     }
 
-    /// <inheritdoc/>
     public void Remove(in ReadOnlySpan<Uri> uriForCachedItems)
     {
         if (uriForCachedItems.Length <= 0)
@@ -88,54 +92,93 @@ internal sealed partial class ImageCache : IImageCache, IImageCacheFilePathOpera
         RemoveCore(filesToDelete);
     }
 
-    /// <inheritdoc/>
-    public async ValueTask<ValueFile> GetFileFromCacheAsync(Uri uri)
+    public ValueTask<ValueFile> GetFileFromCacheAsync(Uri uri)
+    {
+        return GetFileFromCacheAsync(uri, ElementTheme.Default);
+    }
+
+    public async ValueTask<ValueFile> GetFileFromCacheAsync(Uri uri, ElementTheme theme)
     {
         string fileName = GetCacheFileName(uri);
-        string filePath = Path.Combine(CacheFolder, fileName);
+        string defaultFilePath = Path.Combine(CacheFolder, fileName);
+        string themeOrDefaultFilePath = theme is ElementTheme.Dark or ElementTheme.Light
+            ? Path.Combine(CacheFolder, $"{theme}", fileName)
+            : defaultFilePath;
 
-        if (!IsFileInvalid(filePath))
+        if (!IsFileInvalid(themeOrDefaultFilePath))
         {
-            return filePath;
+            return themeOrDefaultFilePath;
         }
 
-        TaskCompletionSource taskCompletionSource = new();
-        try
+        ElementThemeValueFile key = new(fileName, theme);
+
+        // To prevent re-entrancy, always try add first, and if add failed, we try to get the task
+        TaskCompletionSource themeFileTcs = new();
+        if (themefileTasks.TryAdd(key, themeFileTcs.Task))
         {
-            if (concurrentTasks.TryAdd(fileName, taskCompletionSource.Task))
+            try
             {
-                logger.LogDebug("Begin downloading image file from '{Uri}' to '{File}'", uri, filePath);
-                await DownloadFileAsync(uri, filePath).ConfigureAwait(false);
+                if (!IsFileInvalid(defaultFilePath))
+                {
+                    await ConvertAndSaveFileToMonoChromeAsync(defaultFilePath, themeOrDefaultFilePath, theme).ConfigureAwait(false);
+                    return themeOrDefaultFilePath;
+                }
+
+                TaskCompletionSource downloadTcs = new();
+                if (downloadTasks.TryAdd(fileName, downloadTcs.Task))
+                {
+                    try
+                    {
+                        logger.LogColorizedInformation("Begin to download file from '{Uri}' to '{File}'", (uri, ConsoleColor.Cyan), (defaultFilePath, ConsoleColor.Cyan));
+                        await DownloadFileAsync(uri, defaultFilePath).ConfigureAwait(false);
+                    }
+                    finally
+                    {
+                        downloadTcs.TrySetResult();
+                        downloadTasks.TryRemove(fileName, out _);
+                    }
+                }
+                else if (downloadTasks.TryGetValue(fileName, out Task? task))
+                {
+                    logger.LogDebug("Waiting for a queued image download task to complete for '{Uri}'", (uri, ConsoleColor.Cyan));
+                    await task.ConfigureAwait(false);
+                }
+
+                if (!IsFileInvalid(defaultFilePath))
+                {
+                    await ConvertAndSaveFileToMonoChromeAsync(defaultFilePath, themeOrDefaultFilePath, theme).ConfigureAwait(false);
+                    return themeOrDefaultFilePath;
+                }
+
+                return themeOrDefaultFilePath;
             }
-            else if (concurrentTasks.TryGetValue(fileName, out Task? task))
+            finally
             {
-                logger.LogDebug("Waiting for a queued image download task to complete for '{Uri}'", uri);
-                await task.ConfigureAwait(false);
+                themeFileTcs.TrySetResult();
+                themefileTasks.TryRemove(key, out _);
             }
-
-            concurrentTasks.TryRemove(fileName, out _);
         }
-        finally
+        else if (themefileTasks.TryGetValue(key, out Task? themeTask))
         {
-            taskCompletionSource.TrySetResult();
+            await themeTask.ConfigureAwait(false);
+            return themeOrDefaultFilePath;
+        }
+        else
+        {
+            throw HutaoException.NotSupported("The task should not be null.");
         }
-
-        return filePath;
     }
 
     /// <inheritdoc/>
     public ValueFile GetFileFromCategoryAndName(string category, string fileName)
     {
-        Uri dummyUri = Web.HutaoEndpoints.StaticRaw(category, fileName).ToUri();
+        Uri dummyUri = HutaoEndpoints.StaticRaw(category, fileName).ToUri();
         return Path.Combine(CacheFolder, GetCacheFileName(dummyUri));
     }
 
     private static string GetCacheFileName(Uri uri)
     {
-        string url = uri.ToString();
-        byte[] chars = Encoding.UTF8.GetBytes(url);
-        byte[] hash = SHA1.HashData(chars);
-        return System.Convert.ToHexString(hash);
+        return Hash.SHA1HexString(uri.ToString());
     }
 
     private static bool IsFileInvalid(string file, bool treatNullFileAsInvalid = true)
@@ -145,8 +188,51 @@ internal sealed partial class ImageCache : IImageCache, IImageCacheFilePathOpera
             return treatNullFileAsInvalid;
         }
 
-        FileInfo fileInfo = new(file);
-        return fileInfo.Length == 0;
+        return new FileInfo(file).Length == 0;
+    }
+
+    private static async ValueTask ConvertAndSaveFileToMonoChromeAsync(string sourceFile, string themeFile, ElementTheme theme)
+    {
+        if (string.Equals(sourceFile, themeFile, StringComparison.OrdinalIgnoreCase))
+        {
+            return;
+        }
+
+        using (FileStream sourceStream = File.OpenRead(sourceFile))
+        {
+            BitmapDecoder decoder = await BitmapDecoder.CreateAsync(sourceStream.AsRandomAccessStream());
+
+            // Always premultiplied to prevent some channels have a non-zero value when the alpha channel is zero
+            using (SoftwareBitmap sourceBitmap = await decoder.GetSoftwareBitmapAsync(BitmapPixelFormat.Rgba8, BitmapAlphaMode.Premultiplied))
+            {
+                using (BitmapBuffer sourceBuffer = sourceBitmap.LockBuffer(BitmapBufferAccessMode.ReadWrite))
+                {
+                    using (IMemoryBufferReference reference = sourceBuffer.CreateReference())
+                    {
+                        IMemoryBufferByteAccess byteAccess = reference.As<IMemoryBufferByteAccess>();
+                        byte value = theme is ElementTheme.Light ? (byte)0x00 : (byte)0xFF;
+                        ConvertToMonoChrome(byteAccess, value);
+                    }
+                }
+
+                using (FileStream themeStream = File.Create(themeFile))
+                {
+                    BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, themeStream.AsRandomAccessStream());
+                    encoder.SetSoftwareBitmap(sourceBitmap);
+                    await encoder.FlushAsync();
+                }
+            }
+        }
+
+        static void ConvertToMonoChrome(IMemoryBufferByteAccess byteAccess, byte background)
+        {
+            byteAccess.GetBuffer(out Span<Rgba32> span);
+            foreach (ref Rgba32 pixel in span)
+            {
+                pixel.A = (byte)pixel.Luminance255;
+                pixel.R = pixel.G = pixel.B = background;
+            }
+        }
     }
 
     private void RemoveCore(IEnumerable<string> filePaths)
@@ -168,44 +254,93 @@ internal sealed partial class ImageCache : IImageCache, IImageCacheFilePathOpera
     [SuppressMessage("", "SH003")]
     private async Task DownloadFileAsync(Uri uri, string baseFile)
     {
-        int retryCount = 0;
-        HttpClient httpClient = httpClientFactory.CreateClient(nameof(ImageCache));
-        while (retryCount < 3)
+        using (HttpClient httpClient = httpClientFactory.CreateClient(nameof(ImageCache)))
         {
-            using (HttpResponseMessage message = await httpClient.GetAsync(uri, HttpCompletionOption.ResponseHeadersRead).ConfigureAwait(false))
-            {
-                if (message.RequestMessage is { RequestUri: { } target } && target != uri)
-                {
-                    logger.LogDebug("The Request '{Source}' has been redirected to '{Target}'", uri, target);
-                }
+            int retryCount = 0;
 
-                if (message.IsSuccessStatusCode)
+            HttpRequestMessageBuilder requestMessageBuilder = httpRequestMessageBuilderFactory
+                .Create()
+                .SetRequestUri(uri)
+                .SetStaticResourceControlHeadersIf(uri.Host.Contains("api.snapgenshin.com", StringComparison.OrdinalIgnoreCase)) // These headers are only available for our own api
+                .Get();
+
+            while (retryCount < 3)
+            {
+                requestMessageBuilder.Resurrect();
+
+                using (HttpRequestMessage requestMessage = requestMessageBuilder.HttpRequestMessage)
                 {
-                    using (Stream httpStream = await message.Content.ReadAsStreamAsync().ConfigureAwait(false))
+                    using (HttpResponseMessage responseMessage = await httpClient.SendAsync(requestMessage, HttpCompletionOption.ResponseHeadersRead).ConfigureAwait(false))
                     {
-                        using (FileStream fileStream = File.Create(baseFile))
+                        // Redirect detection
+                        if (responseMessage.RequestMessage is { RequestUri: { } target } && target != uri)
                         {
-                            await httpStream.CopyToAsync(fileStream).ConfigureAwait(false);
-                            return;
+                            logger.LogDebug("The Request '{Source}' has been redirected to '{Target}'", uri, target);
+                        }
+
+                        if (responseMessage.IsSuccessStatusCode)
+                        {
+                            if (responseMessage.Content.Headers.ContentType?.MediaType is "application/json")
+                            {
+                                DebugTrackFailedUri(uri);
+                                string raw = await responseMessage.Content.ReadAsStringAsync().ConfigureAwait(false);
+                                logger.LogColorizedCritical("Failed to download '{Uri}' with unexpected body '{Raw}'", (uri, ConsoleColor.Red), (raw, ConsoleColor.DarkYellow));
+                                return;
+                            }
+
+                            using (Stream httpStream = await responseMessage.Content.ReadAsStreamAsync().ConfigureAwait(false))
+                            {
+                                using (FileStream fileStream = File.Create(baseFile))
+                                {
+                                    await httpStream.CopyToAsync(fileStream).ConfigureAwait(false);
+                                    return;
+                                }
+                            }
+                        }
+
+                        switch (responseMessage.StatusCode)
+                        {
+                            case HttpStatusCode.TooManyRequests:
+                                {
+                                    retryCount++;
+                                    TimeSpan delay = responseMessage.Headers.RetryAfter?.Delta ?? DelayFromRetryCount[retryCount];
+                                    logger.LogInformation("Retry download '{Uri}' after {Delay}.", uri, delay);
+                                    await Task.Delay(delay).ConfigureAwait(false);
+                                    break;
+                                }
+
+                            default:
+                                DebugTrackFailedUri(uri);
+                                logger.LogColorizedCritical("Failed to download '{Uri}' with status code '{StatusCode}'", (uri, ConsoleColor.Red), (responseMessage.StatusCode, ConsoleColor.DarkYellow));
+                                return;
                         }
                     }
                 }
-
-                switch (message.StatusCode)
-                {
-                    case HttpStatusCode.TooManyRequests:
-                        {
-                            retryCount++;
-                            TimeSpan delay = message.Headers.RetryAfter?.Delta ?? retryCountToDelay[retryCount];
-                            logger.LogInformation("Retry download '{Uri}' after {Delay}.", uri, delay);
-                            await Task.Delay(delay).ConfigureAwait(false);
-                            break;
-                        }
-
-                    default:
-                        return;
-                }
             }
         }
     }
+
+    [Conditional("DEBUG")]
+    private void DebugTrackFailedUri(Uri uri)
+    {
+        HashSet<string>? set = memoryCache.GetOrCreate(CacheFailedDownloadTasksName, entry => new HashSet<string>());
+        set?.Add(uri.ToString());
+    }
+
+    private readonly struct ElementThemeValueFile
+    {
+        public readonly ValueFile File;
+        public readonly ElementTheme Theme;
+
+        public ElementThemeValueFile(ValueFile file, ElementTheme theme)
+        {
+            File = file;
+            Theme = theme;
+        }
+
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(File, Theme);
+        }
+    }
 }

src/Snap.Hutao/Snap.Hutao/Core/Collection/TwoEnumerbleEnumerator.cs

@@ -0,0 +1,32 @@
+// Copyright (c) DGP Studio. All rights reserved.
+// Licensed under the MIT license.
+
+namespace Snap.Hutao.Core.Collection;
+
+internal sealed class TwoEnumerbleEnumerator<TFirst, TSecond> : IDisposable
+{
+    private readonly IEnumerator<TFirst> firstEnumerator;
+    private readonly IEnumerator<TSecond> secondEnumerator;
+
+    public TwoEnumerbleEnumerator(IEnumerable<TFirst> firstEnumerable, IEnumerable<TSecond> secondEnumerable)
+    {
+        firstEnumerator = firstEnumerable.GetEnumerator();
+        secondEnumerator = secondEnumerable.GetEnumerator();
+    }
+
+    public (TFirst First, TSecond Second) Current { get => (firstEnumerator.Current, secondEnumerator.Current); }
+
+    public bool MoveNext(ref bool moveFirst, ref bool moveSecond)
+    {
+        moveFirst = moveFirst && firstEnumerator.MoveNext();
+        moveSecond = moveSecond && secondEnumerator.MoveNext();
+
+        return moveFirst || moveSecond;
+    }
+
+    public void Dispose()
+    {
+        firstEnumerator.Dispose();
+        secondEnumerator.Dispose();
+    }
+}

src/Snap.Hutao/Snap.Hutao/Core/Convert.cs

@@ -1,25 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-using System.Security.Cryptography;
-using System.Text;
-
-namespace Snap.Hutao.Core;
-
-/// <summary>
-/// 支持Md5转换
-/// </summary>
-[HighQuality]
-internal static class Convert
-{
-    /// <summary>
-    /// 获取字符串的MD5计算结果
-    /// </summary>
-    /// <param name="source">源字符串</param>
-    /// <returns>计算的结果</returns>
-    public static string ToMd5HexString(string source)
-    {
-        byte[] hash = MD5.HashData(Encoding.UTF8.GetBytes(source));
-        return System.Convert.ToHexString(hash);
-    }
-}

src/Snap.Hutao/Snap.Hutao/Core/DataTransfer/ClipboardProvider.cs

@@ -4,7 +4,7 @@
 using Windows.ApplicationModel.DataTransfer;
 using Windows.Storage.Streams;
 
-namespace Snap.Hutao.Core.IO.DataTransfer;
+namespace Snap.Hutao.Core.DataTransfer;
 
 [ConstructorGenerated]
 [Injection(InjectAs.Transient, typeof(IClipboardProvider))]
@@ -13,7 +13,6 @@ internal sealed partial class ClipboardProvider : IClipboardProvider
     private readonly JsonSerializerOptions options;
     private readonly ITaskContext taskContext;
 
-    /// <inheritdoc/>
     public async ValueTask<T?> DeserializeFromJsonAsync<T>()
         where T : class
     {
@@ -31,7 +30,6 @@ internal sealed partial class ClipboardProvider : IClipboardProvider
         return JsonSerializer.Deserialize<T>(json, options);
     }
 
-    /// <inheritdoc/>
     public bool SetText(string text)
     {
         try
@@ -48,7 +46,23 @@ internal sealed partial class ClipboardProvider : IClipboardProvider
         }
     }
 
-    /// <inheritdoc/>
+    public async ValueTask<bool> SetTextAsync(string text)
+    {
+        try
+        {
+            await taskContext.SwitchToMainThreadAsync();
+            DataPackage content = new() { RequestedOperation = DataPackageOperation.Copy };
+            content.SetText(text);
+            Clipboard.SetContent(content);
+            Clipboard.Flush();
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
     public bool SetBitmap(IRandomAccessStream stream)
     {
         try
@@ -65,4 +79,22 @@ internal sealed partial class ClipboardProvider : IClipboardProvider
             return false;
         }
     }
+
+    public async ValueTask<bool> SetBitmapAsync(IRandomAccessStream stream)
+    {
+        try
+        {
+            await taskContext.SwitchToMainThreadAsync();
+            RandomAccessStreamReference reference = RandomAccessStreamReference.CreateFromStream(stream);
+            DataPackage content = new() { RequestedOperation = DataPackageOperation.Copy };
+            content.SetBitmap(reference);
+            Clipboard.SetContent(content);
+            Clipboard.Flush();
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
 }

src/Snap.Hutao/Snap.Hutao/Core/DataTransfer/IClipboardProvider.cs

@@ -0,0 +1,20 @@
+// Copyright (c) DGP Studio. All rights reserved.
+// Licensed under the MIT license.
+
+using Windows.Storage.Streams;
+
+namespace Snap.Hutao.Core.DataTransfer;
+
+internal interface IClipboardProvider
+{
+    ValueTask<T?> DeserializeFromJsonAsync<T>()
+        where T : class;
+
+    bool SetBitmap(IRandomAccessStream stream);
+
+    ValueTask<bool> SetBitmapAsync(IRandomAccessStream stream);
+
+    bool SetText(string text);
+
+    ValueTask<bool> SetTextAsync(string text);
+}

src/Snap.Hutao/Snap.Hutao/Core/Database/Abstraction/IReorderable.cs

@@ -1,7 +1,7 @@
 // Copyright (c) DGP Studio. All rights reserved.
 // Licensed under the MIT license.
 
-namespace Snap.Hutao.Core.Database;
+namespace Snap.Hutao.Core.Database.Abstraction;
 
 internal interface IReorderable
 {

src/Snap.Hutao/Snap.Hutao/Core/Database/Abstraction/ISelectable.cs

@@ -0,0 +1,11 @@
+// Copyright (c) DGP Studio. All rights reserved.
+// Licensed under the MIT license.
+
+using Snap.Hutao.Model.Entity.Abstraction;
+
+namespace Snap.Hutao.Core.Database.Abstraction;
+
+internal interface ISelectable : IAppDbEntity
+{
+    bool IsSelected { get; set; }
+}

src/Snap.Hutao/Snap.Hutao/Core/Database/AdvancedDbCollectionView.cs

@@ -0,0 +1,142 @@
+// Copyright (c) DGP Studio. All rights reserved.
+// Licensed under the MIT license.
+
+using Microsoft.EntityFrameworkCore;
+using Snap.Hutao.Core.Database.Abstraction;
+using Snap.Hutao.Model;
+using Snap.Hutao.Model.Entity.Database;
+using Snap.Hutao.UI.Xaml.Data;
+
+namespace Snap.Hutao.Core.Database;
+
+// The scope of the view follows the scope of the service provider.
+internal sealed class AdvancedDbCollectionView<TEntity> : AdvancedCollectionView<TEntity>, IAdvancedDbCollectionView<TEntity>
+    where TEntity : class, IAdvancedCollectionViewItem, ISelectable
+{
+    private readonly IServiceProvider serviceProvider;
+
+    private bool savingToDatabase = true;
+
+    public AdvancedDbCollectionView(IList<TEntity> source, IServiceProvider serviceProvider)
+        : base(source)
+    {
+        this.serviceProvider = serviceProvider;
+    }
+
+    public IDisposable SuppressChangeCurrentItem()
+    {
+        return new CurrentItemSuppression(this);
+    }
+
+    protected override void OnCurrentChangedOverride()
+    {
+        if (!savingToDatabase)
+        {
+            return;
+        }
+
+        TEntity? currentItem = CurrentItem;
+
+        foreach (TEntity item in SourceCollection)
+        {
+            item.IsSelected = ReferenceEquals(item, currentItem);
+        }
+
+        using (IServiceScope scope = serviceProvider.CreateScope())
+        {
+            AppDbContext dbContext = scope.ServiceProvider.GetRequiredService<AppDbContext>();
+            dbContext.Set<TEntity>().ExecuteUpdate(update => update.SetProperty(entity => entity.IsSelected, false));
+
+            if (currentItem is not null)
+            {
+                dbContext.Set<TEntity>().UpdateAndSave(currentItem);
+            }
+        }
+    }
+
+    private sealed class CurrentItemSuppression : IDisposable
+    {
+        private readonly AdvancedDbCollectionView<TEntity> view;
+        private readonly TEntity? currentItem;
+
+        public CurrentItemSuppression(AdvancedDbCollectionView<TEntity> view)
+        {
+            this.view = view;
+            currentItem = view.CurrentItem;
+            view.savingToDatabase = false;
+        }
+
+        public void Dispose()
+        {
+            view.MoveCurrentTo(currentItem);
+            view.savingToDatabase = true;
+        }
+    }
+}
+
+// The scope of the view follows the scope of the service provider.
+[SuppressMessage("", "SA1402")]
+internal sealed class AdvancedDbCollectionView<TEntityAccess, TEntity> : AdvancedCollectionView<TEntityAccess>, IAdvancedDbCollectionView<TEntityAccess>
+    where TEntityAccess : class, IEntityAccess<TEntity>, IAdvancedCollectionViewItem
+    where TEntity : class, ISelectable
+{
+    private readonly IServiceProvider serviceProvider;
+
+    private bool savingToDatabase = true;
+
+    public AdvancedDbCollectionView(IList<TEntityAccess> source, IServiceProvider serviceProvider)
+        : base(source)
+    {
+        this.serviceProvider = serviceProvider;
+    }
+
+    public IDisposable SuppressChangeCurrentItem()
+    {
+        return new CurrentItemSuppression(this);
+    }
+
+    protected override void OnCurrentChangedOverride()
+    {
+        if (!savingToDatabase)
+        {
+            return;
+        }
+
+        TEntityAccess? currentItem = CurrentItem;
+
+        foreach (TEntityAccess item in SourceCollection)
+        {
+            item.Entity.IsSelected = ReferenceEquals(item, currentItem);
+        }
+
+        using (IServiceScope scope = serviceProvider.CreateScope())
+        {
+            AppDbContext dbContext = scope.ServiceProvider.GetRequiredService<AppDbContext>();
+            dbContext.Set<TEntity>().ExecuteUpdate(update => update.SetProperty(entity => entity.IsSelected, false));
+
+            if (currentItem is not null)
+            {
+                dbContext.Set<TEntity>().UpdateAndSave(currentItem.Entity);
+            }
+        }
+    }
+
+    private sealed class CurrentItemSuppression : IDisposable
+    {
+        private readonly AdvancedDbCollectionView<TEntityAccess, TEntity> view;
+        private readonly TEntityAccess? currentItem;
+
+        public CurrentItemSuppression(AdvancedDbCollectionView<TEntityAccess, TEntity> view)
+        {
+            this.view = view;
+            currentItem = view.CurrentItem;
+            view.savingToDatabase = false;
+        }
+
+        public void Dispose()
+        {
+            view.MoveCurrentTo(currentItem);
+            view.savingToDatabase = true;
+        }
+    }
+}

src/Snap.Hutao/Snap.Hutao/Core/Database/DbSetExtension.cs

@@ -13,13 +13,6 @@ namespace Snap.Hutao.Core.Database;
 [HighQuality]
 internal static class DbSetExtension
 {
-    /// <summary>
-    /// 添加并保存
-    /// </summary>
-    /// <typeparam name="TEntity">实体类型</typeparam>
-    /// <param name="dbSet">数据库集</param>
-    /// <param name="entity">实体</param>
-    /// <returns>影响条数</returns>
     public static int AddAndSave<TEntity>(this DbSet<TEntity> dbSet, TEntity entity)
         where TEntity : class
     {
@@ -27,27 +20,6 @@ internal static class DbSetExtension
         return dbSet.SaveChangesAndClearChangeTracker();
     }
 
-    /// <summary>
-    /// 异步添加并保存
-    /// </summary>
-    /// <typeparam name="TEntity">实体类型</typeparam>
-    /// <param name="dbSet">数据库集</param>
-    /// <param name="entity">实体</param>
-    /// <returns>影响条数</returns>
-    public static ValueTask<int> AddAndSaveAsync<TEntity>(this DbSet<TEntity> dbSet, TEntity entity)
-        where TEntity : class
-    {
-        dbSet.Add(entity);
-        return dbSet.SaveChangesAndClearChangeTrackerAsync();
-    }
-
-    /// <summary>
-    /// 添加列表并保存
-    /// </summary>
-    /// <typeparam name="TEntity">实体类型</typeparam>
-    /// <param name="dbSet">数据库集</param>
-    /// <param name="entities">实体</param>
-    /// <returns>影响条数</returns>
     public static int AddRangeAndSave<TEntity>(this DbSet<TEntity> dbSet, IEnumerable<TEntity> entities)
         where TEntity : class
     {
@@ -55,27 +27,6 @@ internal static class DbSetExtension
         return dbSet.SaveChangesAndClearChangeTracker();
     }
 
-    /// <summary>
-    /// 异步添加列表并保存
-    /// </summary>
-    /// <typeparam name="TEntity">实体类型</typeparam>
-    /// <param name="dbSet">数据库集</param>
-    /// <param name="entities">实体</param>
-    /// <returns>影响条数</returns>
-    public static ValueTask<int> AddRangeAndSaveAsync<TEntity>(this DbSet<TEntity> dbSet, IEnumerable<TEntity> entities)
-        where TEntity : class
-    {
-        dbSet.AddRange(entities);
-        return dbSet.SaveChangesAndClearChangeTrackerAsync();
-    }
-
-    /// <summary>
-    /// 移除并保存
-    /// </summary>
-    /// <typeparam name="TEntity">实体类型</typeparam>
-    /// <param name="dbSet">数据库集</param>
-    /// <param name="entity">实体</param>
-    /// <returns>影响条数</returns>
     public static int RemoveAndSave<TEntity>(this DbSet<TEntity> dbSet, TEntity entity)
         where TEntity : class
     {
@@ -83,27 +34,6 @@ internal static class DbSetExtension
         return dbSet.SaveChangesAndClearChangeTracker();
     }
 
-    /// <summary>
-    /// 异步移除并保存
-    /// </summary>
-    /// <typeparam name="TEntity">实体类型</typeparam>
-    /// <param name="dbSet">数据库集</param>
-    /// <param name="entity">实体</param>
-    /// <returns>影响条数</returns>
-    public static ValueTask<int> RemoveAndSaveAsync<TEntity>(this DbSet<TEntity> dbSet, TEntity entity)
-        where TEntity : class
-    {
-        dbSet.Remove(entity);
-        return dbSet.SaveChangesAndClearChangeTrackerAsync();
-    }
-
-    /// <summary>
-    /// 更新并保存
-    /// </summary>
-    /// <typeparam name="TEntity">实体类型</typeparam>
-    /// <param name="dbSet">数据库集</param>
-    /// <param name="entity">实体</param>
-    /// <returns>影响条数</returns>
     public static int UpdateAndSave<TEntity>(this DbSet<TEntity> dbSet, TEntity entity)
         where TEntity : class
     {
@@ -111,20 +41,6 @@ internal static class DbSetExtension
         return dbSet.SaveChangesAndClearChangeTracker();
     }
 
-    /// <summary>
-    /// 异步更新并保存
-    /// </summary>
-    /// <typeparam name="TEntity">实体类型</typeparam>
-    /// <param name="dbSet">数据库集</param>
-    /// <param name="entity">实体</param>
-    /// <returns>影响条数</returns>
-    public static ValueTask<int> UpdateAndSaveAsync<TEntity>(this DbSet<TEntity> dbSet, TEntity entity)
-        where TEntity : class
-    {
-        dbSet.Update(entity);
-        return dbSet.SaveChangesAndClearChangeTrackerAsync();
-    }
-
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int SaveChangesAndClearChangeTracker<TEntity>(this DbSet<TEntity> dbSet)
         where TEntity : class
@@ -135,16 +51,6 @@ internal static class DbSetExtension
         return count;
     }
 
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static async ValueTask<int> SaveChangesAndClearChangeTrackerAsync<TEntity>(this DbSet<TEntity> dbSet)
-        where TEntity : class
-    {
-        DbContext dbContext = dbSet.Context();
-        int count = await dbContext.SaveChangesAsync().ConfigureAwait(false);
-        dbContext.ChangeTracker.Clear();
-        return count;
-    }
-
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static DbContext Context<TEntity>(this DbSet<TEntity> dbSet)
         where TEntity : class

src/Snap.Hutao/Snap.Hutao/Core/Database/IAdvancedDbCollectionView.cs

@@ -0,0 +1,12 @@
+// Copyright (c) DGP Studio. All rights reserved.
+// Licensed under the MIT license.
+
+using Snap.Hutao.UI.Xaml.Data;
+
+namespace Snap.Hutao.Core.Database;
+
+internal interface IAdvancedDbCollectionView<TEntity> : IAdvancedCollectionView<TEntity>
+    where TEntity : class
+{
+    IDisposable SuppressChangeCurrentItem();
+}

src/Snap.Hutao/Snap.Hutao/Core/Database/ISelectable.cs

@@ -1,23 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-namespace Snap.Hutao.Core.Database;
-
-/// <summary>
-/// 可选择的项
-/// 若要使用 <see cref="ScopedDbCurrent{TEntity, TMessage}"/>
-/// 必须实现该接口
-/// </summary>
-[HighQuality]
-internal interface ISelectable
-{
-    /// <summary>
-    /// 数据库内部Id
-    /// </summary>
-    Guid InnerId { get; }
-
-    /// <summary>
-    /// 获取或设置当前项的选中状态
-    /// </summary>
-    bool IsSelected { get; set; }
-}

src/Snap.Hutao/Snap.Hutao/Core/Database/ObservableReorderableDbCollection.cs

@@ -1,8 +1,8 @@
 // Copyright (c) DGP Studio. All rights reserved.
 // Licensed under the MIT license.
 
-using CommunityToolkit.WinUI.Collections;
 using Microsoft.EntityFrameworkCore;
+using Snap.Hutao.Core.Database.Abstraction;
 using Snap.Hutao.Model;
 using Snap.Hutao.Model.Entity.Database;
 using System.Collections.ObjectModel;
@@ -22,8 +22,6 @@ internal sealed class ObservableReorderableDbCollection<TEntity> : ObservableCol
         this.serviceProvider = serviceProvider;
     }
 
-    public IAdvancedCollectionView? View { get; set; }
-
     protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
     {
         base.OnCollectionChanged(e);
@@ -51,38 +49,33 @@ internal sealed class ObservableReorderableDbCollection<TEntity> : ObservableCol
 
     private void OnReorder()
     {
-        using (View?.DeferRefresh())
-        {
-            AdjustIndex((List<TEntity>)Items);
+        AdjustIndex((List<TEntity>)Items);
 
-            using (IServiceScope scope = serviceProvider.CreateScope())
+        using (IServiceScope scope = serviceProvider.CreateScope())
+        {
+            AppDbContext appDbContext = scope.ServiceProvider.GetRequiredService<AppDbContext>();
+            DbSet<TEntity> dbSet = appDbContext.Set<TEntity>();
+            foreach (ref readonly TEntity item in CollectionsMarshal.AsSpan((List<TEntity>)Items))
             {
-                AppDbContext appDbContext = scope.ServiceProvider.GetRequiredService<AppDbContext>();
-                DbSet<TEntity> dbSet = appDbContext.Set<TEntity>();
-                foreach (ref readonly TEntity item in CollectionsMarshal.AsSpan((List<TEntity>)Items))
-                {
-                    dbSet.UpdateAndSave(item);
-                }
+                dbSet.UpdateAndSave(item);
             }
         }
     }
 }
 
 [SuppressMessage("", "SA1402")]
-internal sealed class ObservableReorderableDbCollection<TEntityOnly, TEntity> : ObservableCollection<TEntityOnly>
-    where TEntityOnly : class, IEntityOnly<TEntity>
+internal sealed class ObservableReorderableDbCollection<TEntityAccess, TEntity> : ObservableCollection<TEntityAccess>
+    where TEntityAccess : class, IEntityAccess<TEntity>
     where TEntity : class, IReorderable
 {
     private readonly IServiceProvider serviceProvider;
 
-    public ObservableReorderableDbCollection(List<TEntityOnly> items, IServiceProvider serviceProvider)
+    public ObservableReorderableDbCollection(List<TEntityAccess> items, IServiceProvider serviceProvider)
         : base(AdjustIndex(items.SortBy(x => x.Entity.Index)))
     {
         this.serviceProvider = serviceProvider;
     }
 
-    public IAdvancedCollectionView? View { get; set; }
-
     protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
     {
         base.OnCollectionChanged(e);
@@ -96,12 +89,12 @@ internal sealed class ObservableReorderableDbCollection<TEntityOnly, TEntity> :
         }
     }
 
-    private static List<TEntityOnly> AdjustIndex(List<TEntityOnly> list)
+    private static List<TEntityAccess> AdjustIndex(List<TEntityAccess> list)
     {
-        Span<TEntityOnly> span = CollectionsMarshal.AsSpan(list);
+        Span<TEntityAccess> span = CollectionsMarshal.AsSpan(list);
         for (int i = 0; i < list.Count; i++)
         {
-            ref readonly TEntityOnly item = ref span[i];
+            ref readonly TEntityAccess item = ref span[i];
             item.Entity.Index = i;
         }
 
@@ -110,19 +103,16 @@ internal sealed class ObservableReorderableDbCollection<TEntityOnly, TEntity> :
 
     private void OnReorder()
     {
-        using (View?.DeferRefresh())
+        AdjustIndex((List<TEntityAccess>)Items);
+
+        using (IServiceScope scope = serviceProvider.CreateScope())
         {
-            AdjustIndex((List<TEntityOnly>)Items);
+            AppDbContext appDbContext = scope.ServiceProvider.GetRequiredService<AppDbContext>();
 
-            using (IServiceScope scope = serviceProvider.CreateScope())
+            DbSet<TEntity> dbSet = appDbContext.Set<TEntity>();
+            foreach (ref readonly TEntityAccess item in CollectionsMarshal.AsSpan((List<TEntityAccess>)Items))
             {
-                AppDbContext appDbContext = scope.ServiceProvider.GetRequiredService<AppDbContext>();
-
-                DbSet<TEntity> dbSet = appDbContext.Set<TEntity>();
-                foreach (ref readonly TEntityOnly item in CollectionsMarshal.AsSpan((List<TEntityOnly>)Items))
-                {
-                    dbSet.UpdateAndSave(item.Entity);
-                }
+                dbSet.UpdateAndSave(item.Entity);
             }
         }
     }

src/Snap.Hutao/Snap.Hutao/Core/Database/ObservableReorderableDbCollectionExtension.cs

@@ -0,0 +1,30 @@
+// Copyright (c) DGP Studio. All rights reserved.
+// Licensed under the MIT license.
+
+using Snap.Hutao.Core.Database.Abstraction;
+using Snap.Hutao.Model;
+using System.Runtime.CompilerServices;
+
+namespace Snap.Hutao.Core.Database;
+
+internal static class ObservableReorderableDbCollectionExtension
+{
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ObservableReorderableDbCollection<TEntity> ToObservableReorderableDbCollection<TEntity>(this IEnumerable<TEntity> source, IServiceProvider serviceProvider)
+        where TEntity : class, IReorderable
+    {
+        return source is List<TEntity> list
+            ? new ObservableReorderableDbCollection<TEntity>(list, serviceProvider)
+            : new ObservableReorderableDbCollection<TEntity>([.. source], serviceProvider);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ObservableReorderableDbCollection<TEntityOnly, TEntity> ToObservableReorderableDbCollection<TEntityOnly, TEntity>(this IEnumerable<TEntityOnly> source, IServiceProvider serviceProvider)
+        where TEntityOnly : class, IEntityAccess<TEntity>
+        where TEntity : class, IReorderable
+    {
+        return source is List<TEntityOnly> list
+            ? new ObservableReorderableDbCollection<TEntityOnly, TEntity>(list, serviceProvider)
+            : new ObservableReorderableDbCollection<TEntityOnly, TEntity>([.. source], serviceProvider);
+    }
+}

src/Snap.Hutao/Snap.Hutao/Core/Database/QueryableExtension.cs

@@ -1,42 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-using Microsoft.EntityFrameworkCore;
-using System.Linq.Expressions;
-using System.Runtime.CompilerServices;
-
-namespace Snap.Hutao.Core.Database;
-
-/// <summary>
-/// 可查询扩展
-/// </summary>
-[HighQuality]
-internal static class QueryableExtension
-{
-    /// <summary>
-    /// <code>source.Where(predicate).ExecuteDelete()</code>
-    /// </summary>
-    /// <typeparam name="TSource">源类型</typeparam>
-    /// <param name="source">源</param>
-    /// <param name="predicate">条件</param>
-    /// <returns>SQL返回个数</returns>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static int ExecuteDeleteWhere<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
-    {
-        return source.Where(predicate).ExecuteDelete();
-    }
-
-    /// <summary>
-    /// <code>source.Where(predicate).ExecuteDeleteAsync(token)</code>
-    /// </summary>
-    /// <typeparam name="TSource">源类型</typeparam>
-    /// <param name="source">源</param>
-    /// <param name="predicate">条件</param>
-    /// <param name="token">取消令牌</param>
-    /// <returns>SQL返回个数</returns>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static ValueTask<int> ExecuteDeleteWhereAsync<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate, CancellationToken token = default)
-    {
-        return source.Where(predicate).ExecuteDeleteAsync(token).AsValueTask();
-    }
-}

src/Snap.Hutao/Snap.Hutao/Core/Database/ScopedDbCurrent.cs

@@ -1,133 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-using CommunityToolkit.Mvvm.Messaging;
-using Microsoft.EntityFrameworkCore;
-using Snap.Hutao.Model;
-using Snap.Hutao.Model.Entity.Database;
-
-namespace Snap.Hutao.Core.Database;
-
-/// <summary>
-/// 范围化的数据库当前项
-/// 简化对数据库中选中项的管理
-/// </summary>
-/// <typeparam name="TEntity">实体的类型</typeparam>
-/// <typeparam name="TMessage">消息的类型</typeparam>
-[ConstructorGenerated]
-internal sealed partial class ScopedDbCurrent<TEntity, TMessage>
-    where TEntity : class, ISelectable
-    where TMessage : Message.ValueChangedMessage<TEntity>, new()
-{
-    private readonly IServiceProvider serviceProvider;
-    private readonly IMessenger messenger;
-
-    private TEntity? current;
-
-    /// <summary>
-    /// 当前选中的项
-    /// </summary>
-    public TEntity? Current
-    {
-        get => current;
-        set
-        {
-            // prevent useless sets
-            if (current == value)
-            {
-                return;
-            }
-
-            if (serviceProvider.IsDisposedSlow())
-            {
-                return;
-            }
-
-            using (IServiceScope scope = serviceProvider.CreateScope())
-            {
-                AppDbContext appDbContext = scope.ServiceProvider.GetRequiredService<AppDbContext>();
-                DbSet<TEntity> dbSet = appDbContext.Set<TEntity>();
-
-                // only update when not processing a deletion
-                if (value is not null && current is not null)
-                {
-                    current.IsSelected = false;
-                    dbSet.UpdateAndSave(current);
-                }
-
-                TMessage message = new() { OldValue = current, NewValue = value };
-
-                current = value;
-
-                if (current is not null)
-                {
-                    current.IsSelected = true;
-                    dbSet.UpdateAndSave(current);
-                }
-
-                messenger.Send(message);
-            }
-        }
-    }
-}
-
-[ConstructorGenerated]
-internal sealed partial class ScopedDbCurrent<TEntityOnly, TEntity, TMessage>
-    where TEntityOnly : class, IEntityOnly<TEntity>
-    where TEntity : class, ISelectable
-    where TMessage : Message.ValueChangedMessage<TEntityOnly>, new()
-{
-    private readonly IServiceProvider serviceProvider;
-    private readonly IMessenger messenger;
-
-    private TEntityOnly? current;
-
-    /// <summary>
-    /// 当前选中的项
-    /// </summary>
-    public TEntityOnly? Current
-    {
-        get => current;
-        set
-        {
-            // prevent useless sets
-            if (current == value)
-            {
-                return;
-            }
-
-            if (serviceProvider.IsDisposedSlow())
-            {
-                return;
-            }
-
-            using (IServiceScope scope = serviceProvider.CreateScope())
-            {
-                AppDbContext appDbContext = scope.ServiceProvider.GetRequiredService<AppDbContext>();
-                DbSet<TEntity> dbSet = appDbContext.Set<TEntity>();
-
-                // only update when not processing a deletion
-                if (value is not null)
-                {
-                    if (current is not null)
-                    {
-                        current.Entity.IsSelected = false;
-                        dbSet.UpdateAndSave(current.Entity);
-                    }
-                }
-
-                TMessage message = new() { OldValue = current, NewValue = value };
-
-                current = value;
-
-                if (current is not null)
-                {
-                    current.Entity.IsSelected = true;
-                    dbSet.UpdateAndSave(current.Entity);
-                }
-
-                messenger.Send(message);
-            }
-        }
-    }
-}

src/Snap.Hutao/Snap.Hutao/Core/Database/SelectableExtension.cs

@@ -1,6 +1,7 @@
 // Copyright (c) DGP Studio. All rights reserved.
 // Licensed under the MIT license.
 
+using Snap.Hutao.Core.Database.Abstraction;
 using System.Runtime.CompilerServices;
 
 namespace Snap.Hutao.Core.Database;
@@ -11,17 +12,17 @@ namespace Snap.Hutao.Core.Database;
 [HighQuality]
 internal static class SelectableExtension
 {
-    /// <summary>
-    /// 获取选中的值或默认值
-    /// </summary>
-    /// <typeparam name="TSource">源类型</typeparam>
-    /// <param name="source">源</param>
-    /// <returns>选中的值或默认值</returns>
-    /// <exception cref="InvalidOperationException">存在多个选中的值</exception>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static TSource? SelectedOrDefault<TSource>(this IEnumerable<TSource> source)
         where TSource : ISelectable
     {
         return source.SingleOrDefault(i => i.IsSelected);
     }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static TSource? SelectedOrFirstOrDefault<TSource>(this IEnumerable<TSource> source)
+        where TSource : ISelectable
+    {
+        return source.SingleOrDefault(i => i.IsSelected) ?? source.FirstOrDefault();
+    }
 }

src/Snap.Hutao/Snap.Hutao/Core/DependencyInjection/Abstraction/ICastService.cs

@@ -1,12 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-namespace Snap.Hutao.Core.DependencyInjection.Abstraction;
-
-/// <summary>
-/// 可转换类型服务
-/// </summary>
-[Obsolete("Not useful anymore")]
-internal interface ICastService
-{
-}

src/Snap.Hutao/Snap.Hutao/Core/DependencyInjection/Abstraction/OverseaSupportFactory.cs

@@ -20,7 +20,7 @@ internal abstract class OverseaSupportFactory<TClient, TClientCN, TClientOS> : I
         this.serviceProvider = serviceProvider;
     }
 
-    public TClient Create(bool isOversea)
+    public virtual TClient Create(bool isOversea)
     {
         return isOversea
             ? serviceProvider.GetRequiredService<TClientOS>()

src/Snap.Hutao/Snap.Hutao/Core/DependencyInjection/CastServiceExtension.cs

@@ -1,26 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-using Snap.Hutao.Core.DependencyInjection.Abstraction;
-
-namespace Snap.Hutao.Core.DependencyInjection;
-
-/// <summary>
-/// 对象扩展
-/// </summary>
-[HighQuality]
-internal static class CastServiceExtension
-{
-    /// <summary>
-    /// <see langword="as"/> 的链式调用扩展
-    /// </summary>
-    /// <typeparam name="T">目标转换类型</typeparam>
-    /// <param name="service">对象</param>
-    /// <returns>转换类型后的对象</returns>
-    [Obsolete("Not useful anymore")]
-    public static T? As<T>(this ICastService service)
-        where T : class
-    {
-        return service as T;
-    }
-}

src/Snap.Hutao/Snap.Hutao/Core/DependencyInjection/DependencyInjection.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT license.
 
 using CommunityToolkit.Mvvm.Messaging;
+using Quartz;
 using Snap.Hutao.Core.Logging;
 using Snap.Hutao.Service;
 using System.Globalization;
@@ -24,14 +25,23 @@ internal static class DependencyInjection
         ServiceProvider serviceProvider = new ServiceCollection()
 
             // Microsoft extension
-            .AddLogging(builder => builder.AddDebug().AddConsoleWindow())
+            .AddLogging(builder =>
+            {
+                builder
+                    .SetMinimumLevel(LogLevel.Trace)
+                    .AddDebug()
+                    .AddConsoleWindow();
+            })
             .AddMemoryCache()
 
+            // Quartz
+            .AddQuartz()
+
             // Hutao extensions
             .AddJsonOptions()
             .AddDatabase()
             .AddInjections()
-            .AddAllHttpClients()
+            .AddConfiguredHttpClients()
 
             // Discrete services
             .AddSingleton<IMessenger, WeakReferenceMessenger>()

src/Snap.Hutao/Snap.Hutao/Core/DependencyInjection/IocConfiguration.cs

@@ -30,31 +30,28 @@ internal static class IocConfiguration
     /// <returns>可继续操作的集合</returns>
     public static IServiceCollection AddDatabase(this IServiceCollection services)
     {
-        return services
-            .AddTransient(typeof(Database.ScopedDbCurrent<,>))
-            .AddTransient(typeof(Database.ScopedDbCurrent<,,>))
-            .AddDbContext<AppDbContext>(AddDbContextCore);
-    }
+        return services.AddDbContextPool<AppDbContext>(AddDbContextCore);
 
-    private static void AddDbContextCore(IServiceProvider provider, DbContextOptionsBuilder builder)
-    {
-        RuntimeOptions runtimeOptions = provider.GetRequiredService<RuntimeOptions>();
-        string dbFile = System.IO.Path.Combine(runtimeOptions.DataFolder, "Userdata.db");
-        string sqlConnectionString = $"Data Source={dbFile}";
-
-        // Temporarily create a context
-        using (AppDbContext context = AppDbContext.Create(sqlConnectionString))
+        static void AddDbContextCore(IServiceProvider serviceProvider, DbContextOptionsBuilder builder)
         {
-            if (context.Database.GetPendingMigrations().Any())
-            {
-                System.Diagnostics.Debug.WriteLine("[Database] Performing AppDbContext Migrations");
-                context.Database.Migrate();
-            }
-        }
+            RuntimeOptions runtimeOptions = serviceProvider.GetRequiredService<RuntimeOptions>();
+            string dbFile = System.IO.Path.Combine(runtimeOptions.DataFolder, "Userdata.db");
+            string sqlConnectionString = $"Data Source={dbFile}";
 
-        builder
-            .EnableSensitiveDataLogging()
-            .UseQueryTrackingBehavior(QueryTrackingBehavior.NoTracking)
-            .UseSqlite(sqlConnectionString);
+            // Temporarily create a context
+            using (AppDbContext context = AppDbContext.Create(serviceProvider, sqlConnectionString))
+            {
+                if (context.Database.GetPendingMigrations().Any())
+                {
+                    System.Diagnostics.Debug.WriteLine("[Database] Performing AppDbContext Migrations");
+                    context.Database.Migrate();
+                }
+            }
+
+            builder
+                .EnableSensitiveDataLogging()
+                .UseQueryTrackingBehavior(QueryTrackingBehavior.NoTracking)
+                .UseSqlite(sqlConnectionString);
+        }
     }
 }

src/Snap.Hutao/Snap.Hutao/Core/DependencyInjection/IocHttpClientConfiguration.cs

@@ -15,7 +15,7 @@ internal static partial class IocHttpClientConfiguration
 {
     private const string ApplicationJson = "application/json";
 
-    public static IServiceCollection AddAllHttpClients(this IServiceCollection services)
+    public static IServiceCollection AddConfiguredHttpClients(this IServiceCollection services)
     {
         services
             .ConfigureHttpClientDefaults(clientBuilder =>
@@ -27,7 +27,7 @@ internal static partial class IocHttpClientConfiguration
                         HttpClientHandler clientHandler = (HttpClientHandler)handler;
                         clientHandler.AllowAutoRedirect = true;
                         clientHandler.UseProxy = true;
-                        clientHandler.Proxy = provider.GetRequiredService<DynamicHttpProxy>();
+                        clientHandler.Proxy = provider.GetRequiredService<HttpProxyUsingSystemProxy>();
                     });
             })
             .AddHttpClients();
@@ -38,11 +38,6 @@ internal static partial class IocHttpClientConfiguration
     [EditorBrowsable(EditorBrowsableState.Never)]
     public static partial IServiceCollection AddHttpClients(this IServiceCollection services);
 
-    /// <summary>
-    /// 默认配置
-    /// </summary>
-    /// <param name="serviceProvider">服务提供器</param>
-    /// <param name="client">配置后的客户端</param>
     private static void DefaultConfiguration(IServiceProvider serviceProvider, HttpClient client)
     {
         RuntimeOptions runtimeOptions = serviceProvider.GetRequiredService<RuntimeOptions>();
@@ -51,10 +46,6 @@ internal static partial class IocHttpClientConfiguration
         client.DefaultRequestHeaders.UserAgent.ParseAdd(runtimeOptions.UserAgent);
     }
 
-    /// <summary>
-    /// 对于需要添加动态密钥1的客户端使用此配置
-    /// </summary>
-    /// <param name="client">配置后的客户端</param>
     private static void XRpcConfiguration(HttpClient client)
     {
         client.Timeout = Timeout.InfiniteTimeSpan;
@@ -65,10 +56,6 @@ internal static partial class IocHttpClientConfiguration
         client.DefaultRequestHeaders.Add("x-rpc-device_id", HoyolabOptions.DeviceId36);
     }
 
-    /// <summary>
-    /// 对于需要添加动态密钥2的客户端使用此配置
-    /// </summary>
-    /// <param name="client">配置后的客户端</param>
     private static void XRpc2Configuration(HttpClient client)
     {
         client.Timeout = Timeout.InfiniteTimeSpan;
@@ -84,11 +71,6 @@ internal static partial class IocHttpClientConfiguration
         client.DefaultRequestHeaders.Add("x-rpc-sdk_version", "2.16.0");
     }
 
-    /// <summary>
-    /// 对于需要添加动态密钥1的客户端使用此配置
-    /// HoYoLAB app
-    /// </summary>
-    /// <param name="client">配置后的客户端</param>
     private static void XRpc3Configuration(HttpClient client)
     {
         client.Timeout = Timeout.InfiniteTimeSpan;
@@ -100,11 +82,6 @@ internal static partial class IocHttpClientConfiguration
         client.DefaultRequestHeaders.Add("x-rpc-device_id", HoyolabOptions.DeviceId36);
     }
 
-    /// <summary>
-    /// 对于需要添加动态密钥2的客户端使用此配置
-    /// HoYoLAB web
-    /// </summary>
-    /// <param name="client">配置后的客户端</param>
     [SuppressMessage("", "IDE0051")]
     private static void XRpc4Configuration(HttpClient client)
     {

src/Snap.Hutao/Snap.Hutao/Core/DependencyInjection/ServiceCollectionExtension.cs

@@ -10,11 +10,6 @@ namespace Snap.Hutao.Core.DependencyInjection;
 [HighQuality]
 internal static partial class ServiceCollectionExtension
 {
-    /// <summary>
-    /// 向容器注册服务
-    /// 此方法将会自动生成
-    /// </summary>
-    /// <param name="services">容器</param>
-    /// <returns>可继续操作的服务集合</returns>
+    [EditorBrowsable(EditorBrowsableState.Never)]
     public static partial IServiceCollection AddInjections(this IServiceCollection services);
 }

src/Snap.Hutao/Snap.Hutao/Core/DependencyInjection/ServiceProviderExtension.cs

@@ -10,21 +10,22 @@ namespace Snap.Hutao.Core.DependencyInjection;
 /// </summary>
 internal static class ServiceProviderExtension
 {
-    /// <inheritdoc cref="ActivatorUtilities.CreateInstance{T}(IServiceProvider, object[])"/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static T CreateInstance<T>(this IServiceProvider serviceProvider, params object[] parameters)
-    {
-        return ActivatorUtilities.CreateInstance<T>(serviceProvider, parameters);
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static bool IsDisposedSlow(this IServiceProvider? serviceProvider)
+    public static bool IsDisposed(this IServiceProvider? serviceProvider, bool treatNullAsDisposed = true)
     {
         if (serviceProvider is null)
         {
-            return true;
+            return treatNullAsDisposed;
         }
 
-        return serviceProvider.GetType().GetField("_disposed")?.GetValue(serviceProvider) is true;
+        try
+        {
+            _ = serviceProvider.GetRequiredService<IServiceScopeFactory>();
+            return false;
+        }
+        catch (ObjectDisposedException)
+        {
+            return true;
+        }
     }
 }

src/Snap.Hutao/Snap.Hutao/Core/Diagnostics/CodeAnalysis/AlsoAsyncSetsAttribute.cs

@@ -1,23 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-namespace Snap.Hutao.Core.Diagnostics.CodeAnalysis;
-
-/// <summary>
-/// 指示此特性附加的属性会在属性改变后会异步地设置的其他属性
-/// </summary>
-[AttributeUsage(AttributeTargets.Property, Inherited = false)]
-internal sealed class AlsoAsyncSetsAttribute : Attribute
-{
-    public AlsoAsyncSetsAttribute(string propertyName)
-    {
-    }
-
-    public AlsoAsyncSetsAttribute(string propertyName1, string propertyName2)
-    {
-    }
-
-    public AlsoAsyncSetsAttribute(params string[] propertyNames)
-    {
-    }
-}

src/Snap.Hutao/Snap.Hutao/Core/Diagnostics/CodeAnalysis/AlsoSetsAttribute.cs

@@ -1,23 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-namespace Snap.Hutao.Core.Diagnostics.CodeAnalysis;
-
-/// <summary>
-/// 指示此特性附加的属性会在属性改变后会设置的其他属性
-/// </summary>
-[AttributeUsage(AttributeTargets.Property, Inherited = false)]
-internal sealed class AlsoSetsAttribute : Attribute
-{
-    public AlsoSetsAttribute(string propertyName)
-    {
-    }
-
-    public AlsoSetsAttribute(string propertyName1, string propertyName2)
-    {
-    }
-
-    public AlsoSetsAttribute(params string[] propertyNames)
-    {
-    }
-}

src/Snap.Hutao/Snap.Hutao/Core/Diagnostics/MeasureExecutionToken.cs

@@ -1,5 +1,7 @@
 // Copyright (c) DGP Studio. All rights reserved.
 // Licensed under the MIT license.
+using Snap.Hutao.Core.Logging;
+
 namespace Snap.Hutao.Core.Diagnostics;
 
 internal readonly struct MeasureExecutionToken : IDisposable
@@ -17,6 +19,6 @@ internal readonly struct MeasureExecutionToken : IDisposable
 
     public void Dispose()
     {
-        logger.LogDebug("{Caller} toke {Time} ms", callerName, stopwatch.GetElapsedTime().TotalMilliseconds);
+        logger.LogColorizedDebug(("{Caller} toke {Time} ms", ConsoleColor.Gray), (callerName, ConsoleColor.Yellow), (stopwatch.GetElapsedTime().TotalMilliseconds, ConsoleColor.DarkGreen));
     }
 }

src/Snap.Hutao/Snap.Hutao/Core/ExceptionService/DatabaseCorruptedException.cs

@@ -1,22 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-namespace Snap.Hutao.Core.ExceptionService;
-
-/// <summary>
-/// 数据库损坏异常
-/// </summary>
-[HighQuality]
-[Obsolete("Use HutaoException instead")]
-internal sealed class DatabaseCorruptedException : Exception
-{
-    /// <summary>
-    /// 构造一个新的用户数据损坏异常
-    /// </summary>
-    /// <param name="message">消息</param>
-    /// <param name="innerException">内部错误</param>
-    public DatabaseCorruptedException(string message, Exception? innerException)
-        : base(SH.FormatCoreExceptionServiceDatabaseCorruptedMessage($"{message}\n{innerException?.Message}"), innerException)
-    {
-    }
-}

src/Snap.Hutao/Snap.Hutao/Core/ExceptionService/ExceptionRecorder.cs

@@ -2,13 +2,10 @@
 // Licensed under the MIT license.
 
 using Microsoft.UI.Xaml;
+using System.Diagnostics;
 
 namespace Snap.Hutao.Core.ExceptionService;
 
-/// <summary>
-/// 异常记录器
-/// </summary>
-[HighQuality]
 [ConstructorGenerated]
 [Injection(InjectAs.Singleton)]
 internal sealed partial class ExceptionRecorder
@@ -16,13 +13,15 @@ internal sealed partial class ExceptionRecorder
     private readonly ILogger<ExceptionRecorder> logger;
     private readonly IServiceProvider serviceProvider;
 
-    /// <summary>
-    /// 记录应用程序异常
-    /// </summary>
-    /// <param name="app">应用程序</param>
     public void Record(Application app)
     {
         app.UnhandledException += OnAppUnhandledException;
+        ConfigureDebugSettings(app);
+    }
+
+    [Conditional("DEBUG")]
+    private void ConfigureDebugSettings(Application app)
+    {
         app.DebugSettings.FailFastOnErrors = false;
 
         app.DebugSettings.IsBindingTracingEnabled = true;
@@ -35,19 +34,13 @@ internal sealed partial class ExceptionRecorder
         app.DebugSettings.LayoutCycleDebugBreakLevel = LayoutCycleDebugBreakLevel.High;
     }
 
-    [SuppressMessage("", "CA2012")]
     private void OnAppUnhandledException(object? sender, Microsoft.UI.Xaml.UnhandledExceptionEventArgs e)
     {
-        ValueTask<string?> task = serviceProvider
-            .GetRequiredService<Web.Hutao.Log.HutaoLogUploadClient>()
-            .UploadLogAsync(e.Exception);
-
-        if (!task.IsCompleted)
-        {
-            task.GetAwaiter().GetResult();
-        }
-
         logger.LogError("未经处理的全局异常:\r\n{Detail}", ExceptionFormat.Format(e.Exception));
+
+        serviceProvider
+            .GetRequiredService<Web.Hutao.Log.HutaoLogUploadClient>()
+            .UploadLog(e.Exception);
     }
 
     private void OnXamlBindingFailed(object? sender, BindingFailedEventArgs e)

src/Snap.Hutao/Snap.Hutao/Core/ExceptionService/HutaoException.cs

@@ -1,46 +1,91 @@
 // Copyright (c) DGP Studio. All rights reserved.
 // Licensed under the MIT license.
 
+using System.Runtime.CompilerServices;
+
 namespace Snap.Hutao.Core.ExceptionService;
 
 internal sealed class HutaoException : Exception
 {
-    public HutaoException(HutaoExceptionKind kind, string message, Exception? innerException)
-        : this(message, innerException)
-    {
-        Kind = kind;
-    }
-
-    private HutaoException(string message, Exception? innerException)
+    public HutaoException(string message, Exception? innerException)
         : base($"{message}\n{innerException?.Message}", innerException)
     {
     }
 
-    public HutaoExceptionKind Kind { get; private set; }
-
     [DoesNotReturn]
-    public static HutaoException Throw(HutaoExceptionKind kind, string message, Exception? innerException = default)
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static HutaoException Throw(string message, Exception? innerException = default)
     {
-        throw new HutaoException(kind, message, innerException);
+        throw new HutaoException(message, innerException);
     }
 
-    public static void ThrowIf(bool condition, HutaoExceptionKind kind, string message, Exception? innerException = default)
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static void ThrowIf([DoesNotReturnIf(true)] bool condition, string message, Exception? innerException = default)
     {
         if (condition)
         {
-            throw new HutaoException(kind, message, innerException);
+            throw new HutaoException(message, innerException);
         }
     }
 
-    public static HutaoException ServiceTypeCastFailed<TFrom, TTo>(string name, Exception? innerException = default)
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static void ThrowIfNot([DoesNotReturnIf(false)] bool condition, string message, Exception? innerException = default)
     {
-        string message = $"This instance of '{typeof(TFrom).FullName}' '{name}' doesn't implement '{typeof(TTo).FullName}'";
-        throw new HutaoException(HutaoExceptionKind.ServiceTypeCastFailed, message, innerException);
+        if (!condition)
+        {
+            throw new HutaoException(message, innerException);
+        }
     }
 
+    [DoesNotReturn]
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static ArgumentException Argument(string message, string? paramName)
+    {
+        throw new ArgumentException(message, paramName);
+    }
+
+    [DoesNotReturn]
+    [MethodImpl(MethodImplOptions.NoInlining)]
     public static HutaoException GachaStatisticsInvalidItemId(uint id, Exception? innerException = default)
     {
-        string message = SH.FormatServiceGachaStatisticsFactoryItemIdInvalid(id);
-        throw new HutaoException(HutaoExceptionKind.GachaStatisticsInvalidItemId, message, innerException);
+        throw new HutaoException(SH.FormatServiceGachaStatisticsFactoryItemIdInvalid(id), innerException);
+    }
+
+    [DoesNotReturn]
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static InvalidCastException InvalidCast<TFrom, TTo>(string name, Exception? innerException = default)
+    {
+        string message = $"This instance of '{typeof(TFrom).FullName}' '{name}' doesn't implement '{typeof(TTo).FullName}'";
+        throw new InvalidCastException(message, innerException);
+    }
+
+    [DoesNotReturn]
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static InvalidOperationException InvalidOperation(string message, Exception? innerException = default)
+    {
+        throw new InvalidOperationException(message, innerException);
+    }
+
+    [DoesNotReturn]
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static NotSupportedException NotSupported(string? message = default, Exception? innerException = default)
+    {
+        throw new NotSupportedException(message, innerException);
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static void NotSupportedIf(bool condition, string? message = default, Exception? innerException = default)
+    {
+        if (condition)
+        {
+            throw new NotSupportedException(message, innerException);
+        }
+    }
+
+    [DoesNotReturn]
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static OperationCanceledException OperationCanceled(string message, Exception? innerException = default)
+    {
+        throw new OperationCanceledException(message, innerException);
     }
 }

src/Snap.Hutao/Snap.Hutao/Core/ExceptionService/HutaoExceptionKind.cs

@@ -1,13 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-namespace Snap.Hutao.Core.ExceptionService;
-
-internal enum HutaoExceptionKind
-{
-    None,
-    ServiceTypeCastFailed,
-    FileSystemCreateFileInsufficientPermissions,
-    PrivateNamedPipeContentHashIncorrect,
-    GachaStatisticsInvalidItemId,
-}

src/Snap.Hutao/Snap.Hutao/Core/ExceptionService/RuntimeEnvironmentException.cs

@@ -1,23 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-namespace Snap.Hutao.Core.ExceptionService;
-
-/// <summary>
-/// 运行环境异常
-/// 用户的计算机中的某些设置不符合要求
-/// </summary>
-[HighQuality]
-[Obsolete("Use HutaoException instead")]
-internal sealed class RuntimeEnvironmentException : Exception
-{
-    /// <summary>
-    /// 构造一个新的运行环境异常
-    /// </summary>
-    /// <param name="message">消息</param>
-    /// <param name="innerException">内部错误</param>
-    public RuntimeEnvironmentException(string message, Exception? innerException)
-        : base($"{message}\n{innerException?.Message}", innerException)
-    {
-    }
-}

src/Snap.Hutao/Snap.Hutao/Core/ExceptionService/ThrowHelper.cs

@@ -1,113 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-using Snap.Hutao.Service.Game;
-using Snap.Hutao.Service.Game.Package;
-using System.IO;
-using System.Runtime.CompilerServices;
-
-namespace Snap.Hutao.Core.ExceptionService;
-
-/// <summary>
-/// 帮助更好的抛出异常
-/// </summary>
-[HighQuality]
-[System.Diagnostics.StackTraceHidden]
-[Obsolete("Use HutaoException instead")]
-internal static class ThrowHelper
-{
-    [DoesNotReturn]
-    [MethodImpl(MethodImplOptions.NoInlining)]
-    public static ArgumentException Argument(string message, string? paramName)
-    {
-        throw new ArgumentException(message, paramName);
-    }
-
-    [DoesNotReturn]
-    [MethodImpl(MethodImplOptions.NoInlining)]
-    public static DatabaseCorruptedException DatabaseCorrupted(string message, Exception? inner)
-    {
-        throw new DatabaseCorruptedException(message, inner);
-    }
-
-    [DoesNotReturn]
-    [MethodImpl(MethodImplOptions.NoInlining)]
-    public static GameFileOperationException GameFileOperation(string message, Exception? inner)
-    {
-        throw new GameFileOperationException(message, inner);
-    }
-
-    [DoesNotReturn]
-    [MethodImpl(MethodImplOptions.NoInlining)]
-    public static InvalidDataException InvalidData(string message, Exception? inner = default)
-    {
-        throw new InvalidDataException(message, inner);
-    }
-
-    [MethodImpl(MethodImplOptions.NoInlining)]
-    public static void InvalidDataIf([DoesNotReturnIf(true)] bool condition, string message, Exception? inner = default)
-    {
-        if (condition)
-        {
-            throw new InvalidDataException(message, inner);
-        }
-    }
-
-    [DoesNotReturn]
-    [MethodImpl(MethodImplOptions.NoInlining)]
-    public static InvalidOperationException InvalidOperation(string message, Exception? inner = default)
-    {
-        throw new InvalidOperationException(message, inner);
-    }
-
-    [DoesNotReturn]
-    [MethodImpl(MethodImplOptions.NoInlining)]
-    public static NotSupportedException NotSupported()
-    {
-        throw new NotSupportedException();
-    }
-
-    [DoesNotReturn]
-    [MethodImpl(MethodImplOptions.NoInlining)]
-    public static NotSupportedException NotSupported(string message)
-    {
-        throw new NotSupportedException(message);
-    }
-
-    [MethodImpl(MethodImplOptions.NoInlining)]
-    public static void NotSupportedIf(bool condition, string message)
-    {
-        if (condition)
-        {
-            throw new NotSupportedException(message);
-        }
-    }
-
-    [DoesNotReturn]
-    [MethodImpl(MethodImplOptions.NoInlining)]
-    public static OperationCanceledException OperationCanceled(string message, Exception? inner = default)
-    {
-        throw new OperationCanceledException(message, inner);
-    }
-
-    [DoesNotReturn]
-    [MethodImpl(MethodImplOptions.NoInlining)]
-    public static PackageConvertException PackageConvert(string message, Exception? inner = default)
-    {
-        throw new PackageConvertException(message, inner);
-    }
-
-    [DoesNotReturn]
-    [MethodImpl(MethodImplOptions.NoInlining)]
-    public static RuntimeEnvironmentException RuntimeEnvironment(string message, Exception? inner)
-    {
-        throw new RuntimeEnvironmentException(message, inner);
-    }
-
-    [DoesNotReturn]
-    [MethodImpl(MethodImplOptions.NoInlining)]
-    public static UserdataCorruptedException UserdataCorrupted(string message, Exception? inner)
-    {
-        throw new UserdataCorruptedException(message, inner);
-    }
-}

src/Snap.Hutao/Snap.Hutao/Core/ExceptionService/UserdataCorruptedException.cs

@@ -1,22 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-namespace Snap.Hutao.Core.ExceptionService;
-
-/// <summary>
-/// 用户数据损坏异常
-/// </summary>
-[HighQuality]
-[Obsolete("Use HutaoException instead")]
-internal sealed class UserdataCorruptedException : Exception
-{
-    /// <summary>
-    /// 构造一个新的用户数据损坏异常
-    /// </summary>
-    /// <param name="message">消息</param>
-    /// <param name="innerException">内部错误</param>
-    public UserdataCorruptedException(string message, Exception? innerException)
-        : base(SH.FormatCoreExceptionServiceUserdataCorruptedMessage($"{message}\n{innerException?.Message}"), innerException)
-    {
-    }
-}

src/Snap.Hutao/Snap.Hutao/Core/Graphics/Imaging/SoftwareBitmapExtension.cs

@@ -1,24 +1,16 @@
 // Copyright (c) DGP Studio. All rights reserved.
 // Licensed under the MIT license.
 
+using Snap.Hutao.UI;
 using Snap.Hutao.Win32.System.WinRT;
 using Windows.Foundation;
 using Windows.Graphics.Imaging;
 using WinRT;
 
-namespace Snap.Hutao.Control.Media;
+namespace Snap.Hutao.Core.Graphics.Imaging;
 
-/// <summary>
-/// 软件位图拓展
-/// </summary>
-[HighQuality]
 internal static class SoftwareBitmapExtension
 {
-    /// <summary>
-    /// 混合模式 正常
-    /// </summary>
-    /// <param name="softwareBitmap">软件位图</param>
-    /// <param name="tint">底色</param>
     public static unsafe void NormalBlend(this SoftwareBitmap softwareBitmap, Bgra32 tint)
     {
         using (BitmapBuffer buffer = softwareBitmap.LockBuffer(BitmapBufferAccessMode.ReadWrite))
@@ -39,25 +31,7 @@ internal static class SoftwareBitmapExtension
         }
     }
 
-    public static unsafe double Luminance(this SoftwareBitmap softwareBitmap)
-    {
-        using (BitmapBuffer buffer = softwareBitmap.LockBuffer(BitmapBufferAccessMode.Read))
-        {
-            using (IMemoryBufferReference reference = buffer.CreateReference())
-            {
-                reference.As<IMemoryBufferByteAccess>().GetBuffer(out Span<Bgra32> bytes);
-                double sum = 0;
-                foreach (ref readonly Bgra32 pixel in bytes)
-                {
-                    sum += pixel.Luminance;
-                }
-
-                return sum / bytes.Length;
-            }
-        }
-    }
-
-    public static unsafe Bgra32 GetAccentColor(this SoftwareBitmap softwareBitmap)
+    public static unsafe Bgra32 GetBgra32AccentColor(this SoftwareBitmap softwareBitmap)
     {
         using (BitmapBuffer buffer = softwareBitmap.LockBuffer(BitmapBufferAccessMode.Read))
         {
@@ -77,4 +51,25 @@ internal static class SoftwareBitmapExtension
             }
         }
     }
+
+    public static unsafe Rgba32 GetRgba32AccentColor(this SoftwareBitmap softwareBitmap)
+    {
+        using (BitmapBuffer buffer = softwareBitmap.LockBuffer(BitmapBufferAccessMode.Read))
+        {
+            using (IMemoryBufferReference reference = buffer.CreateReference())
+            {
+                reference.As<IMemoryBufferByteAccess>().GetBuffer(out Span<Bgra32> bytes);
+                double b = 0, g = 0, r = 0, a = 0;
+                foreach (ref readonly Bgra32 pixel in bytes)
+                {
+                    b += pixel.B;
+                    g += pixel.G;
+                    r += pixel.R;
+                    a += pixel.A;
+                }
+
+                return new((byte)(r / bytes.Length), (byte)(g / bytes.Length), (byte)(b / bytes.Length), (byte)(a / bytes.Length));
+            }
+        }
+    }
 }

src/Snap.Hutao/Snap.Hutao/Core/Graphics/PointInt32Kind.cs

@@ -0,0 +1,17 @@
+// Copyright (c) DGP Studio. All rights reserved.
+// Licensed under the MIT license.
+
+namespace Snap.Hutao.Core.Graphics;
+
+internal enum PointInt32Kind
+{
+    TopLeft,
+    TopCenter,
+    TopRight,
+    CenterLeft,
+    Center,
+    CenterRight,
+    BottomLeft,
+    BottomCenter,
+    BottomRight,
+}