packServer/desktop/Services/Scan/WorkstationOsdService.cs
liufumingren 1dc3404eae fix(osd): 空闲回退写回摄像头名,不再写工作台名
- DesiredText:60 秒没扫到时还原成**摄像头自己的名字**(摄像头没名字才退回工作台名,
  避免把通道名写空)
- 配置里被移除的摄像头同样还原成摄像头名
- 同步注释与文档(桌面 README / 根 README / 后端接口注释)
- 实测(真实 NVR 通道 35/37):首次="测试A/测试B"、扫码="测试A 7734… / 测试B 7734…"、
  70 秒后回退="测试A/测试B",三个阶段的并行时间差 50~103ms

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

685 lines
28 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.Linq;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
using YuncangTrace.LocalService.Services.Hik;
namespace YuncangTrace.LocalService.Services.Scan;
/// <summary>工作台(OSD 目标):本机负责的扫码通道 + 绑定的全部摄像头</summary>
public sealed class OsdWorkstationTarget
{
public int Id { get; init; }
public string Name { get; init; } = string.Empty;
public string Code { get; init; } = string.Empty;
/// <summary>本机(这台设备)绑到该工作台的通道;扫码/识别命中这些通道才算该工作台在扫码</summary>
public List<string> ChannelIds { get; init; } = new();
public List<OsdCameraTarget> Cameras { get; init; } = new();
}
/// <summary>一路要写 OSD 的摄像头(录像机 + 通道号 + 凭据)</summary>
public sealed class OsdCameraTarget
{
public int CameraId { get; init; }
public string Name { get; init; } = string.Empty;
public int ChannelNo { get; init; }
public string NvrHost { get; init; } = string.Empty;
public int NvrPort { get; init; } = 8000;
public string NvrUser { get; init; } = "admin";
public string NvrPassword { get; init; } = string.Empty;
/// <summary>物理身份:同一台录像机的同一个通道(重拉配置时用它继承状态)</summary>
internal string Key => $"{NvrHost}:{NvrPort}/{ChannelNo}";
}
/// <summary>OSD 配置快照(界面/日志用;**不含密码**)</summary>
public sealed class OsdSnapshot
{
public DateTime? PulledAt { get; set; }
public string Revision { get; set; } = string.Empty;
public string? Error { get; set; }
public List<OsdWorkstationTarget> Items { get; set; } = new();
public List<string> Warnings { get; set; } = new();
public int CameraCount => Items.Sum(item => item.Cameras.Count);
public string StatusText
{
get
{
if (!string.IsNullOrWhiteSpace(Error)) return $"OSD 不可用:{Error}";
if (PulledAt is null) return "还没拉取过工作台配置";
return $"OSD {Items.Count} 个工作台 / {CameraCount} 路摄像头 · {PulledAt:HH:mm:ss}"
+ (Warnings.Count > 0 ? $" · {Warnings.Count} 条提示" : string.Empty);
}
}
}
/// <summary>
/// 工作台 OSD 字幕:把「摄像头名 + 运单号」写到该工作台每路摄像头的 OSD(= 录像机通道名)。
///
/// 规则(现场约定):
/// 1. 扫到运单号(扫码枪或面单识别,连续重复命中都算)→ 该工作台所有摄像头 OSD = `摄像头名 + 空格 + 运单号`;
/// 2. **运单号没变就不重写**(每次写设备配置要 1~3 秒,还会刷配置区);连续命中只续「在场」计时;
/// 3. 连续 **60 秒**没有任何命中 → 全部还原成**摄像头自己的名字**(不是工作台名);
/// 4. 配置(工作台/摄像头/通道)由服务端下发,启动拉一次 + 每 1 分钟兜底 + 收到通知立即拉。
///
/// 实现要点:
/// - 设备写入走**后台批量队列**(不堵扫码线程):不同通道**并行**下发(一批最多 4 路),
/// 同一通道保证串行(同一通道的「读整包 → 改 → 写回」会互相覆盖);
/// - 每次写之前重新算目标文本,避免把过期的运单号写上去;
/// - 写失败按 5s→10s→…→60s 退避,不刷日志;配置里移除的摄像头会**还原一次**摄像头名再忘掉;
/// - 文本超过 31 字节(GBK)时优先保运单号,压摄像头名(见 <see cref="OsdText"/>)。
/// </summary>
public sealed class WorkstationOsdService : IDisposable
{
/// <summary>多久没命中就还原成摄像头名(现场约定 1 分钟)</summary>
private static readonly TimeSpan IdleReset = TimeSpan.FromMinutes(1);
/// <summary>配置兜底拉取间隔(变更靠服务端通知立即生效)</summary>
private static readonly TimeSpan RefreshInterval = TimeSpan.FromMinutes(1);
/// <summary>工作线程巡检间隔(扫码会立刻唤醒,这里只是兜底)</summary>
private static readonly TimeSpan WorkerTick = TimeSpan.FromSeconds(1);
/// <summary>一批最多同时写几路(不同通道并行;路数再多就分批,避免把录像机打满)</summary>
private const int MaxParallelWrites = 4;
private readonly DeviceService _device;
private readonly object _gate = new();
private readonly AutoResetEvent _wake = new(false);
/// <summary>
/// OSD 写入用的 SDK 会话池(**进程内共享**)。
///
/// 不能每建一个 ScanService 就 new 一个:`HikDeviceService.Dispose()` 会调
/// `NET_DVR_Cleanup()` 把**全局** SDK 拆掉(界面预览那边还在用),而且它的扫地定时器
/// 会让旧实例一直活着。共享一份既省登录,也不会互相拆台。
/// </summary>
private static readonly HikDeviceService OsdHik = new();
private Dictionary<int, WorkstationState> _workstations = new();
private Dictionary<string, CameraState> _cameras = new(StringComparer.OrdinalIgnoreCase);
private readonly Queue<RetiredWrite> _retired = new();
private CancellationTokenSource? _cts;
private Task? _worker;
private Timer? _timer;
private int _refreshing;
private volatile bool _running;
/// <summary>上一次已经落过日志的错误(同样的错误不每分钟刷一行)</summary>
private string? _lastErrorLogged;
public WorkstationOsdService(DeviceService device)
{
_device = device;
}
public OsdSnapshot Snapshot { get; private set; } = new();
public bool Running => _running;
/// <summary>启动:起工作线程 + 每分钟拉配置(设备服务没开时拉取只记一条提示,开启后下一轮自动生效)</summary>
public void Start()
{
lock (_gate)
{
if (_running) return;
_running = true;
_cts = new CancellationTokenSource();
_worker = Task.Run(() => WorkerLoopAsync(_cts.Token));
_timer = new Timer(_ => _ = RefreshAsync("定时刷新"), null, TimeSpan.Zero, RefreshInterval);
}
if (!_device.Enabled)
{
lock (_gate) Snapshot.Error = "设备服务未开启(开启后才会写 OSD)";
}
}
/// <summary>停止工作线程与定时器(**不主动清 OSD**:下次启动会按配置还原成摄像头名)</summary>
public void Stop()
{
CancellationTokenSource? cts;
Timer? timer;
Task? worker;
lock (_gate)
{
if (!_running) return;
_running = false;
cts = _cts;
timer = _timer;
worker = _worker;
_cts = null;
_timer = null;
_worker = null;
}
try { timer?.Dispose(); } catch { /* 忽略 */ }
try { cts?.Cancel(); } catch { /* 忽略 */ }
try { worker?.Wait(TimeSpan.FromSeconds(3)); } catch { /* 忽略 */ }
try { cts?.Dispose(); } catch { /* 忽略 */ }
lock (_gate)
{
_workstations = new Dictionary<int, WorkstationState>();
_cameras = new Dictionary<string, CameraState>(StringComparer.OrdinalIgnoreCase);
_retired.Clear();
}
}
/// <summary>
/// 拉一次工作台配置。异常只记日志 + 落 <see cref="OsdSnapshot.Error"/>,不影响扫码/识别。
/// </summary>
public async Task RefreshAsync(string reason, CancellationToken ct = default)
{
if (Interlocked.CompareExchange(ref _refreshing, 1, 0) != 0) return; // 上一轮还没回来
try
{
if (!_device.Enabled)
{
lock (_gate) Snapshot.Error = "设备服务未开启(开启后才会写 OSD)";
return;
}
var data = await _device.FetchWorkstationsAsync(ct).ConfigureAwait(false);
Apply(Parse(data), reason);
_lastErrorLogged = null;
}
catch (OperationCanceledException)
{
// 退出中
}
catch (Exception ex)
{
// 后端没升级(404)是预期情况:给一句明确提示,且同一个错误只落一行日志
var message = ex is ApiException { StatusCode: 404 }
? "服务端还没有 /api/scanner/workstations(升级后端后可用)"
: ex.Message;
lock (_gate) Snapshot.Error = message;
if (!string.Equals(_lastErrorLogged, message, StringComparison.Ordinal))
{
_lastErrorLogged = message;
AppLog.Write($"[osd] 拉取工作台配置失败({reason}):{message}");
}
}
finally
{
Interlocked.Exchange(ref _refreshing, 0);
}
}
/// <summary>
/// 任意一次命中(扫码枪 / 面单识别,含连续重复命中)。
///
/// ⚠️ 在扫码线程上调用:只做字典更新 + 唤醒工作线程,**绝不能**在这里写设备。
/// </summary>
public void OnScanActivity(string channelId, string code, DateTime at)
{
var key = (channelId ?? string.Empty).Trim();
var text = (code ?? string.Empty).Trim();
if (!_running || key.Length == 0 || text.Length == 0) return;
var touched = false;
lock (_gate)
{
foreach (var state in _workstations.Values)
{
if (!state.Channels.Contains(key)) continue;
if (!string.Equals(state.LastCode, text, StringComparison.Ordinal))
{
state.LastCode = text;
state.LastCodeAt = at;
}
// 连续扫到同一个码也算「还在扫」:只续计时,不重写 OSD
state.LastActivityAt = at;
touched = true;
}
}
if (!touched) return;
try { _wake.Set(); } catch { /* 停机中 */ }
}
/// <summary>给 agent-status.json 用的紧凑状态(不含密码)</summary>
public AgentOsdStatus ToStatus()
{
lock (_gate)
{
return new AgentOsdStatus
{
Enabled = _running,
PulledAt = Snapshot.PulledAt,
Revision = Snapshot.Revision,
Error = Snapshot.Error,
StatusText = Snapshot.StatusText,
Items = _cameras.Values
.OrderBy(item => item.WorkstationId)
.ThenBy(item => item.Camera.ChannelNo)
.Select(item => new AgentOsdCameraStatus
{
WorkstationId = item.WorkstationId,
WorkstationName = item.WorkstationName,
CameraId = item.Camera.CameraId,
CameraName = item.Camera.Name,
ChannelNo = item.Camera.ChannelNo,
Text = item.LastText ?? string.Empty,
UpdatedAt = item.LastWriteAt,
LastError = item.LastError,
})
.ToList(),
};
}
}
private async Task WorkerLoopAsync(CancellationToken ct)
{
while (!ct.IsCancellationRequested)
{
bool more;
try
{
more = await WriteBatchAsync(ct).ConfigureAwait(false);
}
catch (OperationCanceledException)
{
break;
}
catch (Exception ex)
{
AppLog.Write($"[osd] 写 OSD 循环异常:{ex.Message}");
try { await Task.Delay(TimeSpan.FromSeconds(2), ct).ConfigureAwait(false); }
catch { break; }
continue;
}
// 还有待写的立刻接着来(不再死等 1 秒);没活才让出
if (more) continue;
try { _wake.WaitOne(WorkerTick); } catch { /* 停机中 */ }
}
}
/// <summary>
/// 取一批需要写的摄像头**并行**写一次(退役摄像头优先),返回是否还有剩下的。
///
/// 同一批里每个通道只会出现一次:**不同通道**可以同时下发(录像机只是把配置分别
/// 转给各摄像头,实测同一 UserID 上两路并发读改写 20 次全部成功、其余字段零差异),
/// **同一通道**必须串行,否则「读整包 → 改 → 写回」会互相覆盖。
/// </summary>
private async Task<bool> WriteBatchAsync(CancellationToken ct)
{
// 设备服务被关掉/停用后不要再动设备(配置可能已经过期)
if (!_device.Enabled) return false;
var jobs = new List<(OsdCameraTarget Camera, string Text, CameraState? State)>();
var more = false;
lock (_gate)
{
var now = DateTime.Now;
var taken = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
while (_retired.Count > 0 && jobs.Count < MaxParallelWrites)
{
var retired = _retired.Dequeue();
if (!taken.Add(retired.Camera.Key)) continue;
jobs.Add((retired.Camera, retired.Text, null));
}
foreach (var state in _cameras.Values)
{
if (jobs.Count >= MaxParallelWrites)
{
more = true;
break;
}
if (state.NextAttemptAt > now) continue;
if (!_workstations.TryGetValue(state.WorkstationId, out var workstation)) continue;
var text = DesiredText(workstation, state, now);
if (string.Equals(text, state.LastText, StringComparison.Ordinal)) continue;
if (!taken.Add(state.Camera.Key)) continue;
// 占位:写完(成功/失败)会改成真正的下次时间,避免下一批重复挑同一路
state.NextAttemptAt = now + TimeSpan.FromMinutes(1);
jobs.Add((state.Camera, text, state));
}
if (_retired.Count > 0) more = true;
}
if (jobs.Count == 0) return false;
await Task.WhenAll(jobs.Select(job => WriteCameraAsync(job.Camera, job.Text, ct, job.State)))
.ConfigureAwait(false);
return more;
}
/// <summary>写一路摄像头的 OSD,并更新状态(成功/失败都记在该摄像头上)</summary>
private async Task WriteCameraAsync(OsdCameraTarget camera, string text, CancellationToken ct,
CameraState? state = null)
{
try
{
var result = await Task.Run(() => OsdHik.SetChannelOsdName(
camera.NvrHost, camera.NvrPort, camera.NvrUser, camera.NvrPassword, camera.ChannelNo, text), ct)
.ConfigureAwait(false);
if (state is not null)
{
lock (_gate)
{
state.LastText = result.Text;
state.LastWriteAt = DateTime.Now;
state.LastError = null;
state.FailCount = 0;
state.NextAttemptAt = DateTime.MinValue;
}
}
if (result.Changed)
{
// 日志节流:同一路 10 秒内只落一行(写一台本来就要 1~3 秒)
var now = DateTime.Now;
var shouldLog = state is null || now - state.LastLogAt >= TimeSpan.FromSeconds(10);
if (state is not null && shouldLog) state.LastLogAt = now;
if (shouldLog)
{
var label = string.IsNullOrWhiteSpace(camera.Name) ? $"通道 {camera.ChannelNo}" : camera.Name;
AppLog.Write($"[osd] {camera.NvrHost} 通道 {camera.ChannelNo}({label})→ \"{result.Text}\"");
}
}
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception ex)
{
var failCount = 1;
if (state is not null)
{
lock (_gate)
{
state.FailCount++;
failCount = state.FailCount;
state.LastError = ex.Message;
state.NextAttemptAt = DateTime.Now + Backoff(failCount);
}
}
// 连续失败只每 20 次补一行,避免 NVR 不通时刷屏
if (state is null || failCount == 1 || failCount % 20 == 0)
{
AppLog.Write($"[osd] {camera.NvrHost} 通道 {camera.ChannelNo} 写 OSD 失败"
+ (state is null ? string.Empty : $"(第 {failCount} 次)") + $":{ex.Message}");
}
}
}
private static TimeSpan Backoff(int failCount)
{
var seconds = 5 * Math.Pow(2, Math.Min(failCount - 1, 4)); // 5 → 10 → 20 → 40 → 60
return TimeSpan.FromSeconds(Math.Min(seconds, 60));
}
/// <summary>当前该显示什么:有扫码(60 秒内)是「摄像头名 + 运单号」,否则还原成**摄像头名**</summary>
private static string DesiredText(WorkstationState workstation, CameraState camera, DateTime now)
{
var active = workstation.LastActivityAt is DateTime at
&& now - at <= IdleReset
&& !string.IsNullOrWhiteSpace(workstation.LastCode);
return active
? OsdText.Combine(camera.Camera.Name, workstation.LastCode)
: IdleText(camera.Camera.Name, workstation.WorkstationName);
}
/// <summary>
/// 空闲/退役时要写回去的文本:**摄像头自己的名字**(现场约定)。
/// 摄像头没有名字时才退回工作台名——写空会把通道名清掉,反而更容易看错。
/// </summary>
private static string IdleText(string? cameraName, string? fallback)
{
var name = OsdText.Combine(cameraName, null);
return name.Length > 0 ? name : OsdText.TruncateGbk(fallback, OsdText.MaxBytes);
}
private void Apply(ParsedConfig parsed, string reason)
{
var lines = new List<string>();
lock (_gate)
{
var previousRevision = Snapshot.Revision;
var nextWorkstations = new Dictionary<int, WorkstationState>();
var nextCameras = new Dictionary<string, CameraState>(StringComparer.OrdinalIgnoreCase);
foreach (var target in parsed.Items)
{
// 工作台状态(最近运单号/计时)按 id 继承:重拉配置不能把「正在扫码」清掉
var state = _workstations.TryGetValue(target.Id, out var existing)
? existing
: new WorkstationState();
state.WorkstationName = string.IsNullOrWhiteSpace(target.Name) ? target.Code : target.Name;
state.Channels = new HashSet<string>(target.ChannelIds, StringComparer.OrdinalIgnoreCase);
nextWorkstations[target.Id] = state;
}
foreach (var target in parsed.Items)
{
var workstation = nextWorkstations[target.Id];
foreach (var camera in target.Cameras)
{
// 摄像头状态按「录像机+通道」继承:换名字/重排不影响已写入的记录
var state = _cameras.TryGetValue(camera.Key, out var existing)
? existing
: new CameraState();
state.Camera = camera;
state.WorkstationId = target.Id;
state.WorkstationName = workstation.WorkstationName;
nextCameras[camera.Key] = state;
}
}
// 被移除的摄像头:还原成它自己的名字(best-effort),然后忘掉
foreach (var pair in _cameras)
{
if (nextCameras.ContainsKey(pair.Key)) continue;
var state = pair.Value;
if (string.IsNullOrEmpty(state.LastText)) continue;
var idle = IdleText(state.Camera.Name, state.WorkstationName);
if (string.Equals(state.LastText, idle, StringComparison.Ordinal)) continue;
_retired.Enqueue(new RetiredWrite(state.Camera, idle));
}
_workstations = nextWorkstations;
_cameras = nextCameras;
Snapshot.PulledAt = DateTime.Now;
Snapshot.Revision = parsed.Revision;
Snapshot.Items = parsed.Items.ToList();
Snapshot.Warnings = parsed.Warnings.ToList();
Snapshot.Error = null;
var changed = !string.Equals(previousRevision, parsed.Revision, StringComparison.Ordinal);
if (changed || !string.Equals(reason, "定时刷新", StringComparison.Ordinal))
{
lines.Add($"[osd] 已拉取工作台配置({reason}):{parsed.Items.Count} 个工作台 / "
+ $"{parsed.Items.Sum(item => item.Cameras.Count)} 路摄像头,revision={parsed.Revision}"
+ (changed && previousRevision.Length > 0 ? $"(变更:{previousRevision} → {parsed.Revision})" : string.Empty));
foreach (var target in parsed.Items)
{
lines.Add($"[osd] {target.Name}:通道 {string.Join(",", target.ChannelIds)} → "
+ string.Join(",", target.Cameras.Select(camera =>
$"{camera.Name}({camera.NvrHost} 通道 {camera.ChannelNo})")));
}
lines.AddRange(parsed.Warnings.Select(warning => $"[osd] [WARN] {warning}"));
}
}
foreach (var line in lines) AppLog.Write(line);
if (lines.Count > 0) _wake.Set();
}
/// <summary>解析服务端返回的 `{ revision, items, warnings }`</summary>
private static ParsedConfig Parse(JsonElement data)
{
var result = new ParsedConfig();
if (data.ValueKind != JsonValueKind.Object) return result;
result.Revision = ReadString(data, "revision") ?? string.Empty;
if (data.TryGetProperty("warnings", out var warnings) && warnings.ValueKind == JsonValueKind.Array)
{
foreach (var item in warnings.EnumerateArray())
{
if (item.ValueKind != JsonValueKind.Object) continue;
var message = ReadString(item, "message") ?? string.Empty;
if (message.Length == 0) continue;
var workstation = ReadString(item, "workstationName") ?? string.Empty;
result.Warnings.Add(workstation.Length == 0 ? message : $"「{workstation}」{message}");
}
}
if (!data.TryGetProperty("items", out var items) || items.ValueKind != JsonValueKind.Array) return result;
foreach (var item in items.EnumerateArray())
{
if (item.ValueKind != JsonValueKind.Object) continue;
var workstationId = ReadInt(item, "workstationId");
if (workstationId <= 0) continue;
var channels = new List<string>();
if (item.TryGetProperty("channels", out var channelArray) && channelArray.ValueKind == JsonValueKind.Array)
{
foreach (var channel in channelArray.EnumerateArray())
{
var id = channel.ValueKind == JsonValueKind.Object ? ReadString(channel, "channelId") : null;
if (!string.IsNullOrWhiteSpace(id)) channels.Add(id!.Trim());
}
}
var cameras = new List<OsdCameraTarget>();
if (item.TryGetProperty("cameras", out var cameraArray) && cameraArray.ValueKind == JsonValueKind.Array)
{
foreach (var camera in cameraArray.EnumerateArray())
{
if (camera.ValueKind != JsonValueKind.Object) continue;
var nvr = camera.TryGetProperty("nvr", out var nvrElement) && nvrElement.ValueKind == JsonValueKind.Object
? nvrElement
: default;
var channelNo = ReadInt(camera, "cameraChannelNo");
var host = nvr.ValueKind == JsonValueKind.Object ? ReadString(nvr, "host") ?? string.Empty : string.Empty;
var password = nvr.ValueKind == JsonValueKind.Object ? ReadString(nvr, "password") ?? string.Empty : string.Empty;
if (channelNo <= 0 || host.Length == 0 || password.Length == 0) continue;
cameras.Add(new OsdCameraTarget
{
CameraId = ReadInt(camera, "cameraId"),
Name = ReadString(camera, "cameraName") ?? string.Empty,
ChannelNo = channelNo,
NvrHost = host,
NvrPort = nvr.ValueKind == JsonValueKind.Object && ReadInt(nvr, "port") > 0 ? ReadInt(nvr, "port") : 8000,
NvrUser = nvr.ValueKind == JsonValueKind.Object ? ReadString(nvr, "username") ?? "admin" : "admin",
NvrPassword = password,
});
}
}
if (cameras.Count == 0) continue;
result.Items.Add(new OsdWorkstationTarget
{
Id = workstationId,
Name = ReadString(item, "workstationName") ?? string.Empty,
Code = ReadString(item, "workstationCode") ?? string.Empty,
ChannelIds = channels,
Cameras = cameras,
});
}
return result;
}
private static string? ReadString(JsonElement element, string name)
=> element.TryGetProperty(name, out var value) && value.ValueKind == JsonValueKind.String
? value.GetString()
: null;
private static int ReadInt(JsonElement element, string name)
=> element.TryGetProperty(name, out var value) && value.TryGetInt32(out var number) ? number : 0;
public void Dispose()
{
Stop();
try { _wake.Dispose(); } catch { /* 忽略 */ }
// 不 Dispose OsdHik:它是进程级共享的会话池(Dispose 会 NET_DVR_Cleanup,影响界面预览)
}
private sealed class WorkstationState
{
public string WorkstationName { get; set; } = string.Empty;
public HashSet<string> Channels { get; set; } = new(StringComparer.OrdinalIgnoreCase);
/// <summary>最近一次命中的运单号(连续命中同一个码不会变)</summary>
public string LastCode { get; set; } = string.Empty;
public DateTime? LastCodeAt { get; set; }
/// <summary>最近一次命中时间(**重复命中也会刷新**,用于 60 秒无扫码还原)</summary>
public DateTime? LastActivityAt { get; set; }
}
private sealed class CameraState
{
public OsdCameraTarget Camera { get; set; } = new();
public int WorkstationId { get; set; }
public string WorkstationName { get; set; } = string.Empty;
/// <summary>最后一次**确认**写入的文本(null = 还没写过)</summary>
public string? LastText { get; set; }
public DateTime? LastWriteAt { get; set; }
public string? LastError { get; set; }
public int FailCount { get; set; }
public DateTime NextAttemptAt { get; set; } = DateTime.MinValue;
/// <summary>日志节流:同一路 10 秒内只落一行(写一台本来就要 1~3 秒)</summary>
public DateTime LastLogAt { get; set; } = DateTime.MinValue;
}
private sealed record RetiredWrite(OsdCameraTarget Camera, string Text);
private sealed class ParsedConfig
{
public string Revision { get; set; } = string.Empty;
public List<OsdWorkstationTarget> Items { get; } = new();
public List<string> Warnings { get; } = new();
}
}