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;
///
/// 后台扫码服务的运行主体(LocalSystem)。
///
/// 职责:
/// 1. 读 %ProgramData%\YuncangTrace\agent.json 里的**长期设备令牌**,跑扫码 TCP 收码 + 上报循环;
/// 2. 监视 channels.json(桌面端改通道后自动重连);
/// 3. 定时 NTP 校时(LocalSystem 改系统时间不需要 UAC);
/// 4. 把运行状态写进 agent-status.json,桌面端只读展示;
/// 5. 执行桌面端写进 agent-command.json 的一次性命令(立即上传 / 清空记录 / 立即校时)。
///
/// 与桌面端**完全解耦**:桌面端退出、用户注销都不影响这里。
///
public static class AgentHost
{
/// 状态写盘保活间隔(内容没变也最多 30 秒写一次)
private static readonly TimeSpan StatusKeepAlive = TimeSpan.FromSeconds(30);
/// 心跳日志落盘间隔:心跳 60 秒一次,但日志每 5 分钟才写一行(避免刷屏又能看出断点)
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 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,
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(),
},
LogDropped = AppLog.Dropped,
LogLastDroppedAt = AppLog.LastDroppedAt,
NtpLastSyncAt = ntp.LastSyncAt,
NtpLastOffsetSeconds = ntp.OffsetSeconds,
NtpRoundTripMs = ntp.RoundTripMs,
NtpServerTime = ntp.ServerTime,
};
}
///
/// 边缘任务循环:长轮询领任务 → 交给 worker 执行 → 回结果。
///
/// 云端握着挂起的请求,所以任务一到就能立刻送达(不需要等下一次心跳)。
/// 这里任何异常都只记日志并退避重试,绝不影响扫码链路。
///
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);
}
}
}
/// 执行一个边缘任务;返回要回传给云端的结果对象
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);
var snapshot = scan.LabelScan.Snapshot;
return (new
{
ok = string.IsNullOrWhiteSpace(snapshot.Error),
count = snapshot.Items.Count,
revision = snapshot.Revision,
error = snapshot.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);
}
}
/// 下载结果是多段时取第一段(合并失败才会走到)
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;
}
/// 传完就删:现场机器不会有人来清理临时成片
private static void TryDeleteFile(string path)
{
try
{
if (File.Exists(path)) File.Delete(path);
}
catch (Exception ex)
{
AppLog.Write($"[edge] 清理成片失败({path}):{ex.Message}");
}
}
/// 把 worker 自检结果落到状态里(失败只标记不可用,不影响扫码)
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;
/// 读 worker 返回的字符串字段(data 可能为 null)
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 DelayAsync(TimeSpan delay, CancellationToken ct)
{
try
{
await Task.Delay(delay, ct).ConfigureAwait(false);
return true;
}
catch (OperationCanceledException)
{
return false;
}
}
}