packServer/desktop/Services/Scan/WorkstationOsdService.cs
liufumingren c7cf7127d4 feat(osd): 工作台摄像头 OSD 字幕写入运单号
- 后端:新增 workstationConfigOf 与 GET /api/scanner/workstations,只下发绑定了本机通道的工作台及其摄像头与 NVR 凭据
- 桌面:新增 WorkstationOsdService/OsdText——扫码命中即写「摄像头名 + 单号」,单号不变不重写,连续 60s 未识别恢复工作台名;单线程写队列、失败退避、配置移除的摄像头还原一次
- 桌面:HikDeviceService.SetChannelOsdName 读-改-写 + 回读校验(GBK、31 字节、按字符边界截断)
- 修复 build.ps1 / test-update.ps1 丢失 UTF-8 BOM,PowerShell 5.1 按 GBK 解析中文注释导致语法错误

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-11-01 05:39:40 +08:00

652 lines
26 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 分钟兜底 + 收到通知立即拉。
///
/// 实现要点:
/// - 所有设备写入在**单线程工作队列**里串行执行(写一台 1~3 秒,不能堵扫码线程);
/// - 每次写之前重新算目标文本,避免把过期的运单号写上去;
/// - 写失败按 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);
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)
{
try { _wake.WaitOne(WorkerTick); } catch { /* 停机中 */ }
if (ct.IsCancellationRequested) break;
try
{
await WriteOnceAsync(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; }
}
}
}
/// <summary>挑一路需要写的摄像头执行一次(退役摄像头优先)</summary>
private async Task WriteOnceAsync(CancellationToken ct)
{
// 设备服务被关掉/停用后不要再动设备(配置可能已经过期)
if (!_device.Enabled) return;
RetiredWrite? retired = null;
(CameraState State, string Text)? job = null;
lock (_gate)
{
if (_retired.Count > 0)
{
retired = _retired.Dequeue();
}
else
{
var now = DateTime.Now;
foreach (var state in _cameras.Values)
{
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;
job = (state, text);
break;
}
}
}
if (retired is not null)
{
await WriteCameraAsync(retired.Camera, retired.Text, ct).ConfigureAwait(false);
return;
}
if (job is null) return;
var (jobState, jobText) = job.Value;
await WriteCameraAsync(jobState.Camera, jobText, ct, jobState).ConfigureAwait(false);
}
/// <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)
: workstation.WorkstationName;
}
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;
if (string.Equals(state.LastText, state.WorkstationName, StringComparison.Ordinal)) continue;
_retired.Enqueue(new RetiredWrite(state.Camera, state.WorkstationName));
}
_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();
}
}