跨公司取流:云端边缘任务通道 + 三级降级

场景:查询机 A 和打包仓库 B 在不同网络,B 没有公网 IP。
B 只能主动出站,所以云端从不反向连它 —— 复用设备出站链路做任务通道。

云端(backend)
- 新增 edge_task 服务:Redis List 做队列、短 TTL 存结果,
  多实例共享,不依赖 sticky session
- POST /api/scanner/tasks/poll:设备长轮询领任务(挂 20 秒,
  有任务立刻返回,没任务 204)
- POST /api/scanner/tasks/:id/result:设备回结果
- POST /api/web/edge/check:查询机问「这段有没有录像」,
  云端按主体选出在线扫码服务 → 下发 check → 等结果(默认 8 秒)
- 不阻塞共享 Redis 连接:任务用短间隔轮询而非 BLPOP
  (egg-redis 是共享连接,阻塞命令会卡住其它请求)

桌面端(desktop)
- AgentHost 新增边缘任务循环:长轮询领任务 → 交 worker 执行 → 回结果,
  与扫码链路完全解耦,异常只退避重试
- worker 新增 check 能力(复用 HikPlaybackService.CheckAsync)
- ApiClient 长轮询单独用不限时客户端(共享 HttpClient 的 15 秒超时会掐断)

三级降级(桌面端校验)
1. 局域网有设备管理服务 → 交给它(共用 NVR 会话池)
2. 没有 → 问云端;云端确认有录像时**隐藏预览、只显示下载**
   (跨网拉流成本高,短片段/下载更合适)
3. 云端也判断不了 → 本机自己校验(仓库内操作员的常规路径)

实测(真实 NVR 192.168.8.241 通道 34)
  设备心跳 → 领任务 → worker 校验 → 回结果 → 网页拿到结论
  端到端 2.17 秒(其中 NVR 拉流约 2 秒)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
This commit is contained in:
liufumingren 2026-10-22 00:26:27 +08:00
parent 6f8095913b
commit 290f29e547
10 changed files with 671 additions and 2 deletions

View File

@ -0,0 +1,55 @@
'use strict';
const { Controller } = require('egg');
/**
* 设备态:边缘任务通道(**需长期设备 JWT**)
*
* 打包仓库的扫码服务没有公网 IP,只能自己出站来领任务:
* - `POST /api/scanner/tasks/poll?wait=25`:没有任务就挂住,有任务立刻返回;
* - `POST /api/scanner/tasks/:id/result`:回执行结果。
*
* 云端从不主动连设备 —— 这也正是跨公司场景能成立的原因。
*/
class DeviceEdgeController extends Controller {
/**
* 领任务(长轮询)
*
* 返回 204 表示这段时间没有任务,客户端立刻再发起下一次即可。
*/
async poll() {
const { ctx } = this;
const scanner = ctx.state.scanner;
// 上限 25 秒:比心跳间隔短,也能避开大多数反代的读超时(默认 60s)
const wait = Math.min(Math.max(Number(ctx.query.wait) || 25, 1), 25);
const task = await ctx.service.edgeTask.poll(scanner.id, wait * 1000);
if (!task) {
ctx.status = 204;
return;
}
ctx.logger.info('[edge] 设备 %s 领取任务 %s(%s)', scanner.sn, task.id, task.type);
ctx.body = { ok: true, data: task };
}
/**
* 回任务结果
*
* body: `{ ok: true, ... }` 或 `{ ok: false, error: '...' }`
*/
async result() {
const { ctx } = this;
const id = String(ctx.params.id || '').trim();
if (!id) ctx.throw(400, '缺少任务 id');
const body = ctx.request.body || {};
await ctx.service.edgeTask.submitResult(id, body);
ctx.logger.info('[edge] 设备 %s 回任务 %s:ok=%s', ctx.state.scanner.sn, id, body.ok);
ctx.body = { ok: true };
}
}
module.exports = DeviceEdgeController;

View File

@ -0,0 +1,40 @@
'use strict';
const { Controller } = require('egg');
/**
* web 用户端:边缘能力(`/api/web/edge/*`)
*
* 查询机先在本机局域网找"设备管理服务"(UDP 询问),找不到才来这里问云端。
* 云端把问题转给打包仓库那台扫码服务(它出站领任务、真拉一段录像确认)。
*
* 这样查询机得到的结论和"本机自己校验"是同一套语义,不会各说一套。
*/
class WebEdgeController extends Controller {
/**
* POST /api/web/edge/check { code }
*
* 返回 `data.state`:
* - `ok` 设备确认过:`hasVideo` 为准
* - `no-plan` 这个运单在本主体下算不出回放计划(没绑工作台/摄像头)
* - `no-device` 同主体没有在线的扫码服务,或它们都连不上该 NVR
* - `no-credential` 录像机没有保存密码
*
* `hasVideo` 三态:true / false / null(未知,调用方自己决定怎么展示)
*/
async check() {
const { ctx } = this;
const body = ctx.request.body || {};
const code = String(body.code || ctx.query.code || '').trim();
if (!code) ctx.throw(422, '缺少运单号');
const data = await ctx.service.edgeTask.checkVideo({
subjectId: ctx.state.subjectId,
code,
});
ctx.body = { ok: true, data };
}
}
module.exports = WebEdgeController;

View File

@ -104,6 +104,10 @@ module.exports = (app) => {
// ⚠️ 这个不挂 subjectAdmin:它是打包工位的日常查询入口,普通成员也要能用
router.get('/api/web/pack-query', apiAuth, subjectAuth, controller.web.pack.query);
// 边缘能力:查询机在局域网找不到「设备管理服务」时,来这里问云端
// (云端转给打包仓库那台扫码服务,由它真拉一段确认有没有录像)
router.post('/api/web/edge/check', apiAuth, subjectAuth, controller.web.edge.check);
// ---------- 视频接入:NVR / 摄像头 / 工作台(只碰本主体的数据;仅主体管理员)----------
// 拉取通道 = 前端调本机软件(localhost:17300/api/hik/channels)→ 勾选 → POST /nvrs/:id/channels 落库
router.get('/api/web/nvrs', apiAuth, subjectAuth, subjectAdmin, controller.web.nvr.index);
@ -202,6 +206,9 @@ module.exports = (app) => {
// ---------- 设备态(device):需长期 JWT ----------
router.get('/api/scanner/me', scannerAuth, controller.device.self.me);
router.post('/api/scanner/heartbeat', scannerAuth, controller.device.self.heartbeat);
// 边缘任务通道:设备主动出站领任务(跨公司取流用,云端从不反向连设备)
router.post('/api/scanner/tasks/poll', scannerAuth, controller.device.edge.poll);
router.post('/api/scanner/tasks/:id/result', scannerAuth, controller.device.edge.result);
// 上报(写)额外检查主体是否过期/停用:过期后返回 403 subject_expired,设备暂停推送并靠心跳探测续期
router.post('/api/scan/channels', scannerAuth, subjectActive, controller.device.scan.reportChannels);
router.get('/api/scan/channels', scannerAuth, controller.device.scan.channels);

View File

@ -0,0 +1,251 @@
'use strict';
const { Service } = require('egg');
const crypto = require('crypto');
/**
* 云端「边缘任务」通道
*
* 背景:查询机(A)和打包仓库(B)在不同公司/不同网络,B 没有公网 IP。
* 所以**永远由 B 主动出站**领任务,云端从不反向连它 —— 这条通道复用的就是
* 设备心跳那条出站链路(`POST /api/scanner/tasks/poll` 挂住等任务)。
*
* 只做控制面:
* 云端入队 → 设备长轮询领取 → 设备回结果
*
* 队列用 Redis List(多实例共享,天然不依赖 sticky session),
* 结果放短 TTL 的 key,过期即视为「设备没回」。
*/
/** 超过这个时间没心跳就认为设备离线(与心跳间隔 60s 留足余量) */
const SCANNER_ONLINE_MS = 5 * 60 * 1000;
/** 任务与结果的保留时间:任务没人领就丢,结果没人取就丢 */
const TASK_TTL_SECONDS = 180;
const RESULT_TTL_SECONDS = 180;
/** 单次校验最多等多久(设备侧真拉一小段,正常 2~5 秒) */
const DEFAULT_WAIT_MS = 8000;
/** 同一主体最多试几台设备(多仓库时逐个试,连不上 NVR 的会被跳过) */
const MAX_DEVICES = 2;
class EdgeTaskService extends Service {
get redis() {
return this.app.redis;
}
get prefix() {
return (this.config.cache && this.config.cache.prefix) || '';
}
queueKey(scannerId) {
return `${this.prefix}edge:task:${Number(scannerId)}`;
}
resultKey(taskId) {
return `${this.prefix}edge:result:${taskId}`;
}
/**
* 同主体里最近有心跳的扫码服务(可代取的候选,按心跳时间倒序)
* @param {number} subjectId
* @return {Promise<Array>} scanners 原始行
*/
async onlineScanners(subjectId) {
const Scanners = this.app.model.Scanner;
const threshold = new Date(Date.now() - SCANNER_ONLINE_MS);
return Scanners.findAll({
where: {
subjectId: Number(subjectId),
status: 1,
lastSeenAt: { [this.app.Sequelize.Op.gte]: threshold },
},
order: [ [ 'last_seen_at', 'DESC' ] ],
limit: MAX_DEVICES,
raw: true,
});
}
/**
* 入队一个任务
* @param {number} scannerId 目标设备
* @param {string} type 任务类型(check / download)
* @param {object} payload 任务参数
* @return {Promise<object>} 含 id 的任务对象
*/
async enqueue(scannerId, type, payload) {
const task = {
id: crypto.randomUUID(),
type,
payload,
createdAt: new Date().toISOString(),
};
const key = this.queueKey(scannerId);
await this.redis.lpush(key, JSON.stringify(task));
// 队列本身也给个 TTL:设备长期离线时不让任务无限堆积
await this.redis.expire(key, TASK_TTL_SECONDS);
return task;
}
/**
* 设备侧领取任务(长轮询)
*
* ⚠️ 不用 BLPOP:egg-redis 是共享连接,阻塞命令会把其它请求一起卡住。
* 这里用短间隔轮询,代价是一次 task 最多 200ms 的额外延迟,可以接受。
*
* @param {number} scannerId
* @param {number} waitMs 最长挂多久
* @return {Promise<object|null>} 没任务返回 null
*/
async poll(scannerId, waitMs) {
const deadline = Date.now() + Math.max(0, Number(waitMs) || 0);
const key = this.queueKey(scannerId);
for (;;) {
const raw = await this.redis.rpop(key);
if (raw) {
try {
return JSON.parse(raw);
} catch (err) {
this.ctx.logger.warn('[edge] 任务解析失败,丢弃:%s', err.message);
}
}
if (Date.now() >= deadline) return null;
await sleep(200);
}
}
/**
* 设备回结果
* @param {string} taskId
* @param {object} payload { ok, data | error }
*/
async submitResult(taskId, payload) {
const id = String(taskId || '').trim();
if (!id) return false;
await this.redis.setex(this.resultKey(id), RESULT_TTL_SECONDS, JSON.stringify(payload || {}));
return true;
}
/**
* 等结果(调用方是 web 请求,用户正等着)
* @param {string} taskId
* @param {number} timeoutMs
* @return {Promise<object|null>} 超时返回 null
*/
async waitResult(taskId, timeoutMs) {
const key = this.resultKey(taskId);
const deadline = Date.now() + Math.max(0, Number(timeoutMs) || DEFAULT_WAIT_MS);
for (;;) {
const raw = await this.redis.get(key);
if (raw) {
try {
return JSON.parse(raw);
} catch (err) {
return null;
}
}
if (Date.now() >= deadline) return null;
await sleep(150);
}
}
/**
* 问「这段录像有没有帧」
*
* 顺序:本主体在线的扫码服务 → 下发 check → 等结果;连不上 NVR 的换下一台。
*
* @param {object} params
* @param {number} params.subjectId
* @param {string} params.code 运单号
* @param {number} [params.waitMs]
* @return {Promise<object>} 见 controller 的注释
*/
async checkVideo({ subjectId, code, waitMs = DEFAULT_WAIT_MS }) {
const plan = await this.ctx.service.pack.query({ subjectId, code });
const streams = (plan && plan.streams) || [];
// 没有流计划:连"该查哪台 NVR 的哪个通道"都算不出来,无需惊动设备
if (streams.length === 0) {
return { state: 'no-plan', hasVideo: false };
}
const scanners = await this.onlineScanners(subjectId);
if (scanners.length === 0) {
return { state: 'no-device', hasVideo: null };
}
const stream = streams[0];
let credential;
try {
credential = await this.ctx.service.nvr.credentialOf(stream.nvrId, subjectId);
} catch (err) {
return { state: 'no-credential', hasVideo: null, message: err.message };
}
if (!credential.password) {
return { state: 'no-credential', hasVideo: null, message: '录像机没有保存密码' };
}
const payload = {
nvrId: stream.nvrId,
nvrHost: credential.host,
nvrPort: credential.port,
username: credential.username,
password: credential.password,
channelNo: stream.channelNo,
startTime: stream.startTime,
endTime: stream.endTime,
};
const startedAt = Date.now();
let lastError = null;
for (const scanner of scanners) {
let task;
try {
task = await this.enqueue(scanner.id, 'check', payload);
} catch (err) {
lastError = err.message;
continue;
}
const result = await this.waitResult(task.id, waitMs);
if (!result) {
lastError = '设备没有响应';
continue;
}
// 设备明确说连不上(或参数被拒):换下一台试
if (result.ok === false) {
lastError = result.error || '设备执行失败';
continue;
}
return {
state: 'ok',
hasVideo: Boolean(result.hasRecord),
frames: Number(result.frames) || 0,
source: result.source || '',
message: result.error || null,
scannerSn: scanner.sn,
elapsedMs: Date.now() - startedAt,
};
}
return { state: 'no-device', hasVideo: null, message: lastError };
}
}
function sleep(ms) {
return new Promise(resolve => setTimeout(resolve, ms));
}
module.exports = EdgeTaskService;

View File

@ -1192,6 +1192,25 @@ public partial class MainWindow : Window
/// **只要任意一路有录像就停止**(不需要把每一路都验完)→ 显示预览/下载。
/// 顺序做,避免同时占满设备连接。
/// </summary>
/// <summary>
/// 问云端「这段录像有没有帧」;云端不可用时返回 null(调用方降级到本机校验)
/// </summary>
private async Task<ApiClient.EdgeCheckOutcome?> AskCloudCheckAsync(string code, CancellationToken ct)
{
var token = _session?.Token;
if (_api is null || string.IsNullOrWhiteSpace(token) || string.IsNullOrWhiteSpace(code)) return null;
try
{
return await _api.EdgeCheckAsync(token, _settings.SubjectId, code, ct).ConfigureAwait(false);
}
catch (Exception ex)
{
AppLog.Write($"[edge] 云端校验失败(改由本机):{ex.Message}");
return null;
}
}
private async Task ValidatePlaybackAsync(PackQuery query)
{
// 用后端拍平去重后的 streams(同一摄像头在多次扫码里只验一次)
@ -1223,7 +1242,50 @@ public partial class MainWindow : Window
.Distinct()
.ToList();
var peer = await _gateway.FindAsync(nvrs, ct).ConfigureAwait(false);
if (peer is not null) lines.Add($"[选路] 交由设备管理服务 {peer.Display} 校验");
if (peer is not null)
{
lines.Add($"[选路] 交由设备管理服务 {peer.Display} 校验");
}
else
{
// 局域网没有设备管理服务(跨公司/跨网段)→ 问云端:
// 云端转给能访问 NVR 的扫码服务确认,能确认就不用本机白拉一遍。
lines.Add("[选路] 局域网没有设备管理服务,改问云端…");
ShowPlayback(string.Join(Environment.NewLine, lines));
var cloud = await AskCloudCheckAsync(query.Code, ct);
if (cloud is { State: "ok", HasVideo: { } hasVideo })
{
_validatedStreams = hasVideo ? streams : Array.Empty<PackStream>();
// 跨网只给下载:预览要实时拉流,云端中转成本高且体验差
PreviewButton.Visibility = Visibility.Collapsed;
DownloadButton.Visibility = hasVideo ? Visibility.Visible : Visibility.Collapsed;
DownloadButton.IsEnabled = hasVideo;
lines[0] = hasVideo
? $"云端校验:有录像({cloud.ScannerSn}),跨网只提供下载"
: "云端校验:该时段没有录像";
ShowPlayback(string.Join(Environment.NewLine, lines));
return;
}
if (cloud is { State: "no-plan" })
{
_validatedStreams = Array.Empty<PackStream>();
PreviewButton.Visibility = Visibility.Collapsed;
DownloadButton.Visibility = Visibility.Collapsed;
lines[0] = "这个运单算不出回放计划(扫码时该通道没绑定工作台)";
ShowPlayback(string.Join(Environment.NewLine, lines));
return;
}
// 云端判断不了(没有在线扫码服务 / 云端不可用)→ 本机自己校验
lines.Add(cloud is null
? "[选路] 云端不可用,改由本机校验"
: $"[选路] 云端无法确认({cloud.State}),改由本机校验");
}
try
{

View File

@ -184,6 +184,10 @@ public static class AgentHost
AppLog.Write($"[agent] 扫码已启动:{scan.Channels.Count} 个通道"
+ $"(SN {config.DeviceSn},主体 {config.SubjectId})");
// 边缘任务通道:设备主动出站长轮询领任务(跨公司取流用)。
// 与扫码链路完全解耦:这里出错只记日志,不影响收码上报。
_ = Task.Run(() => RunEdgeTaskLoopAsync(api, settings, hikWorker, ct), CancellationToken.None);
while (!ct.IsCancellationRequested)
{
if (!await DelayAsync(TimeSpan.FromSeconds(1), ct).ConfigureAwait(false)) break;
@ -481,6 +485,87 @@ public static class AgentHost
};
}
/// <summary>
/// 边缘任务循环:长轮询领任务 → 交给 worker 执行 → 回结果。
///
/// 云端握着挂起的请求,所以任务一到就能立刻送达(不需要等下一次心跳)。
/// 这里任何异常都只记日志并退避重试,绝不影响扫码链路。
/// </summary>
private static async Task RunEdgeTaskLoopAsync(ApiClient api, AppSettings settings,
HikWorkerSupervisor worker, CancellationToken ct)
{
var retryMs = 1000;
while (!ct.IsCancellationRequested)
{
try
{
var task = await api.PollEdgeTaskAsync(settings.DeviceToken, 20, ct).ConfigureAwait(false);
retryMs = 1000;
if (task is null) continue; // 这段时间没任务,立刻再挂
AppLog.Write($"[edge] 领到任务 {task.Id}({task.Type})");
var (result, ok) = await ExecuteEdgeTaskAsync(worker, task, ct).ConfigureAwait(false);
await api.SubmitEdgeTaskResultAsync(settings.DeviceToken, task.Id, result, ct)
.ConfigureAwait(false);
AppLog.Write($"[edge] 任务 {task.Id} 完成:ok={ok}");
}
catch (OperationCanceledException)
{
break;
}
catch (Exception ex)
{
AppLog.Write($"[edge] 任务通道异常({retryMs / 1000.0:0.0} 秒后重试):{ex.Message}");
if (!await DelayAsync(TimeSpan.FromMilliseconds(retryMs), ct).ConfigureAwait(false)) break;
retryMs = Math.Min(retryMs * 2, 30000);
}
}
}
/// <summary>执行一个边缘任务;返回要回传给云端的结果对象</summary>
private static async Task<(object Result, bool Ok)> ExecuteEdgeTaskAsync(HikWorkerSupervisor worker,
ApiClient.EdgeTask task, CancellationToken ct)
{
try
{
switch (task.Type)
{
case "check":
{
var data = await worker.CheckAsync(task.Payload, ct).ConfigureAwait(false);
if (data is not { } element) return (new { ok = false, error = "worker 无返回" }, false);
var hasRecord = element.TryGetProperty("hasRecord", out var v) && v.ValueKind == JsonValueKind.True;
var frames = element.TryGetProperty("frames", out var f) && f.TryGetInt32(out var parsed) ? parsed : 0;
return (new
{
ok = true,
hasRecord,
frames,
error = ReadString(element, "error"),
source = ReadString(element, "source"),
}, true);
}
default:
return (new { ok = false, error = $"不支持的任务类型:{task.Type}" }, false);
}
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception ex)
{
return (new { ok = false, error = ex.Message }, false);
}
}
/// <summary>把 worker 自检结果落到状态里(失败只标记不可用,不影响扫码)</summary>
private static void ApplyHikProbe(AgentHikStatus status, JsonElement? probe)
{

View File

@ -44,7 +44,7 @@ public static class HikWorker
// 一次只执行一份计划:避免多个大任务互抢带宽与 ffmpeg CPU,排队交给上层
using var downloadGate = new SemaphoreSlim(1, 1);
var state = new WorkerState { Download = download, Gate = downloadGate };
var state = new WorkerState { Download = download, Playback = playback, Gate = downloadGate };
// 取流接口 + 局域网发现。两个任务都吞异常只记日志 ——
// 发现/取流坏掉不能影响扫码(那是主进程的事,本来就不在这里)。
@ -108,10 +108,51 @@ public static class HikWorker
private sealed class WorkerState
{
public PlaybackDownloadService Download { get; init; } = null!;
public HikPlaybackService Playback { get; init; } = null!;
public SemaphoreSlim Gate { get; init; } = null!;
public bool ShutdownRequested { get; set; }
}
/// <summary>校验某时段有没有录像(真拉一小段,与桌面端本地校验同一套实现)</summary>
private static async Task<HikWorkerResponse> CheckAsync(HikWorkerRequest request, WorkerState state,
CancellationToken ct)
{
if (request.Payload is not { ValueKind: JsonValueKind.Object } payload)
{
return Fail(request, "缺少校验参数");
}
var host = GetString(payload, "nvrHost");
if (string.IsNullOrWhiteSpace(host)) return Fail(request, "缺少 nvrHost");
var port = payload.TryGetProperty("nvrPort", out var portElement) && portElement.TryGetInt32(out var parsedPort)
? parsedPort
: 8000;
if (!payload.TryGetProperty("channelNo", out var channelElement) || !channelElement.TryGetInt32(out var channelNo))
{
return Fail(request, "缺少 channelNo");
}
if (!payload.TryGetProperty("startTime", out var startElement) || !startElement.TryGetDateTimeOffset(out var start)
|| !payload.TryGetProperty("endTime", out var endElement) || !endElement.TryGetDateTimeOffset(out var end))
{
return Fail(request, "startTime/endTime 不合法");
}
var check = await state.Playback.CheckAsync(host!, port,
GetString(payload, "username") ?? "", GetString(payload, "password") ?? "",
channelNo, start, end, ct).ConfigureAwait(false);
return Ok(request, new
{
hasRecord = check.HasRecord,
frames = check.Frames,
error = check.Error,
source = check.Source,
});
}
/// <summary>处理一条连接上的请求(串行,够用:任务本身由上层排队)</summary>
private static async Task ServeAsync(Stream pipe, WorkerState state, CancellationToken ct)
{
@ -137,6 +178,9 @@ public static class HikWorker
case HikWorkerOps.Probe:
return Ok(request, Probe());
case HikWorkerOps.Check:
return await CheckAsync(request, state, ct).ConfigureAwait(false);
case HikWorkerOps.Shutdown:
state.ShutdownRequested = true;
return Ok(request, new { message = "worker 正在退出" });

View File

@ -102,6 +102,9 @@ public static class HikWorkerOps
/// <summary>自检:返回 SDK / ffmpeg 是否就绪、录像根目录</summary>
public const string Probe = "probe";
/// <summary>校验某时段有没有录像(真拉一小段)</summary>
public const string Check = "check";
/// <summary>按流计划下载并合并</summary>
public const string Download = "download";

View File

@ -63,6 +63,10 @@ public sealed class HikWorkerSupervisor : IAsyncDisposable
public async Task<JsonElement?> DownloadAsync(object payload, CancellationToken ct = default)
=> await SendAsync(HikWorkerOps.Download, payload, ct).ConfigureAwait(false);
/// <summary>校验某时段有没有录像(真拉一小段)</summary>
public async Task<JsonElement?> CheckAsync(object payload, CancellationToken ct = default)
=> await SendAsync(HikWorkerOps.Check, payload, ct).ConfigureAwait(false);
private async Task<JsonElement?> SendAsync(string op, object? payload, CancellationToken ct)
{
await EnsureConnectedAsync(ct).ConfigureAwait(false);

View File

@ -132,6 +132,9 @@ public sealed class ApiClient
{
private static readonly HttpClient Http = new() { Timeout = TimeSpan.FromSeconds(15) };
/// <summary>长轮询专用:挂起时间比 15 秒长,必须用不限时的客户端</summary>
private static readonly HttpClient LongPollHttp = new() { Timeout = Timeout.InfiniteTimeSpan };
private static readonly JsonSerializerOptions Json = new()
{
Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
@ -400,6 +403,91 @@ public sealed class ApiClient
ReadSubjectState(data.Value));
}
/// <summary>云端校验结论</summary>
/// <param name="State">ok / no-plan / no-device / no-credential</param>
/// <param name="HasVideo">true/false 可用;null 表示云端也判断不了</param>
public sealed record EdgeCheckOutcome(string State, bool? HasVideo, string? Message, string? ScannerSn);
/// <summary>
/// 边缘任务(跨公司取流用):云端入队,设备主动出站领取
/// </summary>
/// <param name="Id">任务 id(回结果时带上)</param>
/// <param name="Type">check / download</param>
/// <param name="Payload">任务参数(原样交给 worker)</param>
public sealed record EdgeTask(string Id, string Type, JsonElement Payload);
/// <summary>
/// 领任务(长轮询)
///
/// ⚠️ 不能用共享的 <c>Http</c>:它的超时是 15 秒,会把 20 秒的长轮询直接掐断
/// (现象是"任务永远要等到下一轮才到")。这里单独用不限时的客户端。
/// </summary>
public async Task<EdgeTask?> PollEdgeTaskAsync(string deviceToken, int waitSeconds,
CancellationToken ct = default)
{
var wait = Math.Clamp(waitSeconds, 1, 25);
using var timeout = CancellationTokenSource.CreateLinkedTokenSource(ct);
timeout.CancelAfter(TimeSpan.FromSeconds(wait + 15));
using var request = new HttpRequestMessage(HttpMethod.Post,
$"{BaseUrl}/api/scanner/tasks/poll?wait={wait}");
request.Headers.TryAddWithoutValidation("Authorization", $"Bearer {deviceToken}");
HttpResponseMessage response;
try
{
response = await LongPollHttp.SendAsync(request, timeout.Token).ConfigureAwait(false);
}
catch (OperationCanceledException) when (!ct.IsCancellationRequested)
{
// 本次挂起被网络/反代掐断:当作"没有任务",下一轮再领
return null;
}
catch (HttpRequestException ex)
{
throw new ApiException($"无法连接服务器({BaseUrl}):{ex.Message}");
}
using (response)
{
if (response.StatusCode == HttpStatusCode.NoContent) return null;
var text = await response.Content.ReadAsStringAsync(ct).ConfigureAwait(false);
var (data, _) = ReadEnvelope(response, text);
if (data is null || data.Value.ValueKind != JsonValueKind.Object) return null;
var id = GetString(data.Value, "id");
var type = GetString(data.Value, "type");
if (string.IsNullOrWhiteSpace(id) || string.IsNullOrWhiteSpace(type)) return null;
var payload = data.Value.TryGetProperty("payload", out var element) ? element : default;
return new EdgeTask(id!, type!, payload);
}
}
/// <summary>
/// 回任务结果(失败不抛:结果丢了顶多让查询机超时,不该影响扫码链路)
/// </summary>
public async Task SubmitEdgeTaskResultAsync(string deviceToken, string taskId, object result,
CancellationToken ct = default)
{
try
{
var body = JsonSerializer.Serialize(result);
using var response = await SendDeviceAsync($"/api/scanner/tasks/{taskId}/result",
deviceToken, body, "回传边缘任务结果", ct).ConfigureAwait(false);
if (!response.IsSuccessStatusCode)
{
AppLog.Write($"[edge] 回传任务 {taskId} 结果失败:HTTP {(int)response.StatusCode}");
}
}
catch (Exception ex)
{
AppLog.Write($"[edge] 回传任务 {taskId} 结果异常:{ex.Message}");
}
}
/// <summary>解析心跳里的 `subject`(老服务端没有这个字段时返回 null)</summary>
private static DeviceSubjectState? ReadSubjectState(JsonElement data)
{
@ -484,6 +572,36 @@ public sealed class ApiClient
return data.Value;
}
/// <summary>
/// 问云端「这段录像有没有帧」(用户令牌;`POST /api/web/edge/check`)
///
/// 用在「本机局域网找不到设备管理服务」时:云端把问题转给能访问 NVR 的
/// 扫码服务,由它真拉一小段确认。返回 null 表示云端不可用(调用方自行降级)。
/// </summary>
public async Task<EdgeCheckOutcome?> EdgeCheckAsync(string token, int subjectId, string code,
CancellationToken ct = default)
{
using var response = await SendAuthorizedAsync(HttpMethod.Post, "/api/web/edge/check",
token, subjectId, JsonSerializer.Serialize(new { code }), "云端校验录像", ct).ConfigureAwait(false);
var text = await response.Content.ReadAsStringAsync(ct).ConfigureAwait(false);
var (data, _) = ReadEnvelope(response, text);
if (data is null || data.Value.ValueKind != JsonValueKind.Object) return null;
var root = data.Value;
var state = GetString(root, "state") ?? "";
bool? hasVideo = root.TryGetProperty("hasVideo", out var value)
? value.ValueKind switch
{
JsonValueKind.True => true,
JsonValueKind.False => false,
_ => null,
}
: null;
return new EdgeCheckOutcome(state, hasVideo, GetString(root, "message"), GetString(root, "scannerSn"));
}
/// <summary>
/// 取**当前主体**的全部录像机(用户令牌;`GET /api/web/nvrs`,自动翻页)。
/// 后端本来就按主体隔离,桌面端只需要拿列表 + 自己内网连设备。