packServer/desktop/MainWindow.xaml.cs
liufumingren 6f52613e5e feat(desktop): 下线 Edge 企业策略安装(扩展已上架商店)
- 工具菜单去掉「安装浏览器插件(企业策略:Chrome / Edge)」「卸载浏览器插件(企业策略)」,
  删除 Services/ExtensionInstaller.cs(.reg 生成 + 提权导入 + 注册表校验)
- 只保留「安装浏览器插件(Edge 应用商店)」与「复制插件路径(Chrome / 开发者模式)」;
  商店弹窗去掉「审核中会 404」的说法,Chrome 用户直接引导到开发者模式
- 文档同步(桌面 README / 后端 README / extension README / STORE-SUBMISSION / keys README):
  写清老机器上残留的 HKLM 策略怎么手工清理,避免和商店版同时注入
- extension:publish(.crx + updates.xml)保留,仅给内网/离线分发用

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-11-01 16:32:55 +08:00

2067 lines
88 KiB
C#
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

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;
/// <summary>
/// 主窗口:打包查询 / 扫码通道(设备服务开启后出现)/ 主体切换 / 设备服务
///
/// - **设备服务默认不开启**,入口在菜单「服务 → 开启设备服务」;
/// - 「开启设备服务」**只对主体管理员可见**(非管理员菜单项直接隐藏);
/// - 一个主体只允许一台设备在线:开启时服务端会把同主体其他设备踢下线(界面会先提示);
/// - 开启后自动启动「扫码服务」(TCP 收码 + 上报),并显示「扫码通道」页签;
/// - 菜单「工具 → 打开配置页」带令牌直接打开后台网页。
///
/// 关窗口**不是退出**:只是隐藏到托盘(本机服务得继续跑)。
/// 真正退出:托盘菜单「退出」,或点「退出登录」后再取消登录。
/// </summary>
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;
/// <summary>运单回放查询(后端 `/api/web/pack-query`,用当前主体的用户令牌)</summary>
private readonly OrderQueryService _queryService;
/// <summary>按时间回放:校验有没有录像 / 下载(走 RTSP 回放 + ffmpeg)</summary>
private readonly HikPlaybackService _playback;
/// <summary>选路:有设备管理服务就把校验/下载交给它(共用 NVR 会话池)</summary>
private readonly StreamGateway _gateway;
/// <summary>MJPEG 转码管线(回放预览用;整个窗口共用一份,自动复用同一地址的流)</summary>
private readonly HikFfmpegService _ffmpeg = new();
/// <summary>当前展示的查询结果(回放计划;没有工作台时不具备拉流条件)</summary>
private PackQuery? _currentQuery;
/// <summary>
/// 「预览回放 / 下载录像」要用的流。
///
/// 查询命中后**自动**去录像机试拉:只要**任意一路**拉到录像就停止校验,
/// 此时这里放的是**全部**流(没录像的那几路下载时会自己跳过,避免合并不全);
/// 一路都没拉到则为空 —— 两个按钮也不显示。
/// </summary>
private IReadOnlyList<PackStream> _validatedStreams = Array.Empty<PackStream>();
/// <summary>
/// 这次查询是「跨网」:查询机连不到仓库的 NVR,下载只能由云端转给能访问 NVR 的扫码服务代取。
/// 由 <see cref="ValidatePlaybackAsync"/> 的选路结果设置。
/// </summary>
private bool _cloudDownload;
/// <summary>录像机凭据缓存(同一台 NVR 只取一次密码;多路并行下载会同时访问)</summary>
private readonly ConcurrentDictionary<int, NvrCredential> _credentials = new();
/// <summary>正在跑的回放下载任务的取消源</summary>
private CancellationTokenSource? _playbackCts;
/// <summary>正在跑的「自动校验回放」的取消源(与下载分开:新查询只打断校验,不打断下载)</summary>
private CancellationTokenSource? _validateCts;
/// <summary>最近一次下载/合并的输出目录(「打开目录」用)</summary>
private string? _lastOutputFolder;
/// <summary>本次运行是否已尝试过「补发刷新令牌」(后端不支持时避免反复激活)</summary>
private bool _refreshBackfillTried;
/// <summary>已经请求退出登录(主体校验失败时用):Loaded 后续逻辑不要再跑</summary>
private bool _returnToLogin;
/// <summary>当前主体(登录后先拉一次;切换时更新)</summary>
private IReadOnlyList<ApiSubject> _subjects = Array.Empty<ApiSubject>();
/// <summary>允许真正关闭窗口(退出登录 / 退出程序时由 App 置 true)</summary>
public bool AllowClose { get; set; }
/// <summary>用户点了「退出登录」</summary>
public event Action? LogoutRequested;
/// <summary>窗口被隐藏到托盘(用来弹一次气泡提示)</summary>
public event Action? HiddenToTray;
/// <summary>菜单「帮助 → 检查更新」(交给 App 处理,复用启动时的检查逻辑)</summary>
public event Action? CheckUpdateRequested;
/// <summary>菜单「服务 → 重启软件」(交给 App 处理:先退出再延迟拉起)</summary>
public event Action? RestartRequested;
public MainWindow(LocalHttpServer server, AppSettings settings, Session session, ApiClient api,
DeviceService device, ScanService scan, HikDeviceService hik, IReadOnlyList<ApiSubject> 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;
}
/// <summary>
/// 被协议拉起 / 另一个实例把参数转过来时调用:<c>yuncang://open?code=xxx</c>
/// </summary>
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();
}
// ---------------- 主体 ----------------
/// <summary>
/// 确定界面使用的当前主体:
/// 1) 账号下没有任何主体 → 提示后退回登录页(扫码服务仍按原主体继续跑);
/// 2) 已保存的主体仍属于当前登录账号 → 沿用;
/// 3) 不属于(换账号登录)→ 后台服务模式下不改服务配置,只把界面切到当前账号可用的主体;
/// 普通模式下清掉旧主体与设备本地状态;
/// 4) 没有保存过主体 → 自动选第一个可用的。
/// </summary>
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();
}
/// <summary>页签上方的主体/服务不一致提示(null / 空 = 隐藏)</summary>
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;
}
/// <summary>菜单里的设备令牌状态(到期时间取自 agent-token.json)</summary>
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} 已续期)";
}
}
/// <summary>手动让后台服务用刷新令牌续期一次(测试/排障)</summary>
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);
}
/// <summary>后台服务当前绑定的主体 id(未处于服务模式时为 0)。</summary>
private int ServiceSubjectId
{
get
{
if (!AgentPaths.MachineMode) return 0;
try { return AgentFiles.LoadConfig()?.SubjectId ?? 0; }
catch { return 0; }
}
}
/// <summary>后台服务绑定的主体与当前界面主体不一致(换账号登录后可能出现)。</summary>
private bool ServiceSubjectMismatch
{
get
{
var id = ServiceSubjectId;
return AgentPaths.MachineMode && _device.Enabled && id > 0 && id != _settings.SubjectId;
}
}
/// <summary>
/// 把当前设置转成后台服务的 agent.json(长期设备令牌是关键,服务靠它上报)。
/// </summary>
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,
};
/// <summary>
/// 服务模式自检:服务副本版本 / 运行状态。
/// 升级后首次启动会提示更新副本(一次 UAC);服务被停下时提示启动。
/// </summary>
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}");
}
}
/// <summary>启动扫码服务(TCP 收码 + 通道同步;仅**旧模式**用,服务模式下由 Windows 服务负责)</summary>
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);
}
// ---------------- 服务状态 ----------------
/// <summary>只刷菜单里的状态项:本机服务跟随程序生命周期(启动即开、退出即停)</summary>
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}");
}
}
/// <summary>用资源管理器打开日志目录(按天一个 log_yyyy-MM-dd.txt)</summary>
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);
}
}
/// <summary>Edge 加载项商店的安装页(已上架,点「获取」即可)</summary>
private const string ExtensionStoreUrl =
"https://microsoftedge.microsoft.com/addons/detail/mgdonmkicojkabgalgekobaoohaohfcj";
/// <summary>
/// 「工具 → 安装浏览器插件(Edge 应用商店)」:用 msedge.exe 打开商店安装页。
///
/// Edge 扩展已上架商店,装了 Edge 就点「获取」,不需要开发者模式、不需要管理员权限,
/// 也不需要企业策略;Chrome 装不了 Edge 商店的扩展,走「复制插件路径(Chrome / 开发者模式)」。
/// </summary>
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);
}
}
/// <summary>找 Edge 的可执行文件(没装返回 null)</summary>
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;
}
/// <summary>
/// 「工具 → 复制插件路径(开发者模式)」:插件随安装包释放到 &lt;安装目录&gt;\extension,
/// 复制这个 Windows 路径,再到 chrome://extensions「加载已解压的扩展程序」里粘进去。
/// </summary>
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);
}
}
/// <summary>剪贴板不可用时的兜底:把路径写进临时 txt 并用记事本打开</summary>
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}");
}
}
/// <summary>
/// 复制到剪贴板:**全部操作放到后台 STA 线程,带超时**,绝不卡住界面。
///
/// 现场实测:远程桌面 / 剪贴板同步工具(这台机器上是 BilldDesk)会长期把剪贴板开着,
/// 这时 `OpenClipboard` 直接失败,`OleGetClipboard`(读)甚至会一直阻塞到对方松手 ——
/// 所以连「先核对内容」都得放到后台线程,主线程只等一小会儿。
/// </summary>
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);
/// <summary>谁正把剪贴板开着(远程桌面 / 剪贴板同步工具最常见),查不到就返回 null</summary>
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;
}
}
/// <summary>补一次 OleFlushClipboard(把「延迟渲染」的数据真正落到剪贴板里)</summary>
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}");
}
}
/// <summary>读回剪贴板核对内容(写失败但实际已写入 / 本来就在里面)</summary>
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;
}
/// <summary>在一条新的 STA 线程上执行剪贴板操作(COM 单元干净,超时后不再等,界面不会被卡住)</summary>
private static bool RunOnStaThread(Func<bool> 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();
/// <summary>
/// 菜单「工具 → 打开配置页」:用系统浏览器打后台(带令牌,免登录)。
///
/// 地址就是后端根地址(开发环境 `http://127.0.0.1:7300/`),前端启动时会拂 `?token=` 存进本地;
/// 登陆态不在 URL 里长期停留(前端拿到就 `replaceState` 掉了)。
/// </summary>
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)";
}
// ---------------- 设置:录像存储路径 ----------------
/// <summary>
/// 设置录像存储根目录
///
/// 切换时把老目录里的文件**全部搬过去**(保留年/月/日结构),搬完删掉空的旧目录。
/// 有文件时先让用户确认——这是不可回退的操作。
/// </summary>
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<string>(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();
}
/// <summary>
/// 用户主动查询(输入框回车 / 点查询 / 协议唤起)。
///
/// ⚠️ **查询不产生扫码记录**:扫码记录只来自真实通道(扫码枪/中控),
/// 以前这里会往 `DESKTOP` 通道记一笔,结果查一次运单就多一条「无工作台」的噪声记录。
/// </summary>
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);
}
/// <summary>把一次查询结果填到「打包查询」页(也会清掉页签上的「有新结果」圆点)</summary>
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<PackStream>();
_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;
}
/// <summary>
/// 预览回放:按工作台的画布布局多路同时播
///
/// 走 RTSP 回放(实测这台 NVR 只有 554 能拉回放,8000 的 GetFileByTime 不推数据)。
/// </summary>
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<int, NvrCredential>();
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;
}
/// <summary>预览/下载按钮的显隐同样可能来自线程池线程,统一在这里切回 UI 线程。</summary>
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;
}
/// <summary>
/// 自动校验回放:**真的去录像机拉一下**这段时间有没有录像
///
/// 为什么必须真拉:NVR 不会告诉你「这段是空的」,只有在回放通道上拉流才知道。
/// 查询命中扫码记录后自动跑(不需要用户点按钮),每路拉 2 秒;
/// **只要任意一路有录像就停止**(不需要把每一路都验完)→ 显示预览/下载。
/// 顺序做,避免同时占满设备连接。
/// </summary>
/// <summary>
/// 问云端「这段录像有没有帧」;云端不可用时返回 null(调用方降级到本机校验)
/// </summary>
private async Task<ApiClient.EdgeCheckOutcome?> 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<string> { $"正在校验 {streams.Count} 路回放…" };
ShowPlayback(string.Join(Environment.NewLine, lines));
var valid = new List<PackStream>();
var clockNoted = new HashSet<int>();
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<PackStream>();
// 本机连不到仓库的 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<PackStream>();
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<PackStream>();
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}");
}
}
/// <summary>
/// 下载录像:选一个目录,多路**自动**按工作台布局合并成一个视频
///
/// 流程:
/// 1. 各路段先下到**系统临时目录**(不污染用户选的目录);
/// 2. 多路 → 自动合并(不再弹「要合并吗」);单路 → 直接搬过去;
/// 3. 成功后删临时片段,用户目录里只留一个成片;失败则把片段搬过去保留数据。
/// </summary>
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<string>();
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<Task>();
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<PlaybackProgress>(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;
}
}
/// <summary>
/// 跨网下载:云端建任务 → 仓库设备(能访问 NVR 的那台)拉流合并并上传 → 本机取回落盘。
///
/// 查询机到仓库 NVR 的 8000/554 都不通,所以这里**不回落**本机直连。
/// </summary>
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<string>(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<string> { $"已保存:{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;
}
}
/// <summary>合并失败时把片段从临时目录搬到用户目录(不丢数据),再清临时目录</summary>
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 });
}
/// <summary>
/// 把多路片段按工作台布局合并成一个视频
///
/// 画布尺寸与每路的位置都来自**扫码当时的快照**(canvasWidth/Height + layout),
/// 所以合并出来的画面和当时工作台上看到的一模一样。
///
/// 合并成功 → 删临时目录里各路段;失败 → 把片段搬到 <paramref name="folder"/> 保住数据。
/// </summary>
private async Task<bool> ComposeAsync(PackQuery query, List<(PackStream Stream, PlaybackClip Clip)> done,
string output, string workDir)
{
var merged = new List<string>();
try
{
var progress = new Progress<PlaybackProgress>(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));
}
}
/// <summary>取(并缓存)录像机凭据;密码只在内存里</summary>
private async Task<NvrCredential> 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<string>
{
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();
}
}