desktop: 选路改为「有设备管理服务就统一走它」

之前的判定是「本机连不上 NVR 才走 B」,导致同 LAN 多台机器各连各的,
录像机并发登录数照样被打满,设备管理服务的会话池闲置。

选路(StreamGateway)
- 新增 StreamGateway:广播询问(带 NVR 地址)→ 有应答就用它,
  没有才本机直连;结果缓存 15 秒(含"没找到"的负结果)
- 转发失败时 Invalidate,下次重新探测
- 广播询问带 nvrHosts:对端实测连不上该 NVR 就不应答

校验走设备管理服务
- B 侧新增 POST /check,复用 HikPlaybackService.CheckAsync
  (真拉一小段,语义与桌面端本地校验一致)
- 桌面端校验改为优先交给设备管理服务;服务无响应则降级本机并重新探测
- 并发上限 4,避免多台查询机同时校验把 NVR 打满

下载走设备管理服务
- PlaybackDownloadService 去掉 CanReachNvrAsync 判定,改用 StreamGateway
- 服务端(hik-worker)自身不装网关,永远本地执行

其他
- 边端端口支持 YUNCANG_EDGE_UDP_PORT / YUNCANG_EDGE_HTTP_PORT 覆盖
  (同机并行跑两个实例测试时用,与 YUNCANG_LOCAL_WS_PORT 同思路)
- SDK 校验路径不数帧(返回 -1),界面只在有帧数时显示"试拉 N 帧"
- 顺带修复:下载临时文件名未对 CameraName 做 Sanitize,
  摄像头名含 ? : * 等字符时会整段下载失败

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
This commit is contained in:
liufumingren 2026-10-21 23:51:54 +08:00
parent 46e4f12802
commit 6f8095913b
8 changed files with 346 additions and 60 deletions

View File

@ -6,6 +6,7 @@ using System.Net;
using System.Threading.Tasks;
using System.Windows;
using YuncangTrace.LocalService.Services;
using YuncangTrace.LocalService.Services.Edge;
using YuncangTrace.LocalService.Services.Hik;
using YuncangTrace.LocalService.Services.Scan;
@ -31,6 +32,9 @@ public partial class App : Application
private HikStreamService? _stream;
private HikPreviewService? _preview;
private HikNativePreviewService? _native;
/// <summary>取流选路:有设备管理服务就用它,没有才本机直连</summary>
private StreamGateway? _gateway;
private TrayIconService? _tray;
private MainWindow? _main;
private LoginWindow? _loginWindow;
@ -132,6 +136,9 @@ public partial class App : Application
};
_wsServer.Log += AppLog.Write;
// 选路网关:局域网里有设备管理服务就统一交给它(共用 NVR 会话池),没有才本机直连
_gateway = new StreamGateway(() => _settings.SubjectId);
// 网页查件页的「下载录像」走这里:任何装了本机软件的电脑都能下,存到自己设置的目录
_server.PlaybackDownload = new PlaybackDownloadService(
queryService,
@ -139,7 +146,8 @@ public partial class App : Application
() => _api,
() => _settings.SubjectId,
() => _session?.Token,
() => _settings.VideoRootResolved);
() => _settings.VideoRootResolved,
_gateway);
StartLocalServer();
// 启动协议永远指向「当前这个 exe」:换目录/从 Debug 换成发布版/重新安装后,
@ -443,7 +451,7 @@ public partial class App : Application
{
_device ??= new DeviceService(api, _settings, session);
_scan ??= new ScanService(_device);
_main = new MainWindow(server, _settings, session, api, _device, _scan, _hik!, _subjects);
_main = new MainWindow(server, _settings, session, api, _device, _scan, _hik!, _subjects, _gateway!);
_main.LogoutRequested += OnLogoutRequested;
_main.HiddenToTray += OnHiddenToTray;
_main.RestartRequested += RestartApplication;

View File

@ -11,6 +11,7 @@ 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;
@ -46,6 +47,9 @@ public partial class MainWindow : Window
/// <summary>按时间回放:校验有没有录像 / 下载(走 RTSP 回放 + ffmpeg)</summary>
private readonly HikPlaybackService _playback;
/// <summary>选路:有设备管理服务就把校验/下载交给它(共用 NVR 会话池)</summary>
private readonly StreamGateway _gateway;
/// <summary>MJPEG 转码管线(回放预览用;整个窗口共用一份,自动复用同一地址的流)</summary>
private readonly HikFfmpegService _ffmpeg = new();
@ -98,7 +102,8 @@ public partial class MainWindow : Window
public event Action? RestartRequested;
public MainWindow(LocalHttpServer server, AppSettings settings, Session session, ApiClient api,
DeviceService device, ScanService scan, HikDeviceService hik, IReadOnlyList<ApiSubject> subjects)
DeviceService device, ScanService scan, HikDeviceService hik, IReadOnlyList<ApiSubject> subjects,
StreamGateway gateway)
{
InitializeComponent();
@ -109,6 +114,7 @@ public partial class MainWindow : Window
_device = device;
_scan = scan;
_subjects = subjects;
_gateway = gateway;
_queryService = new OrderQueryService(() => _api, () => _settings.SubjectId, () => _session.Token);
_playback = new HikPlaybackService(hik);
@ -1209,6 +1215,16 @@ public partial class MainWindow : Window
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) lines.Add($"[选路] 交由设备管理服务 {peer.Display} 校验");
try
{
for (var i = 0; i < streams.Count; i++)
@ -1232,15 +1248,48 @@ public partial class MainWindow : Window
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);
var hasRecord = false;
var frames = 0;
string? error = null;
if (check.HasRecord) valid.Add(stream);
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);
lines.Add(check.HasRecord
? $"[有录像] {stream.DisplayName} {FormatRange(stream, clock)} 试拉 {check.Frames} 帧"
: $"[无录像] {stream.DisplayName} {FormatRange(stream, clock)} {check.Error}");
if (remote is null)
{
// 服务端没回结果:视为校验失败,降级到本机再试一次
_gateway.Invalidate();
peer = null;
lines.Add("[选路] 设备管理服务无响应,改由本机校验");
}
else
{
hasRecord = remote.HasRecord;
frames = remote.Frames;
error = remote.Error;
}
}
if (peer is null)
{
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;
}
if (hasRecord) valid.Add(stream);
// SDK 路径不数帧(返回 -1),只有 RTSP 兜底才有帧数
var frameText = frames > 0 ? $" 试拉 {frames} 帧" : "";
lines.Add(hasRecord
? $"[有录像] {stream.DisplayName} {FormatRange(stream, clock)}{frameText}"
: $"[无录像] {stream.DisplayName} {FormatRange(stream, clock)} {error}");
}
catch (Exception ex)
{

View File

@ -9,6 +9,7 @@ using System.Text;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
using YuncangTrace.LocalService.Services.Hik;
namespace YuncangTrace.LocalService.Services;
@ -37,6 +38,7 @@ public sealed class EdgeHttpService
private readonly EdgeDownloadTasks _tasks;
private readonly SemaphoreSlim _downloadGate;
private readonly SemaphoreSlim _checkGate = new(4, 4);
private readonly Func<int, bool> _subjectGuard;
/// <param name="subjectGuard">主体校验:返回 false 直接 403(避免跨主体取流)</param>
@ -47,7 +49,8 @@ public sealed class EdgeHttpService
_subjectGuard = subjectGuard;
}
public async Task RunAsync(PlaybackDownloadService download, CancellationToken ct)
public async Task RunAsync(PlaybackDownloadService download, HikPlaybackService playback,
CancellationToken ct)
{
TcpListener listener;
try
@ -103,7 +106,7 @@ public sealed class EdgeHttpService
continue;
}
_ = Task.Run(() => HandleAsync(client, download, ct), CancellationToken.None);
_ = Task.Run(() => HandleAsync(client, download, playback, ct), CancellationToken.None);
}
}
finally
@ -121,7 +124,8 @@ public sealed class EdgeHttpService
private sealed record HttpRequest(string Method, string Path, Dictionary<string, string> Headers, byte[] Body);
private async Task HandleAsync(TcpClient client, PlaybackDownloadService download, CancellationToken ct)
private async Task HandleAsync(TcpClient client, PlaybackDownloadService download,
HikPlaybackService playback, CancellationToken ct)
{
try
{
@ -134,7 +138,7 @@ public sealed class EdgeHttpService
var request = await ReadRequestAsync(stream, timeout.Token).ConfigureAwait(false);
if (request is null) return;
await RouteAsync(stream, request, download, timeout.Token).ConfigureAwait(false);
await RouteAsync(stream, request, download, playback, timeout.Token).ConfigureAwait(false);
}
}
catch (OperationCanceledException)
@ -148,7 +152,7 @@ public sealed class EdgeHttpService
}
private async Task RouteAsync(Stream stream, HttpRequest request, PlaybackDownloadService download,
CancellationToken ct)
HikPlaybackService playback, CancellationToken ct)
{
var path = request.Path.Split('?')[0];
@ -181,6 +185,13 @@ public sealed class EdgeHttpService
return;
}
if (path.Equals("/check", StringComparison.OrdinalIgnoreCase)
&& request.Method.Equals("POST", StringComparison.OrdinalIgnoreCase))
{
await HandleCheckAsync(stream, request, playback, ct).ConfigureAwait(false);
return;
}
if (path.Equals("/download", StringComparison.OrdinalIgnoreCase)
&& request.Method.Equals("POST", StringComparison.OrdinalIgnoreCase))
{
@ -297,6 +308,96 @@ public sealed class EdgeHttpService
}, ct).ConfigureAwait(false);
}
/// <summary>
/// 校验该时段有没有录像:**真拉一小段**(与桌面端本地的校验同一套实现)。
///
/// 查询机会先在局域网问"谁能服务这台 NVR",拿到应答后把校验也交给它,
/// 这样多台查询机不会各自登录一次 NVR。
/// </summary>
private async Task HandleCheckAsync(Stream stream, HttpRequest request, HikPlaybackService playback,
CancellationToken ct)
{
string host;
int port = 8000;
string username;
string password;
int channelNo;
DateTimeOffset start;
DateTimeOffset end;
try
{
using var doc = JsonDocument.Parse(request.Body);
var root = doc.RootElement;
host = ReadString(root, "nvrHost") ?? "";
username = ReadString(root, "username") ?? "";
password = ReadString(root, "password") ?? "";
if (root.TryGetProperty("nvrPort", out var portElement) && portElement.TryGetInt32(out var parsedPort))
{
port = parsedPort;
}
if (!root.TryGetProperty("channelNo", out var channelElement) || !channelElement.TryGetInt32(out channelNo))
{
throw new InvalidOperationException("缺少 channelNo");
}
if (!root.TryGetProperty("startTime", out var startElement) || !startElement.TryGetDateTimeOffset(out start)
|| !root.TryGetProperty("endTime", out var endElement) || !endElement.TryGetDateTimeOffset(out end))
{
throw new InvalidOperationException("startTime/endTime 不合法");
}
if (string.IsNullOrWhiteSpace(host) || port is <= 0 or > 65535)
{
throw new InvalidOperationException("nvrHost/nvrPort 不合法");
}
}
catch (Exception ex)
{
await WriteJsonAsync(stream, 400, "Bad Request", new { ok = false, error = ex.Message }, ct)
.ConfigureAwait(false);
return;
}
await _checkGate.WaitAsync(ct).ConfigureAwait(false);
try
{
var check = await playback.CheckAsync(host, port, username, password, channelNo, start, end, ct)
.ConfigureAwait(false);
await WriteJsonAsync(stream, 200, "OK", new
{
ok = true,
hasRecord = check.HasRecord,
frames = check.Frames,
error = check.Error,
source = check.Source,
}, ct).ConfigureAwait(false);
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception ex)
{
await WriteJsonAsync(stream, 200, "OK", new
{
ok = true,
hasRecord = false,
frames = 0,
error = ex.Message,
source = "",
}, ct).ConfigureAwait(false);
}
finally
{
_checkGate.Release();
}
}
private async Task HandleDownloadAsync(Stream stream, HttpRequest request, PlaybackDownloadService download,
CancellationToken ct)
{

View File

@ -53,7 +53,7 @@ public static class HikWorker
subjectId => AgentFiles.LoadConfig() is { } config && config.SubjectId == subjectId && subjectId > 0);
_ = Task.Run(() => RunLanResponderAsync(ct), CancellationToken.None);
_ = Task.Run(() => edgeHttp.RunAsync(download, ct), CancellationToken.None);
_ = Task.Run(() => edgeHttp.RunAsync(download, playback, ct), CancellationToken.None);
try
{

View File

@ -117,8 +117,17 @@ public static class HikWorkerOps
/// </summary>
public static class HikWorkerPorts
{
public const int UdpQuery = 17310;
public const int Http = 17311;
/// <summary>可用 <c>YUNCANG_EDGE_UDP_PORT</c> 临时覆盖(同机并行跑两个实例测试时用)</summary>
public static int UdpQuery { get; } = Resolve("YUNCANG_EDGE_UDP_PORT", 17310);
/// <summary>可用 <c>YUNCANG_EDGE_HTTP_PORT</c> 临时覆盖</summary>
public static int Http { get; } = Resolve("YUNCANG_EDGE_HTTP_PORT", 17311);
private static int Resolve(string name, int fallback)
{
var raw = Environment.GetEnvironmentVariable(name);
return int.TryParse(raw, out var port) && port is > 0 and < 65536 ? port : fallback;
}
}
/// <summary>局域网询问/应答的报文(两端共用)</summary>

View File

@ -20,6 +20,9 @@ public sealed record EdgeTaskStatus(string TaskId, string State, string? Progres
/// <summary>探测某台 NVR 从取流服务那边能不能连上</summary>
public sealed record EdgeProbeResult(bool Reachable, long LatencyMs);
/// <summary>校验结果(服务端真去拉了一小段,不是查库猜的)</summary>
public sealed record EdgeCheckResult(bool HasRecord, int Frames, string? Error, string? Source);
/// <summary>
/// 取流服务的 HTTP 客户端(查询机这一侧)。
///
@ -60,6 +63,39 @@ public sealed class EdgeClient : IDisposable
return new EdgeProbeResult(reachable, latency);
}
/// <summary>
/// 校验该时段有没有录像(由设备管理服务在它自己的内网执行)
///
/// 与桌面端本地 [HikPlaybackService.CheckAsync] 语义一致:真拉一小段看有没有帧,
/// 所以两边不会各说一套。
/// </summary>
public async Task<EdgeCheckResult?> CheckAsync(NvrCredential credential, int channelNo,
DateTimeOffset start, DateTimeOffset end, CancellationToken ct = default)
{
var payload = new
{
nvrHost = credential.Host,
nvrPort = credential.Port,
username = credential.Username,
password = credential.Password,
channelNo,
startTime = start.ToString("O"),
endTime = end.ToString("O"),
};
using var response = await SendAsync(HttpMethod.Post, "/check", payload, ct).ConfigureAwait(false);
if (!response.IsSuccessStatusCode) return null;
using var doc = JsonDocument.Parse(await response.Content.ReadAsStringAsync(ct).ConfigureAwait(false));
var root = doc.RootElement;
var hasRecord = root.TryGetProperty("hasRecord", out var value)
&& value.ValueKind == JsonValueKind.True;
var frames = root.TryGetProperty("frames", out var f) && f.TryGetInt32(out var parsed) ? parsed : 0;
return new EdgeCheckResult(hasRecord, frames, GetString(root, "error"), GetString(root, "source"));
}
/// <summary>下发下载计划,返回任务 id(服务端后台执行)</summary>
public async Task<string?> CreateDownloadAsync(string code,
IReadOnlyList<PackStream> streams,

View File

@ -0,0 +1,101 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
namespace YuncangTrace.LocalService.Services.Edge;
/// <summary>
/// 决定「这次取流请求由谁执行」:局域网里的**设备管理服务**,还是本机。
///
/// 规则只有一条 —— **有设备管理服务就全部交给它**,没有才由本机自己连 NVR。
/// 不看"本机能不能连 NVR":多台查询机各自连 NVR 会把录像机的并发登录数打满
/// (海康常见 6~16),而设备管理服务本来就有会话池,能复用、能限流。
///
/// 探测结果缓存 <see cref="CacheTtl"/> 秒(含"没找到"的负结果),
/// 避免每次请求都白等一次广播;转发失败时调用 <see cref="Invalidate"/> 重新探测。
/// </summary>
public sealed class StreamGateway
{
private static readonly TimeSpan CacheTtl = TimeSpan.FromSeconds(15);
private readonly Func<int> _subjectId;
private readonly SemaphoreSlim _gate = new(1, 1);
private string _cacheKey = "";
private EdgePeer? _cached;
private DateTime _cachedAt = DateTime.MinValue;
/// <param name="subjectIdProvider">当前主体(探测只认同主体应答)</param>
public StreamGateway(Func<int> subjectIdProvider)
{
_subjectId = subjectIdProvider;
}
/// <summary>找一台能服务这些 NVR 的设备管理服务;没有返回 null(调用方走本机)</summary>
public async Task<EdgePeer?> FindAsync(IReadOnlyList<(string Host, int Port)> nvrs,
CancellationToken ct = default)
{
var subjectId = _subjectId();
if (subjectId <= 0) return null;
var key = BuildKey(subjectId, nvrs);
if (TryGetCached(key, out var cached)) return cached;
await _gate.WaitAsync(ct).ConfigureAwait(false);
try
{
if (TryGetCached(key, out cached)) return cached;
var peer = await EdgeDiscoveryClient.FindAsync(subjectId, nvrs, ct).ConfigureAwait(false);
if (peer is not null)
{
AppLog.Write($"[edge] 走设备管理服务 {peer.Display}"
+ $"(可服务 {string.Join("、", peer.Reachable)})");
}
_cacheKey = key;
_cached = peer;
_cachedAt = DateTime.UtcNow;
return peer;
}
finally
{
_gate.Release();
}
}
/// <summary>转发失败时调用:下次重新探测,避免一直指着一台已经不可用的服务</summary>
public void Invalidate()
{
_cached = null;
_cachedAt = DateTime.MinValue;
_cacheKey = "";
}
private bool TryGetCached(string key, out EdgePeer? peer)
{
if (_cachedAt != DateTime.MinValue
&& string.Equals(_cacheKey, key, StringComparison.Ordinal)
&& DateTime.UtcNow - _cachedAt < CacheTtl)
{
peer = _cached;
return true;
}
peer = null;
return false;
}
private static string BuildKey(int subjectId, IReadOnlyList<(string Host, int Port)> nvrs)
{
var hosts = nvrs
.Where(item => !string.IsNullOrWhiteSpace(item.Host))
.Select(item => $"{item.Host}:{item.Port}")
.Distinct(StringComparer.OrdinalIgnoreCase)
.OrderBy(item => item, StringComparer.OrdinalIgnoreCase);
return subjectId + "|" + string.Join(",", hosts);
}
}

View File

@ -2,7 +2,6 @@ using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net.Sockets;
using System.Threading;
using System.Threading.Tasks;
using YuncangTrace.LocalService.Services.Edge;
@ -52,13 +51,17 @@ public sealed class PlaybackDownloadService
private readonly Func<string?> _token;
private readonly Func<string> _root;
/// <summary>选路:有设备管理服务就交给它,没有才本机下载(服务端自身为 null)</summary>
private readonly StreamGateway? _gateway;
public PlaybackDownloadService(
OrderQueryService query,
HikPlaybackService playback,
Func<ApiClient?> apiProvider,
Func<int> subjectIdProvider,
Func<string?> tokenProvider,
Func<string> videoRootProvider)
Func<string> videoRootProvider,
StreamGateway? gateway = null)
{
_query = query;
_playback = playback;
@ -66,6 +69,7 @@ public sealed class PlaybackDownloadService
_subjectId = subjectIdProvider;
_token = tokenProvider;
_root = videoRootProvider;
_gateway = gateway;
}
/// <summary>
@ -101,16 +105,21 @@ public sealed class PlaybackDownloadService
.Distinct()
.ToList();
// 选路:本机能直连 NVR 就自己下(与以前行为完全一致);
// 连不上说明在别的网段 —— 找同主体的取流服务代取,取回来落到本机。
if (nvrs.Count > 0 && !await CanReachNvrAsync(nvrs[0].Host, nvrs[0].NvrPort, ct).ConfigureAwait(false))
// 选路:局域网里有设备管理服务就交给它(共用它的 NVR 会话池,避免多机各自登录),
// 没有才由本机自己连 NVR。
var peer = _gateway is null
? null
: await _gateway.FindAsync(nvrs, ct).ConfigureAwait(false);
if (peer is not null)
{
var viaEdge = await TryDownloadViaEdgeAsync(code, streams, scanTime, nvrs, progress, ct)
var viaEdge = await TryDownloadViaEdgeAsync(peer, code, streams, scanTime, progress, ct)
.ConfigureAwait(false);
if (viaEdge is not null) return viaEdge;
progress?.Report("本机连不上录像机,也没有可用的取流服务,尝试直连…");
_gateway?.Invalidate();
progress?.Report("设备管理服务执行失败,改由本机直连录像机…");
}
return await DownloadByPlanAsync(
@ -123,49 +132,20 @@ public sealed class PlaybackDownloadService
ct).ConfigureAwait(false);
}
/// <summary>本机能不能连到这台 NVR(只判 TCP,不发设备协议)</summary>
private static async Task<bool> CanReachNvrAsync(string host, int port, CancellationToken ct)
{
try
{
using var tcp = new TcpClient();
using var timeout = CancellationTokenSource.CreateLinkedTokenSource(ct);
timeout.CancelAfter(TimeSpan.FromMilliseconds(600));
await tcp.ConnectAsync(host, port, timeout.Token).ConfigureAwait(false);
return tcp.Connected;
}
catch (OperationCanceledException) when (!ct.IsCancellationRequested)
{
return false;
}
catch
{
return false;
}
}
/// <summary>
/// 跨网路径:广播找同主体的取流服务 → 派任务 → 轮询 → 把成片拉回本机。
/// 交给设备管理服务:派任务 → 轮询 → 把成片拉回本机。
///
/// 返回 null 表示「没找到/没接单」,调用方继续走本机直连(保持原有失败语义)。
/// 返回 null 表示「没接单/没完成」,调用方降级到本机直连(保持原有失败语义)。
/// </summary>
private async Task<PlaybackDownloadResult?> TryDownloadViaEdgeAsync(
EdgePeer peer,
string code,
IReadOnlyList<PackStream> streams,
DateTime scanTime,
IReadOnlyList<(string Host, int Port)> nvrs,
IProgress<string>? progress,
CancellationToken ct)
{
var subjectId = _subjectId?.Invoke() ?? 0;
if (subjectId <= 0) return null;
progress?.Report("本机连不上录像机,正在查找取流服务…");
var peer = await EdgeDiscoveryClient.FindAsync(subjectId, nvrs, ct).ConfigureAwait(false);
if (peer is null) return null;
progress?.Report($"已找到取流服务 {peer.Display},正在下发任务…");
progress?.Report($"交由设备管理服务 {peer.Display} 执行…");
// 凭据仍从后端取:取流服务那边只有设备令牌,拿不到用户态凭据
var credentials = new List<NvrCredential>();
@ -275,7 +255,7 @@ public sealed class PlaybackDownloadService
var credential = await CredentialAsync(stream.NvrId, credentials, credentialGate,
credentialProvider, ct).ConfigureAwait(false);
var name = $"{Sanitize(code)}_{stream.CameraId}_{stream.CameraName}"
var name = $"{Sanitize(code)}_{stream.CameraId}_{Sanitize(stream.CameraName)}"
+ $"_{stream.StartTime.ToLocalTime():yyyyMMdd_HHmmss}.mp4";
var path = Path.Combine(workDir, name);
@ -400,8 +380,10 @@ public sealed class PlaybackDownloadService
return await api.NvrCredentialAsync(token, _subjectId(), nvrId, ct).ConfigureAwait(false);
}
private static string Sanitize(string text)
private static string Sanitize(string? text)
{
if (string.IsNullOrEmpty(text)) return "_";
var invalid = Path.GetInvalidFileNameChars();
return new string(text.Select(ch => invalid.Contains(ch) ? '_' : ch).ToArray());
}