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>
This commit is contained in:
liufumingren 2026-11-01 05:39:27 +08:00
parent 78a923235d
commit c7cf7127d4
17 changed files with 1348 additions and 9 deletions

View File

@ -80,6 +80,9 @@ packService/
定时任务每分钟扫一次,详情 / 列表 / 回调读路径也会顺手收口(详见 [`backend/README.md`](backend/README.md))
- [x] **顶栏下载入口(2026-10-29)**:所有页面右上角都有「桌面端 / Android 扫码台」下载按钮(**不看权限**),
版本号读 `/download/version.json` 与 `/download/android_client/version.json`,没发布过安装包时按钮置灰
- [x] **工作台 OSD 字幕(2026-11-01)**:设备服务按工作台把「摄像头名 + 运单号」写进每路摄像头的 OSD
(= 录像机通道名,录像/回放都带);运单号没变不重写,连续 60 秒没扫到还原成工作台名;
配置由 GET /api/scanner/workstations 下发(详见 [desktop/README.md](desktop/README.md) 的「工作台 OSD 字幕」)
- [ ] 扩展:目标地址换成真实打包视频页(现在指向百度占位)—— 在扩展「设置」里改「目标地址模板」即可,需要真实地址
后端接口细节见 [`backend/README.md`](backend/README.md),扩展用法见 [`extension/README.md`](extension/README.md)。

View File

@ -109,6 +109,24 @@ class ScanController extends Controller {
);
ctx.body = { ok: true, data };
}
/**
* GET /api/scanner/workstations —— 本机**工作台 + 全部绑定摄像头**(OSD 字幕用,需长期 JWT)
*
* 只返回绑定了本机扫码通道的工作台,每项带 `channels`(本机通道)与 `cameras`
* (摄像头名 / 录像机通道号 / 录像机凭据)。设备端据此把「摄像头名 + 运单号」
* 写进对应通道的 OSD(= 录像机通道名),1 分钟没有扫码就还原成工作台名称。
*/
async workstations() {
const { ctx } = this;
const data = await ctx.service.labelScan.workstationConfigOf(ctx.state.scanner);
const cameraCount = data.items.reduce((sum, item) => sum + item.cameras.length, 0);
ctx.logger.info(
'[osd] 设备 %s 拉取工作台配置:%d 个工作台 / %d 路摄像头(warning %d)',
ctx.state.scanner.sn, data.items.length, cameraCount, data.warnings.length,
);
ctx.body = { ok: true, data };
}
}
module.exports = ScanController;

View File

@ -261,4 +261,5 @@ module.exports = (app) => {
router.get('/api/scan/records', scannerAuth, controller.device.scan.records);
// 面单摄像头识别配置(读,不写业务数据,所以不挂 subjectActive)
router.get('/api/scanner/label-cameras', scannerAuth, controller.device.scan.labelCameras);
router.get('/api/scanner/workstations', scannerAuth, controller.device.scan.workstations);
};

View File

@ -237,6 +237,150 @@ class LabelScanService extends Service {
return { revision: revisionOf({ items, channels }), items, channels, warnings, scannedAt: new Date() };
}
/**
* 取本设备的**工作台 + 全部绑定摄像头**配置(OSD 字幕用)
*
* 与 {@link configOf} 的区别:这里不挑「面单摄像头」,也不做识别相关字段,
* 只回答「这台设备负责哪些工作台、每个工作台有哪些摄像头、各自在录像机哪个通道」。
* 设备端据此把 `摄像头名 + 运单号` 写到对应通道的 OSD 上(改的是录像机通道名)。
*
* 只下发**绑了本机扫码通道**的工作台:
* - 没有本机通道 → 扫码事件到不了这台设备,写了也不会更新,下发只会引起多台设备抢写;
* - 同一摄像头只属于一个工作台(`bindCameras` 已保证),不存在两套文本互相覆盖。
*
* @param {object} scanner 当前设备(ctx.state.scanner,已鉴权)
* @return {Promise<object>} { revision, items, warnings, scannedAt }
*/
async workstationConfigOf(scanner) {
const scannerId = Number(scanner.id);
const subjectId = Number(scanner.subjectId) || 0;
const warnings = [];
const workstations = await this.Workstation.findAll({
where: { subjectId, status: 1 },
attributes: [ 'id', 'code', 'name', 'wsType' ],
order: [[ 'id', 'ASC' ]],
});
if (!workstations.length) {
return { revision: revisionOf({ items: [] }), items: [], warnings, scannedAt: new Date() };
}
const ids = workstations.map(row => Number(row.id));
// 本机通道 → 工作台(只认本设备绑定的通道;虚拟通道 `CAM-<工作台id>` 也在这张表里)
const channelLinks = await this.app.model.WorkstationScanChannel.findAll({
where: { workstationId: { [Op.in]: ids }, scannerId },
attributes: [ 'id', 'workstationId', 'channelId', 'channelName', 'sortNo' ],
order: [[ 'workstationId', 'ASC' ], [ 'sortNo', 'ASC' ], [ 'id', 'ASC' ]],
});
const channelsByWorkstation = new Map();
for (const link of channelLinks) {
const key = Number(link.workstationId);
const channelId = String(link.channelId || '').trim();
if (!channelId) continue;
if (!channelsByWorkstation.has(key)) channelsByWorkstation.set(key, []);
channelsByWorkstation.get(key).push({ channelId, channelName: link.channelName || '' });
}
const links = await this.app.model.WorkstationCamera.findAll({
where: { workstationId: { [Op.in]: ids } },
include: [{
model: this.app.model.Camera,
as: 'camera',
required: true,
include: [{ model: this.Nvr, as: 'nvr', attributes: [ 'id', 'name', 'host', 'port', 'username' ] }],
}],
order: [[ 'workstationId', 'ASC' ], [ 'sortNo', 'ASC' ], [ 'id', 'ASC' ]],
});
const passwordCache = new Map();
const items = [];
for (const workstation of workstations) {
const workstationId = Number(workstation.id);
const workstationName = workstation.name || workstation.code || `工作台${workstationId}`;
const channels = channelsByWorkstation.get(workstationId) || [];
if (!channels.length) {
// 没有任何本机通道:这台设备收不到该工作台的扫码,OSD 由别的设备负责
continue;
}
const cameras = [];
for (const link of links) {
if (Number(link.workstationId) !== workstationId) continue;
const camera = link.camera;
if (!camera) continue;
const cameraName = camera.name || camera.channelName || `通道${camera.channelNo}`;
if (Number(camera.status) !== 1) {
warnings.push({
workstationId,
workstationName,
message: `摄像头「${cameraName}」已停用,不会写 OSD`,
});
continue;
}
const nvr = camera.nvr;
const channelNo = Number(camera.channelNo) || 0;
if (!nvr || !nvr.host || channelNo <= 0) {
warnings.push({
workstationId,
workstationName,
message: `摄像头「${cameraName}」缺少录像机或通道号,不会写 OSD`,
});
continue;
}
let password = passwordCache.get(Number(nvr.id));
if (password === undefined) {
password = await this.passwordOf(nvr.id);
passwordCache.set(Number(nvr.id), password);
}
if (!password) {
warnings.push({
workstationId,
workstationName,
message: `录像机「${nvr.name || nvr.host}」没有保存密码,无法写 OSD(到「录像机」里补一次密码)`,
});
continue;
}
cameras.push({
cameraId: Number(camera.id),
cameraName,
cameraChannelNo: channelNo,
streamType: Number(link.streamType) === 1 ? 1 : 0,
nvr: {
id: Number(nvr.id),
name: nvr.name || '',
host: nvr.host,
port: Number(nvr.port) || 8000,
username: nvr.username || 'admin',
password,
},
});
}
if (!cameras.length) continue;
items.push({
workstationId,
workstationCode: workstation.code || '',
workstationName,
wsType: Number(workstation.wsType) === 1 ? 1 : 2,
channels,
cameras,
});
}
return { revision: revisionOf({ items }), items, warnings, scannedAt: new Date() };
}
/**
* 确保「纯摄像头工作台」的虚拟通道存在(幂等)。
*

View File

@ -256,4 +256,38 @@ describe('test/app/controller/scanner.test.js', () => {
await http.delete('/api/scanners/1').expect(200);
});
});
it('GET /api/scanner/workstations 返回工作台 OSD 配置(需设备令牌)', async () => {
mock(app, 'model', {
User: {},
Scanner: {
async findByPk() {
return instance({ id: 1, sn: 'SN-001', status: 1, tokenJti: 'jti-1' });
},
},
});
app.mockService('labelScan', 'workstationConfigOf', async () => ({
revision: 'sha1:0123456789abcdef',
items: [{
workstationId: 2,
workstationCode: 'WS-2',
workstationName: '2号线',
wsType: 1,
channels: [{ channelId: 'CH1', channelName: '2号线扫码枪' }],
cameras: [{ cameraId: 11, cameraName: '2号线面单', cameraChannelNo: 45, streamType: 0, nvr: { id: 1 } }],
}],
warnings: [],
}));
const res = await http
.get('/api/scanner/workstations')
.set('Authorization', `Bearer ${signScannerToken()}`)
.expect(200);
assert(res.body.ok === true, JSON.stringify(res.body));
assert(res.body.data.items.length === 1 && res.body.data.items[0].cameras.length === 1);
});
it('GET /api/scanner/workstations 没令牌 401', async () => {
await http.get('/api/scanner/workstations').expect(401);
});});

View File

@ -277,3 +277,131 @@ describe('test/app/service/label-scan.test.js', () => {
});
});
});
/**
* 工作台 OSD 字幕配置(`service/label_scan#workstationConfigOf`)
*
* 设备端要把「摄像头名 + 运单号」写到录像机通道的 OSD(= 通道名),
* 所以这里必须给全:**本机负责的工作台**、工作台的全部摄像头、每路摄像头的录像机凭据。
*/
describe('test/app/service/label-scan.test.js - workstationConfigOf', () => {
const subjectId = 1;
const scanner = { id: 7, subjectId, sn: 'MINGREN' };
const instance = (data) => Object.assign({
toJSON: () => data,
update: async (fields) => Object.assign(data, fields),
}, data);
const workstation = (id, name, wsType = 1) => instance({ id, code: `WS-${id}`, name, wsType, status: 1 });
const cameraLink = (workstationId, camera) => instance({
id: camera.id * 100,
workstationId,
cameraId: camera.id,
streamType: 0,
isLabelCamera: 0,
camera: instance({
id: camera.id,
name: camera.name,
channelNo: camera.channelNo,
status: camera.status === undefined ? 1 : camera.status,
nvr: instance({ id: 1, name: '录像机1', host: '192.168.8.241', port: 8000, username: 'admin' }),
}),
});
const channelLink = (workstationId, channelId, channelName) =>
instance({ id: 1, workstationId, scannerId: 7, channelId, channelName, sortNo: 1 });
let nvrPassword = 'p@ss';
beforeEach(() => {
nvrPassword = 'p@ss';
app.mockService('nvr', 'passwordOf', () => nvrPassword);
});
function mockModels({ workstations, links, channels }) {
mock(app, 'model', {
Workstation: { async findAll() { return workstations; } },
WorkstationScanChannel: { async findAll() { return channels; } },
WorkstationCamera: { async findAll() { return links; } },
Nvr: { async findByPk() { return instance({ id: 1, name: '录像机1', host: '192.168.8.241', passwordEnc: 'x' }); } },
});
}
it('工作台 + 全部摄像头(含名称/通道号/录像机凭据)', async () => {
mockModels({
workstations: [ workstation(2, '2号线') ],
links: [
cameraLink(2, { id: 11, name: '2号线面单', channelNo: 45 }),
cameraLink(2, { id: 12, name: '2号线全景', channelNo: 46 }),
],
channels: [ channelLink(2, 'CH1', '2号线扫码枪') ],
});
const ctx = app.createAnonymousContext();
const data = await ctx.service.labelScan.workstationConfigOf(scanner);
assert(data.items.length === 1, JSON.stringify(data));
const item = data.items[0];
assert(item.workstationId === 2 && item.workstationName === '2号线');
assert(item.channels.length === 1 && item.channels[0].channelId === 'CH1');
assert(item.cameras.length === 2, JSON.stringify(item.cameras));
const camera = item.cameras.find(row => row.cameraId === 11);
assert(camera.cameraName === '2号线面单' && camera.cameraChannelNo === 45);
assert(camera.nvr.host === '192.168.8.241' && camera.nvr.password === 'p@ss');
assert(/^sha1:[0-9a-f]{16}$/.test(data.revision), data.revision);
assert(data.warnings.length === 0);
});
it('没绑本机通道的工作台不下发(扫码事件到不了这台设备)', async () => {
mockModels({
workstations: [ workstation(2, '2号线'), workstation(3, '3号线') ],
links: [
cameraLink(2, { id: 11, name: '2号线面单', channelNo: 45 }),
cameraLink(3, { id: 13, name: '3号线面单', channelNo: 55 }),
],
channels: [ channelLink(3, 'CH9', '9号枪') ],
});
const ctx = app.createAnonymousContext();
const data = await ctx.service.labelScan.workstationConfigOf(scanner);
assert(data.items.length === 1, JSON.stringify(data));
assert(data.items[0].workstationId === 3);
});
it('停用的摄像头不写 OSD,并给提示', async () => {
mockModels({
workstations: [ workstation(2, '2号线') ],
links: [
cameraLink(2, { id: 11, name: '2号线面单', channelNo: 45 }),
cameraLink(2, { id: 12, name: '2号线全景', channelNo: 46, status: 0 }),
],
channels: [ channelLink(2, 'CH1', '2号线扫码枪') ],
});
const ctx = app.createAnonymousContext();
const data = await ctx.service.labelScan.workstationConfigOf(scanner);
assert(data.items[0].cameras.length === 1, JSON.stringify(data.items[0].cameras));
assert(data.items[0].cameras[0].cameraId === 11);
assert(data.warnings.some(row => /已停用/.test(row.message)), JSON.stringify(data.warnings));
});
it('录像机没有密码 → 该路不下发(设备端写不了 OSD)', async () => {
nvrPassword = '';
mockModels({
workstations: [ workstation(2, '2号线') ],
links: [ cameraLink(2, { id: 11, name: '2号线面单', channelNo: 45 }) ],
channels: [ channelLink(2, 'CH1', '2号线扫码枪') ],
});
const ctx = app.createAnonymousContext();
const data = await ctx.service.labelScan.workstationConfigOf(scanner);
assert(data.items.length === 0, JSON.stringify(data.items));
assert(data.warnings.some(row => /没有保存密码/.test(row.message)), JSON.stringify(data.warnings));
});
});

View File

@ -64,6 +64,9 @@ public sealed class AgentStatus
/// <summary>面单识别配置的拉取状态(只拉配置,识别 worker 还没接)</summary>
public AgentLabelScanStatus LabelScan { get; set; } = new();
/// <summary>工作台 OSD 字幕(把「摄像头名 + 运单号」写进录像机通道名)</summary>
public AgentOsdStatus Osd { get; set; } = new();
public string NtpLastSyncAt { get; set; } = "";
public double NtpLastOffsetSeconds { get; set; }
public double NtpRoundTripMs { get; set; }
@ -230,6 +233,36 @@ public sealed class AgentLabelScanStatus
public List<string> Warnings { get; set; } = new();
}
/// <summary>
/// 工作台 OSD 字幕状态(agent-status.json;桌面端/排障用,**不含密码**)
/// </summary>
public sealed class AgentOsdStatus
{
public bool Enabled { get; set; }
public DateTime? PulledAt { get; set; }
public string Revision { get; set; } = "";
public string? Error { get; set; }
public string StatusText { get; set; } = "";
/// <summary>每路摄像头当前 OSD 文本 / 最近写入时间 / 错误</summary>
public List<AgentOsdCameraStatus> Items { get; set; } = new();
}
/// <summary>一路摄像头的 OSD 状态</summary>
public sealed class AgentOsdCameraStatus
{
public int WorkstationId { get; set; }
public string WorkstationName { get; set; } = "";
public int CameraId { get; set; }
public string CameraName { get; set; } = "";
public int ChannelNo { get; set; }
/// <summary>最后一次确认写入的文本(空 = 还没写过)</summary>
public string Text { get; set; } = "";
public DateTime? UpdatedAt { get; set; }
public string? LastError { get; set; }
}
/// <summary>桌面端 → 后台服务的一次性命令(写文件,服务每秒轮询)</summary>
public sealed class AgentCommand
{

View File

@ -541,6 +541,7 @@ public static class AgentHost
}).ToList(),
Warnings = scan.LabelScan.Snapshot.Warnings.Select(item => item.Display).ToList(),
},
Osd = scan.Osd.ToStatus(),
LogDropped = AppLog.Dropped,
LogLastDroppedAt = AppLog.LastDroppedAt,
NtpLastSyncAt = ntp.LastSyncAt,
@ -603,13 +604,21 @@ public static class AgentHost
{
// 只是「叫醒」:真正的配置以 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));
}

View File

@ -868,6 +868,23 @@ public sealed class ApiClient
return data.Value;
}
/// <summary>
/// 拉取本机**负责的工作台 + 全部绑定摄像头**(设备令牌;`GET /api/scanner/workstations`)。
///
/// 用来写 OSD 字幕:每项带 `channels`(本机扫码通道)与 `cameras`
/// (摄像头名 / 录像机通道号 / 录像机凭据),设备端据此把「摄像头名 + 运单号」写进通道名。
/// </summary>
public async Task<JsonElement> GetWorkstationsAsync(string deviceToken, CancellationToken ct = default)
{
using var response = await SendDeviceAsync(HttpMethod.Get, "/api/scanner/workstations", deviceToken, null,
"拉取工作台配置", ct).ConfigureAwait(false);
var text = await response.Content.ReadAsStringAsync(ct).ConfigureAwait(false);
var (data, message) = ReadEnvelope(response, text);
if (data is null) throw Failure(response, text, message);
return data.Value;
}
// ==================== 内部:请求 ====================
/// <summary>带用户令牌 + 主体 header 的请求</summary>

View File

@ -370,6 +370,10 @@ public sealed class DeviceService
public Task<System.Text.Json.JsonElement> FetchLabelCamerasAsync(CancellationToken ct = default)
=> _api.GetLabelCamerasAsync(_settings.DeviceToken, ct);
/// <summary>拉取本机负责的工作台 + 全部绑定摄像头(`GET /api/scanner/workstations`,OSD 用)</summary>
public Task<System.Text.Json.JsonElement> FetchWorkstationsAsync(CancellationToken ct = default)
=> _api.GetWorkstationsAsync(_settings.DeviceToken, ct);
/// <summary>立即触发一次上报(界面的「立即上传」)</summary>
public void TriggerUpload()
{

View File

@ -515,6 +515,122 @@ public sealed class HikDeviceService : IDisposable
}
}
/// <summary>
/// 写某通道的 OSD 名字(就是 NVR 的**通道名**,会烧进实时流和录像)。
///
/// 做法是「读-改-写整包」:
/// 1. <c>NET_DVR_GET_PICCFG_V30</c> 拿到整包(本机 7752 字节,<c>dwSize</c> 已填好);
/// 2. 只改 <c>sChanName</c>(偏移 4、长度 32、GBK、\0 结尾);
/// 3. 用**设备返回的字节数**原样写回 <c>NET_DVR_SET_PICCFG_V30</c>;
/// 4. 再 GET 回读校验,不一致就当失败(不能只信 SET 的返回值)。
///
/// 中文/长度由调用方用 <see cref="OsdText"/> 处理(≤31 字节);这里只做长度兜底。
/// </summary>
/// <returns>写入后的真实值,以及这次有没有真的改动(值相同就跳过,避免无意义写配置)</returns>
public HikOsdWriteResult SetChannelOsdName(string host, int port, string userName, string password,
int channel, string name)
{
Validate(host, port, userName, password);
if (channel <= 0) throw new ArgumentException("channel 必须是正整数");
var text = name ?? string.Empty;
var nameBytes = HikSdk.EncodeGbk(text);
if (nameBytes.Length > HikSdk.ChannelNameMaxBytes)
{
throw new ArgumentException($"OSD 文本超过 {HikSdk.ChannelNameMaxBytes} 字节(GBK):{text}");
}
var actual = string.Empty;
var changed = false;
ExecuteWithSession(host, port, userName, password, userId =>
{
var (ok, returned, buffer) = ReadPicCfg(userId, channel);
if (!ok)
{
var err = HikSdk.NET_DVR_GetLastError();
throw new HikException(err, $"读取通道 {channel} 图像参数失败:{HikSdk.DescribeError(err)}");
}
actual = ReadPicCfgName(buffer);
// 值没变就不写:每次写配置 1~3 秒,而且会刷设备配置区
if (string.Equals(actual, text, StringComparison.Ordinal)) return;
Array.Clear(buffer, HikSdk.ChannelNameOffset, HikSdk.ChannelNameLength);
Array.Copy(nameBytes, 0, buffer, HikSdk.ChannelNameOffset, nameBytes.Length);
var handle = Marshal.AllocHGlobal(buffer.Length);
try
{
Marshal.Copy(buffer, 0, handle, buffer.Length);
if (!HikSdk.NET_DVR_SetDVRConfig(userId, HikSdk.NET_DVR_SET_PICCFG_V30, channel,
handle, (uint)returned))
{
var err = HikSdk.NET_DVR_GetLastError();
throw new HikException(err, $"写通道 {channel} OSD 失败:{HikSdk.DescribeError(err)}");
}
}
finally
{
Marshal.FreeHGlobal(handle);
}
// 回读校验:有的固件 SET 返回 true 但没落盘
var (readOk, _, verify) = ReadPicCfg(userId, channel);
if (!readOk)
{
var err = HikSdk.NET_DVR_GetLastError();
throw new HikException(err, $"通道 {channel} OSD 写入后回读失败:{HikSdk.DescribeError(err)}");
}
actual = ReadPicCfgName(verify);
if (!string.Equals(actual, text, StringComparison.Ordinal))
{
throw new HikException(0, $"通道 {channel} OSD 写入未生效(回读到 \"{actual}\")");
}
changed = true;
});
return new HikOsdWriteResult(actual, changed);
}
/// <summary>读单通道图像参数(整包)。返回的 <paramref name="returned"/> 是设备给的结构体字节数</summary>
private static (bool Ok, int Returned, byte[] Buffer) ReadPicCfg(int userId, int channel)
{
var buffer = new byte[PicCfgBufferSize];
BitConverter.GetBytes(PicCfgBufferSize).CopyTo(buffer, 0);
var handle = Marshal.AllocHGlobal(PicCfgBufferSize);
try
{
Marshal.Copy(buffer, 0, handle, PicCfgBufferSize);
if (!HikSdk.NET_DVR_GetDVRConfig(userId, HikSdk.NET_DVR_GET_PICCFG_V30, channel,
handle, PicCfgBufferSize, out var returned))
{
return (false, 0, buffer);
}
var data = new byte[PicCfgBufferSize];
Marshal.Copy(handle, data, 0, PicCfgBufferSize);
return (true, (int)returned, data);
}
finally
{
Marshal.FreeHGlobal(handle);
}
}
/// <summary>从 PICCFG 整包里取通道名(GBK,遇到 \0 截断)</summary>
private static string ReadPicCfgName(byte[] buffer)
{
var bytes = new byte[PicCfgNameLength];
Array.Copy(buffer, PicCfgNameOffset, bytes, 0, PicCfgNameLength);
var end = Array.IndexOf(bytes, (byte)0);
return HikSdk.DecodeGbk(bytes, end < 0 ? PicCfgNameLength : end).Trim();
}
/// <summary>抓帧缓冲区(4MB 足够 1080p JPEG)</summary>
private const int JpegBufferSize = 4 * 1024 * 1024;
@ -1560,6 +1676,13 @@ public sealed class HikChannelInfo
/// <param name="Enabled">是否启用 NTP 校时</param>
public sealed record HikNtpConfig(string Server, int IntervalMinutes, bool Enabled);
/// <summary>
/// 写 OSD(通道名)的结果。
/// </summary>
/// <param name="Text">写入后设备上的真实文本(回读值)</param>
/// <param name="Changed">这次是否真的写了(false = 设备上本来就是这个值,已跳过)</param>
public sealed record HikOsdWriteResult(string Text, bool Changed);
/// <summary>通道接口返回体</summary>
public sealed class HikChannelsResult
{ public string endpoint { get; init; } = string.Empty;

View File

@ -50,6 +50,23 @@ internal static class HikSdk
/// </summary>
internal const uint NET_DVR_GET_PICCFG_V30 = 1002;
/// <summary>
/// NET_DVR_SET_PICCFG_V30:写单通道图像参数。
///
/// OSD(通道名)就靠它:**先 GET 整包、只改 <c>sChanName</c>、再原样整包写回**,
/// 不要自己拼结构体 —— 这台固件返回 7752 字节,字段比老版头文件多。
/// </summary>
internal const uint NET_DVR_SET_PICCFG_V30 = 1003;
/// <summary>PICCFG 里通道名字段的偏移(<c>DWORD dwSize</c> 之后)</summary>
internal const int ChannelNameOffset = 4;
/// <summary>PICCFG 里通道名字段的长度(GBK,含结尾 \0)</summary>
internal const int ChannelNameLength = 32;
/// <summary>通道名最多能写的字节数(GBK:一个汉字 2 字节,即最多 15 个汉字)</summary>
internal const int ChannelNameMaxBytes = ChannelNameLength - 1;
/// <summary>
/// NET_DVR_GET_PTZPOS:读取通道的 PTZ 参数(输出 <c>NET_DVR_PTZPOS</c>,4 个 WORD = 8 字节)。
///
@ -452,12 +469,7 @@ internal static class HikSdk
{
try
{
if (!_codePagesRegistered)
{
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
_codePagesRegistered = true;
}
EnsureCodePages();
return Encoding.GetEncoding(936).GetString(bytes, 0, count);
}
catch
@ -466,6 +478,38 @@ internal static class HikSdk
}
}
/// <summary>
/// GBK(936) 编码:写通道名 / OSD 用(设备只认 GBK,UTF-8 会变乱码)。
/// 编不了的字符(emoji 等)在 GBK 里会变成 `?`,调用方应先用 <see cref="ChannelNameMaxBytes"/> 截断。
/// </summary>
internal static byte[] EncodeGbk(string? text)
{
try
{
EnsureCodePages();
return Encoding.GetEncoding(936).GetBytes(text ?? string.Empty);
}
catch
{
return Encoding.ASCII.GetBytes(text ?? string.Empty);
}
}
private static void EnsureCodePages()
{
if (_codePagesRegistered) return;
try
{
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
}
catch
{
// 注册失败就用 ASCII 兜底(调用方已经 try/catch)
}
_codePagesRegistered = true;
}
private static void WriteFixed(byte[] buffer, string? value)
{
var bytes = Encoding.Latin1.GetBytes(value ?? string.Empty);

View File

@ -0,0 +1,93 @@
using System;
using System.Text;
using YuncangTrace.LocalService.Services.Hik;
namespace YuncangTrace.LocalService.Services.Scan;
/// <summary>
/// OSD 文本拼装(录像机通道名,GBK,最多 <see cref="MaxBytes"/> 字节)。
///
/// 现场要求:扫到运单号后,把「摄像头名 + 空格 + 运单号」写到该工作台所有摄像头的 OSD;
/// 没扫码时还原成工作台名称。设备只认 GBK 且字段只有 31 字节——
/// **运单号必须完整**(它才是取证要看的),所以超长时先压摄像头名,压完还超才截运单号。
/// </summary>
internal static class OsdText
{
/// <summary>通道名字段 32 字节,留 1 字节给结尾 \0</summary>
internal const int MaxBytes = HikSdk.ChannelNameMaxBytes;
/// <summary>
/// 拼「摄像头名 + 运单号」。设备上看到的示例:<c>2号线面单 SF1164748936737</c>。
/// </summary>
internal static string Combine(string? cameraName, string? code)
{
var name = Clean(cameraName);
var number = Clean(code);
if (number.Length == 0) return TruncateGbk(name, MaxBytes);
if (name.Length == 0) return TruncateGbk(number, MaxBytes);
var full = $"{name} {number}";
if (GbkLength(full) <= MaxBytes) return full;
// 先保运单号:给摄像头名留出剩余空间(至少 1 个汉字 = 2 字节才值得留)
var budget = MaxBytes - GbkLength(number) - 1;
if (budget >= 2)
{
var prefix = TruncateGbk(name, budget);
if (prefix.Length > 0) return $"{prefix} {number}";
}
// 运单号本身就把字段占满了(极少见):只能截断它
return TruncateGbk(number, MaxBytes);
}
/// <summary>按 GBK 字节数截断,**不切断汉字**(切断会变成 `?`)</summary>
internal static string TruncateGbk(string? text, int maxBytes)
{
var value = text ?? string.Empty;
if (value.Length == 0 || maxBytes <= 0) return string.Empty;
if (GbkLength(value) <= maxBytes) return value;
var builder = new StringBuilder(value.Length);
var used = 0;
foreach (var ch in value)
{
if (char.IsSurrogate(ch)) continue;
var bytes = GbkLength(ch.ToString());
if (used + bytes > maxBytes) break;
builder.Append(ch);
used += bytes;
}
return builder.ToString().TrimEnd();
}
/// <summary>去掉换行/控制字符(设备上会显示成方块),并把连续空格压成一个</summary>
internal static string Clean(string? text)
{
if (string.IsNullOrWhiteSpace(text)) return string.Empty;
var builder = new StringBuilder(text.Length);
var lastSpace = true; // 开头的空格不要
foreach (var ch in text)
{
var normalized = char.IsControl(ch) ? ' ' : ch;
if (normalized == ' ')
{
if (lastSpace) continue;
lastSpace = true;
builder.Append(' ');
continue;
}
lastSpace = false;
builder.Append(normalized);
}
return builder.ToString().Trim();
}
internal static int GbkLength(string? text) => HikSdk.EncodeGbk(text).Length;
}

View File

@ -87,6 +87,9 @@ public sealed class ScanService
_device = device;
LabelScan = new LabelScanMonitor(device, (channelId, code, wsType, afterAbsence) =>
ReportCameraScanAsync(channelId, ChannelNameOf(channelId), code, wsType, afterAbsence));
// 工作台 OSD 字幕:扫码/识别命中 → 写「摄像头名 + 运单号」,1 分钟没扫 → 还原工作台名
Osd = new WorkstationOsdService(device);
ScanActivity += (channelId, code, at) => Osd.OnScanActivity(channelId, code, at);
// 扫码枪那条路也要按「通道 → 工作台类型」决定记录规则(散单取第一次、团购取最后一次)
device.ChannelModeOf = LabelScan.ModeOf;
// 主体续期/恢复后补一次通道对账(暂停期间通道变动不会推上去)
@ -111,6 +114,9 @@ public sealed class ScanService
/// </summary>
public LabelScanMonitor LabelScan { get; }
/// <summary>工作台 OSD 字幕(摄像头名 + 运单号 → 录像机通道名)</summary>
public WorkstationOsdService Osd { get; }
/// <summary>通道同步状态(给界面看的一句话)</summary>
public string ChannelSyncStatus { get; private set; } = string.Empty;
@ -139,6 +145,14 @@ public sealed class ScanService
/// </summary>
public event Action<ScanChannel, string>? Barcode;
/// <summary>
/// 任意一次命中(扫码枪 + 面单识别,**含连续重复命中**):`(channelId, code, at)`。
///
/// 只给「在扫什么」这类轻量状态用(例如工作台 OSD 字幕的 60 秒在场计时):
/// 在扫码/识别线程上同步触发,订阅者**不能**做耗时操作(写设备、发请求都不行)。
/// </summary>
public event Action<string, string, DateTime>? ScanActivity;
/// <summary>读通道配置</summary>
public void Load()
{
@ -273,6 +287,8 @@ public sealed class ScanService
if (key.Length == 0 || text.Length == 0) return new CameraScanResult(false, false);
var now = DateTime.Now;
// 连续命中也算「还在扫」:OSD 字幕靠它续 60 秒在场计时(不重写文本)
RaiseScanActivity(key, text);
var presenceKey = $"{key}|{text}";
bool firstInView;
DateTime? knownScanTime = null;
@ -667,6 +683,7 @@ public sealed class ScanService
RequestChannelSync();
EnsureWatchdog();
LabelScan.Start(); // 面单识别配置:启动拉一次 + 每 5 分钟兜底
Osd.Start(); // 工作台 OSD:启动拉一次 + 每 1 分钟兜底
AppLog.Write($"[scan] 扫码服务已启动,通道 {Channels.Count} 个");
Changed?.Invoke();
return Task.CompletedTask;
@ -703,6 +720,7 @@ public sealed class ScanService
StopDiscovery();
LabelScan.Stop();
Osd.Stop();
AppLog.Write("[scan] 扫码服务已停止");
Changed?.Invoke();
@ -1021,9 +1039,28 @@ public sealed class ScanService
{
var added = _device.ReportOnChannel(channel.ChannelId, channel.DisplayName, code);
// 连续扫描(~80ms 一次)也会走到这里:OSD 只续计时,不会重写
RaiseScanActivity(channel.ChannelId, code);
if (added) Barcode?.Invoke(channel, code);
Changed?.Invoke();
}
/// <summary>触发 <see cref="ScanActivity"/>;订阅者异常绝不影响扫码主链路</summary>
private void RaiseScanActivity(string channelId, string code)
{
var handlers = ScanActivity;
if (handlers is null) return;
try
{
handlers(channelId, code, DateTime.Now);
}
catch (Exception ex)
{
AppLog.Write($"[scan] 扫码活动事件处理失败(通道 {channelId}):{ex.Message}");
}
}
}
/// <summary>添加通道的结果(<see cref="Channel"/> 为空表示失败,<see cref="Message"/> 是给用户看的一句话)</summary>

View File

@ -0,0 +1,651 @@
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();
}
}

View File

@ -1,4 +1,4 @@
#requires -Version 5.1
#requires -Version 5.1
<#
.SYNOPSIS
打「云仓视频溯源软件」的安装包(MSI 和/或 EXE),并生成本机自动更新用的 version.json。

View File

@ -1,4 +1,4 @@
#requires -Version 5.1
#requires -Version 5.1
<#
.SYNOPSIS
验证「自动更新」全链路(**不卸载重装**):启动当前已安装的旧版本,让它自己升级到后端最新版。