liufumingren 53da30f733 feat(label-scan): 多码同框全部解出 + 条码历史判断新码/最后出现
一帧里只认第一个解码成功的条码,两张面单并排时必然只报旧码、漏掉新码
(角点顺序由检测器决定,跟哪张是新面单无关)。改成:

- 一帧的每个候选都解,不再解出第一个就停;同帧两个新码都上报,不压帧不投票;
- 新增条码历史(旧→新,最多 4 个):本帧解出的每个码都刷新「最后出现时间」;
  历史里没有的码立即上报,已有一律只刷新在场、不重复建档/播报;
- 多码同框时上报/续期的是「最后出现的那个」,不是检测器先解出来的那个;
  一直看得见的码不重排(避免每帧互相顶掉导致上报抖动),离开又回来的挪到末尾;
- 超过 45 秒没再出现的码淘汰(与「面单离开」同一阈值),再出现按新码上报。

排障新增 agent-status.json 的 LabelScan.Items[].RecentCodes(历史,旧→新)。

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-11-10 23:04:29 +08:00

788 lines
34 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);
/// <summary>心跳日志落盘间隔:心跳 60 秒一次,但日志每 5 分钟才写一行(避免刷屏又能看出断点)</summary>
private static readonly TimeSpan HeartbeatLogInterval = TimeSpan.FromMinutes(5);
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;
DateTime? lastHeartbeatLoggedAt = null;
DateTime? lastHeartbeatFailLoggedAt = 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 时能自己重连
// 自检要尽早:worker 一就绪,局域网询问才有应答(UDP 17310)。
// 以前延后 20 秒,导致「刚启动/刚更新完」这段时间本机查询探测不到设备管理服务,
// 白白退化成云端中转 —— 而云任务反过来才把 worker 拉起来,形成恶性循环。
_ = Task.Run(async () =>
{
try
{
if (!await DelayAsync(TimeSpan.FromSeconds(3), 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, scan, ct), CancellationToken.None);
while (!ct.IsCancellationRequested)
{
// 400ms 一轮:状态文件写得及时,桌面端才能尽快看到「刚识别到的条码」
// (识别本身是毫秒级,慢在拉流和解码,不该再被状态刷新拖 1 秒)
if (!await DelayAsync(TimeSpan.FromMilliseconds(400), 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 秒,每 5 分钟落一行日志)");
}
else if (lastHeartbeatError is not null)
{
AppLog.Write("[agent] 设备心跳已恢复");
}
else if (lastHeartbeatLoggedAt is null
|| DateTime.UtcNow - lastHeartbeatLoggedAt.Value >= HeartbeatLogInterval)
{
// 心跳本身 60 秒一次,但只在每 5 分钟落一行,方便隔天回看「几点断的」
var online = scan.Channels.Count(item => item.Connected);
AppLog.Write($"[agent] 心跳正常(在线通道 {online}/{scan.Channels.Count},"
+ $"待上传 {ScanRecordStore.PendingCount()} 条)");
lastHeartbeatLoggedAt = DateTime.UtcNow;
}
lastHeartbeatAt = DateTime.Now;
lastHeartbeatError = null;
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception ex)
{
// 首次失败必记;持续失败每 5 分钟补一行,避免刷屏又不至于整段没痕迹
if (lastHeartbeatError is null
|| lastHeartbeatFailLoggedAt is null
|| DateTime.UtcNow - lastHeartbeatFailLoggedAt.Value >= HeartbeatLogInterval)
{
AppLog.Write($"[agent] 设备心跳失败:{ex.Message}");
lastHeartbeatFailLoggedAt = DateTime.UtcNow;
}
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,
LabelScan = new AgentLabelScanStatus
{
Pulled = scan.LabelScan.Snapshot.PulledAt is not null,
PulledAt = scan.LabelScan.Snapshot.PulledAt,
Revision = scan.LabelScan.Snapshot.Revision,
StatusText = scan.LabelScan.Snapshot.StatusText,
Error = scan.LabelScan.Snapshot.Error,
Items = scan.LabelScan.Runtimes.Select(runtime => new AgentLabelCameraStatus
{
WorkstationId = runtime.WorkstationId,
CameraId = runtime.CameraId,
WorkstationName = runtime.WorkstationName,
CameraName = runtime.CameraName,
ChannelId = runtime.ChannelId,
ChannelName = runtime.ChannelName,
Summary = runtime.Summary,
StateText = runtime.StateText,
LastCode = runtime.LastCode,
LastCodeAt = runtime.LastCodeAt,
LastHitAt = runtime.LastHitAt,
StreamText = runtime.StreamText,
LastDecodeMs = runtime.LastDecodeMs,
LastCvMs = runtime.LastCvMs,
LastPath = runtime.LastPath,
RoiFailStreak = runtime.RoiFailStreak,
SteadyHits = runtime.SteadyHits,
FramesRead = runtime.FramesRead,
FrameThrottled = runtime.FrameThrottled,
FramesDecoded = runtime.FramesDecoded,
LastWaitMs = runtime.LastWaitMs,
LastLoopMs = runtime.LastLoopMs,
RoiText = runtime.RoiText,
RecentCodes = runtime.RecentCodes,
RoiRatio = runtime.RoiRatio,
FrameLag = runtime.FrameLag,
FrameDropped = runtime.FrameDropped,
Hits = runtime.Hits,
LastError = runtime.LastError,
}).ToList(),
Warnings = scan.LabelScan.Snapshot.Warnings.Select(item => item.Display).ToList(),
},
Osd = scan.Osd.ToStatus(),
LogDropped = AppLog.Dropped,
LogLastDroppedAt = AppLog.LastDroppedAt,
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, ScanService scan, 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, scan, 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, ScanService scan, ApiClient.EdgeTask task, CancellationToken ct)
{
try
{
switch (task.Type)
{
case "labelScan.refresh":
{
// 只是「叫醒」:真正的配置以 GET /api/scanner/label-cameras 为准
await scan.LabelScan.RefreshAsync("服务端通知变更", ct).ConfigureAwait(false);
// 工作台/摄像头绑定的变更也会推这个通知:OSD 字幕配置一起重拉
await scan.Osd.RefreshAsync("服务端通知变更", ct).ConfigureAwait(false);
var snapshot = scan.LabelScan.Snapshot;
var osd = scan.Osd.Snapshot;
return (new
{
// ok 只看面单识别配置:OSD 是附加能力,后端没升级(404)时不该把整个任务判失败
ok = string.IsNullOrWhiteSpace(snapshot.Error),
count = snapshot.Items.Count,
revision = snapshot.Revision,
osdWorkstations = osd.Items.Count,
osdCameras = osd.CameraCount,
error = snapshot.Error,
osdError = osd.Error,
}, string.IsNullOrWhiteSpace(snapshot.Error));
}
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;
}
}
}