liufumingren 993c7acd30 跨公司下载:云端中转成片(分片上传 + Range 下载)
A(查询机)和 B(仓库)不同网络、B 无公网 IP。B 出站领任务后把成片传回云端中转,
A 再从云端取回本地 —— 全程不需要任何一方有公网入口。

云端
- POST /api/web/edge/download      建任务(按主体选在线设备 → 下发 download)
- GET  /api/web/edge/download/:id  查进度(queued/uploading/done/failed)
- GET  /api/web/edge/download/:id/file  取成片,支持 Range(浏览器播放要拖动进度条)
- POST /api/scanner/tasks/:id/upload  设备分片上传(原始字节流,不是 base64)
- bodyParser 对该上传路由禁用:否则原始请求体会被解析掉
- 成片落 run/edge-files(run/ 属部署保留目录,不会被发布覆盖)
- 每次建任务顺手清理过期文件;元数据按主体校验,越权一律 404

桌面端
- AgentHost 新增 download 任务执行:worker 拉流合并 → 分片上传 → 传完删本地临时文件
- 失败时把 uploadTaskId 带回云端,立刻落 failed,查询机不用干等到超时
- ApiClient 新增建任务 / 查状态 / 取文件 / 分片上传
- PlaybackDownloadService 改为三级选路:
  LAN 设备管理服务 → 云端中转 → 本机直连

实测(真实 NVR)
  建任务 → 设备拉流 1.9MB → 上传 → 下载:7.5 秒,字节数一致,ftypisom
  Range: bytes=0-99 → HTTP 206 + Content-Range 正确

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-10-22 00:30:09 +08:00

700 lines
29 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.Generic;
using System.IO;
using System.Linq;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
using YuncangTrace.LocalService.Services.Scan;
namespace YuncangTrace.LocalService.Services;
/// <summary>
/// 后台扫码服务的运行主体(LocalSystem)。
///
/// 职责:
/// 1. 读 <c>%ProgramData%\YuncangTrace\agent.json</c> 里的**长期设备令牌**,跑扫码 TCP 收码 + 上报循环;
/// 2. 监视 <c>channels.json</c>(桌面端改通道后自动重连);
/// 3. 定时 NTP 校时(LocalSystem 改系统时间不需要 UAC);
/// 4. 把运行状态写进 <c>agent-status.json</c>,桌面端只读展示;
/// 5. 执行桌面端写进 <c>agent-command.json</c> 的一次性命令(立即上传 / 清空记录 / 立即校时)。
///
/// 与桌面端**完全解耦**:桌面端退出、用户注销都不影响这里。
/// </summary>
public static class AgentHost
{
/// <summary>状态写盘保活间隔(内容没变也最多 30 秒写一次)</summary>
private static readonly TimeSpan StatusKeepAlive = TimeSpan.FromSeconds(30);
private sealed class NtpState
{
public string LastSyncAt { get; set; } = "";
public double OffsetSeconds { get; set; }
public double RoundTripMs { get; set; }
public DateTime? ServerTime { get; set; }
public string? Error { get; set; }
}
public static async Task RunAsync(CancellationToken ct)
{
AgentPaths.MachineMode = true;
AgentPaths.IsServiceProcess = true;
AppLog.Write("[agent] 后台扫码服务启动");
try
{
while (!ct.IsCancellationRequested)
{
var config = AgentFiles.LoadConfig();
if (config is null
|| string.IsNullOrWhiteSpace(config.ServerBaseUrl)
|| string.IsNullOrWhiteSpace(config.DeviceToken))
{
AppLog.Write("[agent] 还没有可用配置(等待桌面端「开启设备服务」写入 agent.json)");
AgentFiles.SaveStatus(new AgentStatus
{
Running = false,
Version = Version,
LastError = "没有配置(agent.json 缺失或缺少设备令牌)",
});
if (!await DelayAsync(TimeSpan.FromSeconds(3), ct).ConfigureAwait(false)) break;
continue;
}
try
{
await RunCoreAsync(config, ct).ConfigureAwait(false);
}
catch (OperationCanceledException)
{
break;
}
catch (Exception ex)
{
AppLog.Write($"[agent] 运行失败:{ex.Message}");
AgentFiles.SaveStatus(new AgentStatus
{
Running = false,
Version = Version,
DeviceSn = config.DeviceSn,
SubjectId = config.SubjectId,
LastError = ex.Message,
});
if (!await DelayAsync(TimeSpan.FromSeconds(5), ct).ConfigureAwait(false)) break;
}
}
}
finally
{
AgentFiles.SaveStatus(new AgentStatus { Running = false, Version = Version });
AppLog.Write("[agent] 后台扫码服务停止");
}
}
private static string Version =>
typeof(AgentHost).Assembly.GetName().Version?.ToString() ?? "1.0.0";
private static async Task RunCoreAsync(AgentConfig config, CancellationToken ct)
{
// 用内存里的设置喂给 DeviceService:它只用到 DeviceToken / DeviceSn / SubjectId / Enabled
var settings = new AppSettings
{
ServerBaseUrl = config.ServerBaseUrl,
SubjectId = config.SubjectId,
DeviceId = config.DeviceId,
DeviceSn = config.DeviceSn,
DeviceServiceEnabled = true,
DeviceToken = config.DeviceToken,
NtpEnabled = config.NtpEnabled,
NtpServer = config.NtpServer,
NtpSyncIntervalMinutes = config.NtpIntervalMinutes,
};
var api = new ApiClient(config.ServerBaseUrl);
// 服务不需要用户令牌(激活/停用由桌面端做),只用长期设备令牌上报
var session = new Session { ServerBaseUrl = config.ServerBaseUrl };
var device = new DeviceService(api, settings, session);
var scan = new ScanService(device);
var ntp = new NtpState();
// 令牌以 agent-token.json 为准(服务续期后会更新它),没有才退回 agent.json
var storedToken = AgentFiles.LoadToken();
var refreshToken = !string.IsNullOrWhiteSpace(storedToken?.RefreshToken)
? storedToken!.RefreshToken
: config.RefreshToken;
if (!string.IsNullOrWhiteSpace(storedToken?.DeviceToken))
{
settings.DeviceToken = storedToken!.DeviceToken;
}
var nextRefreshAt = DateTime.MinValue;
DateTime? lastTokenRefreshAt = null;
string? lastTokenRefreshError = null;
var nextHeartbeatAt = DateTime.MinValue;
DateTime? lastHeartbeatAt = null;
string? lastHeartbeatError = null;
var configTime = AgentFiles.FileTime(AgentPaths.ConfigFile);
var channelsTime = AgentFiles.FileTime(AgentPaths.ChannelsFile);
var nextNtpAt = config.NtpEnabled ? DateTime.UtcNow : DateTime.MaxValue;
var lastStatusJson = string.Empty;
var lastStatusWriteAt = DateTime.MinValue;
// 取流子进程:懒启动,崩了只影响取流,扫码链路完全不受影响
var hikStatus = new AgentHikStatus { VideoRoot = AgentPaths.VideosRoot };
await using var hikWorker = new HikWorkerSupervisor();
hikWorker.StateChanged += () =>
{
hikStatus.Connected = hikWorker.IsConnected;
hikStatus.BlockedUntil = hikWorker.BlockedUntil;
hikStatus.LastError = hikWorker.LastError;
};
try
{
device.EnsureUploadLoop();
await scan.StartAsync().ConfigureAwait(false);
scan.StartDiscovery(); // 常驻发现:设备 DHCP 换 IP 时能自己重连
// 延后自检:不抢服务启动的 CPU,也能让状态文件尽快反映「SDK 是否就位」
_ = Task.Run(async () =>
{
try
{
if (!await DelayAsync(TimeSpan.FromSeconds(20), ct).ConfigureAwait(false)) return;
ApplyHikProbe(hikStatus, await hikWorker.ProbeAsync(ct).ConfigureAwait(false));
hikStatus.Connected = hikWorker.IsConnected;
AppLog.Write($"[agent] 取流自检:sdk={hikStatus.SdkDir ?? "未找到"},"
+ $"ffmpeg={hikStatus.FfmpegPath ?? "未找到"}");
}
catch (OperationCanceledException)
{
// 服务停止,正常
}
catch (Exception ex)
{
hikStatus.Available = false;
hikStatus.LastError = ex.Message;
AppLog.Write($"[agent] 取流自检失败(扫码不受影响):{ex.Message}");
}
}, CancellationToken.None);
AppLog.Write($"[agent] 扫码已启动:{scan.Channels.Count} 个通道"
+ $"(SN {config.DeviceSn},主体 {config.SubjectId})");
// 边缘任务通道:设备主动出站长轮询领任务(跨公司取流用)。
// 与扫码链路完全解耦:这里出错只记日志,不影响收码上报。
_ = Task.Run(() => RunEdgeTaskLoopAsync(api, settings, hikWorker, ct), CancellationToken.None);
while (!ct.IsCancellationRequested)
{
if (!await DelayAsync(TimeSpan.FromSeconds(1), ct).ConfigureAwait(false)) break;
// ① 配置变了(换令牌 / 换服务器 / 改 NTP)→ 外层重建链路
var newConfigTime = AgentFiles.FileTime(AgentPaths.ConfigFile);
if (newConfigTime != configTime)
{
AppLog.Write("[agent] agent.json 已变更,重建扫码链路");
break;
}
// ② 通道配置变了(桌面端增删/改静音)→ 重新加载并连接
var newChannelsTime = AgentFiles.FileTime(AgentPaths.ChannelsFile);
if (newChannelsTime != channelsTime)
{
channelsTime = newChannelsTime;
AppLog.Write("[agent] channels.json 已变更,重新加载通道");
scan.Stop();
await scan.StartAsync().ConfigureAwait(false);
scan.StartDiscovery();
// 文件里就是完整通道列表:按全量对账再推一次,
// 桌面端那边推送失败(离线/未登录)时也能保证服务器跟着删/加。
scan.RequestChannelSync(replace: true);
}
// ③ 桌面端的一次性命令
var command = AgentFiles.LoadCommand();
if (command is not null)
{
AgentFiles.ClearCommand();
// 手动续期(测试/排障):不管剩多少天都立即换一次
if (command.RefreshTokenAt is not null)
{
var refreshed = await TryRefreshTokenAsync(api, config.DeviceSn, refreshToken)
.ConfigureAwait(false);
if (refreshed is not null)
{
settings.DeviceToken = refreshed.Token;
refreshToken = refreshed.RefreshToken;
AgentFiles.SaveToken(new AgentToken
{
DeviceToken = refreshed.Token,
RefreshToken = refreshed.RefreshToken,
ExpiresAt = JwtUtil.Expiry(refreshed.Token),
});
lastTokenRefreshAt = DateTime.Now;
lastTokenRefreshError = null;
nextRefreshAt = DateTime.MinValue;
}
else
{
lastTokenRefreshError = "手动续期失败(详见日志)";
}
}
await ApplyCommandAsync(command, device, scan, config, ntp).ConfigureAwait(false);
if (command.ReloadChannelsAt is not null)
{
channelsTime = AgentFiles.FileTime(AgentPaths.ChannelsFile);
}
if (command.NtpSyncAt is not null && config.NtpEnabled)
{
nextNtpAt = DateTime.UtcNow.AddMinutes(Math.Max(config.NtpIntervalMinutes, 5));
}
}
// ④ 令牌自动续期:访问令牌剩不到 7 天(或已过期)时用刷新令牌换新
if (!string.IsNullOrWhiteSpace(refreshToken) && DateTime.Now >= nextRefreshAt)
{
var expiresAt = JwtUtil.Expiry(settings.DeviceToken);
var needRefresh = expiresAt is null || expiresAt.Value - DateTime.Now < TimeSpan.FromDays(7);
if (needRefresh)
{
var refreshed = await TryRefreshTokenAsync(api, config.DeviceSn, refreshToken)
.ConfigureAwait(false);
if (refreshed is not null)
{
settings.DeviceToken = refreshed.Token;
refreshToken = refreshed.RefreshToken;
AgentFiles.SaveToken(new AgentToken
{
DeviceToken = refreshed.Token,
RefreshToken = refreshed.RefreshToken,
ExpiresAt = JwtUtil.Expiry(refreshed.Token),
});
lastTokenRefreshAt = DateTime.Now;
lastTokenRefreshError = null;
nextRefreshAt = DateTime.MinValue;
}
else
{
lastTokenRefreshError = "自动续期失败(10 分钟后重试)";
nextRefreshAt = DateTime.Now.AddMinutes(10); // 失败 10 分钟后再试(别每分钟刷日志)
}
}
else
{
nextRefreshAt = DateTime.Now.AddMinutes(30); // 还没到窗口,半小时后复查
}
}
// ⑤ 设备心跳:每 60 秒一次,让后端 last_seen_at 反映「后台服务还在」
if (DateTime.UtcNow >= nextHeartbeatAt)
{
try
{
var beat = await api.HeartbeatAsync(settings.DeviceToken, ct).ConfigureAwait(false);
// 心跳顺带同步主体状态:过期/停用 → 上报循环暂停(GUI/服务两种模式都走这里)
device.ApplySubjectState(beat?.Subject);
if (lastHeartbeatAt is null)
{
AppLog.Write("[agent] 设备心跳已开始(每 60 秒)");
}
else if (lastHeartbeatError is not null)
{
AppLog.Write("[agent] 设备心跳已恢复");
}
lastHeartbeatAt = DateTime.Now;
lastHeartbeatError = null;
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception ex)
{
// 只在第一次失败时记日志,恢复时再记一行,避免每 30 秒刷屏
if (lastHeartbeatError is null)
{
AppLog.Write($"[agent] 设备心跳失败:{ex.Message}");
}
lastHeartbeatError = ex.Message;
// 401 = 令牌过期/被撤销,下一轮让续期逻辑先试一下
if (ex is ApiException { StatusCode: 401 })
{
nextRefreshAt = DateTime.MinValue;
}
}
finally
{
nextHeartbeatAt = DateTime.UtcNow.AddSeconds(60);
}
}
// ⑥ NTP
if (config.NtpEnabled && DateTime.UtcNow >= nextNtpAt)
{
await SyncNtpAsync(config.NtpServer, ntp).ConfigureAwait(false);
nextNtpAt = DateTime.UtcNow.AddMinutes(Math.Max(config.NtpIntervalMinutes, 5));
}
// ⑦ 状态:内容变化才写,30 秒没变化保活写一次(避免每 2 秒重写文件)
{
var status = BuildStatus(scan, device, config, ntp, hikStatus);
status.TokenExpiresAt = JwtUtil.Expiry(settings.DeviceToken);
status.RefreshTokenExpiresAt = AgentFiles.LoadToken()?.RefreshExpiresAt;
status.LastTokenRefreshAt = lastTokenRefreshAt;
status.LastTokenRefreshError = lastTokenRefreshError;
status.LastHeartbeatAt = lastHeartbeatAt;
status.LastHeartbeatError = lastHeartbeatError;
status.UpdatedAt = default; // 签名忽略时间戳
var signature = JsonSerializer.Serialize(status);
if (signature != lastStatusJson || DateTime.UtcNow - lastStatusWriteAt >= StatusKeepAlive)
{
AgentFiles.SaveStatus(status);
lastStatusJson = signature;
lastStatusWriteAt = DateTime.UtcNow;
SaveDiscovered(scan);
}
}
}
}
finally
{
scan.Stop();
device.StopUploadLoop();
AgentFiles.SaveStatus(BuildStatus(scan, device, config, ntp, hikStatus, running: false));
AppLog.Write("[agent] 扫码链路已停止");
}
}
private static async Task ApplyCommandAsync(AgentCommand command, DeviceService device, ScanService scan,
AgentConfig config, NtpState ntp)
{
if (command.TriggerUploadAt is not null)
{
AppLog.Write("[agent] 收到命令:立即上传");
device.TriggerUpload();
}
if (command.ClearRecordsAt is not null)
{
var removed = ScanRecordStore.Clear(command.ClearChannelId);
AppLog.Write($"[agent] 收到命令:清空扫码记录 {removed} 条"
+ (string.IsNullOrWhiteSpace(command.ClearChannelId) ? "" : $"(通道 {command.ClearChannelId})"));
}
if (command.ReloadChannelsAt is not null)
{
AppLog.Write("[agent] 收到命令:重新加载通道");
scan.Stop();
await scan.StartAsync().ConfigureAwait(false);
scan.StartDiscovery();
}
if (command.NtpSyncAt is not null)
{
var server = string.IsNullOrWhiteSpace(command.NtpServer) ? config.NtpServer : command.NtpServer!;
AppLog.Write("[agent] 收到命令:立即校时");
await SyncNtpAsync(server, ntp).ConfigureAwait(false);
}
}
private static async Task<DeviceTokenRefresh?> TryRefreshTokenAsync(ApiClient api, string sn, string refreshToken)
{
try
{
var result = await api.RefreshDeviceTokenAsync(sn, refreshToken).ConfigureAwait(false);
var expiresAt = JwtUtil.Expiry(result.Token);
AppLog.Write($"[agent] 设备令牌已续期(新到期 {expiresAt?.ToString("yyyy-MM-dd HH:mm:ss") ?? "未知"})");
return result;
}
catch (Exception ex)
{
AppLog.Write($"[agent] 设备令牌续期失败:{ex.Message}");
return null;
}
}
private static async Task SyncNtpAsync(string server, NtpState state)
{
try
{
var result = await ClockSyncService.SyncAsync(server).ConfigureAwait(false);
state.LastSyncAt = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
state.OffsetSeconds = result.Offset.TotalSeconds;
state.RoundTripMs = result.RoundTrip.TotalMilliseconds;
state.ServerTime = result.ServerTime.LocalDateTime;
state.Error = null;
AppLog.Write(result.Offset.Duration() < ClockSyncService.MinimumAdjust
? $"[agent] NTP 校时:{server} 偏差 {result.Offset.TotalSeconds:+0.00;-0.00} 秒(在误差范围内,未调整)"
: $"[agent] NTP 校时完成:{server} 偏差 {result.Offset.TotalSeconds:+0.00;-0.00} 秒,"
+ $"往返 {result.RoundTrip.TotalMilliseconds:0} ms");
}
catch (Exception ex)
{
state.Error = $"NTP 校时失败:{ex.Message}";
AppLog.Write($"[agent] NTP 校时失败({server}):{ex.Message}");
}
}
private static AgentStatus BuildStatus(ScanService scan, DeviceService device, AgentConfig config,
NtpState ntp, AgentHikStatus hik, bool running = true)
{
return new AgentStatus
{
Running = running && scan.Running,
Version = Version,
DeviceSn = config.DeviceSn,
SubjectId = config.SubjectId,
UploadStatus = scan.UploadStatus,
ChannelSyncStatus = scan.ChannelSyncStatus,
PendingRecords = ScanRecordStore.PendingCount(),
Channels = scan.Channels.Select(channel => new AgentChannelStatus
{
Mac = channel.Mac,
Connected = channel.Connected,
LastIp = channel.LastIp,
LastCode = channel.LastCode,
LastCodeAt = channel.LastCodeAt,
}).ToList(),
LastError = ntp.Error,
Hik = hik,
NtpLastSyncAt = ntp.LastSyncAt,
NtpLastOffsetSeconds = ntp.OffsetSeconds,
NtpRoundTripMs = ntp.RoundTripMs,
NtpServerTime = ntp.ServerTime,
};
}
/// <summary>
/// 边缘任务循环:长轮询领任务 → 交给 worker 执行 → 回结果。
///
/// 云端握着挂起的请求,所以任务一到就能立刻送达(不需要等下一次心跳)。
/// 这里任何异常都只记日志并退避重试,绝不影响扫码链路。
/// </summary>
private static async Task RunEdgeTaskLoopAsync(ApiClient api, AppSettings settings,
HikWorkerSupervisor worker, CancellationToken ct)
{
var retryMs = 1000;
while (!ct.IsCancellationRequested)
{
try
{
var task = await api.PollEdgeTaskAsync(settings.DeviceToken, 20, ct).ConfigureAwait(false);
retryMs = 1000;
if (task is null) continue; // 这段时间没任务,立刻再挂
AppLog.Write($"[edge] 领到任务 {task.Id}({task.Type})");
var (result, ok) = await ExecuteEdgeTaskAsync(api, settings, worker, task, ct).ConfigureAwait(false);
await api.SubmitEdgeTaskResultAsync(settings.DeviceToken, task.Id, result, ct)
.ConfigureAwait(false);
AppLog.Write($"[edge] 任务 {task.Id} 完成:ok={ok}");
}
catch (OperationCanceledException)
{
break;
}
catch (Exception ex)
{
AppLog.Write($"[edge] 任务通道异常({retryMs / 1000.0:0.0} 秒后重试):{ex.Message}");
if (!await DelayAsync(TimeSpan.FromMilliseconds(retryMs), ct).ConfigureAwait(false)) break;
retryMs = Math.Min(retryMs * 2, 30000);
}
}
}
/// <summary>执行一个边缘任务;返回要回传给云端的结果对象</summary>
private static async Task<(object Result, bool Ok)> ExecuteEdgeTaskAsync(ApiClient api, AppSettings settings,
HikWorkerSupervisor worker, ApiClient.EdgeTask task, CancellationToken ct)
{
try
{
switch (task.Type)
{
case "check":
{
var data = await worker.CheckAsync(task.Payload, ct).ConfigureAwait(false);
if (data is not { } element) return (new { ok = false, error = "worker 无返回" }, false);
var hasRecord = element.TryGetProperty("hasRecord", out var v) && v.ValueKind == JsonValueKind.True;
var frames = element.TryGetProperty("frames", out var f) && f.TryGetInt32(out var parsed) ? parsed : 0;
return (new
{
ok = true,
hasRecord,
frames,
error = ReadString(element, "error"),
source = ReadString(element, "source"),
}, true);
}
case "download":
{
var uploadTaskId = task.Payload.ValueKind == JsonValueKind.Object
? ReadString(task.Payload, "uploadTaskId") ?? ""
: "";
try
{
var data = await worker.DownloadAsync(task.Payload, ct).ConfigureAwait(false);
var file = ReadString(data, "merged")
?? ReadFirstSegment(data);
if (string.IsNullOrEmpty(file) || !File.Exists(file))
{
return (new { ok = false, error = "没有生成成片", uploadTaskId }, false);
}
if (uploadTaskId.Length == 0)
{
return (new { ok = false, error = "任务缺少 uploadTaskId", uploadTaskId }, false);
}
var size = await api.UploadEdgeFileAsync(settings.DeviceToken, uploadTaskId, file, ct)
.ConfigureAwait(false);
TryDeleteFile(file);
return (new { ok = true, size, uploadTaskId }, true);
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception ex)
{
return (new { ok = false, error = ex.Message, uploadTaskId }, false);
}
}
default:
return (new { ok = false, error = $"不支持的任务类型:{task.Type}" }, false);
}
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception ex)
{
return (new { ok = false, error = ex.Message }, false);
}
}
/// <summary>下载结果是多段时取第一段(合并失败才会走到)</summary>
private static string? ReadFirstSegment(JsonElement? data)
{
if (data is not { ValueKind: JsonValueKind.Object } element) return null;
if (!element.TryGetProperty("segments", out var segments) || segments.ValueKind != JsonValueKind.Array)
{
return null;
}
foreach (var item in segments.EnumerateArray())
{
var value = item.ValueKind == JsonValueKind.String ? item.GetString() : null;
if (!string.IsNullOrWhiteSpace(value)) return value;
}
return null;
}
/// <summary>传完就删:现场机器不会有人来清理临时成片</summary>
private static void TryDeleteFile(string path)
{
try
{
if (File.Exists(path)) File.Delete(path);
}
catch (Exception ex)
{
AppLog.Write($"[edge] 清理成片失败({path}):{ex.Message}");
}
}
/// <summary>把 worker 自检结果落到状态里(失败只标记不可用,不影响扫码)</summary>
private static void ApplyHikProbe(AgentHikStatus status, JsonElement? probe)
{
if (probe is not { } element || element.ValueKind != JsonValueKind.Object)
{
status.Available = false;
return;
}
status.Available = element.TryGetProperty("sdkFound", out var found)
&& found.ValueKind == JsonValueKind.True;
status.SdkDir = ReadString(element, "sdkDir");
status.FfmpegPath = ReadString(element, "ffmpegPath");
var root = ReadString(element, "videoRoot");
if (!string.IsNullOrWhiteSpace(root)) status.VideoRoot = root;
status.ProbedAt = DateTime.Now;
if (!status.Available)
{
status.LastError ??= "未找到 HCNetSDK.dll(服务目录 native\\HCNetSDK 缺失)";
}
}
private static string? ReadString(JsonElement element, string name)
=> element.TryGetProperty(name, out var value) && value.ValueKind == JsonValueKind.String
? value.GetString()
: null;
/// <summary>读 worker 返回的字符串字段(data 可能为 null)</summary>
private static string? ReadString(JsonElement? data, string name)
=> data is { } element ? ReadString(element, name) : null;
private static void SaveDiscovered(ScanService scan)
{
var devices = scan.DiscoveredDevices
.Select(item => new AgentDiscoveredDevice
{
Mac = item.Mac,
Ip = item.Ip,
HostName = item.HostName,
Model = item.Model,
Firmware = item.Version,
})
.ToList();
AgentFiles.SaveDiscovered(devices);
}
private static async Task<bool> DelayAsync(TimeSpan delay, CancellationToken ct)
{
try
{
await Task.Delay(delay, ct).ConfigureAwait(false);
return true;
}
catch (OperationCanceledException)
{
return false;
}
}
}