miao-moe/LanMountainDesktop
1
0
Fork 0
mirror of https://github.com/wwiinnddyy/LanMountainDesktop.git synced 2026-06-20 23:54:26 +08:00
Code Issues Packages Projects Releases Wiki Activity

feat.依旧试增量更新这一块，看看velopack

Browse Source
This commit is contained in:
lincube
2026-04-18 19:50:33 +08:00
parent 4b897831de
commit e8d2575bc1
9 changed files with 2246 additions and 13 deletions
Download Patch File Download Diff File Expand all files Collapse all files

91
LanMountainDesktop.Launcher/Services/LauncherFlowCoordinator.cs
View File

@@ -63,9 +63,23 @@ internal sealed class LauncherFlowCoordinator
var reporter = (ISplashStageReporter)splashWindow;
// 创建加载详情窗口（可选，用于显示详细加载状态）
LoadingDetailsWindow? loadingDetailsWindow = null;
if (_context.IsDebugMode || _context.GetOption("show-loading-details") == "true")
{
await Dispatcher.UIThread.InvokeAsync(() =>
{
loadingDetailsWindow = new LoadingDetailsWindow();
loadingDetailsWindow.Show();
});
}
// 跟踪主程序是否已就绪，就绪后自动关闭 Splash 窗口
var hostReadyTcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
// 加载状态管理
var loadingState = new LoadingStateMessage();
// 启动 IPC 服务端监听主程序进度
using var ipcServer = new LauncherIpcServer(msg =>
{
@@ -73,12 +87,29 @@ internal sealed class LauncherFlowCoordinator
{
try
{
// 更新加载状态
loadingState = loadingState with
{
Stage = msg.Stage,
OverallProgressPercent = msg.ProgressPercent,
Message = msg.Message,
Timestamp = DateTimeOffset.UtcNow
};
// 报告到 Splash 窗口
reporter.Report(msg.Stage.ToString().ToLower(), msg.Message ?? "");
// 主程序报告就绪后，关闭 Splash 窗口
if (msg.Stage == StartupStage.Ready && splashWindow.IsVisible && splashWindow.IsLoaded)
// 更新加载详情窗口
loadingDetailsWindow?.UpdateLoadingState(loadingState);
// 主程序报告就绪后，关闭 Splash 窗口和加载详情窗口
if (msg.Stage == StartupStage.Ready)
{
splashWindow.Close();
if (splashWindow.IsVisible && splashWindow.IsLoaded)
{
splashWindow.Close();
}
loadingDetailsWindow?.Close();
hostReadyTcs.TrySetResult();
}
}
@@ -133,20 +164,52 @@ internal sealed class LauncherFlowCoordinator
// 维持 IPC 管道服务端供主程序报告启动进度。
if (hostProcess is not null)
{
// 等待主程序就绪或进程退出（取先发生者）
// 如果主程序在 60 秒内未报告 Ready，也关闭 Splash 窗口作为超时保护
var readyOrTimeout = Task.WhenAny(
hostReadyTcs.Task,
Task.Delay(TimeSpan.FromSeconds(60)));
var processExitTask = hostProcess.WaitForExitAsync();
// 先等待就绪/超时，然后等待进程退出
await readyOrTimeout;
// 等待主程序就绪或进程退出（取先发生者）
// 延长超时到 120 秒，给主程序足够的加载时间
var readyOrTimeoutOrExit = Task.WhenAny(
hostReadyTcs.Task,
processExitTask,
Task.Delay(TimeSpan.FromSeconds(120)));
var completedTask = await readyOrTimeoutOrExit;
// 检查是否是进程先退出（异常情况）
if (completedTask == processExitTask)
{
var exitCode = hostProcess.ExitCode;
Console.Error.WriteLine($"[LauncherFlowCoordinator] Host process exited unexpectedly with code: {exitCode}");
// 关闭 Splash 窗口
await Dispatcher.UIThread.InvokeAsync(() =>
{
try
{
if (splashWindow.IsVisible && splashWindow.IsLoaded)
{
splashWindow.Close();
}
}
catch (Exception ex)
{
Console.Error.WriteLine($"[LauncherFlowCoordinator] Error closing splash window: {ex.Message}");
}
});
return new LauncherResult
{
Success = false,
Stage = "launch",
Code = "host_crashed",
Message = $"主程序异常退出，退出代码: {exitCode}"
};
}
// 如果 Splash 窗口仍然打开（超时情况），关闭它
if (splashWindow.IsVisible)
{
Console.WriteLine("[LauncherFlowCoordinator] Timeout waiting for Ready signal, closing splash window...");
await Dispatcher.UIThread.InvokeAsync(() =>
{
try
@@ -163,7 +226,11 @@ internal sealed class LauncherFlowCoordinator
});
}
await processExitTask;
// 继续等待主程序进程退出（如果它还在运行）
if (!hostProcess.HasExited)
{
await processExitTask;
}
}
else
{

250
LanMountainDesktop.Launcher/Views/LoadingDetailsWindow.axaml Normal file
View File

@@ -0,0 +1,250 @@
<Window xmlns="https://github.com/avaloniaui"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
mc:Ignorable="d"
d:DesignWidth="600"
d:DesignHeight="500"
x:Class="LanMountainDesktop.Launcher.Views.LoadingDetailsWindow"
Title="阑山桌面 - 加载详情"
Width="600"
Height="500"
WindowStartupLocation="CenterScreen"
CanResize="True"
MinWidth="500"
MinHeight="400"
Background="{DynamicResource SolidBackgroundFillColorBaseBrush}"
Icon="/Assets/logo.ico">
<Grid RowDefinitions="Auto,*,Auto,Auto">
<!-- 标题栏 -->
<Border Grid.Row="0"
Background="{DynamicResource CardBackgroundFillColorDefaultBrush}"
Padding="20,16">
<Grid ColumnDefinitions="*,Auto">
<StackPanel Grid.Column="0" Spacing="4">
<TextBlock Text="正在启动阑山桌面"
FontSize="18"
FontWeight="SemiBold"
Foreground="{DynamicResource TextFillColorPrimaryBrush}"/>
<TextBlock x:Name="SubtitleText"
Text="初始化系统组件..."
FontSize="13"
Foreground="{DynamicResource TextFillColorSecondaryBrush}"/>
</StackPanel>
<Border Grid.Column="1"
Background="{DynamicResource AccentFillColorDefaultBrush}"
CornerRadius="12"
Padding="12,6"
VerticalAlignment="Center">
<TextBlock x:Name="PercentText"
Text="0%"
FontSize="16"
FontWeight="Bold"
Foreground="White"/>
</Border>
</Grid>
</Border>
<!-- 主要内容区域 -->
<Grid Grid.Row="1" Margin="16,12">
<Grid.RowDefinitions>
<RowDefinition Height="Auto"/>
<RowDefinition Height="Auto"/>
<RowDefinition Height="*"/>
</Grid.RowDefinitions>
<!-- 整体进度条 -->
<ProgressBar x:Name="OverallProgressBar"
Grid.Row="0"
Height="8"
Minimum="0"
Maximum="100"
Value="0"
CornerRadius="4"
Margin="0,0,0,16"/>
<!-- 当前活动项 -->
<Border Grid.Row="1"
Background="{DynamicResource CardBackgroundFillColorSecondaryBrush}"
CornerRadius="8"
Padding="16,12"
Margin="0,0,0,12">
<Grid RowDefinitions="Auto,Auto,Auto" ColumnDefinitions="Auto,*">
<!-- 图标 -->
<Border Grid.Row="0" Grid.RowSpan="3" Grid.Column="0"
Width="40"
Height="40"
CornerRadius="20"
Background="{DynamicResource AccentFillColorDefaultBrush}"
Margin="0,0,12,0"
VerticalAlignment="Center">
<TextBlock x:Name="CurrentItemIcon"
Text="&#xE768;"
FontSize="20"
FontFamily="{DynamicResource SymbolThemeFontFamily}"
Foreground="White"
HorizontalAlignment="Center"
VerticalAlignment="Center"/>
</Border>
<!-- 名称 -->
<TextBlock x:Name="CurrentItemName"
Grid.Row="0" Grid.Column="1"
Text="正在初始化..."
FontSize="15"
FontWeight="SemiBold"
Foreground="{DynamicResource TextFillColorPrimaryBrush}"/>
<!-- 描述 -->
<TextBlock x:Name="CurrentItemDescription"
Grid.Row="1" Grid.Column="1"
Text="准备加载系统组件"
FontSize="13"
Foreground="{DynamicResource TextFillColorSecondaryBrush}"
Margin="0,4,0,0"/>
<!-- 进度 -->
<Grid Grid.Row="2" Grid.Column="1" Margin="0,8,0,0">
<ProgressBar x:Name="CurrentItemProgress"
Height="4"
Minimum="0"
Maximum="100"
Value="0"
CornerRadius="2"/>
</Grid>
</Grid>
</Border>
<!-- 加载项列表 -->
<Border Grid.Row="2"
Background="{DynamicResource CardBackgroundFillColorDefaultBrush}"
CornerRadius="8">
<Grid RowDefinitions="Auto,*">
<!-- 列表标题 -->
<Grid Grid.Row="0" Margin="12,8" ColumnDefinitions="*,Auto,Auto">
<TextBlock Grid.Column="0"
Text="加载项"
FontSize="12"
FontWeight="SemiBold"
Foreground="{DynamicResource TextFillColorTertiaryBrush}"/>
<TextBlock x:Name="CompletedCountText"
Grid.Column="1"
Text="0"
FontSize="12"
Foreground="{DynamicResource TextFillColorSecondaryBrush}"
Margin="0,0,4,0"/>
<TextBlock Grid.Column="2"
Text="已完成"
FontSize="12"
Foreground="{DynamicResource TextFillColorTertiaryBrush}"/>
</Grid>
<!-- 列表内容 -->
<ScrollViewer Grid.Row="1"
VerticalScrollBarVisibility="Auto"
Margin="8,0,8,8">
<ItemsControl x:Name="LoadingItemsList">
<ItemsControl.ItemTemplate>
<DataTemplate>
<Grid ColumnDefinitions="Auto,*,Auto,Auto"
Margin="4,3"
Opacity="{Binding Opacity}">
<!-- 状态图标 -->
<TextBlock Grid.Column="0"
Text="{Binding StatusIcon}"
FontSize="14"
FontFamily="{DynamicResource SymbolThemeFontFamily}"
Foreground="{Binding StatusColor}"
Margin="0,0,8,0"
VerticalAlignment="Center"/>
<!-- 名称 -->
<TextBlock Grid.Column="1"
Text="{Binding Name}"
FontSize="13"
Foreground="{DynamicResource TextFillColorPrimaryBrush}"
TextTrimming="CharacterEllipsis"
VerticalAlignment="Center"/>
<!-- 进度 -->
<TextBlock Grid.Column="2"
Text="{Binding ProgressText}"
FontSize="12"
Foreground="{DynamicResource TextFillColorSecondaryBrush}"
Margin="8,0"
VerticalAlignment="Center"/>
<!-- 类型标签 -->
<Border Grid.Column="3"
Background="{Binding TypeBackground}"
CornerRadius="4"
Padding="6,2"
VerticalAlignment="Center">
<TextBlock Text="{Binding TypeLabel}"
FontSize="11"
Foreground="{Binding TypeForeground}"/>
</Border>
</Grid>
</DataTemplate>
</ItemsControl.ItemTemplate>
</ItemsControl>
</ScrollViewer>
</Grid>
</Border>
</Grid>
<!-- 错误信息区域 -->
<Border x:Name="ErrorPanel"
Grid.Row="2"
Background="{DynamicResource SystemFillColorCriticalBackgroundBrush}"
BorderBrush="{DynamicResource SystemFillColorCriticalBrush}"
BorderThickness="1"
CornerRadius="8"
Padding="12,10"
Margin="16,0,16,12"
IsVisible="False">
<Grid ColumnDefinitions="Auto,*">
<TextBlock Grid.Column="0"
Text="&#xE783;"
FontSize="16"
FontFamily="{DynamicResource SymbolThemeFontFamily}"
Foreground="{DynamicResource SystemFillColorCriticalBrush}"
Margin="0,0,8,0"
VerticalAlignment="Center"/>
<TextBlock x:Name="ErrorText"
Grid.Column="1"
Text="加载过程中出现错误"
FontSize="13"
Foreground="{DynamicResource SystemFillColorCriticalBrush}"
TextWrapping="Wrap"/>
</Grid>
</Border>
<!-- 底部按钮 -->
<Border Grid.Row="3"
Background="{DynamicResource CardBackgroundFillColorDefaultBrush}"
Padding="16,12">
<Grid ColumnDefinitions="*,Auto">
<TextBlock x:Name="VersionText"
Grid.Column="0"
Text="v1.0.0"
FontSize="12"
Foreground="{DynamicResource TextFillColorTertiaryBrush}"
VerticalAlignment="Center"/>
<StackPanel Grid.Column="1" Orientation="Horizontal" Spacing="8">
<Button x:Name="DetailsButton"
Content="查看详情"
Width="90"
Height="32"
FontSize="13"/>
<Button x:Name="CancelButton"
Content="取消"
Width="90"
Height="32"
FontSize="13"/>
</StackPanel>
</Grid>
</Border>
</Grid>
</Window>

396
LanMountainDesktop.Launcher/Views/LoadingDetailsWindow.axaml.cs Normal file
View File

@@ -0,0 +1,396 @@
using Avalonia.Controls;
using Avalonia.Interactivity;
using Avalonia.Markup.Xaml;
using Avalonia.Media;
using Avalonia.Threading;
using LanMountainDesktop.Launcher.Services;
using LanMountainDesktop.Shared.Contracts.Launcher;
using System.Collections.ObjectModel;
using System.ComponentModel;
namespace LanMountainDesktop.Launcher.Views;
/// <summary>
/// 加载详情窗口 - 显示详细的加载状态和进度
/// </summary>
public partial class LoadingDetailsWindow : Window
{
private readonly ObservableCollection<LoadingItemViewModel> _items = new();
private readonly DispatcherTimer _updateTimer;
private DateTimeOffset _startTime;
public LoadingDetailsWindow()
{
AvaloniaXamlLoader.Load(this);
// 初始化列表
var itemsList = this.FindControl<ItemsControl>("LoadingItemsList");
if (itemsList != null)
{
itemsList.ItemsSource = _items;
}
// 创建更新定时器
_updateTimer = new DispatcherTimer
{
Interval = TimeSpan.FromMilliseconds(100)
};
_updateTimer.Tick += OnUpdateTimerTick;
_startTime = DateTimeOffset.UtcNow;
}
/// <summary>
/// 窗口加载完成
/// </summary>
protected override void OnLoaded(RoutedEventArgs e)
{
base.OnLoaded(e);
_updateTimer.Start();
}
/// <summary>
/// 窗口关闭
/// </summary>
protected override void OnClosing(WindowClosingEventArgs e)
{
_updateTimer.Stop();
base.OnClosing(e);
}
/// <summary>
/// 更新加载状态
/// </summary>
public void UpdateLoadingState(LoadingStateMessage state)
{
Dispatcher.UIThread.Post(() =>
{
try
{
// 更新标题和副标题
UpdateHeader(state);
// 更新整体进度
UpdateOverallProgress(state);
// 更新当前活动项
UpdateCurrentItem(state);
// 更新列表
UpdateItemsList(state);
// 更新错误信息
UpdateErrorPanel(state);
// 更新完成计数
UpdateCompletedCount(state);
}
catch (Exception ex)
{
Console.Error.WriteLine($"[LoadingDetailsWindow] Error updating state: {ex.Message}");
}
});
}
/// <summary>
/// 更新标题
/// </summary>
private void UpdateHeader(LoadingStateMessage state)
{
var subtitleText = this.FindControl<TextBlock>("SubtitleText");
if (subtitleText != null)
{
subtitleText.Text = GetStageDescription(state.Stage);
}
}
/// <summary>
/// 更新整体进度
/// </summary>
private void UpdateOverallProgress(LoadingStateMessage state)
{
var progressBar = this.FindControl<ProgressBar>("OverallProgressBar");
var percentText = this.FindControl<TextBlock>("PercentText");
if (progressBar != null)
{
progressBar.Value = state.OverallProgressPercent;
}
if (percentText != null)
{
percentText.Text = $"{state.OverallProgressPercent}%";
}
}
/// <summary>
/// 更新当前活动项
/// </summary>
private void UpdateCurrentItem(LoadingStateMessage state)
{
var currentItem = state.ActiveItems.FirstOrDefault();
if (currentItem == null) return;
var nameText = this.FindControl<TextBlock>("CurrentItemName");
var descText = this.FindControl<TextBlock>("CurrentItemDescription");
var progressBar = this.FindControl<ProgressBar>("CurrentItemProgress");
var iconText = this.FindControl<TextBlock>("CurrentItemIcon");
if (nameText != null)
{
nameText.Text = currentItem.Name;
}
if (descText != null)
{
descText.Text = currentItem.Message ?? GetItemDescription(currentItem);
}
if (progressBar != null)
{
progressBar.Value = currentItem.ProgressPercent;
}
if (iconText != null)
{
iconText.Text = GetItemIcon(currentItem.Type);
}
}
/// <summary>
/// 更新列表
/// </summary>
private void UpdateItemsList(LoadingStateMessage state)
{
// 同步列表项
foreach (var item in state.ActiveItems)
{
var existing = _items.FirstOrDefault(i => i.Id == item.Id);
if (existing != null)
{
existing.UpdateFrom(item);
}
else
{
_items.Add(new LoadingItemViewModel(item));
}
}
// 移除已完成的项（保留最近完成的5个）
var completedItems = _items.Where(i => i.State == LoadingState.Completed).ToList();
if (completedItems.Count > 5)
{
var itemsToRemove = completedItems.OrderBy(i => i.CompletedTime).Take(completedItems.Count - 5);
foreach (var item in itemsToRemove)
{
_items.Remove(item);
}
}
// 按状态排序：进行中 -> 等待中 -> 已完成 -> 失败
var sortedItems = _items.OrderBy(i => GetStatePriority(i.State)).ToList();
_items.Clear();
foreach (var item in sortedItems)
{
_items.Add(item);
}
}
/// <summary>
/// 更新错误面板
/// </summary>
private void UpdateErrorPanel(LoadingStateMessage state)
{
var errorPanel = this.FindControl<Border>("ErrorPanel");
var errorText = this.FindControl<TextBlock>("ErrorText");
if (errorPanel != null)
{
errorPanel.IsVisible = state.HasErrors;
}
if (errorText != null && state.ErrorMessages?.Any() == true)
{
errorText.Text = string.Join("\n", state.ErrorMessages.Take(3));
}
}
/// <summary>
/// 更新完成计数
/// </summary>
private void UpdateCompletedCount(LoadingStateMessage state)
{
var countText = this.FindControl<TextBlock>("CompletedCountText");
if (countText != null)
{
countText.Text = state.CompletedCount.ToString();
}
}
/// <summary>
/// 定时更新
/// </summary>
private void OnUpdateTimerTick(object? sender, EventArgs e)
{
// 可以在这里添加时间显示等实时更新
}
/// <summary>
/// 获取阶段描述
/// </summary>
private static string GetStageDescription(StartupStage stage) => stage switch
{
StartupStage.Initializing => "正在初始化系统...",
StartupStage.LoadingSettings => "正在加载设置...",
StartupStage.LoadingPlugins => "正在加载插件...",
StartupStage.InitializingUI => "正在初始化界面...",
StartupStage.Ready => "加载完成",
_ => "正在加载..."
};
/// <summary>
/// 获取项描述
/// </summary>
private static string GetItemDescription(LoadingItem item)
{
if (!string.IsNullOrEmpty(item.Description))
return item.Description;
return item.Type switch
{
LoadingItemType.Plugin => "正在加载插件...",
LoadingItemType.Component => "正在加载组件...",
LoadingItemType.Resource => "正在加载资源...",
LoadingItemType.Data => "正在加载数据...",
LoadingItemType.Network => "正在下载...",
_ => "正在处理..."
};
}
/// <summary>
/// 获取项图标
/// </summary>
private static string GetItemIcon(LoadingItemType type) => type switch
{
LoadingItemType.Plugin => "\uE768",
LoadingItemType.Component => "\uE7C4",
LoadingItemType.Resource => "\uE7C5",
LoadingItemType.Data => "\uE7C6",
LoadingItemType.Network => "\uE774",
LoadingItemType.Settings => "\uE713",
LoadingItemType.System => "\uE7C7",
_ => "\uE768"
};
/// <summary>
/// 获取状态优先级
/// </summary>
private static int GetStatePriority(LoadingState state) => state switch
{
LoadingState.InProgress => 0,
LoadingState.Pending => 1,
LoadingState.Completed => 2,
LoadingState.Failed => 3,
LoadingState.Timeout => 4,
LoadingState.Cancelled => 5,
_ => 6
};
}
/// <summary>
/// 加载项视图模型
/// </summary>
public class LoadingItemViewModel : INotifyPropertyChanged
{
public string Id { get; }
public string Name { get; private set; }
public LoadingItemType Type { get; private set; }
public LoadingState State { get; private set; }
public int ProgressPercent { get; private set; }
public DateTimeOffset? CompletedTime { get; private set; }
public string StatusIcon => GetStatusIcon(State);
public IBrush StatusColor => GetStatusColor(State);
public string ProgressText => State == LoadingState.Completed ? "完成" : $"{ProgressPercent}%";
public string TypeLabel => GetTypeLabel(Type);
public IBrush TypeBackground => GetTypeBackground(Type);
public IBrush TypeForeground => GetTypeForeground(Type);
public double Opacity => State == LoadingState.Completed ? 0.6 : 1.0;
public event PropertyChangedEventHandler? PropertyChanged;
public LoadingItemViewModel(LoadingItem item)
{
Id = item.Id;
UpdateFrom(item);
}
public void UpdateFrom(LoadingItem item)
{
Name = item.Name;
Type = item.Type;
State = item.State;
ProgressPercent = item.ProgressPercent;
if (State == LoadingState.Completed && !CompletedTime.HasValue)
{
CompletedTime = DateTimeOffset.UtcNow;
}
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(string.Empty));
}
private static string GetStatusIcon(LoadingState state) => state switch
{
LoadingState.Pending => "\uE7C3",
LoadingState.InProgress => "\uE768",
LoadingState.Completed => "\uE73E",
LoadingState.Failed => "\uE783",
LoadingState.Timeout => "\uE71A",
LoadingState.Cancelled => "\uE711",
_ => "\uE7C3"
};
private static IBrush GetStatusColor(LoadingState state) => state switch
{
LoadingState.Pending => new SolidColorBrush(Colors.Gray),
LoadingState.InProgress => new SolidColorBrush(Colors.DodgerBlue),
LoadingState.Completed => new SolidColorBrush(Colors.Green),
LoadingState.Failed => new SolidColorBrush(Colors.Red),
LoadingState.Timeout => new SolidColorBrush(Colors.Orange),
LoadingState.Cancelled => new SolidColorBrush(Colors.Gray),
_ => new SolidColorBrush(Colors.Gray)
};
private static string GetTypeLabel(LoadingItemType type) => type switch
{
LoadingItemType.Plugin => "插件",
LoadingItemType.Component => "组件",
LoadingItemType.Resource => "资源",
LoadingItemType.Data => "数据",
LoadingItemType.Network => "网络",
LoadingItemType.Settings => "设置",
LoadingItemType.System => "系统",
_ => "其他"
};
private static IBrush GetTypeBackground(LoadingItemType type) => type switch
{
LoadingItemType.Plugin => new SolidColorBrush(Color.Parse("#E3F2FD")),
LoadingItemType.Component => new SolidColorBrush(Color.Parse("#F3E5F5")),
LoadingItemType.Resource => new SolidColorBrush(Color.Parse("#E8F5E9")),
LoadingItemType.Data => new SolidColorBrush(Color.Parse("#FFF3E0")),
LoadingItemType.Network => new SolidColorBrush(Color.Parse("#E0F7FA")),
_ => new SolidColorBrush(Color.Parse("#F5F5F5"))
};
private static IBrush GetTypeForeground(LoadingItemType type) => type switch
{
LoadingItemType.Plugin => new SolidColorBrush(Color.Parse("#1976D2")),
LoadingItemType.Component => new SolidColorBrush(Color.Parse("#7B1FA2")),
LoadingItemType.Resource => new SolidColorBrush(Color.Parse("#388E3C")),
LoadingItemType.Data => new SolidColorBrush(Color.Parse("#F57C00")),
LoadingItemType.Network => new SolidColorBrush(Color.Parse("#0097A7")),
_ => new SolidColorBrush(Color.Parse("#616161"))
};
}

231
LanMountainDesktop.Shared.Contracts/Launcher/LoadingState.cs Normal file
View File

@@ -0,0 +1,231 @@
namespace LanMountainDesktop.Shared.Contracts.Launcher;
/// <summary>
/// 加载项类型
/// </summary>
public enum LoadingItemType
{
/// <summary>
/// 系统初始化
/// </summary>
System,
/// <summary>
/// 设置加载
/// </summary>
Settings,
/// <summary>
/// 插件
/// </summary>
Plugin,
/// <summary>
/// 组件
/// </summary>
Component,
/// <summary>
/// 资源
/// </summary>
Resource,
/// <summary>
/// 数据
/// </summary>
Data,
/// <summary>
/// 网络请求
/// </summary>
Network,
/// <summary>
/// 其他
/// </summary>
Other
}
/// <summary>
/// 加载状态
/// </summary>
public enum LoadingState
{
/// <summary>
/// 等待中
/// </summary>
Pending,
/// <summary>
/// 进行中
/// </summary>
InProgress,
/// <summary>
/// 已完成
/// </summary>
Completed,
/// <summary>
/// 失败
/// </summary>
Failed,
/// <summary>
/// 已取消
/// </summary>
Cancelled,
/// <summary>
/// 超时
/// </summary>
Timeout
}
/// <summary>
/// 加载项信息
/// </summary>
public record LoadingItem
{
/// <summary>
/// 加载项唯一标识
/// </summary>
public required string Id { get; init; }
/// <summary>
/// 加载项类型
/// </summary>
public LoadingItemType Type { get; init; }
/// <summary>
/// 加载项名称
/// </summary>
public required string Name { get; init; }
/// <summary>
/// 加载项描述
/// </summary>
public string? Description { get; init; }
/// <summary>
/// 当前状态
/// </summary>
public LoadingState State { get; init; }
/// <summary>
/// 进度百分比 (0-100)
/// </summary>
public int ProgressPercent { get; init; }
/// <summary>
/// 状态消息
/// </summary>
public string? Message { get; init; }
/// <summary>
/// 错误信息（当 State 为 Failed 时）
/// </summary>
public string? ErrorMessage { get; init; }
/// <summary>
/// 开始时间
/// </summary>
public DateTimeOffset? StartTime { get; init; }
/// <summary>
/// 结束时间
/// </summary>
public DateTimeOffset? EndTime { get; init; }
/// <summary>
/// 预计剩余时间（秒）
/// </summary>
public int? EstimatedRemainingSeconds { get; init; }
/// <summary>
/// 子加载项
/// </summary>
public List<LoadingItem>? Children { get; init; }
/// <summary>
/// 额外数据
/// </summary>
public Dictionary<string, string>? Metadata { get; init; }
/// <summary>
/// 时间戳
/// </summary>
public DateTimeOffset Timestamp { get; init; } = DateTimeOffset.UtcNow;
}
/// <summary>
/// 加载状态更新消息
/// </summary>
public record LoadingStateMessage
{
/// <summary>
/// 当前启动阶段
/// </summary>
public StartupStage Stage { get; init; }
/// <summary>
/// 整体进度百分比 (0-100)
/// </summary>
public int OverallProgressPercent { get; init; }
/// <summary>
/// 当前活动的加载项
/// </summary>
public List<LoadingItem> ActiveItems { get; init; } = new();
/// <summary>
/// 已完成的加载项数量
/// </summary>
public int CompletedCount { get; init; }
/// <summary>
/// 总加载项数量
/// </summary>
public int TotalCount { get; init; }
/// <summary>
/// 状态消息
/// </summary>
public string? Message { get; init; }
/// <summary>
/// 是否有错误
/// </summary>
public bool HasErrors { get; init; }
/// <summary>
/// 错误消息列表
/// </summary>
public List<string>? ErrorMessages { get; init; }
/// <summary>
/// 时间戳
/// </summary>
public DateTimeOffset Timestamp { get; init; } = DateTimeOffset.UtcNow;
}
/// <summary>
/// 详细的加载进度消息（用于实时更新）
/// </summary>
public record DetailedProgressMessage : StartupProgressMessage
{
/// <summary>
/// 当前加载项
/// </summary>
public LoadingItem? CurrentItem { get; init; }
/// <summary>
/// 所有加载项
/// </summary>
public List<LoadingItem>? AllItems { get; init; }
/// <summary>
/// 是否为主要更新
/// </summary>
public bool IsMajorUpdate { get; init; }
}

76
LanMountainDesktop/App.axaml.cs
View File

@@ -20,6 +20,7 @@ using LanMountainDesktop.Models;
using LanMountainDesktop.PluginSdk;
using LanMountainDesktop.Services;
using LanMountainDesktop.Services.Launcher;
using LanMountainDesktop.Services.Loading;
using LanMountainDesktop.Services.Settings;
using LanMountainDesktop.Shared.Contracts.Launcher;
using LanMountainDesktop.Theme;
@@ -74,6 +75,8 @@ public partial class App : Application
private bool _uiUnhandledExceptionHooked;
private DesktopShellHost? _desktopShellHost;
private LauncherIpcClient? _launcherIpcClient;
private LoadingStateManager? _loadingStateManager;
private LoadingStateReporter? _loadingStateReporter;
internal static SingleInstanceService? CurrentSingleInstanceService { get; set; }
internal static IHostApplicationLifecycle? CurrentHostApplicationLifecycle =>
@@ -178,6 +181,16 @@ public partial class App : Application
if (connected)
{
AppLogger.Info("LauncherIpc", "Connected to Launcher IPC server.");
// 初始化加载状态管理器
_loadingStateManager = new LoadingStateManager();
_loadingStateReporter = new LoadingStateReporter(_loadingStateManager, _launcherIpcClient);
_loadingStateReporter.Start();
// 注册系统初始化加载项
_loadingStateManager.RegisterItem("system.init", LoadingItemType.System, "系统初始化", "初始化系统核心组件");
_loadingStateManager.StartItem("system.init", "正在连接启动器...");
ReportStartupProgress(StartupStage.Initializing, 10, "正在初始化...");
}
}
@@ -213,6 +226,41 @@ public partial class App : Application
});
}
/// <summary>
/// 同步向 Launcher 报告启动进度，确保关键消息可靠送达
/// 用于 Ready 等关键状态报告
/// </summary>
private void ReportStartupProgressSync(StartupStage stage, int percent, string message)
{
if (_launcherIpcClient is null)
return;
try
{
// 使用同步等待确保消息发送完成
var task = _launcherIpcClient.ReportProgressAsync(new StartupProgressMessage
{
Stage = stage,
ProgressPercent = percent,
Message = message
});
// 等待最多 5 秒，确保消息发送成功
if (!task.Wait(TimeSpan.FromSeconds(5)))
{
AppLogger.Warn("LauncherIpc", "Report progress timeout after 5 seconds");
}
else
{
AppLogger.Info("LauncherIpc", $"Successfully reported stage: {stage}");
}
}
catch (Exception ex)
{
AppLogger.Warn("LauncherIpc", $"Failed to report progress synchronously: {ex.Message}");
}
}
private void ApplyDesignTimeTheme()
{
RequestedThemeVariant = ThemeVariant.Light;
@@ -927,10 +975,36 @@ public partial class App : Application
AppLogger.Info("App", $"Main window created. Reason='{reason}'. LogFile={AppLogger.LogFilePath}");
LogBrowserStartupDiagnostics();
SetDesktopShellState(DesktopShellState.ForegroundDesktop, $"MainWindowCreated:{reason}");
ReportStartupProgress(StartupStage.Ready, 100, "就绪");
// 延迟报告 Ready 直到窗口实际打开并可见
// 使用 Opened 事件确保所有资源已加载完毕
mainWindow.Opened += OnMainWindowOpened;
return mainWindow;
}
/// <summary>
/// 主窗口打开完成事件 - 此时所有组件、资源及功能模块均已完全加载
/// </summary>
private void OnMainWindowOpened(object? sender, EventArgs e)
{
if (sender is MainWindow mainWindow)
{
mainWindow.Opened -= OnMainWindowOpened;
AppLogger.Info("App", "Main window opened and ready. Reporting Ready to Launcher...");
// 完成系统初始化加载项
_loadingStateManager?.CompleteItem("system.init", "系统初始化完成");
// 报告 Ready 状态，启动器可以安全关闭 Splash 窗口
ReportStartupProgressSync(StartupStage.Ready, 100, "就绪");
// 停止加载状态上报
_loadingStateReporter?.Stop();
}
}
private MainWindow GetOrCreateMainWindow(
IClassicDesktopStyleApplicationLifetime desktop,
string reason)

380
LanMountainDesktop/Services/Loading/LoadingStateManager.cs Normal file
View File

@@ -0,0 +1,380 @@
using System.Collections.Concurrent;
using LanMountainDesktop.Shared.Contracts.Launcher;
namespace LanMountainDesktop.Services.Loading;
/// <summary>
/// 加载状态管理器 - 管理所有加载项的状态
/// </summary>
public class LoadingStateManager : IDisposable
{
private readonly ConcurrentDictionary<string, LoadingItem> _items = new();
private readonly ConcurrentDictionary<string, DateTimeOffset> _startTimes = new();
private readonly object _lock = new();
private readonly CancellationTokenSource _cts = new();
/// <summary>
/// 状态变更事件
/// </summary>
public event EventHandler<LoadingStateChangedEventArgs>? StateChanged;
/// <summary>
/// 整体进度变更事件
/// </summary>
public event EventHandler<OverallProgressChangedEventArgs>? OverallProgressChanged;
/// <summary>
/// 当前启动阶段
/// </summary>
public StartupStage CurrentStage { get; private set; } = StartupStage.Initializing;
/// <summary>
/// 整体进度百分比
/// </summary>
public int OverallProgressPercent { get; private set; }
/// <summary>
/// 是否正在加载
/// </summary>
public bool IsLoading => _items.Values.Any(i => i.State == LoadingState.InProgress);
/// <summary>
/// 是否有错误
/// </summary>
public bool HasErrors => _items.Values.Any(i => i.State == LoadingState.Failed);
/// <summary>
/// 获取所有加载项
/// </summary>
public IReadOnlyCollection<LoadingItem> GetAllItems() => _items.Values.ToList();
/// <summary>
/// 获取活动的加载项
/// </summary>
public IReadOnlyCollection<LoadingItem> GetActiveItems() =>
_items.Values.Where(i => i.State is LoadingState.InProgress or LoadingState.Pending).ToList();
/// <summary>
/// 注册加载项
/// </summary>
public LoadingItem RegisterItem(
string id,
LoadingItemType type,
string name,
string? description = null,
Dictionary<string, string>? metadata = null)
{
var item = new LoadingItem
{
Id = id,
Type = type,
Name = name,
Description = description,
State = LoadingState.Pending,
ProgressPercent = 0,
Metadata = metadata,
Timestamp = DateTimeOffset.UtcNow
};
_items[id] = item;
StateChanged?.Invoke(this, new LoadingStateChangedEventArgs
{
Item = item,
PreviousState = null,
CurrentState = item.State
});
return item;
}
/// <summary>
/// 开始加载
/// </summary>
public void StartItem(string id, string? message = null)
{
if (!_items.TryGetValue(id, out var item))
return;
var previousState = item.State;
var startTime = DateTimeOffset.UtcNow;
_startTimes[id] = startTime;
var updatedItem = item with
{
State = LoadingState.InProgress,
StartTime = startTime,
Message = message ?? $"正在加载 {item.Name}...",
Timestamp = DateTimeOffset.UtcNow
};
_items[id] = updatedItem;
StateChanged?.Invoke(this, new LoadingStateChangedEventArgs
{
Item = updatedItem,
PreviousState = previousState,
CurrentState = updatedItem.State
});
UpdateOverallProgress();
}
/// <summary>
/// 更新进度
/// </summary>
public void UpdateProgress(string id, int percent, string? message = null, int? estimatedRemainingSeconds = null)
{
if (!_items.TryGetValue(id, out var item))
return;
var updatedItem = item with
{
ProgressPercent = Math.Clamp(percent, 0, 100),
Message = message ?? item.Message,
EstimatedRemainingSeconds = estimatedRemainingSeconds,
Timestamp = DateTimeOffset.UtcNow
};
_items[id] = updatedItem;
StateChanged?.Invoke(this, new LoadingStateChangedEventArgs
{
Item = updatedItem,
PreviousState = item.State,
CurrentState = updatedItem.State,
IsProgressUpdate = true
});
UpdateOverallProgress();
}
/// <summary>
/// 完成加载
/// </summary>
public void CompleteItem(string id, string? message = null)
{
if (!_items.TryGetValue(id, out var item))
return;
var previousState = item.State;
var endTime = DateTimeOffset.UtcNow;
_startTimes.TryRemove(id, out _);
var updatedItem = item with
{
State = LoadingState.Completed,
ProgressPercent = 100,
EndTime = endTime,
Message = message ?? $"{item.Name} 加载完成",
Timestamp = DateTimeOffset.UtcNow
};
_items[id] = updatedItem;
StateChanged?.Invoke(this, new LoadingStateChangedEventArgs
{
Item = updatedItem,
PreviousState = previousState,
CurrentState = updatedItem.State
});
UpdateOverallProgress();
}
/// <summary>
/// 标记失败
/// </summary>
public void FailItem(string id, string errorMessage, string? details = null)
{
if (!_items.TryGetValue(id, out var item))
return;
var previousState = item.State;
var endTime = DateTimeOffset.UtcNow;
_startTimes.TryRemove(id, out _);
var fullErrorMessage = string.IsNullOrEmpty(details)
? errorMessage
: $"{errorMessage}: {details}";
var updatedItem = item with
{
State = LoadingState.Failed,
ErrorMessage = fullErrorMessage,
EndTime = endTime,
Message = $"{item.Name} 加载失败",
Timestamp = DateTimeOffset.UtcNow
};
_items[id] = updatedItem;
StateChanged?.Invoke(this, new LoadingStateChangedEventArgs
{
Item = updatedItem,
PreviousState = previousState,
CurrentState = updatedItem.State
});
UpdateOverallProgress();
}
/// <summary>
/// 标记超时
/// </summary>
public void TimeoutItem(string id, string? message = null)
{
if (!_items.TryGetValue(id, out var item))
return;
var previousState = item.State;
var endTime = DateTimeOffset.UtcNow;
_startTimes.TryRemove(id, out _);
var updatedItem = item with
{
State = LoadingState.Timeout,
EndTime = endTime,
Message = message ?? $"{item.Name} 加载超时",
Timestamp = DateTimeOffset.UtcNow
};
_items[id] = updatedItem;
StateChanged?.Invoke(this, new LoadingStateChangedEventArgs
{
Item = updatedItem,
PreviousState = previousState,
CurrentState = updatedItem.State
});
UpdateOverallProgress();
}
/// <summary>
/// 设置当前启动阶段
/// </summary>
public void SetStage(StartupStage stage, string? message = null)
{
CurrentStage = stage;
OverallProgressChanged?.Invoke(this, new OverallProgressChangedEventArgs
{
Stage = stage,
OverallProgressPercent = OverallProgressPercent,
Message = message
});
}
/// <summary>
/// 更新整体进度
/// </summary>
private void UpdateOverallProgress()
{
lock (_lock)
{
var items = _items.Values.ToList();
if (items.Count == 0)
{
OverallProgressPercent = 0;
return;
}
// 计算加权进度
var totalWeight = items.Count;
var completedWeight = items.Count(i => i.State == LoadingState.Completed);
var inProgressWeight = items
.Where(i => i.State == LoadingState.InProgress)
.Sum(i => i.ProgressPercent / 100.0);
var progress = (int)((completedWeight + inProgressWeight) / totalWeight * 100);
OverallProgressPercent = Math.Clamp(progress, 0, 100);
OverallProgressChanged?.Invoke(this, new OverallProgressChangedEventArgs
{
Stage = CurrentStage,
OverallProgressPercent = OverallProgressPercent
});
}
}
/// <summary>
/// 获取加载状态消息
/// </summary>
public LoadingStateMessage GetLoadingStateMessage()
{
var items = _items.Values.ToList();
var activeItems = items.Where(i => i.State is LoadingState.InProgress or LoadingState.Pending).ToList();
var errorItems = items.Where(i => i.State == LoadingState.Failed).ToList();
return new LoadingStateMessage
{
Stage = CurrentStage,
OverallProgressPercent = OverallProgressPercent,
ActiveItems = activeItems,
CompletedCount = items.Count(i => i.State == LoadingState.Completed),
TotalCount = items.Count,
HasErrors = errorItems.Any(),
ErrorMessages = errorItems.Select(i => $"{i.Name}: {i.ErrorMessage}").ToList()
};
}
/// <summary>
/// 清理所有加载项
/// </summary>
public void Clear()
{
_items.Clear();
_startTimes.Clear();
OverallProgressPercent = 0;
}
/// <summary>
/// 检查超时项
/// </summary>
public void CheckTimeouts(TimeSpan timeout)
{
var now = DateTimeOffset.UtcNow;
var timeoutItems = _items.Values
.Where(i => i.State == LoadingState.InProgress && i.StartTime.HasValue)
.Where(i => now - i.StartTime.Value > timeout)
.ToList();
foreach (var item in timeoutItems)
{
TimeoutItem(item.Id, $"{item.Name} 加载超时（超过 {timeout.TotalSeconds} 秒）");
}
}
public void Dispose()
{
_cts.Cancel();
_items.Clear();
_startTimes.Clear();
}
}
/// <summary>
/// 加载状态变更事件参数
/// </summary>
public class LoadingStateChangedEventArgs : EventArgs
{
public required LoadingItem Item { get; init; }
public LoadingState? PreviousState { get; init; }
public required LoadingState CurrentState { get; init; }
public bool IsProgressUpdate { get; init; }
}
/// <summary>
/// 整体进度变更事件参数
/// </summary>
public class OverallProgressChangedEventArgs : EventArgs
{
public StartupStage Stage { get; init; }
public int OverallProgressPercent { get; init; }
public string? Message { get; init; }
}

360
LanMountainDesktop/Services/Loading/LoadingStateReporter.cs Normal file
View File

@@ -0,0 +1,360 @@
using System.Timers;
using LanMountainDesktop.Services.Launcher;
using LanMountainDesktop.Shared.Contracts.Launcher;
namespace LanMountainDesktop.Services.Loading;
/// <summary>
/// 加载状态上报器 - 将加载状态实时上报给 Launcher
/// </summary>
public class LoadingStateReporter : IDisposable
{
private readonly LoadingStateManager _manager;
private readonly LauncherIpcClient? _ipcClient;
private readonly System.Timers.Timer _reportTimer;
private readonly object _lock = new();
private bool _isDisposed;
/// <summary>
/// 上报间隔（毫秒）
/// </summary>
public int ReportIntervalMs { get; set; } = 100;
/// <summary>
/// 是否启用批量上报优化
/// </summary>
public bool EnableBatching { get; set; } = true;
/// <summary>
/// 最小上报间隔（毫秒），用于限制高频更新
/// </summary>
public int MinReportIntervalMs { get; set; } = 50;
private DateTimeOffset _lastReportTime = DateTimeOffset.MinValue;
private DetailedProgressMessage? _pendingMessage;
private bool _hasPendingMessage;
public LoadingStateReporter(
LoadingStateManager manager,
LauncherIpcClient? ipcClient = null)
{
_manager = manager ?? throw new ArgumentNullException(nameof(manager));
_ipcClient = ipcClient;
// 创建定时上报定时器
_reportTimer = new System.Timers.Timer(ReportIntervalMs);
_reportTimer.Elapsed += OnReportTimerElapsed;
_reportTimer.AutoReset = true;
// 订阅状态变更事件
_manager.StateChanged += OnStateChanged;
_manager.OverallProgressChanged += OnOverallProgressChanged;
}
/// <summary>
/// 启动上报
/// </summary>
public void Start()
{
if (_isDisposed) return;
_reportTimer.Start();
AppLogger.Info("LoadingStateReporter", "Loading state reporter started");
}
/// <summary>
/// 停止上报
/// </summary>
public void Stop()
{
_reportTimer.Stop();
// 发送任何待处理的消息
FlushPendingMessage();
AppLogger.Info("LoadingStateReporter", "Loading state reporter stopped");
}
/// <summary>
/// 立即上报当前状态
/// </summary>
public async Task ReportImmediatelyAsync()
{
if (_isDisposed || _ipcClient == null) return;
var message = CreateDetailedProgressMessage();
await SendMessageAsync(message);
}
/// <summary>
/// 上报单个加载项的进度
/// </summary>
public async Task ReportItemProgressAsync(string itemId, int percent, string? message = null)
{
if (_isDisposed || _ipcClient == null) return;
var item = _manager.GetAllItems().FirstOrDefault(i => i.Id == itemId);
if (item == null) return;
var updatedItem = item with
{
ProgressPercent = percent,
Message = message ?? item.Message,
Timestamp = DateTimeOffset.UtcNow
};
var progressMessage = new DetailedProgressMessage
{
Stage = _manager.CurrentStage,
ProgressPercent = _manager.OverallProgressPercent,
CurrentItem = updatedItem,
AllItems = _manager.GetAllItems().ToList(),
Message = message,
IsMajorUpdate = false
};
await SendMessageAsync(progressMessage);
}
/// <summary>
/// 上报阶段变更
/// </summary>
public async Task ReportStageChangeAsync(StartupStage stage, string? message = null)
{
if (_isDisposed || _ipcClient == null) return;
var progressMessage = new DetailedProgressMessage
{
Stage = stage,
ProgressPercent = _manager.OverallProgressPercent,
AllItems = _manager.GetAllItems().ToList(),
Message = message ?? $"进入阶段: {stage}",
IsMajorUpdate = true
};
await SendMessageAsync(progressMessage);
}
/// <summary>
/// 上报错误
/// </summary>
public async Task ReportErrorAsync(string errorMessage, string? details = null)
{
if (_isDisposed || _ipcClient == null) return;
var fullMessage = string.IsNullOrEmpty(details)
? errorMessage
: $"{errorMessage}: {details}";
var progressMessage = new DetailedProgressMessage
{
Stage = _manager.CurrentStage,
ProgressPercent = _manager.OverallProgressPercent,
AllItems = _manager.GetAllItems().ToList(),
Message = fullMessage,
IsMajorUpdate = true
};
await SendMessageAsync(progressMessage);
}
/// <summary>
/// 状态变更事件处理
/// </summary>
private void OnStateChanged(object? sender, LoadingStateChangedEventArgs e)
{
if (_isDisposed) return;
// 重要状态变更立即上报
if (e.CurrentState is LoadingState.Completed or LoadingState.Failed or LoadingState.Timeout)
{
_ = Task.Run(async () =>
{
try
{
await ReportImmediatelyAsync();
}
catch (Exception ex)
{
AppLogger.Warn("LoadingStateReporter", $"Failed to report state change: {ex.Message}");
}
});
}
else
{
// 其他状态变更标记为待处理
QueueMessage(CreateDetailedProgressMessage());
}
}
/// <summary>
/// 整体进度变更事件处理
/// </summary>
private void OnOverallProgressChanged(object? sender, OverallProgressChangedEventArgs e)
{
if (_isDisposed) return;
QueueMessage(CreateDetailedProgressMessage(e.Message));
}
/// <summary>
/// 定时上报处理
/// </summary>
private void OnReportTimerElapsed(object? sender, ElapsedEventArgs e)
{
FlushPendingMessage();
}
/// <summary>
/// 将消息加入待处理队列
/// </summary>
private void QueueMessage(DetailedProgressMessage message)
{
if (!EnableBatching)
{
// 如果不启用批量，立即发送
_ = Task.Run(async () => await SendMessageAsync(message));
return;
}
lock (_lock)
{
_pendingMessage = message;
_hasPendingMessage = true;
}
}
/// <summary>
/// 刷新待处理消息
/// </summary>
private void FlushPendingMessage()
{
DetailedProgressMessage? message;
lock (_lock)
{
if (!_hasPendingMessage) return;
message = _pendingMessage;
_pendingMessage = null;
_hasPendingMessage = false;
}
if (message != null)
{
_ = Task.Run(async () =>
{
try
{
await SendMessageAsync(message);
}
catch (Exception ex)
{
AppLogger.Warn("LoadingStateReporter", $"Failed to flush pending message: {ex.Message}");
}
});
}
}
/// <summary>
/// 创建详细的进度消息
/// </summary>
private DetailedProgressMessage CreateDetailedProgressMessage(string? message = null)
{
var activeItems = _manager.GetActiveItems().ToList();
var currentItem = activeItems.FirstOrDefault();
return new DetailedProgressMessage
{
Stage = _manager.CurrentStage,
ProgressPercent = _manager.OverallProgressPercent,
CurrentItem = currentItem,
AllItems = _manager.GetAllItems().ToList(),
Message = message ?? currentItem?.Message,
IsMajorUpdate = false
};
}
/// <summary>
/// 发送消息
/// </summary>
private async Task SendMessageAsync(DetailedProgressMessage message)
{
if (_ipcClient == null) return;
// 检查最小上报间隔
var now = DateTimeOffset.UtcNow;
var elapsed = now - _lastReportTime;
if (elapsed.TotalMilliseconds < MinReportIntervalMs)
{
await Task.Delay(MinReportIntervalMs - (int)elapsed.TotalMilliseconds);
}
try
{
// 转换为 StartupProgressMessage 以保持兼容性
var baseMessage = new StartupProgressMessage
{
Stage = message.Stage,
ProgressPercent = message.ProgressPercent,
Message = FormatMessage(message),
Timestamp = DateTimeOffset.UtcNow
};
await _ipcClient.ReportProgressAsync(baseMessage);
_lastReportTime = DateTimeOffset.UtcNow;
}
catch (Exception ex)
{
AppLogger.Warn("LoadingStateReporter", $"Failed to send message: {ex.Message}");
}
}
/// <summary>
/// 格式化消息
/// </summary>
private string FormatMessage(DetailedProgressMessage message)
{
var parts = new List<string>();
if (message.CurrentItem != null)
{
parts.Add($"[{message.CurrentItem.Type}] {message.CurrentItem.Name}");
if (message.CurrentItem.ProgressPercent > 0)
{
parts.Add($"{message.CurrentItem.ProgressPercent}%");
}
}
if (!string.IsNullOrEmpty(message.Message))
{
parts.Add(message.Message);
}
var completedCount = message.AllItems?.Count(i => i.State == LoadingState.Completed) ?? 0;
var totalCount = message.AllItems?.Count ?? 0;
if (totalCount > 0)
{
parts.Add($"({completedCount}/{totalCount})");
}
return string.Join(" - ", parts);
}
public void Dispose()
{
if (_isDisposed) return;
_isDisposed = true;
Stop();
_reportTimer.Elapsed -= OnReportTimerElapsed;
_reportTimer.Dispose();
_manager.StateChanged -= OnStateChanged;
_manager.OverallProgressChanged -= OnOverallProgressChanged;
}
}

201
LanMountainDesktop/Services/Loading/LoadingStateUsageExample.cs Normal file
View File

@@ -0,0 +1,201 @@
using LanMountainDesktop.Shared.Contracts.Launcher;
namespace LanMountainDesktop.Services.Loading;
/// <summary>
/// 加载状态管理使用示例
/// </summary>
public static class LoadingStateUsageExample
{
/// <summary>
/// 示例：插件加载
/// </summary>
public static async Task LoadPluginsExample(LoadingStateManager manager)
{
// 注册插件加载项
var pluginItem = manager.RegisterItem(
"plugins.core",
LoadingItemType.Plugin,
"核心插件",
"加载系统核心插件",
new Dictionary<string, string> { { "version", "1.0.0" } });
// 开始加载
manager.StartItem("plugins.core", "正在下载插件...");
try
{
// 模拟下载进度
for (int i = 0; i <= 100; i += 10)
{
manager.UpdateProgress(
"plugins.core",
i,
$"正在下载... {i}%",
estimatedRemainingSeconds: (100 - i) / 10);
await Task.Delay(100);
}
// 完成加载
manager.CompleteItem("plugins.core", "核心插件加载完成");
}
catch (Exception ex)
{
// 标记失败
manager.FailItem("plugins.core", "插件加载失败", ex.Message);
}
}
/// <summary>
/// 示例：组件加载
/// </summary>
public static async Task LoadComponentsExample(LoadingStateManager manager)
{
var components = new[]
{
("comp.weather", "天气组件"),
("comp.clock", "时钟组件"),
("comp.calendar", "日历组件")
};
foreach (var (id, name) in components)
{
// 注册组件
manager.RegisterItem(id, LoadingItemType.Component, name);
// 开始加载
manager.StartItem(id, $"正在加载 {name}...");
// 模拟加载过程
for (int i = 0; i <= 100; i += 20)
{
manager.UpdateProgress(id, i);
await Task.Delay(50);
}
// 完成
manager.CompleteItem(id, $"{name} 加载完成");
}
}
/// <summary>
/// 示例：网络资源加载
/// </summary>
public static async Task LoadNetworkResourcesExample(LoadingStateManager manager)
{
// 注册网络加载项
manager.RegisterItem(
"network.config",
LoadingItemType.Network,
"配置数据",
"从服务器获取最新配置");
manager.StartItem("network.config", "正在连接服务器...");
try
{
// 模拟网络请求
await Task.Delay(1000);
manager.UpdateProgress("network.config", 50, "正在下载数据...");
await Task.Delay(1000);
manager.CompleteItem("network.config", "配置数据已更新");
}
catch (Exception ex)
{
manager.FailItem("network.config", "网络请求失败", ex.Message);
}
}
/// <summary>
/// 示例：带超时的加载
/// </summary>
public static async Task LoadWithTimeoutExample(
LoadingStateManager manager,
LoadingTimeoutHandler timeoutHandler)
{
// 设置超时时间为 10 秒
timeoutHandler.SetItemTimeout("data.heavy", TimeSpan.FromSeconds(10));
// 注册加载项
manager.RegisterItem(
"data.heavy",
LoadingItemType.Data,
"大数据处理",
"处理大量数据，可能需要较长时间");
// 订阅超时事件
timeoutHandler.ItemTimeout += (s, e) =>
{
Console.WriteLine($"加载项 '{e.ItemName}' 超时！");
};
timeoutHandler.ItemRetry += (s, e) =>
{
Console.WriteLine($"正在重试 '{e.ItemName}' ({e.RetryCount}/{e.MaxRetryCount})...");
};
// 开始加载
manager.StartItem("data.heavy", "正在处理数据...");
// 模拟长时间操作
await Task.Delay(15000);
// 完成
manager.CompleteItem("data.heavy", "数据处理完成");
}
/// <summary>
/// 示例：完整启动流程
/// </summary>
public static async Task FullStartupExample(
LoadingStateManager manager,
LoadingStateReporter reporter,
LoadingTimeoutHandler timeoutHandler)
{
// 启动超时处理器
timeoutHandler.Start();
// 设置阶段
manager.SetStage(StartupStage.Initializing, "开始初始化...");
// 1. 系统初始化
manager.RegisterItem("system.init", LoadingItemType.System, "系统初始化");
manager.StartItem("system.init");
await Task.Delay(500);
manager.CompleteItem("system.init");
// 2. 加载设置
manager.SetStage(StartupStage.LoadingSettings, "正在加载设置...");
manager.RegisterItem("settings.load", LoadingItemType.Settings, "用户设置");
manager.StartItem("settings.load");
await Task.Delay(800);
manager.CompleteItem("settings.load");
// 3. 加载插件
manager.SetStage(StartupStage.LoadingPlugins, "正在加载插件...");
await LoadPluginsExample(manager);
// 4. 加载组件
await LoadComponentsExample(manager);
// 5. 加载网络资源
await LoadNetworkResourcesExample(manager);
// 6. 初始化界面
manager.SetStage(StartupStage.InitializingUI, "正在初始化界面...");
manager.RegisterItem("ui.init", LoadingItemType.System, "界面初始化");
manager.StartItem("ui.init");
await Task.Delay(600);
manager.CompleteItem("ui.init");
// 完成
manager.SetStage(StartupStage.Ready, "加载完成");
// 停止超时处理器
timeoutHandler.Stop();
}
}

274
LanMountainDesktop/Services/Loading/LoadingTimeoutHandler.cs Normal file
View File

@@ -0,0 +1,274 @@
using System.Timers;
namespace LanMountainDesktop.Services.Loading;
/// <summary>
/// 加载超时处理器 - 监控加载项超时并执行相应处理
/// </summary>
public class LoadingTimeoutHandler : IDisposable
{
private readonly LoadingStateManager _manager;
private readonly System.Timers.Timer _checkTimer;
private readonly Dictionary<string, TimeSpan> _itemTimeouts = new();
private readonly Dictionary<string, int> _retryCounts = new();
private readonly object _lock = new();
private bool _isDisposed;
/// <summary>
/// 默认超时时间
/// </summary>
public TimeSpan DefaultTimeout { get; set; } = TimeSpan.FromSeconds(30);
/// <summary>
/// 最大重试次数
/// </summary>
public int MaxRetryCount { get; set; } = 3;
/// <summary>
/// 检查间隔
/// </summary>
public TimeSpan CheckInterval { get; set; } = TimeSpan.FromSeconds(5);
/// <summary>
/// 超时事件
/// </summary>
public event EventHandler<LoadingTimeoutEventArgs>? ItemTimeout;
/// <summary>
/// 重试事件
/// </summary>
public event EventHandler<LoadingRetryEventArgs>? ItemRetry;
/// <summary>
/// 最终失败事件（超过最大重试次数）
/// </summary>
public event EventHandler<LoadingTimeoutEventArgs>? ItemFailed;
public LoadingTimeoutHandler(LoadingStateManager manager)
{
_manager = manager ?? throw new ArgumentNullException(nameof(manager));
_checkTimer = new System.Timers.Timer(CheckInterval.TotalMilliseconds);
_checkTimer.Elapsed += OnCheckTimerElapsed;
_checkTimer.AutoReset = true;
// 订阅状态变更事件
_manager.StateChanged += OnStateChanged;
}
/// <summary>
/// 启动监控
/// </summary>
public void Start()
{
if (_isDisposed) return;
_checkTimer.Start();
AppLogger.Info("LoadingTimeoutHandler", "Timeout handler started");
}
/// <summary>
/// 停止监控
/// </summary>
public void Stop()
{
_checkTimer.Stop();
AppLogger.Info("LoadingTimeoutHandler", "Timeout handler stopped");
}
/// <summary>
/// 为特定加载项设置超时
/// </summary>
public void SetItemTimeout(string itemId, TimeSpan timeout)
{
lock (_lock)
{
_itemTimeouts[itemId] = timeout;
}
}
/// <summary>
/// 获取加载项的超时时间
/// </summary>
public TimeSpan GetItemTimeout(string itemId)
{
lock (_lock)
{
return _itemTimeouts.TryGetValue(itemId, out var timeout) ? timeout : DefaultTimeout;
}
}
/// <summary>
/// 重置重试计数
/// </summary>
public void ResetRetryCount(string itemId)
{
lock (_lock)
{
_retryCounts[itemId] = 0;
}
}
/// <summary>
/// 定时检查超时
/// </summary>
private void OnCheckTimerElapsed(object? sender, ElapsedEventArgs e)
{
if (_isDisposed) return;
try
{
var activeItems = _manager.GetActiveItems().ToList();
var now = DateTimeOffset.UtcNow;
foreach (var item in activeItems)
{
if (!item.StartTime.HasValue) continue;
var timeout = GetItemTimeout(item.Id);
var elapsed = now - item.StartTime.Value;
if (elapsed > timeout)
{
HandleTimeout(item.Id, elapsed);
}
}
}
catch (Exception ex)
{
AppLogger.Warn("LoadingTimeoutHandler", $"Error checking timeouts: {ex.Message}");
}
}
/// <summary>
/// 处理超时
/// </summary>
private void HandleTimeout(string itemId, TimeSpan elapsed)
{
lock (_lock)
{
var retryCount = _retryCounts.GetValueOrDefault(itemId, 0);
if (retryCount < MaxRetryCount)
{
// 重试
_retryCounts[itemId] = retryCount + 1;
var item = _manager.GetAllItems().FirstOrDefault(i => i.Id == itemId);
if (item != null)
{
AppLogger.Warn("LoadingTimeoutHandler",
$"Item '{item.Name}' timed out after {elapsed.TotalSeconds}s, retrying ({retryCount + 1}/{MaxRetryCount})...");
ItemRetry?.Invoke(this, new LoadingRetryEventArgs
{
ItemId = itemId,
ItemName = item.Name,
RetryCount = retryCount + 1,
MaxRetryCount = MaxRetryCount,
ElapsedTime = elapsed
});
// 重新启动该项
_manager.StartItem(itemId, $"第 {retryCount + 1} 次重试...");
}
}
else
{
// 最终失败
_retryCounts.Remove(itemId);
var item = _manager.GetAllItems().FirstOrDefault(i => i.Id == itemId);
if (item != null)
{
AppLogger.Error("LoadingTimeoutHandler",
$"Item '{item.Name}' failed after {MaxRetryCount} retries ({elapsed.TotalSeconds}s)");
var args = new LoadingTimeoutEventArgs
{
ItemId = itemId,
ItemName = item.Name,
ElapsedTime = elapsed,
RetryCount = MaxRetryCount,
IsFinalFailure = true
};
ItemTimeout?.Invoke(this, args);
ItemFailed?.Invoke(this, args);
// 标记为失败
_manager.FailItem(itemId,
$"加载超时（超过 {elapsed.TotalSeconds:F0} 秒）",
$"已重试 {MaxRetryCount} 次但仍失败");
}
}
}
}
/// <summary>
/// 状态变更事件处理
/// </summary>
private void OnStateChanged(object? sender, LoadingStateChangedEventArgs e)
{
// 当项完成或失败时，清除重试计数
if (e.CurrentState is LoadingState.Completed or LoadingState.Failed or LoadingState.Cancelled)
{
lock (_lock)
{
_retryCounts.Remove(e.Item.Id);
}
}
// 当项开始时，如果是第一次开始，初始化重试计数
if (e.CurrentState == LoadingState.InProgress &&
(e.PreviousState == null || e.PreviousState == LoadingState.Pending))
{
lock (_lock)
{
if (!_retryCounts.ContainsKey(e.Item.Id))
{
_retryCounts[e.Item.Id] = 0;
}
}
}
}
public void Dispose()
{
if (_isDisposed) return;
_isDisposed = true;
Stop();
_checkTimer.Elapsed -= OnCheckTimerElapsed;
_checkTimer.Dispose();
_manager.StateChanged -= OnStateChanged;
_itemTimeouts.Clear();
_retryCounts.Clear();
}
}
/// <summary>
/// 加载超时事件参数
/// </summary>
public class LoadingTimeoutEventArgs : EventArgs
{
public required string ItemId { get; init; }
public required string ItemName { get; init; }
public required TimeSpan ElapsedTime { get; init; }
public int RetryCount { get; init; }
public bool IsFinalFailure { get; init; }
}
/// <summary>
/// 加载重试事件参数
/// </summary>
public class LoadingRetryEventArgs : EventArgs
{
public required string ItemId { get; init; }
public required string ItemName { get; init; }
public required int RetryCount { get; init; }
public required int MaxRetryCount { get; init; }
public required TimeSpan ElapsedTime { get; init; }
}