using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
namespace YuncangTrace.LocalService.Services.Scan;
///
/// 扫码服务(从 AndroidScanCenter 移植到桌面端):管通道配置 + TCP 收码 + 上报服务器。
///
/// - 只有**设备服务开启**(主体管理员)并且扫码服务启动时才真正连设备;
/// - 每条通道一条 TCP 连接,收到条码 → 过滤 → 交给 上报;
/// - 通道也上报给服务器(`POST /api/scan/channels`),施工时在「工作台」里绑定通道(团散在工作台区分)。
///
public sealed class ScanService
{
private readonly DeviceService _device;
private readonly DeviceScanner _scanner = new();
private readonly Dictionary _connections = new(StringComparer.OrdinalIgnoreCase);
private readonly SemaphoreSlim _gate = new(1, 1);
// 通道自动同步:任何变动 → 唤醒后台循环 → 推上去 + 回查确认,失败退避重试直到成功
private readonly SemaphoreSlim _syncSignal = new(0, 1);
private CancellationTokenSource? _syncCts;
private Task? _syncTask;
private int _syncRetryMs = 1000;
/// 下一次推送是否用「全量对账」语义(添加/删除通道时置 true,成功后清掉)
private volatile bool _syncReplace;
// 看门狗:设备断电重启时 TCP 不发 FIN,read 会永久挂住 → 定期回查设备侧 ClientIP
private CancellationTokenSource? _watchdogCts;
private Task? _watchdogTask;
/// 每个通道上次自愈的时间(每台设备 60 秒最多查一次)
private readonly Dictionary _lastHealAt = new(StringComparer.OrdinalIgnoreCase);
/// 每个通道上次写「连不上/自愈」日志的时间(离线设备不要每 60 秒刷屏)
private readonly Dictionary _healLogAt = new(StringComparer.OrdinalIgnoreCase);
/// 常驻发现(开关打开时才有)
private DiscoveryMonitor? _monitor;
/// 发现列表变了(新增/更新/掉线)
public event Action? DiscoveredChanged;
/// 是否正在持续发现
public bool Monitoring => _monitor is not null;
/// 当前发现到的设备
public IReadOnlyList DiscoveredDevices
=> _monitor?.Devices ?? Array.Empty();
/// 打开「扫描」:常驻 UDP(每 3 秒探测、一直收),不是扫一轮停一会儿
public void StartDiscovery()
{
if (_monitor is not null) return;
_monitor = new DiscoveryMonitor();
_monitor.Changed += OnDiscoveredChanged;
_monitor.Start();
OnDiscoveredChanged();
}
/// 关掉「扫描」
public void StopDiscovery()
{
if (_monitor is null) return;
_monitor.Changed -= OnDiscoveredChanged;
_monitor.Dispose();
_monitor = null;
DiscoveredChanged?.Invoke();
}
private void OnDiscoveredChanged()
{
// 顺手把已有通道的 IP 刷新一下(DHCP 换地址就能立刻重连到新地址)
ApplyDiscoveredIps(_monitor?.Devices ?? Array.Empty());
DiscoveredChanged?.Invoke();
}
public ScanService(DeviceService device)
{
_device = device;
}
/// 通道同步状态(给界面看的一句话)
public string ChannelSyncStatus { get; private set; } = string.Empty;
/// 扫码记录上报状态(空串 = 没有积压、也没报错)
public string UploadStatus => _device.UploadStatus;
/// 立即把积压的扫码记录推一次
public void TriggerUpload() => _device.TriggerUpload();
/// 通道列表引用(配置页/主界面共用一份,改完调 )
public List Channels { get; private set; } = new();
/// 扫码服务是否已启动
public bool Running { get; private set; }
/// 通道状态变化(界面刷新用)
public event Action? Changed;
///
/// 收到一条**新**条码(连续扫描时同一个码只报一次)。
///
/// 落本地记录、延迟上报、同步通道都在本类内部完成,订阅者只用于"提示/展示"。
/// ⚠️ **不要用这个事件去查运单**:扫码和运单查询是两条独立链路,
/// 历史上就是在这里自动查了一次,用户看到的是"没点查询,打包查询却一直在自动查"。
/// 运单查询只允许用户主动发起(输入框回车 / 点查询 / 协议叫醒)。
///
public event Action? Barcode;
/// 读通道配置
public void Load()
{
Channels = ChannelStore.Load();
}
/// 存通道配置
public void SaveChannels()
{
ChannelStore.Save(Channels);
}
/// 发现局域网设备(UDP 48899 广播);顺手把已有通道的 IP 刷新成最新
public async Task> DiscoverAsync(CancellationToken ct = default)
{
var devices = await _scanner.DiscoverAsync(ct).ConfigureAwait(false);
ApplyDiscoveredIps(devices);
return devices;
}
///
/// 设备 DHCP 换 IP 后必须重连:通道靠 MAC 绑定,`LastIp` 只是缓存,
/// 不刷新的话会一直重连一个旧地址(Android 侧 `Connection#setIp` 就是干这个的)。
///
private void ApplyDiscoveredIps(IReadOnlyList devices)
{
var changed = new List();
foreach (var device in devices)
{
if (string.IsNullOrWhiteSpace(device.Ip)) continue;
var channel = Channels.FirstOrDefault(item => item.Mac.Equals(device.Mac, StringComparison.OrdinalIgnoreCase));
if (channel is null || channel.LastIp.Equals(device.Ip, StringComparison.Ordinal)) continue;
AppLog.Write($"[scan] 通道 {channel.Number} 设备 IP 变了:{channel.LastIp} → {device.Ip},重新连接");
channel.LastIp = device.Ip;
changed.Add(channel);
}
if (changed.Count == 0) return;
SaveChannels();
Changed?.Invoke();
foreach (var channel in changed)
{
if (Running) StartConnection(channel);
}
}
/// 给某条通道的扫码枪发一串原始字节(调试用,走设备透传)
public async Task SendCommandAsync(ScanChannel channel, byte[] payload)
{
if (!_connections.TryGetValue(channel.Mac, out var connection)) return false;
return await connection.SendRawAsync(payload).ConfigureAwait(false);
}
///
/// 切换某条通道的扫码枪静音(与 AndroidScanCenter 一致):
/// **只存本地 + 让这条连接重新走一遍**,不在现有 socket 上补写指令 ——
/// 连上时会按最新值把「连续扫描 + 间隔 0 + 静音」整条下发。
///
public void SetMuted(ScanChannel channel, bool muted)
{
if (channel.Muted == muted) return;
channel.Muted = muted;
SaveChannels();
Changed?.Invoke();
if (_connections.TryGetValue(channel.Mac, out var connection))
{
// 设备当前没通也不怕:下次连上时按记住的值下发
connection.RequestReconnect("扫码枪设置变更,主动重连");
AppLog.Write($"[scan] 通道 {channel.Number}「{channel.DisplayName}」" + (muted ? "已设为静音" : "已恢复蜂鸣") + ",正在重新下发设置");
}
else
{
AppLog.Write($"[scan] 通道 {channel.Number}「{channel.DisplayName}」" + (muted ? "已设为静音" : "已恢复蜂鸣") + "(设备未连通,连上后自动生效)");
}
}
public Task ReadConfigAsync(string ip, CancellationToken ct = default)
=> _scanner.ReadSysConfigAsync(ip, ct);
public Task WriteConfigAsync(string ip, IReadOnlyDictionary patch, CancellationToken ct = default)
=> _scanner.WriteSysConfigAsync(ip, patch, ct);
/// 确保设备上有一条给中控用的 TCP 服务(没有它这条通道永远收不到码)
public Task EnsureTcpServerAsync(string ip, string? preferredName = null,
CancellationToken ct = default)
=> _scanner.EnsureTcpServerAsync(ip, preferredName, ct);
/// 把设备名写进设备(SYS.HostName + 落 flash)
public Task WriteHostNameAsync(string ip, string name, CancellationToken ct = default)
=> _scanner.WriteHostNameAsync(ip, name, ct);
public Task RestartAsync(string ip, CancellationToken ct = default)
=> _scanner.RestartAsync(ip, ct);
///
/// 添加通道(按 MAC 去重)。
///
/// 顺序与 AndroidScanCenter 一致,且**先配设备、后落本地**:
/// ① 确保设备有 TCP-SERVER 服务(失败就整个失败,本地什么都不写);
/// ② 设备名与设备自报的不一样就写进设备(失败不阻断,只影响设备面板/其他上位机看到的叫法);
/// ③ 才把通道写进本地配置并开始连。
/// 回滚本地行不通:中间设备名可能已经写上去了,回滚只能回一半。
///
/// 指定通道号(<=0 或被占用时退回最小空号)
/// 进度文案回调(界面显示用)
public async Task AddChannelAsync(string mac, string name, string ip, int number,
string? reportedHostName = null, Action? stage = null, CancellationToken ct = default)
{
var key = (mac ?? string.Empty).Trim().ToUpperInvariant();
var trimmed = (name ?? string.Empty).Trim();
// 已存在:只更新名字/IP/通道号,不重配设备
var existing = Channels.FirstOrDefault(item => item.Mac.Equals(key, StringComparison.OrdinalIgnoreCase));
if (existing is not null)
{
existing.LastIp = string.IsNullOrWhiteSpace(ip) ? existing.LastIp : ip;
if (trimmed.Length > 0) existing.Name = trimmed;
if (number > 0 && ChannelStore.FindByNumber(Channels, number, existing.Mac) is null) existing.Number = number;
SaveChannels();
Changed?.Invoke();
if (Running) StartConnection(existing);
return new AddChannelResult(existing, true, "该设备已在通道列表里,已更新名称/通道号");
}
// ① 设备 TCP 服务(失败直接中止)
stage?.Invoke("正在检查设备 TCP 服务…");
var ensure = await EnsureTcpServerAsync(ip, null, ct).ConfigureAwait(false);
if (!ensure.Ok) return new AddChannelResult(null, false, ensure.Message);
// ② 设备名(可选,失败不阻断)
var patchNote = string.Empty;
if (trimmed.Length > 0 && !trimmed.Equals((reportedHostName ?? string.Empty).Trim(), StringComparison.Ordinal))
{
stage?.Invoke($"正在把设备名「{trimmed}」写入设备…");
var ok = await WriteHostNameAsync(ip, trimmed, ct).ConfigureAwait(false);
if (!ok) patchNote = "(设备名写入失败,不影响收码)";
}
// ③ 落本地
var wanted = number > 0 && ChannelStore.FindByNumber(Channels, number) is null
? number
: ChannelStore.NextNumber(Channels);
var channel = new ScanChannel
{
Mac = key,
Name = trimmed.Length > 0 ? trimmed : key,
LastIp = ip,
Number = wanted,
TcpPort = ScanProtocol.TcpPort,
SockName = ensure.SockName,
};
Channels.Add(channel);
SaveChannels();
Changed?.Invoke();
RequestChannelSync(replace: true);
if (Running) StartConnection(channel);
var message = $"通道 {channel.Number}「{channel.DisplayName}」已添加{ensure.Message}{patchNote}";
return new AddChannelResult(channel, true, message, ensure.Kind);
}
/// 删除通道
public void RemoveChannel(ScanChannel channel)
{
StopConnection(channel);
Channels.Remove(channel);
SaveChannels();
Changed?.Invoke();
// 全量对账:服务器会软删这条通道并解绑工作台
RequestChannelSync(replace: true);
}
/// 启动扫码服务:连接所有通道 + (后台)同步通道列表到服务器
public Task StartAsync()
{
Load();
Running = true;
foreach (var channel in Channels) StartConnection(channel);
RequestChannelSync();
EnsureWatchdog();
AppLog.Write($"[scan] 扫码服务已启动,通道 {Channels.Count} 个");
Changed?.Invoke();
return Task.CompletedTask;
}
/// 停止扫码服务(断开所有连接)
public void Stop()
{
Running = false;
foreach (var connection in _connections.Values.ToList()) connection.Stop();
_connections.Clear();
try
{
_syncCts?.Cancel();
}
catch
{
// 忽略
}
_syncCts = null;
_syncTask = null;
try
{
_watchdogCts?.Cancel();
}
catch
{
// 忽略
}
_watchdogCts = null;
_watchdogTask = null;
StopDiscovery();
AppLog.Write("[scan] 扫码服务已停止");
Changed?.Invoke();
}
///
/// 看门狗(每 30 秒):连接看着在线但**很久没收到字节**时,回查设备侧还认不认这条连接。
///
/// 设备断电重启时 TCP 层不会发 FIN/RST,中控这侧阻塞的 `ReadAsync` 会永久挂住,
/// 既不报断开也不重连 —— 只有回查设备侧 `SOCK.ClientIP`(CID 10001)才能发现。
///
private void EnsureWatchdog()
{
if (_watchdogTask is { IsCompleted: false }) return;
_watchdogCts = new CancellationTokenSource();
_watchdogTask = Task.Run(() => WatchdogLoopAsync(_watchdogCts.Token));
}
private async Task WatchdogLoopAsync(CancellationToken ct)
{
while (!ct.IsCancellationRequested)
{
try
{
await Task.Delay(TimeSpan.FromSeconds(15), ct).ConfigureAwait(false);
}
catch (OperationCanceledException)
{
break;
}
foreach (var connection in _connections.Values.ToList())
{
var channel = connection.Channel;
if (!channel.Connected) continue;
// 设备平时一直在推帧(~0.7s 一帧),20 秒一个字节都没有就可疑了
if ((DateTime.Now - connection.LastRxAt).TotalSeconds < 20) continue;
try
{
var states = await _scanner.ReadSockStatesAsync(channel.LastIp, ct).ConfigureAwait(false);
// ⚠️ 读不到(UDP 完全没应答)= 设备已断电/断网/离线。
// 以前这里「读不到就不断言」,结果设备真离线了界面还一直是「在线」
// (设备断电时 TCP 不发 FIN,本地 socket 一直挂着)。
if (states is null)
{
AppLog.Write($"[scan] 通道 {channel.Number}({channel.DisplayName})设备无应答"
+ $"({channel.LastIp} 已 {Math.Round((DateTime.Now - connection.LastRxAt).TotalSeconds)}s 没数据),判为离线并重连");
connection.RequestReconnect("设备无应答(疑似断电/离线)");
continue;
}
var name = string.IsNullOrWhiteSpace(channel.SockName) ? ScanProtocol.SockName : channel.SockName;
var mine = states.FirstOrDefault(item =>
item.Name.Equals(name, StringComparison.OrdinalIgnoreCase));
// 设备能应答、但我们那条条目不见了:说明设备重载/配置被改,重连让它自愈
if (mine is null)
{
AppLog.Write($"[scan] 通道 {channel.Number} 设备上已没有「{name}」条目,强制重连(会自愈)");
connection.RequestReconnect($"设备上已没有「{name}」条目");
continue;
}
if (mine.Clients.Any(ip => ip.Equals(connection.LocalIp, StringComparison.Ordinal))) continue;
AppLog.Write($"[scan] 通道 {channel.Number} 设备侧已不认这条连接"
+ $"(ClientIP=[{mine.ClientIp}],本机 {connection.LocalIp}),强制重连");
connection.RequestReconnect($"设备侧已不认这条连接(ClientIP=[{mine.ClientIp}])");
}
catch (OperationCanceledException)
{
break;
}
catch (Exception ex)
{
AppLog.Write($"[scan] 通道 {channel.Number} 假死检查失败(忽略):{ex.Message}");
}
}
}
}
///
/// 把通道列表同步到服务器(`POST /api/scan/channels` 之后再用 `GET` **回查确认**)。
///
/// `replace = true` = 全量对账(添加/删除通道时用):服务器会软删本中控下不在列表里的旧通道,
/// 并解绑对应工作台绑定(通道列表存在本地,与本机设备是否在线无关)。
///
/// 不用手动点:添加 / 删除 都会调 ,
/// 后台循环一直重试到服务器确实有这批通道为止(断网、服务器重启都不用手管)。
///
public void RequestChannelSync(bool replace = false)
{
if (replace) _syncReplace = true;
EnsureSyncLoop();
try
{
if (_syncSignal.CurrentCount == 0) _syncSignal.Release();
}
catch
{
// 忽略
}
}
private void EnsureSyncLoop()
{
if (_syncTask is { IsCompleted: false }) return;
_syncCts = new CancellationTokenSource();
_syncTask = Task.Run(() => SyncLoopAsync(_syncCts.Token));
}
private async Task SyncLoopAsync(CancellationToken ct)
{
while (!ct.IsCancellationRequested)
{
try
{
// 只等信号:**不靠超时**。以前写成 WaitAsync(30s) + 无条件推送,
// 结果每 30 秒就往服务器重推一次通道、刷一条日志(看起来像“一直在重连”)。
await _syncSignal.WaitAsync(ct).ConfigureAwait(false);
}
catch (OperationCanceledException)
{
break;
}
await PushChannelsUntilConfirmedAsync(ct).ConfigureAwait(false);
}
}
/// 推一次 + 回查确认;不成功就退避重试,直到服务器真的有这批通道
private async Task PushChannelsUntilConfirmedAsync(CancellationToken ct)
{
while (!ct.IsCancellationRequested)
{
if (!_device.Enabled)
{
SetSyncStatus("设备服务未开启,通道等开启后再同步");
return;
}
var local = Channels
.Select(item => (item.ChannelId, item.DisplayName))
.ToList();
// replace = 全量对账:本地通道列表就是全部(设备离线不影响通道配置),
// 推空列表也合法 —— 表示通道已巨部删除,服务器要跟着删。
var replace = _syncReplace;
if (local.Count == 0 && !replace)
{
SetSyncStatus("当前没有通道");
return;
}
try
{
await _device.ReportChannelsAsync(local, replace, ct).ConfigureAwait(false);
// 服务器回查:确保它真的收到了(POST 成功≠入库成功,例如主体变更/令牌失效)
var remote = await _device.ChannelsAsync(ct).ConfigureAwait(false);
var missing = local.Where(item => !remote.Contains(item.ChannelId)).Select(item => item.ChannelId).ToList();
if (missing.Count == 0)
{
_syncRetryMs = 1000;
if (replace) _syncReplace = false;
SetSyncStatus($"通道已同步({local.Count} 个)");
AppLog.Write($"[scan] 通道已同步到服务器并确认:{local.Count} 个" + (replace ? "(全量对账)" : ""));
return;
}
throw new InvalidOperationException($"服务器上还缺通道 {string.Join('/', missing)}");
}
catch (OperationCanceledException)
{
return;
}
catch (Exception ex)
{
SetSyncStatus($"通道同步失败,{_syncRetryMs / 1000} 秒后重试");
AppLog.Write($"[scan] 通道同步失败({_syncRetryMs}ms 后重试):{ex.Message}");
try
{
await Task.Delay(_syncRetryMs, ct).ConfigureAwait(false);
}
catch (OperationCanceledException)
{
return;
}
_syncRetryMs = Math.Min(_syncRetryMs * 2, 30000);
}
}
}
private void SetSyncStatus(string status)
{
if (ChannelSyncStatus == status) return;
ChannelSyncStatus = status;
Changed?.Invoke();
}
private void StartConnection(ScanChannel channel)
{
StopConnection(channel);
if (string.IsNullOrWhiteSpace(channel.LastIp)) return;
var connection = new ChannelConnection(channel);
connection.Barcode += OnBarcode;
connection.StateChanged += (_, _) => Changed?.Invoke();
connection.HealNeeded += healChannel => _ = HealAsync(healChannel);
_connections[channel.Mac] = connection;
connection.Start();
}
///
/// 自愈:连不上时回查设备上我们那条 TCP 服务(`packcenter / TCP-SERVER / 8087`)还在不在,
/// 被删了/被改了就重建(照搬 AndroidScanCenter 的 healIfNeeded)。
///
/// 只在「连不上」时查(连得上就不动设备配置),每台设备 60 秒最多查一次。
///
private async Task HealAsync(ScanChannel channel)
{
if (!Running || !_device.Enabled) return;
if (string.IsNullOrWhiteSpace(channel.LastIp)) return;
var now = DateTime.Now;
if (_lastHealAt.TryGetValue(channel.Mac, out var last) && (now - last).TotalSeconds < 60) return;
_lastHealAt[channel.Mac] = now;
// 离线设备每 60 秒会自愈一次;日志只在第一次 / 每 10 分钟记一遍
var shouldLog = !_healLogAt.TryGetValue(channel.Mac, out var lastLog)
|| (now - lastLog).TotalMinutes >= 10;
if (shouldLog) _healLogAt[channel.Mac] = now;
try
{
if (shouldLog)
{
AppLog.Write($"[scan] 通道 {channel.Number} 连不上({channel.LastIp}),回查设备的 TCP 服务…");
}
var result = await _scanner.EnsureTcpServerAsync(channel.LastIp, channel.SockName).ConfigureAwait(false);
if (shouldLog || result.Ok)
{
AppLog.Write($"[scan] 通道 {channel.Number} 自愈:{result.Message}");
}
if (result.Ok)
{
if (!string.IsNullOrWhiteSpace(result.SockName) && result.SockName != channel.SockName)
{
channel.SockName = result.SockName;
SaveChannels();
}
if (_connections.TryGetValue(channel.Mac, out var connection))
{
connection.RequestReconnect("设备 TCP 服务已就绪,立即重连");
}
}
}
catch (OperationCanceledException)
{
// 忽略
}
catch (Exception ex)
{
if (shouldLog)
{
AppLog.Write($"[scan] 通道 {channel.Number} 自愈失败(稍后再试):{ex.Message}");
}
}
}
private void StopConnection(ScanChannel channel)
{
if (!_connections.TryGetValue(channel.Mac, out var existing)) return;
try
{
existing.Stop();
existing.Dispose();
}
catch
{
// 忽略
}
_connections.Remove(channel.Mac);
channel.Connected = false;
}
///
/// 收到条码。
///
/// ⚠️ 连续扫描模式下同一个码每 ~80ms 报一次:
/// - 记录库只把「最近扫描时间」刷到最新,不新增记录;
/// - 这里只在**新扫码事件**(换了条码 / 已上报过的码又扫到)时通知界面,
/// 否则订阅者会被连续扫描刷屏。订阅者**只能做展示**,不能据此发起运单查询。
/// 真正的上报在扫到后 5 分钟没再扫到同一个码时才做(时间取最后一次扫描)。
///
private void OnBarcode(ScanChannel channel, string code)
{
var added = _device.ReportOnChannel(channel.ChannelId, channel.DisplayName, code);
if (added) Barcode?.Invoke(channel, code);
Changed?.Invoke();
}
}
/// 添加通道的结果( 为空表示失败, 是给用户看的一句话)
public sealed record AddChannelResult(
ScanChannel? Channel,
bool Ok,
string Message,
TcpServerEnsureKind EnsureKind = TcpServerEnsureKind.AlreadyReady);