using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Input;
using YuncangTrace.LocalService.Services;
using YuncangTrace.LocalService.Services.Edge;
using YuncangTrace.LocalService.Services.Hik;
using YuncangTrace.LocalService.Services.Scan;
using YuncangTrace.LocalService.Views;
namespace YuncangTrace.LocalService;
///
/// 主窗口:打包查询 / 扫码通道(设备服务开启后出现)/ 主体切换 / 设备服务
///
/// - **设备服务默认不开启**,入口在菜单「服务 → 开启设备服务」;
/// - 「开启设备服务」**只对主体管理员可见**(非管理员菜单项直接隐藏);
/// - 一个主体只允许一台设备在线:开启时服务端会把同主体其他设备踢下线(界面会先提示);
/// - 开启后自动启动「扫码服务」(TCP 收码 + 上报),并显示「扫码通道」页签;
/// - 菜单「工具 → 打开配置页」带令牌直接打开后台网页。
///
/// 关窗口**不是退出**:只是隐藏到托盘(本机服务得继续跑)。
/// 真正退出:托盘菜单「退出」,或点「退出登录」后再取消登录。
///
public partial class MainWindow : Window
{
private readonly LocalHttpServer _server;
private readonly AppSettings _settings;
private readonly Session _session;
private readonly ApiClient _api;
private readonly DeviceService _device;
private readonly ScanService _scan;
private readonly ScanTabView _scanTabView;
private readonly ScanRecordsView _scanRecordsView;
private readonly LabelCameraView _labelCameraView;
/// 运单回放查询(后端 `/api/web/pack-query`,用当前主体的用户令牌)
private readonly OrderQueryService _queryService;
/// 按时间回放:校验有没有录像 / 下载(走 RTSP 回放 + ffmpeg)
private readonly HikPlaybackService _playback;
/// 选路:有设备管理服务就把校验/下载交给它(共用 NVR 会话池)
private readonly StreamGateway _gateway;
/// MJPEG 转码管线(回放预览用;整个窗口共用一份,自动复用同一地址的流)
private readonly HikFfmpegService _ffmpeg = new();
/// 当前展示的查询结果(回放计划;没有工作台时不具备拉流条件)
private PackQuery? _currentQuery;
///
/// 「预览回放 / 下载录像」要用的流。
///
/// 查询命中后**自动**去录像机试拉:只要**任意一路**拉到录像就停止校验,
/// 此时这里放的是**全部**流(没录像的那几路下载时会自己跳过,避免合并不全);
/// 一路都没拉到则为空 —— 两个按钮也不显示。
///
private IReadOnlyList _validatedStreams = Array.Empty();
///
/// 这次查询是「跨网」:查询机连不到仓库的 NVR,下载只能由云端转给能访问 NVR 的扫码服务代取。
/// 由 的选路结果设置。
///
private bool _cloudDownload;
/// 录像机凭据缓存(同一台 NVR 只取一次密码;多路并行下载会同时访问)
private readonly ConcurrentDictionary _credentials = new();
/// 正在跑的回放下载任务的取消源
private CancellationTokenSource? _playbackCts;
/// 正在跑的「自动校验回放」的取消源(与下载分开:新查询只打断校验,不打断下载)
private CancellationTokenSource? _validateCts;
/// 最近一次下载/合并的输出目录(「打开目录」用)
private string? _lastOutputFolder;
/// 本次运行是否已尝试过「补发刷新令牌」(后端不支持时避免反复激活)
private bool _refreshBackfillTried;
/// 已经请求退出登录(主体校验失败时用):Loaded 后续逻辑不要再跑
private bool _returnToLogin;
/// 当前主体(登录后先拉一次;切换时更新)
private IReadOnlyList _subjects = Array.Empty();
/// 允许真正关闭窗口(退出登录 / 退出程序时由 App 置 true)
public bool AllowClose { get; set; }
/// 用户点了「退出登录」
public event Action? LogoutRequested;
/// 窗口被隐藏到托盘(用来弹一次气泡提示)
public event Action? HiddenToTray;
/// 菜单「帮助 → 检查更新」(交给 App 处理,复用启动时的检查逻辑)
public event Action? CheckUpdateRequested;
/// 菜单「服务 → 重启软件」(交给 App 处理:先退出再延迟拉起)
public event Action? RestartRequested;
public MainWindow(LocalHttpServer server, AppSettings settings, Session session, ApiClient api,
DeviceService device, ScanService scan, HikDeviceService hik, IReadOnlyList subjects,
StreamGateway gateway)
{
InitializeComponent();
_server = server;
_settings = settings;
_session = session;
_api = api;
_device = device;
_scan = scan;
_subjects = subjects;
_gateway = gateway;
_queryService = new OrderQueryService(() => _api, () => _settings.SubjectId, () => _session.Token);
_playback = new HikPlaybackService(hik);
// 扫码通道页:开启扫码服务后才显示(内容控件需要 ScanService,所以代码里建)
_scanTabView = new ScanTabView(_scan);
ScanTabHost.Content = _scanTabView;
// 扫码记录页(对应 AndroidScanCenter 的「通道回放」):与通道页一同显示/隐藏
_scanRecordsView = new ScanRecordsView(_scan);
RecordsTabHost.Content = _scanRecordsView;
// 面单摄像头页:单独一个页签(列表 + 最近识别到的条码),与扫码页一同显示/隐藏
_labelCameraView = new LabelCameraView(_scan);
LabelCameraTabHost.Content = _labelCameraView;
// ⚠️ 扫码**只**落本地记录 + 上报服务器(都发生在 ScanService 内部)。
// 界面上不再订阅扫码事件:历史版本会在每次扫码时自动查一次运单(还会连带自动校验回放),
// 用户看到的现象就是「没点查询,打包查询却一直在自动查」。运单查询只允许用户主动发起
// (输入框回车 / 点查询 / 网页或插件用 yuncang:// 协议叫醒)。
UserText.Text = $"已登录:{session.DisplayName}";
Loaded += async (_, _) =>
{
UpdateServerState();
UpdateVideoPathMenu();
UpdateNtpMenu();
await EnsureSubjectAsync();
if (_returnToLogin) return; // EnsureSubjectAsync 已请求退回登录页
UpdateDeviceMenu();
// 上次已经开着设备服务:服务模式由后台服务收码,本进程只做界面/配置
if (_device.Enabled)
{
if (AgentPaths.MachineMode)
{
_scan.Load();
_scanTabView.Refresh();
await EnsureAgentServiceAsync();
}
else
{
await StartScanServiceAsync();
}
}
};
Closing += OnClosing;
}
///
/// 被协议拉起 / 另一个实例把参数转过来时调用:yuncang://open?code=xxx
///
public void HandleLaunchUrl(string url)
{
AppLog.Write($"收到启动协议:{url}");
var code = ProtocolHelper.ParseCode(url);
if (code is null)
{
AppLog.Write("协议里没带 code,忽略");
return;
}
QueryBox.Text = code;
// 查打包时默认切回「打包查询」页签
MainTabs.SelectedIndex = 0;
_ = RunQueryAsync();
}
// ---------------- 主体 ----------------
///
/// 确定界面使用的当前主体:
/// 1) 账号下没有任何主体 → 提示后退回登录页(扫码服务仍按原主体继续跑);
/// 2) 已保存的主体仍属于当前登录账号 → 沿用;
/// 3) 不属于(换账号登录)→ 后台服务模式下不改服务配置,只把界面切到当前账号可用的主体;
/// 普通模式下清掉旧主体与设备本地状态;
/// 4) 没有保存过主体 → 自动选第一个可用的。
///
private async Task EnsureSubjectAsync()
{
try
{
if (_subjects.Count == 0) _subjects = await _api.SubjectsAsync(_session.Token);
}
catch (Exception ex)
{
AppLog.Write($"读取主体列表失败:{ex.Message}");
return;
}
// 一个主体都没有:这个账号在桌面端什么都做不了(查询、扫码、设备服务都要主体)
if (_subjects.Count == 0)
{
var keepService = AgentPaths.MachineMode && _device.Enabled;
AppLog.Write($"[subject] 当前账号没有任何主体,退回登录页(后台服务{(keepService ? "保留" : "未开启")})");
MessageBox.Show(this,
"当前账号下没有任何主体,无法使用桌面端。\n\n"
+ (keepService
? "后台扫码服务仍在按原主体扫码、上报,不受影响。\n如需停止请登录管理员账号后用「服务 → 关闭设备服务」。\n\n"
: "请先到网页端「主体 / 成员」创建主体。\n\n")
+ "点击「确定」后返回登录页。",
"无法使用", MessageBoxButton.OK, MessageBoxImage.Warning);
_returnToLogin = true;
LogoutRequested?.Invoke();
return;
}
var saved = _settings.SubjectId;
var current = saved > 0 ? _subjects.FirstOrDefault(item => item.Id == saved) : null;
if (current is not null && !current.Expired) return;
// 后台服务是独立进程,绑定的是它自己的主体:换账号登录不能把它的配置/令牌清掉
var serviceSubject = ServiceSubjectId;
if (saved > 0)
{
if (AgentPaths.MachineMode && serviceSubject == saved)
{
// 不弹窗:正常进主界面,提示统一显示在页签上方(见 UpdateDeviceMenu)
AppLog.Write($"[subject] 当前账号不属于后台服务主体 {saved},只切换界面主体");
var fallback = _subjects.FirstOrDefault(item => !item.Expired) ?? _subjects[0];
ApplySubject(fallback, announce: false);
return;
}
// 普通模式(或服务已不存在):旧主体失效,清掉设备本地状态
AppLog.Write($"[subject] 保存的主体 {saved} 不属于当前账号,已清除");
_settings.SubjectId = 0;
_settings.SubjectName = string.Empty;
_settings.SubjectRole = 2;
if (!AgentPaths.MachineMode && _device.Enabled) _device.ResetLocalState();
_settings.Save();
}
var usable = _subjects.FirstOrDefault(item => !item.Expired) ?? _subjects.FirstOrDefault();
if (usable is not null) ApplySubject(usable, announce: false);
else AppLog.Write("[subject] 账号下没有主体(网页端创建后重启本软件即可看到)");
}
private void ApplySubject(ApiSubject subject, bool announce = true)
{
var changed = _settings.SubjectId != subject.Id;
_settings.SubjectId = subject.Id;
_settings.SubjectName = subject.Name;
_settings.SubjectRole = subject.Role;
_settings.Save();
// 换主体后设备令牌不再属于当前主体:本地关掉(旧设备的令牌由服务端处理)
if (changed && _device.Enabled && !AgentPaths.MachineMode) _device.ResetLocalState();
// 菜单/页签/提示(含「服务主体与当前主体不一致」)跟着主体一起刷新
UpdateDeviceMenu();
if (announce)
{
MessageBox.Show(this,
$"已切换到主体「{subject.Display}」\n\n"
+ (subject.IsAdmin ? "你是该主体的管理员,可以开启设备服务。" : "你是普通成员,无法开启设备服务。"),
"切换主体", MessageBoxButton.OK, MessageBoxImage.Information);
}
}
private void UpdateContextText()
{
var subject = string.IsNullOrWhiteSpace(_settings.SubjectName) ? "未选择" : _settings.SubjectName;
// 后台服务绑定的主体可能与当前登录账号无关(换账号登录):此时本界面只能查自己账号的主体
var serviceSubjectId = ServiceSubjectId;
var mismatch = AgentPaths.MachineMode
&& _device.Enabled
&& serviceSubjectId > 0
&& serviceSubjectId != _settings.SubjectId;
var device = _device.Enabled
? $"已开启({_settings.DeviceSn}" + (AgentPaths.MachineMode ? ",后台服务" : "") + ")"
: "未开启";
if (mismatch) device += $",服务主体 id={serviceSubjectId}";
ContextText.Text = $"主体:{subject} · 设备服务:{device}";
ContextText.ToolTip = $"主体:{subject}\n设备服务:{device}"
+ (AgentPaths.MachineMode ? $"\n后台服务:{ServiceInstaller.QueryState()}\n数据目录:{AgentPaths.MachineRoot}" : string.Empty)
+ (mismatch
? $"\n\n注意:后台服务按主体 id={serviceSubjectId} 运行,当前账号不属于该主体。\n"
+ "本界面的查询只针对当前主体;要停止后台服务请用「服务 → 关闭设备服务」。"
: string.Empty);
MenuSubject.Header = $"当前主体:{subject}";
}
private async void SwitchSubject_Click(object sender, RoutedEventArgs e)
{
// 后台服务绑定的是「服务主体」的设备令牌:只有当前界面主体就是服务主体时才必须先停服务,
// 否则扫码会按旧主体的令牌上报。换账号登录后两者已经不一致,切界面主体不影响服务。
var boundToCurrentSubject = AgentPaths.MachineMode
&& _device.Enabled
&& ServiceSubjectId == _settings.SubjectId;
if (boundToCurrentSubject)
{
MessageBox.Show(this,
"后台扫码服务正在运行(绑定当前主体)。\n\n如需切换主体,请先在「服务 → 关闭设备服务」里停止后台服务。",
"切换主体", MessageBoxButton.OK, MessageBoxImage.Information);
return;
}
try
{
_subjects = await _api.SubjectsAsync(_session.Token);
}
catch (Exception ex)
{
MessageBox.Show(this, $"读取主体列表失败:{ex.Message}", "切换主体",
MessageBoxButton.OK, MessageBoxImage.Warning);
return;
}
if (_subjects.Count == 0)
{
MessageBox.Show(this, "账号下还没有主体。请先到网页端「主体 / 成员」创建主体。", "切换主体",
MessageBoxButton.OK, MessageBoxImage.Information);
return;
}
var picker = new SubjectPickerWindow(_subjects, _settings.SubjectId) { Owner = this };
if (picker.ShowDialog() != true || picker.SelectedSubject is null) return;
ApplySubject(picker.SelectedSubject);
// 新主体如果是管理员且之前开着设备服务:直接在新主体下重新开启(会踢掉该主体的旧设备)
if (_device.Enabled && _settings.SubjectRole == 1)
{
var answer = MessageBox.Show(this,
$"设备服务已在新主体「{_settings.SubjectName}」下重新开启?\n\n"
+ "注意:这会踢掉该主体原本在线的设备。",
"设备服务", MessageBoxButton.YesNo, MessageBoxImage.Question);
if (answer == MessageBoxResult.Yes) await EnableDeviceAsync(silentConfirm: true);
}
UpdateDeviceMenu();
}
// ---------------- 设备服务 ----------------
private void UpdateDeviceMenu()
{
var isAdmin = _settings.SubjectRole == 1 && _settings.SubjectId > 0;
// 非管理员看不到「开启设备服务」
MenuEnableDevice.Visibility = isAdmin && !_device.Enabled ? Visibility.Visible : Visibility.Collapsed;
MenuDisableDevice.Visibility = _device.Enabled ? Visibility.Visible : Visibility.Collapsed;
// 后台服务跑在别的主体:普通成员不该看见那台服务的数据(本地文件属于服务的主体,与当前账号无关)
var mismatch = ServiceSubjectMismatch;
var canSeeServiceData = !mismatch || isAdmin;
// 扫码通道 / 扫码记录 / 面单摄像头页签只在「扫码服务开着」时出现
var scanTabs = _device.Enabled && canSeeServiceData ? Visibility.Visible : Visibility.Collapsed;
ScanTab.Visibility = scanTabs;
RecordsTab.Visibility = scanTabs;
LabelCameraTab.Visibility = scanTabs;
if (scanTabs == Visibility.Collapsed && MainTabs.SelectedIndex >= 1) MainTabs.SelectedIndex = 0;
// 服务主体不一致:统一显示在页签上方(不弹窗,正常进界面)
SetMainNotice(mismatch
? $"当前账号不属于后台扫码服务绑定的主体(id={ServiceSubjectId}),后台服务仍按原主体扫码、上报,不受影响。"
+ (isAdmin
? $"如需在当前主体「{_settings.SubjectName}」扫码,请先「服务 → 关闭设备服务」,再「开启设备服务」重新绑定。"
: "你不是当前主体的管理员,看不到后台服务的扫码数据,也无法开启设备服务。")
: null);
// NTP 校时属于服务模式:设备服务开着才显示(开启后强制启用,不能停用)
MenuNtp.Visibility = scanTabs;
MenuNtpStatus.Visibility = scanTabs;
// 令牌续期只对「后台服务」有意义
var machine = _device.Enabled && AgentPaths.MachineMode;
MenuRefreshToken.Visibility = machine ? Visibility.Visible : Visibility.Collapsed;
MenuTokenStatus.Visibility = machine ? Visibility.Visible : Visibility.Collapsed;
if (machine) UpdateTokenStatus();
UpdateContextText();
}
/// 页签上方的主体/服务不一致提示(null / 空 = 隐藏)
private void SetMainNotice(string? text)
{
if (string.IsNullOrWhiteSpace(text))
{
SubjectNoticeText.Text = string.Empty;
SubjectNoticeBar.Visibility = Visibility.Collapsed;
return;
}
SubjectNoticeText.Text = text;
SubjectNoticeBar.Visibility = Visibility.Visible;
}
/// 菜单里的设备令牌状态(到期时间取自 agent-token.json)
private void UpdateTokenStatus()
{
var token = AgentFiles.LoadToken();
var status = AgentFiles.LoadStatus();
if (token?.ExpiresAt is { } expiresAt)
{
MenuTokenStatus.Header = $"设备令牌:{expiresAt:yyyy-MM-dd} 到期";
}
else
{
MenuTokenStatus.Header = "设备令牌:—";
}
if (status?.LastTokenRefreshAt is { } refreshedAt)
{
MenuTokenStatus.Header += $"({refreshedAt:MM-dd HH:mm} 已续期)";
}
}
/// 手动让后台服务用刷新令牌续期一次(测试/排障)
private void RefreshDeviceToken_Click(object sender, RoutedEventArgs e)
{
if (!AgentPaths.MachineMode)
{
MessageBox.Show(this, "当前不是服务模式(后台服务未运行),不需要在这里续期。",
"设备令牌", MessageBoxButton.OK, MessageBoxImage.Information);
return;
}
AgentFiles.QueueCommand(command => command.RefreshTokenAt = DateTime.UtcNow);
AppLog.Write("[agent] 已请求后台服务立即续期设备令牌");
MessageBox.Show(this,
"已通知后台服务续期设备令牌。\n\n几秒后可重新打开本菜单查看「设备令牌:… 到期(… 已续期)」,"
+ "服务日志里会有「设备令牌已续期」。",
"设备令牌", MessageBoxButton.OK, MessageBoxImage.Information);
}
/// 后台服务当前绑定的主体 id(未处于服务模式时为 0)。
private int ServiceSubjectId
{
get
{
if (!AgentPaths.MachineMode) return 0;
try { return AgentFiles.LoadConfig()?.SubjectId ?? 0; }
catch { return 0; }
}
}
/// 后台服务绑定的主体与当前界面主体不一致(换账号登录后可能出现)。
private bool ServiceSubjectMismatch
{
get
{
var id = ServiceSubjectId;
return AgentPaths.MachineMode && _device.Enabled && id > 0 && id != _settings.SubjectId;
}
}
///
/// 把当前设置转成后台服务的 agent.json(长期设备令牌是关键,服务靠它上报)。
///
private AgentConfig BuildAgentConfig() => new()
{
ServerBaseUrl = _settings.ServerBaseUrl,
DeviceToken = _settings.DeviceToken,
RefreshToken = _settings.DeviceRefreshToken,
DeviceSn = _settings.DeviceSn,
DeviceId = _settings.DeviceId,
SubjectId = _settings.SubjectId,
NtpEnabled = _settings.NtpEnabled,
NtpServer = _settings.NtpServer,
NtpIntervalMinutes = _settings.NtpSyncIntervalMinutes,
};
///
/// 服务模式自检:服务副本版本 / 运行状态。
/// 升级后首次启动会提示更新副本(一次 UAC);服务被停下时提示启动。
///
private async Task EnsureAgentServiceAsync()
{
try
{
// 老版本激活的设备没有刷新令牌:登录后自动重新激活一次补发
// (会轮换 jti,服务读到新配置/令牌文件后自动恢复,扫码中断几秒)
if (!_refreshBackfillTried
&& AgentPaths.MachineMode
&& _device.Enabled
&& string.IsNullOrWhiteSpace(_settings.DeviceRefreshToken)
&& _settings.SubjectRole == 1
// 换账号登录时不能拿新账号的主体去覆盖后台服务的配置
&& (ServiceSubjectId == 0 || ServiceSubjectId == _settings.SubjectId))
{
_refreshBackfillTried = true;
try
{
var activation = await _device.EnableAsync();
_device.StopUploadLoop(); // 服务模式由后台服务上报
AgentFiles.SaveConfig(BuildAgentConfig());
AgentFiles.SaveToken(new AgentToken
{
DeviceToken = activation.Token,
RefreshToken = activation.RefreshToken,
ExpiresAt = JwtUtil.Expiry(activation.Token),
});
AppLog.Write("[agent] 已补发刷新令牌(重新激活设备服务)");
}
catch (Exception ex)
{
AppLog.Write($"[agent] 补发刷新令牌失败(可在「关闭/开启设备服务」后重试):{ex.Message}");
}
}
if (ServiceInstaller.NeedsBinaryUpdate)
{
var answer = MessageBox.Show(this,
"后台扫码服务版本与本软件不一致(升级后需要更新副本)。\n\n"
+ "更新会弹一次管理员授权(UAC),期间扫码中断几秒。现在更新吗?",
"后台扫码服务", MessageBoxButton.YesNo, MessageBoxImage.Question);
if (answer == MessageBoxResult.Yes)
{
var result = await ServiceInstaller.InstallOrUpdateAsync();
AppLog.Write($"[agent] 更新后台服务:{result.Message}");
if (!result.Ok)
{
MessageBox.Show(this, result.Message, "后台扫码服务",
MessageBoxButton.OK, MessageBoxImage.Warning);
}
}
return;
}
var state = ServiceInstaller.QueryState();
if (state == AgentServiceState.Running) return;
if (state == AgentServiceState.NotInstalled)
{
AppLog.Write("[agent] 设备服务已开启,但后台服务未安装(可能被手动删除)");
return;
}
var start = MessageBox.Show(this,
$"后台扫码服务当前{state}(未运行)。\n\n启动后才会继续收码上报(会弹一次管理员授权)。现在启动吗?",
"后台扫码服务", MessageBoxButton.YesNo, MessageBoxImage.Question);
if (start != MessageBoxResult.Yes) return;
var started = await ServiceInstaller.StartAsync();
AppLog.Write($"[agent] 启动后台服务:{started.Message}");
if (!started.Ok)
{
MessageBox.Show(this, started.Message, "后台扫码服务",
MessageBoxButton.OK, MessageBoxImage.Warning);
}
}
catch (Exception ex)
{
AppLog.Write($"[agent] 自检后台服务失败:{ex.Message}");
}
}
/// 启动扫码服务(TCP 收码 + 通道同步;仅**旧模式**用,服务模式下由 Windows 服务负责)
private async Task StartScanServiceAsync()
{
if (AgentPaths.MachineMode) return; // 后台服务负责收码,这里不能重复连设备
try
{
await _scan.StartAsync();
_scanTabView.Refresh();
}
catch (Exception ex)
{
AppLog.Write($"[scan] 启动扫码服务失败:{ex.Message}");
}
}
private void StopScanService()
{
_scan.Stop();
_scanTabView.Refresh();
}
private async void EnableDevice_Click(object sender, RoutedEventArgs e) => await EnableDeviceAsync();
private async Task EnableDeviceAsync(bool silentConfirm = false)
{
if (_settings.SubjectId <= 0)
{
MessageBox.Show(this, "还没有选择主体,请先在「服务 → 切换主体」里选一个主体。", "开启设备服务",
MessageBoxButton.OK, MessageBoxImage.Information);
return;
}
if (_settings.SubjectRole != 1)
{
MessageBox.Show(this, "只有主体管理员才能开启设备服务。", "开启设备服务",
MessageBoxButton.OK, MessageBoxImage.Warning);
return;
}
try
{
// ① 先问服务器:该主体下是不是已经有设备了
var others = await _device.OtherDevicesAsync();
if (others.Count > 0 && !silentConfirm)
{
var names = string.Join("\n", others.Select(item => $"· {item.Name ?? "未命名"}({item.Sn})"));
var answer = MessageBox.Show(this,
$"主体「{_settings.SubjectName}」下已有在线设备:\n\n{names}\n\n"
+ "一个主体只允许一台设备在线,开启后上面的设备会被踢下线(它的上报会立刻失效)。\n\n确定继续吗?",
"开启设备服务", MessageBoxButton.YesNo, MessageBoxImage.Warning);
if (answer != MessageBoxResult.Yes) return;
}
// ② 开服务(拿**长期设备令牌**(默认 365 天) + 上报通道)
var activation = await _device.EnableAsync();
// ③ 切到服务模式:数据目录 → ProgramData,写 agent.json,安装/启动 Windows 服务
// (只有这一步要管理员权限,之后开机自启、退出桌面端都不再弹 UAC)
AgentPaths.MachineMode = true;
var migrated = AgentPaths.MigrateUserDataToMachine();
if (migrated is not null) AppLog.Write($"[agent] {migrated}");
// 服务模式:NTP 校时是强制项(写进 agent.json,由服务以 LocalSystem 执行,不需要 UAC)
((App)System.Windows.Application.Current).EnsureNtpSync();
AgentFiles.SaveConfig(BuildAgentConfig());
// 令牌单独一份(服务续期后写它,避免和 agent.json 的其它设置互相覆盖)
AgentFiles.SaveToken(new AgentToken
{
DeviceToken = activation.Token,
RefreshToken = activation.RefreshToken,
ExpiresAt = JwtUtil.Expiry(activation.Token),
});
// 后台服务会自己收码/上报 → 本进程的上报循环停掉,避免重复上传
_device.StopUploadLoop();
var installed = await ServiceInstaller.InstallOrUpdateAsync();
AppLog.Write($"[agent] 安装后台服务:{installed.Message}");
if (installed.Ok)
{
_scan.Load(); // 从 ProgramData 重新读通道(服务用同一份)
_scanTabView.Refresh();
}
else
{
// 用户取消 UAC / 策略拦截 → 退回旧模式:程序开着才能扫码
AgentPaths.MachineMode = false;
MessageBox.Show(this,
$"后台扫码服务安装失败:{installed.Message}\n\n"
+ "已退回旧模式:本软件运行期间才收码上报,退出软件后扫码会停止。",
"开启设备服务", MessageBoxButton.OK, MessageBoxImage.Warning);
_device.EnsureUploadLoop();
_device.TriggerUpload();
await StartScanServiceAsync();
}
UpdateNtpMenu();
var kicked = activation.Kicked.Count;
MessageBox.Show(this,
(installed.Ok ? "设备服务已开启(系统后台服务)。" : "设备服务已开启(旧模式)。") + "\n\n"
+ $"设备 SN:{activation.Sn}\n"
+ (kicked > 0 ? $"已踢下线 {kicked} 台设备。\n" : string.Empty)
+ (installed.Ok
? "\n扫码由系统服务在后台收码上报:退出本软件/用户注销都不会停止,开机自动运行。"
: "\n注意:退出本软件后扫码会停止。"),
"开启设备服务", MessageBoxButton.OK, MessageBoxImage.Information);
UpdateDeviceMenu();
MainTabs.SelectedIndex = 1;
}
catch (Exception ex)
{
AppLog.Write($"[device] 开启设备服务失败:{ex.Message}");
MessageBox.Show(this, $"开启失败:{ex.Message}", "开启设备服务",
MessageBoxButton.OK, MessageBoxImage.Warning);
UpdateDeviceMenu();
}
}
private async void DisableDevice_Click(object sender, RoutedEventArgs e)
{
var answer = MessageBox.Show(this,
"要关闭设备服务吗?\n\n关闭后本机不再向服务器上报扫码记录,设备令牌会立即失效,扫码通道也会断开。",
"关闭设备服务", MessageBoxButton.YesNo, MessageBoxImage.Question);
if (answer != MessageBoxResult.Yes) return;
StopScanService();
// 服务模式:先把后台服务停掉/卸载(取消 UAC 就中止,不能先注销令牌)
if (AgentPaths.MachineMode || ServiceInstaller.IsInstalled)
{
var removed = await ServiceInstaller.UninstallAsync();
AppLog.Write($"[agent] 卸载后台服务:{removed.Message}");
if (!removed.Ok)
{
MessageBox.Show(this,
$"停止后台服务失败:{removed.Message}\n\n设备服务未关闭(令牌仍有效),请稍后重试。",
"关闭设备服务", MessageBoxButton.OK, MessageBoxImage.Warning);
return;
}
}
await _device.DisableAsync();
// 回写数据 + 回到普通模式
AgentPaths.MachineMode = false;
AgentFiles.ClearToken();
var copied = AgentPaths.CopyMachineDataToUser();
if (copied is not null) AppLog.Write($"[agent] {copied}");
_scan.Load();
_scanTabView.Refresh();
UpdateDeviceMenu();
MessageBox.Show(this, "设备服务已关闭。", "关闭设备服务",
MessageBoxButton.OK, MessageBoxImage.Information);
}
// ---------------- 服务状态 ----------------
/// 只刷菜单里的状态项:本机服务跟随程序生命周期(启动即开、退出即停)
private void UpdateServerState()
{
MenuServiceStatus.Header = _server.IsRunning ? "服务状态:运行中" : "服务状态:未启动";
}
// ---------------- 菜单(工具 / 帮助) ----------------
private void FocusQuery_Click(object sender, RoutedEventArgs e)
{
QueryBox.Focus();
QueryBox.SelectAll();
}
private void ClearUpdateCache_Click(object sender, RoutedEventArgs e)
{
var dir = Path.Combine(Path.GetTempPath(), "YuncangTraceUpdate");
try
{
if (Directory.Exists(dir)) Directory.Delete(dir, recursive: true);
AppLog.Write($"已清理更新缓存:{dir}");
}
catch (Exception ex)
{
AppLog.Write($"清理更新缓存失败:{ex.Message}");
}
}
/// 用资源管理器打开日志目录(按天一个 log_yyyy-MM-dd.txt)
private void OpenLogFolder_Click(object sender, RoutedEventArgs e)
{
try
{
Directory.CreateDirectory(AppLog.LogDirectory);
Process.Start(new ProcessStartInfo("explorer.exe", $"\"{AppLog.LogDirectory}\"") { UseShellExecute = true });
}
catch (Exception ex)
{
MessageBox.Show(this, $"打开日志目录失败:{ex.Message}\n\n{AppLog.LogDirectory}",
"打开日志目录", MessageBoxButton.OK, MessageBoxImage.Warning);
}
}
/// Edge 加载项商店的安装页(已上架,点「获取」即可)
private const string ExtensionStoreUrl =
"https://microsoftedge.microsoft.com/addons/detail/mgdonmkicojkabgalgekobaoohaohfcj";
///
/// 「工具 → 安装浏览器插件(Edge 应用商店)」:用 msedge.exe 打开商店安装页。
///
/// Edge 扩展已上架商店,装了 Edge 就点「获取」,不需要开发者模式、不需要管理员权限,
/// 也不需要企业策略;Chrome 装不了 Edge 商店的扩展,走「复制插件路径(Chrome / 开发者模式)」。
///
private void OpenExtensionStore_Click(object sender, RoutedEventArgs e)
{
try
{
AppLog.Write($"打开 Edge 加载项商店页:{ExtensionStoreUrl}");
// 装了 Edge 就用 Edge 打开:这个页面只对 Edge 有效,默认浏览器是 Chrome 时点「获取」也装不上
var edge = FindEdgePath();
if (edge != null)
{
Process.Start(new ProcessStartInfo(edge, ExtensionStoreUrl) { UseShellExecute = true });
}
else
{
AppLog.Write("没找到 msedge.exe,用默认浏览器打开商店页(可能是 Chrome,装不了,需手动换 Edge)");
Process.Start(new ProcessStartInfo(ExtensionStoreUrl) { UseShellExecute = true });
}
MessageBox.Show(this,
"已打开「云仓视频溯源 · 单号注入」的 Edge 加载项页面。\n\n"
+ "· 点「获取」→「添加扩展」,几秒就装好,不需要开发者模式,也不需要管理员权限;\n"
+ "· 这个页面只对 Microsoft Edge 有效(Chrome 装不了 Edge 商店的扩展);\n"
+ "· 用 Chrome 的话:菜单「复制插件路径(Chrome / 开发者模式)」,"
+ "再到 chrome://extensions 打开开发者模式、加载已解压的扩展程序。",
"安装浏览器插件", MessageBoxButton.OK, MessageBoxImage.Information);
}
catch (Exception ex)
{
AppLog.Write($"打开插件商店页失败:{ex.Message}");
MessageBox.Show(this,
$"打开商店页面失败:{ex.Message}\n\n请手动在 Edge 里访问:\n{ExtensionStoreUrl}",
"安装浏览器插件", MessageBoxButton.OK, MessageBoxImage.Warning);
}
}
/// 找 Edge 的可执行文件(没装返回 null)
private static string? FindEdgePath()
{
string[] candidates =
[
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86), @"Microsoft\Edge\Application\msedge.exe"),
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), @"Microsoft\Edge\Application\msedge.exe"),
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), @"Microsoft\Edge\Application\msedge.exe"),
];
foreach (var path in candidates)
{
if (File.Exists(path)) return path;
}
return null;
}
///
/// 「工具 → 复制插件路径(开发者模式)」:插件随安装包释放到 <安装目录>\extension,
/// 复制这个 Windows 路径,再到 chrome://extensions「加载已解压的扩展程序」里粘进去。
///
private async void CopyExtensionPath_Click(object sender, RoutedEventArgs e)
{
var path = Path.Combine(AppContext.BaseDirectory, "extension");
if (!Directory.Exists(path))
{
MessageBox.Show(this,
$"没有找到插件目录:\n\n{path}\n\n请安装最新版本后再试。",
"复制插件路径", MessageBoxButton.OK, MessageBoxImage.Warning);
return;
}
// 剪贴板被别的程序占着时写入会重试几秒,放到后台做,别把界面卡住
if (await Task.Run(() => TrySetClipboardText(path)))
{
AppLog.Write($"已复制插件路径:{path}");
MessageBox.Show(this,
$"已复制插件路径:\n\n{path}\n\n打开 chrome://extensions → 打开「开发者模式」→「加载已解压的扩展程序」→ 粘贴该路径。",
"复制插件路径", MessageBoxButton.OK, MessageBoxImage.Information);
return;
}
AppLog.Write($"复制插件路径失败(剪贴板被其他程序占用):{path}");
var holder = GetClipboardHolderName();
AppLog.Write(holder == null
? "没查到占用剪贴板的进程"
: $"占用剪贴板的进程:{holder}");
var owner = string.IsNullOrEmpty(holder) ? "别的程序" : $"「{holder}」";
var openNotepad = MessageBox.Show(this,
$"剪贴板正被{owner}占着(远程桌面 / 剪贴板同步工具 / 输入法都会这样),这次没能写进去。\n\n" +
$"· 路径:\n{path}\n" +
"· 如果剪贴板里已经是这个路径,直接粘贴就行,不用管这个提示;\n" +
$"· 关掉{owner},或稍等一两秒再点一次「复制插件路径(开发者模式)」;\n" +
"· 远程桌面里遇到的话,在远程机器上重启 rdpclip.exe 后重试。\n\n" +
"要打开记事本显示这个路径吗(方便对照抄写)?",
"复制插件路径", MessageBoxButton.YesNo, MessageBoxImage.Warning);
if (openNotepad == MessageBoxResult.Yes)
{
ShowPathInNotepad(path);
}
}
/// 剪贴板不可用时的兜底:把路径写进临时 txt 并用记事本打开
private static void ShowPathInNotepad(string path)
{
try
{
var file = Path.Combine(Path.GetTempPath(), "yuncang-extension-path.txt");
File.WriteAllText(file, path, Encoding.UTF8);
Process.Start(new ProcessStartInfo("notepad.exe", $"\"{file}\"") { UseShellExecute = true });
}
catch (Exception ex)
{
AppLog.Write($"打开记事本显示插件路径失败:{ex.Message}");
}
}
///
/// 复制到剪贴板:**全部操作放到后台 STA 线程,带超时**,绝不卡住界面。
///
/// 现场实测:远程桌面 / 剪贴板同步工具(这台机器上是 BilldDesk)会长期把剪贴板开着,
/// 这时 `OpenClipboard` 直接失败,`OleGetClipboard`(读)甚至会一直阻塞到对方松手 ——
/// 所以连「先核对内容」都得放到后台线程,主线程只等一小会儿。
///
private static bool TrySetClipboardText(string text) => RunOnStaThread(
() => TrySetClipboardTextCore(text, DateTime.UtcNow + TimeSpan.FromSeconds(4)),
TimeSpan.FromSeconds(5));
private static bool TrySetClipboardTextCore(string text, DateTime deadline)
{
// 剪贴板里本来就是这段文字(上次复制过 / 上次其实写进去了)→ 直接算成功,别弹「被占用」
if (ClipboardContainsText(text, 1, deadline)) return true;
if (WriteClipboard(text, deadline)) return true;
// 写 API 报错但内容可能已经进去了(OleFlushClipboard 失败时数据仍在)
return ClipboardContainsText(text, 3, deadline);
}
private static bool WriteClipboard(string text, DateTime deadline)
{
if (RetryClipboardWrite(() => Clipboard.SetDataObject(text, true), "WPF", deadline))
{
return true;
}
if (RetryClipboardWrite(() => System.Windows.Forms.Clipboard.SetDataObject(text, true), "WinForms", deadline))
{
return true;
}
// 写 API 抛错时最常见的是「OleSetClipboard 成功、OleFlushClipboard 失败」:
// 数据其实已经在剪贴板里了,补一次 flush 让延迟渲染落盘,调用方会再读回来核对
FlushClipboardRetry();
return false;
}
[DllImport("ole32.dll")]
private static extern int OleFlushClipboard();
[DllImport("user32.dll")]
private static extern IntPtr GetOpenClipboardWindow();
[DllImport("user32.dll")]
private static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint processId);
/// 谁正把剪贴板开着(远程桌面 / 剪贴板同步工具最常见),查不到就返回 null
private static string? GetClipboardHolderName()
{
try
{
var hwnd = GetOpenClipboardWindow();
if (hwnd == IntPtr.Zero) return null;
_ = GetWindowThreadProcessId(hwnd, out var processId);
if (processId == 0) return null;
using var process = Process.GetProcessById((int)processId);
return process.ProcessName;
}
catch
{
return null;
}
}
/// 补一次 OleFlushClipboard(把「延迟渲染」的数据真正落到剪贴板里)
private static void FlushClipboardRetry()
{
int[] delaysMs = [ 0, 120, 250 ];
foreach (var delay in delaysMs)
{
if (delay > 0)
{
Thread.Sleep(delay);
}
var hr = OleFlushClipboard();
if (hr >= 0)
{
AppLog.Write("补 OleFlushClipboard 成功,剪贴板数据已落盘");
return;
}
AppLog.Write($"补 OleFlushClipboard 失败:0x{hr:X8}");
}
}
/// 读回剪贴板核对内容(写失败但实际已写入 / 本来就在里面)
private static bool ClipboardContainsText(string text, int attempts, DateTime deadline)
{
for (var attempt = 1; attempt <= attempts; attempt++)
{
try
{
if (Clipboard.ContainsText() && string.Equals(Clipboard.GetText(), text, StringComparison.Ordinal))
{
AppLog.Write($"剪贴板内容核对通过(第 {attempt}/{attempts} 次),按复制成功处理");
return true;
}
}
catch (Exception ex)
{
AppLog.Write($"读剪贴板核对失败(第 {attempt}/{attempts} 次):{ex.Message}");
}
if (attempt < attempts)
{
if (DateTime.UtcNow.AddMilliseconds(120) >= deadline) break;
Thread.Sleep(120);
}
}
return false;
}
/// 在一条新的 STA 线程上执行剪贴板操作(COM 单元干净,超时后不再等,界面不会被卡住)
private static bool RunOnStaThread(Func action, TimeSpan timeout)
{
var result = false;
string? error = null;
var thread = new Thread(() =>
{
try
{
result = action();
}
catch (Exception ex)
{
error = ex.Message;
}
})
{
IsBackground = true,
Name = "clipboard-op",
};
thread.SetApartmentState(ApartmentState.STA);
thread.Start();
if (!thread.Join(timeout))
{
AppLog.Write($"剪贴板操作超时({timeout.TotalSeconds:0} 秒没返回):剪贴板多半被别的程序锁着,先不写了");
return false;
}
if (error != null)
{
AppLog.Write($"剪贴板后台线程异常:{error}");
}
return result;
}
private static bool RetryClipboardWrite(Action write, string api, DateTime deadline)
{
// 剪贴板被占通常是「一下子」的事(远程桌面同步、浏览器刚复制完、输入法在读写),退避等一下就好
int[] delaysMs = [ 150, 300, 500 ];
for (var attempt = 1; ; attempt++)
{
try
{
write();
return true;
}
catch (Exception ex)
{
AppLog.Write($"{api} 写剪贴板失败(第 {attempt} 次):{ex.Message}");
var delay = attempt <= delaysMs.Length ? delaysMs[attempt - 1] : 500;
if (DateTime.UtcNow.AddMilliseconds(delay) >= deadline)
{
return false;
}
Thread.Sleep(delay);
}
}
}
private void ClearLogs_Click(object sender, RoutedEventArgs e)
{
var answer = MessageBox.Show(this,
$"确定删除全部日志文件吗?\n\n{AppLog.LogDirectory}",
"清理日志", MessageBoxButton.YesNo, MessageBoxImage.Question);
if (answer != MessageBoxResult.Yes) return;
var removed = AppLog.Clear();
AppLog.Write($"已清理日志:删除 {removed} 个文件");
MessageBox.Show(this,
removed > 0 ? $"已删除 {removed} 个日志文件。" : "没有可清理的日志文件。",
"清理日志", MessageBoxButton.OK, MessageBoxImage.Information);
}
private void Restart_Click(object sender, RoutedEventArgs e) => RestartRequested?.Invoke();
///
/// 菜单「工具 → 打开配置页」:用系统浏览器打后台(带令牌,免登录)。
///
/// 地址就是后端根地址(开发环境 `http://127.0.0.1:7300/`),前端启动时会拂 `?token=` 存进本地;
/// 登陆态不在 URL 里长期停留(前端拿到就 `replaceState` 掉了)。
///
private void OpenConsole_Click(object sender, RoutedEventArgs e)
{
try
{
var baseUrl = AppSettings.Normalize(_settings.ServerBaseUrl);
var url = $"{baseUrl}/?token={Uri.EscapeDataString(_session.Token)}";
AppLog.Write($"打开配置页:{baseUrl}");
Process.Start(new ProcessStartInfo(url) { UseShellExecute = true });
}
catch (Exception ex)
{
MessageBox.Show(this, $"打开配置页失败:{ex.Message}", "打开配置页",
MessageBoxButton.OK, MessageBoxImage.Warning);
}
}
private void CheckUpdate_Click(object sender, RoutedEventArgs e) => CheckUpdateRequested?.Invoke();
private void About_Click(object sender, RoutedEventArgs e)
{
var version = GetType().Assembly.GetName().Version?.ToString() ?? "1.0.0";
var subject = string.IsNullOrWhiteSpace(_settings.SubjectName) ? "未选择" : _settings.SubjectName;
MessageBox.Show(this,
$"云仓视频溯源软件(本机服务)\n\n"
+ $"版本:{version}\n"
+ $"环境:{BuildInfo.EnvironmentLabel}\n"
+ $"主体:{subject}\n"
+ $"设备服务:{(_device.Enabled ? $"已开启({_settings.DeviceSn})" : "未开启")}\n"
+ $"服务:{(_server.IsRunning ? "运行中" : "未启动")}",
"关于",
MessageBoxButton.OK,
MessageBoxImage.Information);
}
// ---------------- 设置:NTP 校时 ----------------
private void SettingsNtp_Click(object sender, RoutedEventArgs e)
{
if (!_device.Enabled)
{
MessageBox.Show(this, "NTP 校时属于服务模式的一部分,请先在「服务」菜单里开启设备服务。", "NTP 校时",
MessageBoxButton.OK, MessageBoxImage.Information);
return;
}
var api = _api;
var session = _session;
if (api is null || session is null) return;
var window = new NtpWindow(_settings, api, session, _settings.SubjectId) { Owner = this };
window.ShowDialog();
// 窗口里可能改过设置:服务模式强制项再确认一次,并确保定时校时在跑
((App)System.Windows.Application.Current).EnsureNtpSync();
UpdateNtpMenu();
}
private void UpdateNtpMenu()
{
if (!_settings.NtpEnabled)
{
MenuNtpStatus.Header = "NTP 校时:已关闭";
return;
}
var server = string.IsNullOrWhiteSpace(_settings.NtpServer) ? "(未设置)" : _settings.NtpServer;
MenuNtpStatus.Header = string.IsNullOrWhiteSpace(_settings.NtpLastSyncAt)
? $"NTP 校时:{server}(尚未同步)"
: $"NTP 校时:{server}(上次 {_settings.NtpLastSyncAt},偏差 {_settings.NtpLastOffsetSeconds:+0.0;-0.0}s)";
}
// ---------------- 设置:录像存储路径 ----------------
///
/// 设置录像存储根目录
///
/// 切换时把老目录里的文件**全部搬过去**(保留年/月/日结构),搬完删掉空的旧目录。
/// 有文件时先让用户确认——这是不可回退的操作。
///
private void SettingsVideoPath_Click(object sender, RoutedEventArgs e)
{
var current = _settings.VideoRootResolved;
using var dialog = new System.Windows.Forms.FolderBrowserDialog
{
Description = "选择录像存储根目录(文件会按 年/月/日 自动分目录)",
UseDescriptionForTitle = true,
SelectedPath = Directory.Exists(current) ? current : string.Empty,
};
if (dialog.ShowDialog() != System.Windows.Forms.DialogResult.OK) return;
var target = Path.GetFullPath(dialog.SelectedPath);
if (string.Equals(
target.TrimEnd(Path.DirectorySeparatorChar),
Path.GetFullPath(current).TrimEnd(Path.DirectorySeparatorChar),
StringComparison.OrdinalIgnoreCase))
{
return;
}
var hasFiles = Directory.Exists(current)
&& Directory.EnumerateFiles(current, "*", SearchOption.AllDirectories).Any();
var message = hasFiles
? $"切换路径将把所有文件转移到新的目录:\n\n{current}\n → {target}\n\n是否确认?"
: $"录像将保存到:\n\n{target}\n\n是否确认?";
if (MessageBox.Show(this, message, "设置录像存储路径",
MessageBoxButton.YesNo, MessageBoxImage.Question) != MessageBoxResult.Yes)
{
return;
}
Directory.CreateDirectory(target);
if (hasFiles)
{
var progress = new Progress(text => MenuVideoPath.Header = text);
var (moved, error) = VideoStorage.MoveAll(current, target, progress);
if (error is not null)
{
UpdateVideoPathMenu();
MessageBox.Show(this, $"文件转移失败:{error}\n\n路径未修改(文件可能已部分移动,请检查)。",
"设置录像存储路径", MessageBoxButton.OK, MessageBoxImage.Warning);
return;
}
_settings.VideoRoot = target;
_settings.Save();
UpdateVideoPathMenu();
MessageBox.Show(this, $"已切换,并转移 {moved} 个文件。\n\n新目录:{target}",
"设置录像存储路径", MessageBoxButton.OK, MessageBoxImage.Information);
return;
}
_settings.VideoRoot = target;
_settings.Save();
UpdateVideoPathMenu();
MessageBox.Show(this, $"录像目录已设置为:\n{target}", "设置录像存储路径",
MessageBoxButton.OK, MessageBoxImage.Information);
}
private void UpdateVideoPathMenu()
=> MenuVideoPath.Header = $"录像目录:{_settings.VideoRootResolved}";
private void OpenVideoFolder_Click(object sender, RoutedEventArgs e)
{
var root = _settings.VideoRootResolved;
try
{
Directory.CreateDirectory(root);
Process.Start(new ProcessStartInfo("explorer.exe", $"\"{root}\"") { UseShellExecute = true });
}
catch (Exception ex)
{
MessageBox.Show(this, $"打不开录像目录:{ex.Message}", "录像目录",
MessageBoxButton.OK, MessageBoxImage.Warning);
}
}
// ---------------- 查询 ----------------
private void Query_Click(object sender, RoutedEventArgs e) => _ = RunQueryAsync();
private void QueryBox_KeyDown(object sender, KeyEventArgs e)
{
if (e.Key == Key.Enter) _ = RunQueryAsync();
}
///
/// 用户主动查询(输入框回车 / 点查询 / 协议唤起)。
///
/// ⚠️ **查询不产生扫码记录**:扫码记录只来自真实通道(扫码枪/中控),
/// 以前这里会往 `DESKTOP` 通道记一笔,结果查一次运单就多一条「无工作台」的噪声记录。
///
private async Task RunQueryAsync()
{
var code = QueryBox.Text.Trim();
if (code.Length == 0) return;
AppLog.Write($"查询:{code}");
ResultBox.Text = "查询中…";
var outcome = await _queryService.QueryAsync(code);
ApplyQuery(code, outcome);
}
/// 把一次查询结果填到「打包查询」页(也会清掉页签上的「有新结果」圆点)
private void ApplyQuery(string code, PackQueryOutcome outcome)
{
QueryBox.Text = code;
_currentQuery = outcome.Query;
ResultBox.Text = outcome.Http.Ok
? outcome.Query?.Render() ?? "(后端没有返回数据)"
: $"{(int)outcome.Http.StatusCode} {outcome.Http.Message}";
ResultBox.ScrollToHome();
// 新的查询结果:先停掉上一次还在跑的校验,按空状态重新来(不影响正在下载的任务)
_validateCts?.Cancel();
_validateCts = null;
_validatedStreams = Array.Empty();
_cloudDownload = false;
PreviewButton.Visibility = Visibility.Collapsed;
DownloadButton.Visibility = Visibility.Collapsed;
PlaybackPanel.Visibility = Visibility.Collapsed;
OpenFolderButton.Visibility = Visibility.Collapsed;
_lastOutputFolder = null;
// 查询命中扫码记录 → **自动**校验回放(不用用户点按钮):
// 真的去录像机拉一下,确认这段时间有没有录像,再决定是否显示预览/下载。
if (_currentQuery is { Streams.Count: > 0 } query)
{
// 不能直接 fire-and-forget:方法内部有 await ConfigureAwait(false),
// 异常进不了任何 try,界面会静默停在第一句提示上(现场表现为“卡住”)。
_ = RunValidatePlaybackAsync(query);
}
}
private async Task RunValidatePlaybackAsync(PackQuery query)
{
try
{
await ValidatePlaybackAsync(query).ConfigureAwait(false);
}
catch (OperationCanceledException)
{
// 新查询覆盖旧查询:正常
}
catch (Exception ex)
{
AppLog.Write($"[playback] 自动校验异常({query.Code}):{ex}");
ShowPlayback($"校验回放失败:{ex.Message}");
}
}
// ---------------- 回放:校验 / 下载 ----------------
private void HidePlayback_Click(object sender, RoutedEventArgs e)
{
_validateCts?.Cancel();
_playbackCts?.Cancel();
PlaybackPanel.Visibility = Visibility.Collapsed;
}
///
/// 预览回放:按工作台的画布布局多路同时播
///
/// 走 RTSP 回放(实测这台 NVR 只有 554 能拉回放,8000 的 GetFileByTime 不推数据)。
///
private async void Preview_Click(object sender, RoutedEventArgs e)
{
var query = _currentQuery;
if (query is null) return;
// 只用校验通过的流(没拉到录像的不预览)
var streams = _validatedStreams.ToList();
if (streams.Count == 0) return;
if (!_playback.Available)
{
ShowPlayback("没有找到 ffmpeg,无法预览回放。把 ffmpeg.exe 放到安装目录 native\\ffmpeg\\ 后再试。");
return;
}
PreviewButton.IsEnabled = false;
try
{
var credentials = new Dictionary();
foreach (var nvrId in streams.Select(item => item.NvrId).Distinct())
{
try
{
credentials[nvrId] = await CredentialAsync(nvrId, CancellationToken.None);
}
catch (Exception ex)
{
ShowPlayback($"取录像机凭据失败:{ex.Message}");
return;
}
}
var window = new PlaybackPreviewWindow(streams, _ffmpeg, _playback, credentials)
{
Owner = this,
};
window.Show();
}
finally
{
PreviewButton.IsEnabled = true;
}
}
private void ShowPlayback(string text)
{
// 校验流程里有 await ConfigureAwait(false),到这里可能已在线程池线程上,
// 直接写控件会抛“调用线程无法访问此对象”。统一切回 UI 线程。
if (!Dispatcher.CheckAccess())
{
Dispatcher.Invoke(() => ShowPlayback(text));
return;
}
PlaybackText.Text = text;
PlaybackPanel.Visibility = Visibility.Visible;
}
/// 预览/下载按钮的显隐同样可能来自线程池线程,统一在这里切回 UI 线程。
private void SetRouteButtons(bool showPreview, bool showDownload)
{
if (!Dispatcher.CheckAccess())
{
Dispatcher.Invoke(() => SetRouteButtons(showPreview, showDownload));
return;
}
PreviewButton.Visibility = showPreview ? Visibility.Visible : Visibility.Collapsed;
DownloadButton.Visibility = showDownload ? Visibility.Visible : Visibility.Collapsed;
PreviewButton.IsEnabled = showPreview;
DownloadButton.IsEnabled = showDownload;
}
///
/// 自动校验回放:**真的去录像机拉一下**这段时间有没有录像
///
/// 为什么必须真拉:NVR 不会告诉你「这段是空的」,只有在回放通道上拉流才知道。
/// 查询命中扫码记录后自动跑(不需要用户点按钮),每路拉 2 秒;
/// **只要任意一路有录像就停止**(不需要把每一路都验完)→ 显示预览/下载。
/// 顺序做,避免同时占满设备连接。
///
///
/// 问云端「这段录像有没有帧」;云端不可用时返回 null(调用方降级到本机校验)
///
private async Task AskCloudCheckAsync(string code, CancellationToken ct)
{
var token = _session?.Token;
if (_api is null || string.IsNullOrWhiteSpace(token) || string.IsNullOrWhiteSpace(code)) return null;
try
{
return await _api.EdgeCheckAsync(token, _settings.SubjectId, code, ct).ConfigureAwait(false);
}
catch (Exception ex)
{
AppLog.Write($"[edge] 云端校验失败(改由本机):{ex.Message}");
return null;
}
}
private async Task ValidatePlaybackAsync(PackQuery query)
{
// 用后端拍平去重后的 streams(同一摄像头在多次扫码里只验一次)
var streams = query.Streams.ToList();
if (streams.Count == 0) return;
if (!_playback.Available)
{
ShowPlayback("没有找到 ffmpeg,无法校验回放。把 ffmpeg.exe 放到安装目录 native\\ffmpeg\\ 后再试。");
return;
}
_validateCts?.Cancel();
_validateCts = new CancellationTokenSource();
var ct = _validateCts.Token;
// 每次重新选路前先按「本机可达」算,云端校验通过才置为跨网
_cloudDownload = false;
var lines = new List { $"正在校验 {streams.Count} 路回放…" };
ShowPlayback(string.Join(Environment.NewLine, lines));
var valid = new List();
var clockNoted = new HashSet();
var checkedStreams = 0;
// 有设备管理服务就由它校验:多台查询机共用它的 NVR 会话池,
// 不会各自登录一次(海康并发登录上限通常只有 6~16)。
var nvrs = streams
.Select(item => (Host: item.NvrHost, Port: item.NvrPort))
.Where(item => !string.IsNullOrWhiteSpace(item.Host))
.Distinct()
.ToList();
var peer = await _gateway.FindAsync(nvrs, ct).ConfigureAwait(false);
if (peer is not null)
{
AppLog.Write($"[route] {query.Code} 本机校验交给设备管理服务 {peer.Display}");
}
else
{
// 局域网没有设备管理服务(跨公司/跨网段)→ 问云端:
// 云端转给能访问 NVR 的扫码服务确认,能确认就不用本机白拉一遍。
AppLog.Write($"[route] {query.Code} 局域网没有设备管理服务,改问云端");
ShowPlayback(string.Join(Environment.NewLine, lines));
var cloud = await AskCloudCheckAsync(query.Code, ct);
if (cloud is { State: "ok", HasVideo: { } hasVideo })
{
_validatedStreams = hasVideo ? streams : Array.Empty();
// 本机连不到仓库的 NVR → 下载必须走云端中转(本机直连只会 ffmpeg −138)
_cloudDownload = hasVideo;
// 跨网只给下载:预览要实时拉流,云端中转成本高且体验差
SetRouteButtons(showPreview: false, showDownload: hasVideo);
AppLog.Write($"[route] {query.Code} 云端校验:hasVideo={hasVideo}"
+ $"({cloud.ScannerSn},{cloud.Frames} 帧)→ 跨网只给下载");
lines[0] = hasVideo
? $"云端校验:有录像({cloud.ScannerSn}),跨网只提供下载"
: "云端校验:该时段没有录像";
ShowPlayback(string.Join(Environment.NewLine, lines));
return;
}
if (cloud is { State: "no-plan" })
{
_validatedStreams = Array.Empty();
SetRouteButtons(showPreview: false, showDownload: false);
AppLog.Write($"[route] {query.Code} 云端判定无回放计划 → 不给按钮");
lines[0] = "这个运单算不出回放计划(扫码时该通道没绑定工作台)";
ShowPlayback(string.Join(Environment.NewLine, lines));
return;
}
// 云端判断不了(没有在线扫码服务 / 云端不可用)→ 本机自己校验
AppLog.Write($"[route] {query.Code} 云端无法确认({(cloud is null ? "不可用" : cloud.State)})→ 本机校验");
}
try
{
for (var i = 0; i < streams.Count; i++)
{
ct.ThrowIfCancellationRequested();
var stream = streams[i];
checkedStreams = i + 1;
lines[0] = $"正在校验第 {i + 1}/{streams.Count} 路:{stream.DisplayName}…";
ShowPlayback(string.Join(Environment.NewLine, lines));
try
{
var credential = await CredentialAsync(stream.NvrId, ct);
// 时钟对齐只有**本机直连录像机**时才需要(回放会整体错位)。
// 走设备管理服务时本机不该登录 NVR —— 那正是「共用会话池」要避免的并发登录。
var hasRecord = false;
var frames = 0;
string? error = null;
if (peer is not null)
{
using var client = new EdgeClient(peer);
var remote = await client.CheckAsync(credential, stream.ChannelNo,
stream.StartTime, stream.EndTime, ct).ConfigureAwait(false);
if (remote is null)
{
// 服务端没回结果:视为校验失败,降级到本机再试一次
_gateway.Invalidate();
peer = null;
AppLog.Write($"[route] {query.Code} 设备管理服务无响应,改由本机校验");
}
else
{
hasRecord = remote.HasRecord;
frames = remote.Frames;
error = remote.Error;
}
}
if (peer is null)
{
// 本机直连:先和录像机对时(否则短窗口会整体错位甚至截掉面单)
var clock = _playback.ClockOffset(credential.Host, credential.Port,
credential.Username, credential.Password);
if (clockNoted.Add(stream.NvrId) && Math.Abs(clock.TotalSeconds) >= 2)
{
AppLog.Write($"[playback] 录像机与本机相差 {clock.TotalSeconds:+0.0;-0.0} 秒,回放时间已按录像机对齐");
ShowPlayback(string.Join(Environment.NewLine, lines));
}
var check = await _playback.CheckAsync(credential.Host, credential.Port,
credential.Username, credential.Password, stream.ChannelNo,
stream.StartTime, stream.EndTime, ct);
hasRecord = check.HasRecord;
frames = check.Frames;
error = check.Error;
lines.Add(hasRecord
? $"[有录像] {stream.DisplayName} {FormatRange(stream, clock)}{(frames > 0 ? $" 试拉 {frames} 帧" : "")}"
: $"[无录像] {stream.DisplayName} {FormatRange(stream, clock)} {error}");
}
else
{
// 走设备管理服务:只报结果,本机不碰录像机
lines.Add(hasRecord
? $"[有录像] {stream.DisplayName} {FormatRange(stream, TimeSpan.Zero)}(设备管理服务){(frames > 0 ? $" 试拉 {frames} 帧" : "")}"
: $"[无录像] {stream.DisplayName} {FormatRange(stream, TimeSpan.Zero)} {error}(设备管理服务)");
}
if (hasRecord) valid.Add(stream);
}
catch (Exception ex)
{
lines.Add($"[失败] {stream.DisplayName} {ex.Message}");
}
ShowPlayback(string.Join(Environment.NewLine, lines));
// 任意一路拉到录像就够了:后面的不再逐路试(每路都要真拉 2 秒,很慢)
if (valid.Count > 0) break;
}
// 预览/下载仍用**全部**流 —— 没录像的那几路下载时会自己跳过,
// 只留校验通过的那一路会导致合并不全(甚至退化成单路)。
_validatedStreams = valid.Count > 0 ? streams : Array.Empty();
if (valid.Count > 0)
{
lines[0] = checkedStreams >= streams.Count
? $"校验完成:{valid.Count}/{streams.Count} 路有录像,可以预览或下载"
: $"校验完成:{valid[0].DisplayName} 有录像(其余 {streams.Count - checkedStreams} 路未检查),可以预览或下载";
SetRouteButtons(showPreview: true, showDownload: true);
}
else
{
lines[0] = "校验完成:没有拉到录像,不显示预览和下载";
AppLog.Write($"[route] {query.Code} 本机校验:没有拉到录像 → 不给按钮");
}
ShowPlayback(string.Join(Environment.NewLine, lines));
}
catch (OperationCanceledException)
{
// 新查询 / 用户关闭面板:不提示
}
catch (Exception ex)
{
ShowPlayback($"校验回放失败:{ex.Message}");
AppLog.Write($"[playback] 自动校验失败:{ex.Message}");
}
}
///
/// 下载录像:选一个目录,多路**自动**按工作台布局合并成一个视频
///
/// 流程:
/// 1. 各路段先下到**系统临时目录**(不污染用户选的目录);
/// 2. 多路 → 自动合并(不再弹「要合并吗」);单路 → 直接搬过去;
/// 3. 成功后删临时片段,用户目录里只留一个成片;失败则把片段搬过去保留数据。
///
private async void Download_Click(object sender, RoutedEventArgs e)
{
var query = _currentQuery;
if (query is null) return;
// 只用校验通过的流(没拉到录像的不下载)
var streams = _validatedStreams.ToList();
if (streams.Count == 0) return;
// 跨网:本机连不到仓库的 NVR(直连只会让 ffmpeg 报 −138),交给云端转给仓库设备代取
if (_cloudDownload)
{
await DownloadViaCloudAsync(query).ConfigureAwait(true);
return;
}
if (!_playback.Available)
{
ShowPlayback("没有找到 ffmpeg,无法下载录像。把 ffmpeg.exe 放到安装目录 native\\ffmpeg\\ 后再试。");
return;
}
// 不弹目录选择:统一存到「设置里的录像根目录」,按**扫码日期**分 年/月/日
var scanTime = query.Records.Count > 0 ? query.Records[0].ScanTime.LocalDateTime : DateTime.Now;
var folder = VideoStorage.FolderFor(_settings.VideoRootResolved, scanTime);
Directory.CreateDirectory(folder);
var stamp = DateTime.Now.ToString("yyyyMMdd_HHmmss");
// 各路段先下在临时目录:用户选的目录里最终只留成片
var workDir = Path.Combine(Path.GetTempPath(), "YuncangTrace", "playback", $"{SanitizeFile(query.Code)}_{stamp}");
Directory.CreateDirectory(workDir);
_playbackCts?.Cancel();
_playbackCts = new CancellationTokenSource();
var ct = _playbackCts.Token;
DownloadButton.IsEnabled = false;
var lines = new List();
ShowPlayback("准备下载…");
// 多路**并行**下载(最多 2 路同时):RTSP 回放是按实时速率推的,
// 串行做 2 路 30 秒要 80 秒;并行能压到 40 秒左右。
// 限 2 是给 NVR 留余量(同时开太多回放连接会互相抢带宽)。
const int maxParallel = 2;
var gate = new SemaphoreSlim(maxParallel);
var saved = new PlaybackClip?[streams.Count];
var tasks = new List();
void UpdateLine(int slot, string text) => Dispatcher.Invoke(() =>
{
lines[slot] = text;
ShowPlayback(string.Join(Environment.NewLine, lines));
});
try
{
for (var i = 0; i < streams.Count; i++)
{
var slot = i;
var stream = streams[i];
lines.Add($"第 {i + 1}/{streams.Count} 路:{stream.DisplayName} 排队中…");
ShowPlayback(string.Join(Environment.NewLine, lines));
tasks.Add(Task.Run(async () =>
{
await gate.WaitAsync(ct).ConfigureAwait(false);
try
{
UpdateLine(slot, $"第 {slot + 1}/{streams.Count} 路:{stream.DisplayName} 连接中…");
var credential = await CredentialAsync(stream.NvrId, ct).ConfigureAwait(false);
var name = $"{SanitizeFile(query.Code)}_{stream.CameraId}_{stream.CameraName}"
+ $"_{stream.StartTime.ToLocalTime():yyyyMMdd_HHmmss}.mp4";
var path = Path.Combine(workDir, name);
var progress = new Progress(p =>
UpdateLine(slot, $"第 {slot + 1}/{streams.Count} 路:{stream.DisplayName} {p.Message}"));
var file = await _playback.DownloadAsync(credential.Host, credential.Port,
credential.Username, credential.Password, stream.ChannelNo,
stream.StartTime, stream.EndTime, path, progress, ct).ConfigureAwait(false);
saved[slot] = file;
UpdateLine(slot, $"第 {slot + 1}/{streams.Count} 路:{stream.DisplayName} ✓ {file.Path}");
}
catch (OperationCanceledException)
{
UpdateLine(slot, $"第 {slot + 1}/{streams.Count} 路:{stream.DisplayName} 已取消");
}
catch (Exception ex)
{
UpdateLine(slot, $"第 {slot + 1}/{streams.Count} 路:{stream.DisplayName} ✗ {ex.Message}");
}
finally
{
gate.Release();
}
}, ct));
}
await Task.WhenAll(tasks).ConfigureAwait(true);
// 保持与 streams 一一对应(失败的那路不参与合并)
var done = new List<(PackStream Stream, PlaybackClip Clip)>();
for (var i = 0; i < streams.Count; i++)
{
if (saved[i] is { } clip) done.Add((streams[i], clip));
}
if (done.Count > 0)
{
// 多路 → 自动合并(不弹确认);单路 → 直接搬过去
if (done.Count > 1)
{
var output = Path.Combine(folder,
$"{SanitizeFile(query.Code)}_合并_{done[0].Stream.StartTime.ToLocalTime():yyyyMMdd_HHmmss}.mp4");
var ok = await ComposeAsync(query, done, output, workDir);
if (ok)
{
_lastOutputFolder = folder;
OpenFolderButton.Visibility = Visibility.Visible;
ShowPlayback(string.Join(Environment.NewLine, lines)
+ Environment.NewLine + $"已合并:{output}");
}
}
else
{
var single = done[0].Clip.Path;
var target = Path.Combine(folder, Path.GetFileName(single));
if (File.Exists(target)) File.Delete(target);
File.Move(single, target);
_lastOutputFolder = folder;
OpenFolderButton.Visibility = Visibility.Visible;
ShowPlayback(string.Join(Environment.NewLine, lines)
+ Environment.NewLine + $"已保存:{target}");
}
// 临时片段用完就删(用户目录里只留成片)
TryDeleteDirectory(workDir);
}
}
catch (OperationCanceledException)
{
lines.Add("已取消");
ShowPlayback(string.Join(Environment.NewLine, lines));
TryDeleteDirectory(workDir);
}
finally
{
DownloadButton.IsEnabled = true;
}
}
///
/// 跨网下载:云端建任务 → 仓库设备(能访问 NVR 的那台)拉流合并并上传 → 本机取回落盘。
///
/// 查询机到仓库 NVR 的 8000/554 都不通,所以这里**不回落**本机直连。
///
private async Task DownloadViaCloudAsync(PackQuery query)
{
var service = _server.PlaybackDownload;
if (service is null)
{
ShowPlayback("本机服务还没就绪,稍后重试(或重启软件)。");
return;
}
var scanTime = query.Records.Count > 0 ? query.Records[0].ScanTime.LocalDateTime : DateTime.Now;
_playbackCts?.Cancel();
_playbackCts = new CancellationTokenSource();
var ct = _playbackCts.Token;
DownloadButton.IsEnabled = false;
OpenFolderButton.Visibility = Visibility.Collapsed;
ShowPlayback("跨网下载:正在联系仓库设备(要等它拉完流并上传)…");
// 进度也要落日志:云端为什么没接单(无在线设备/无密码/上传超时)只能从这里看出来
var progress = new Progress(text =>
{
AppLog.Write($"[playback] 跨网:{text}");
ShowPlayback($"跨网下载:{text}");
});
try
{
var result = await service.DownloadViaCloudAsync(query.Code, scanTime, progress, ct)
.ConfigureAwait(true);
_lastOutputFolder = result.Folder;
OpenFolderButton.Visibility = Visibility.Visible;
var saved = result.Merged ?? result.Segments.FirstOrDefault() ?? result.Folder;
var text = new List { $"已保存:{saved}", "(跨网:仓库设备代取)" };
text.AddRange(result.Warnings);
ShowPlayback(string.Join(Environment.NewLine, text));
AppLog.Write($"[playback] 跨网下载完成:{saved}");
}
catch (OperationCanceledException)
{
ShowPlayback("已取消");
}
catch (Exception ex)
{
ShowPlayback($"跨网下载失败:{ex.Message}");
AppLog.Write($"[playback] 跨网下载失败:{ex.Message}");
}
finally
{
DownloadButton.IsEnabled = true;
}
}
/// 合并失败时把片段从临时目录搬到用户目录(不丢数据),再清临时目录
private void MoveSegmentsOut(List<(PackStream Stream, PlaybackClip Clip)> done, string folder, string workDir)
{
foreach (var (_, clip) in done)
{
var path = clip.Path;
try
{
var target = Path.Combine(folder, Path.GetFileName(path));
if (File.Exists(target)) File.Delete(target);
File.Move(path, target);
}
catch (Exception ex)
{
AppLog.Write($"[playback] 搬移片段失败:{ex.Message}");
}
}
TryDeleteDirectory(workDir);
}
private static void TryDeleteDirectory(string dir)
{
try
{
if (Directory.Exists(dir)) Directory.Delete(dir, recursive: true);
}
catch (Exception ex)
{
AppLog.Write($"[playback] 清理临时目录失败({dir}):{ex.Message}");
}
}
private void OpenOutputFolder_Click(object sender, RoutedEventArgs e)
{
if (_lastOutputFolder is not { } folder || !Directory.Exists(folder)) return;
Process.Start(new ProcessStartInfo("explorer.exe", $"\"{folder}\"") { UseShellExecute = true });
}
///
/// 把多路片段按工作台布局合并成一个视频
///
/// 画布尺寸与每路的位置都来自**扫码当时的快照**(canvasWidth/Height + layout),
/// 所以合并出来的画面和当时工作台上看到的一模一样。
///
/// 合并成功 → 删临时目录里各路段;失败 → 把片段搬到 保住数据。
///
private async Task ComposeAsync(PackQuery query, List<(PackStream Stream, PlaybackClip Clip)> done,
string output, string workDir)
{
var merged = new List();
try
{
var progress = new Progress(p =>
ShowPlayback(string.Join(Environment.NewLine, merged) + Environment.NewLine + p.Message));
// 各路真实起点不同(都从自己的关键帧开始)→ 按偏移摆回同一时间轴
var path = await _playback.ComposeAsync(
done.Select(item => item.Clip.Path).ToList(),
done.Select(item => item.Stream).ToList(),
output,
done.Select(item => item.Clip.StartOffset).ToList(),
progress, CancellationToken.None);
merged.Add($"合并完成:{path}");
return true;
}
catch (Exception ex)
{
merged.Add($"合并失败:{ex.Message}");
MessageBox.Show(this, $"合并失败:{ex.Message}\n\n各路段已分别保存,可直接使用。",
"合并", MessageBoxButton.OK, MessageBoxImage.Warning);
MoveSegmentsOut(done, Path.GetDirectoryName(output) ?? AppContext.BaseDirectory, workDir);
return false;
}
finally
{
ShowPlayback(string.Join(Environment.NewLine, merged));
}
}
/// 取(并缓存)录像机凭据;密码只在内存里
private async Task CredentialAsync(int nvrId, CancellationToken ct)
{
if (_credentials.TryGetValue(nvrId, out var cached)) return cached;
var credential = await _api.NvrCredentialAsync(_session.Token, _settings.SubjectId, nvrId, ct);
if (string.IsNullOrEmpty(credential.Password))
{
throw new InvalidOperationException(
$"录像机「{credential.Name}」没有保存密码,请到网页端「录像机」页补填后再试");
}
_credentials.TryAdd(nvrId, credential);
return credential;
}
private static string FormatRange(PackStream stream, TimeSpan offset = default)
=> $"{stream.StartTime.Add(offset).ToLocalTime():HH:mm:ss}~{stream.EndTime.Add(offset).ToLocalTime():HH:mm:ss}({stream.DurationSec} 秒,录像机时间)";
private static string SanitizeFile(string text)
{
var invalid = Path.GetInvalidFileNameChars();
return new string(text.Select(ch => invalid.Contains(ch) ? '_' : ch).ToArray());
}
// ---------------- 退出登录 / 关闭 ----------------
private void Logout_Click(object sender, RoutedEventArgs e)
{
// ⚠️ 文案必须与 App.OnLogoutRequested 的真实分支一致:
// 分支只看 AgentPaths.MachineMode,不看服务此刻是否在跑。
// - MachineMode = true :只清登录态,不停/不卸载服务,也不注销设备令牌;
// - MachineMode = false:设备服务开着才 DisableAsync(令牌作废 + 停本进程扫码)。
// 服务实际状态单独查一次 SCM,避免把「已停止」说成「继续运行」。
var lines = new List
{
AgentPaths.MachineMode
? "退出登录会清除本机登录状态并返回登录页:不会停止或卸载后台扫码服务,也不会注销设备令牌。"
: "退出登录会清除本机登录状态并返回登录页。",
};
if (AgentPaths.MachineMode)
{
lines.Add(ServiceInstaller.QueryState() switch
{
AgentServiceState.Running => "后台服务「YuncangTraceAgent」当前运行中,退出登录后扫码、上报、心跳、定时校时继续执行。",
AgentServiceState.Stopped => "后台服务「YuncangTraceAgent」当前是停止状态(退出登录不会把它启动起来)。",
AgentServiceState.StartPending => "后台服务「YuncangTraceAgent」正在启动。",
AgentServiceState.StopPending => "后台服务「YuncangTraceAgent」正在停止。",
AgentServiceState.NotInstalled => "后台服务「YuncangTraceAgent」当前未安装(服务已被移除,退出登录不会重建)。",
_ => "无法查询后台服务「YuncangTraceAgent」的状态。",
});
lines.Add("如需真正停止后台服务,请用菜单「服务 → 关闭设备服务」(停服务 + 卸载 + 注销设备令牌,需要 Windows 管理员授权)。");
}
else if (_device.Enabled)
{
lines.Add("当前没有安装后台服务(普通模式),设备服务由本程序运行:退出登录会关闭它,设备令牌立即作废,本程序的扫码/上报停止。");
}
else
{
lines.Add("当前没有安装后台服务,也没有开启设备服务:退出登录不影响任何后台进程。");
}
lines.Add("在登录页点取消,则只退出桌面端,同样不影响已在运行的后台服务。");
var answer = MessageBox.Show(this,
"要退出登录吗?\n\n" + string.Join(Environment.NewLine, lines),
"退出登录", MessageBoxButton.YesNo, MessageBoxImage.Question);
if (answer != MessageBoxResult.Yes) return;
LogoutRequested?.Invoke();
}
private void OnClosing(object? sender, CancelEventArgs e)
{
if (AllowClose)
{
return;
}
// 关窗口 = 缩到托盘,别把本机服务带走
e.Cancel = true;
Hide();
HiddenToTray?.Invoke();
}
}