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;
/// 工作台(OSD 目标):本机负责的扫码通道 + 绑定的全部摄像头
public sealed class OsdWorkstationTarget
{
public int Id { get; init; }
public string Name { get; init; } = string.Empty;
public string Code { get; init; } = string.Empty;
/// 本机(这台设备)绑到该工作台的通道;扫码/识别命中这些通道才算该工作台在扫码
public List ChannelIds { get; init; } = new();
public List Cameras { get; init; } = new();
}
/// 一路要写 OSD 的摄像头(录像机 + 通道号 + 凭据)
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;
/// 物理身份:同一台录像机的同一个通道(重拉配置时用它继承状态)
internal string Key => $"{NvrHost}:{NvrPort}/{ChannelNo}";
}
/// OSD 配置快照(界面/日志用;**不含密码**)
public sealed class OsdSnapshot
{
public DateTime? PulledAt { get; set; }
public string Revision { get; set; } = string.Empty;
public string? Error { get; set; }
public List Items { get; set; } = new();
public List 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);
}
}
}
///
/// 工作台 OSD 字幕:把「摄像头名 + 运单号」写到该工作台每路摄像头的 OSD(= 录像机通道名)。
///
/// 规则(现场约定):
/// 1. 扫到运单号(扫码枪或面单识别,连续重复命中都算)→ 该工作台所有摄像头 OSD = `摄像头名 + 空格 + 运单号`;
/// 2. **运单号没变就不重写**(每次写设备配置要 1~3 秒,还会刷配置区);连续命中只续「在场」计时;
/// 3. 连续 **60 秒**没有任何命中 → 全部还原成**工作台名称**;
/// 4. 配置(工作台/摄像头/通道)由服务端下发,启动拉一次 + 每 1 分钟兜底 + 收到通知立即拉。
///
/// 实现要点:
/// - 所有设备写入在**单线程工作队列**里串行执行(写一台 1~3 秒,不能堵扫码线程);
/// - 每次写之前重新算目标文本,避免把过期的运单号写上去;
/// - 写失败按 5s→10s→…→60s 退避,不刷日志;配置里移除的摄像头会**还原一次**工作台名再忘掉;
/// - 文本超过 31 字节(GBK)时优先保运单号,压摄像头名(见 )。
///
public sealed class WorkstationOsdService : IDisposable
{
/// 多久没命中就还原成工作台名称(现场约定 1 分钟)
private static readonly TimeSpan IdleReset = TimeSpan.FromMinutes(1);
/// 配置兜底拉取间隔(变更靠服务端通知立即生效)
private static readonly TimeSpan RefreshInterval = TimeSpan.FromMinutes(1);
/// 工作线程巡检间隔(扫码会立刻唤醒,这里只是兜底)
private static readonly TimeSpan WorkerTick = TimeSpan.FromSeconds(1);
private readonly DeviceService _device;
private readonly object _gate = new();
private readonly AutoResetEvent _wake = new(false);
///
/// OSD 写入用的 SDK 会话池(**进程内共享**)。
///
/// 不能每建一个 ScanService 就 new 一个:`HikDeviceService.Dispose()` 会调
/// `NET_DVR_Cleanup()` 把**全局** SDK 拆掉(界面预览那边还在用),而且它的扫地定时器
/// 会让旧实例一直活着。共享一份既省登录,也不会互相拆台。
///
private static readonly HikDeviceService OsdHik = new();
private Dictionary _workstations = new();
private Dictionary _cameras = new(StringComparer.OrdinalIgnoreCase);
private readonly Queue _retired = new();
private CancellationTokenSource? _cts;
private Task? _worker;
private Timer? _timer;
private int _refreshing;
private volatile bool _running;
/// 上一次已经落过日志的错误(同样的错误不每分钟刷一行)
private string? _lastErrorLogged;
public WorkstationOsdService(DeviceService device)
{
_device = device;
}
public OsdSnapshot Snapshot { get; private set; } = new();
public bool Running => _running;
/// 启动:起工作线程 + 每分钟拉配置(设备服务没开时拉取只记一条提示,开启后下一轮自动生效)
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)";
}
}
/// 停止工作线程与定时器(**不主动清 OSD**:下次启动会按配置还原成工作台名)
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();
_cameras = new Dictionary(StringComparer.OrdinalIgnoreCase);
_retired.Clear();
}
}
///
/// 拉一次工作台配置。异常只记日志 + 落 ,不影响扫码/识别。
///
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);
}
}
///
/// 任意一次命中(扫码枪 / 面单识别,含连续重复命中)。
///
/// ⚠️ 在扫码线程上调用:只做字典更新 + 唤醒工作线程,**绝不能**在这里写设备。
///
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 { /* 停机中 */ }
}
/// 给 agent-status.json 用的紧凑状态(不含密码)
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; }
}
}
}
/// 挑一路需要写的摄像头执行一次(退役摄像头优先)
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);
}
/// 写一路摄像头的 OSD,并更新状态(成功/失败都记在该摄像头上)
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));
}
/// 当前该显示什么:有扫码(60 秒内)是「摄像头名 + 运单号」,否则是工作台名称
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();
lock (_gate)
{
var previousRevision = Snapshot.Revision;
var nextWorkstations = new Dictionary();
var nextCameras = new Dictionary(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(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();
}
/// 解析服务端返回的 `{ revision, items, warnings }`
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();
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();
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 Channels { get; set; } = new(StringComparer.OrdinalIgnoreCase);
/// 最近一次命中的运单号(连续命中同一个码不会变)
public string LastCode { get; set; } = string.Empty;
public DateTime? LastCodeAt { get; set; }
/// 最近一次命中时间(**重复命中也会刷新**,用于 60 秒无扫码还原)
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;
/// 最后一次**确认**写入的文本(null = 还没写过)
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;
/// 日志节流:同一路 10 秒内只落一行(写一台本来就要 1~3 秒)
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 Items { get; } = new();
public List Warnings { get; } = new();
}
}