Files
TuneBossPC/TuneBoss.Core/BLE/BleManager.cs
T
2026-09-28 16:55:31 +08:00

669 lines
32 KiB
C#

using System.Collections.Concurrent;
using System.Reactive.Linq;
using System.Reactive.Subjects;
using Windows.Devices.Bluetooth;
using Windows.Devices.Bluetooth.Advertisement;
using Windows.Devices.Bluetooth.GenericAttributeProfile;
using Windows.Storage.Streams;
using TuneBoss.Core.Models;
using TuneBoss.Core.Protocol;
using System.Runtime.InteropServices.WindowsRuntime;
namespace TuneBoss.Core.BLE;
/// <summary>
/// Windows WinRT BLE implementation of IBleService.
/// Uses Nordic UART Service (NUS) over a single bidirectional characteristic.
/// </summary>
public sealed class BleManager : IBleService
{
// ── NUS UUIDs ────────────────────────────────────────────────────────────
private static readonly Guid NusServiceUuid = new("0000f0f0-0000-1000-8000-00805f9b34fb");
private static readonly Guid NusCharUuid = new("0000f0f1-0000-1000-8000-00805f9b34fb");
// ── Config ───────────────────────────────────────────────────────────────
private const int CommandTimeoutMs = 3000; // 3s default timeout
private const int SilenceWindowMs = 300; // diag silence detection window
private const int MaxSilenceWaitMs = 5000; // max wait for diagnostics drain
private const int KeepaliveIdleMs = 15000; // send keepalive after 15s idle
// ── GATT resources ───────────────────────────────────────────────────────
private BluetoothLEDevice? _device;
private GattDeviceService? _nusService;
private GattCharacteristic? _nusChar;
// ── State ────────────────────────────────────────────────────────────────
private BleConnectionState _connectionState = BleConnectionState.Disconnected;
private GenerationConfig? _genConfig;
private byte _seqNum = 1;
// ── Rx processing ────────────────────────────────────────────────────────
private readonly ConcurrentQueue<byte[]> _bleQueue = new();
private readonly SemaphoreSlim _bleSignal = new(0);
private CancellationTokenSource? _loopCts;
// ── Packet parser state ──────────────────────────────────────────────────
private readonly PacketParser _parser;
// ── Response rendezvous ──────────────────────────────────────────────────
// The BLE receive loop sets this when a non-streaming packet arrives.
private readonly SemaphoreSlim _responseReady = new(0);
private volatile byte[]? _responsePayload;
private readonly object _responseLock = new();
// ── Diagnostics ──────────────────────────────────────────────────────────
private readonly Subject<DiagnosticsFrame> _diagSubject = new();
private volatile bool _diagnosticsRunning;
private long _lastDiagTickUtc;
// ── Observables ──────────────────────────────────────────────────────────
private readonly BehaviorSubject<BleConnectionState> _connSubject =
new(BleConnectionState.Disconnected);
private readonly Subject<BleDeviceInfo> _scanSubject = new();
private BluetoothLEAdvertisementWatcher? _watcher;
// ── Keepalive ────────────────────────────────────────────────────────────
private long _lastCommandTickUtc;
// ────────────────────────────────────────────────────────────────────────
// Constructor
// ────────────────────────────────────────────────────────────────────────
public BleManager()
{
_parser = new PacketParser(OnFullPacketReceived);
}
// ── IBleService: State ───────────────────────────────────────────────────
public BleConnectionState ConnectionState => _connectionState;
public bool IsConnected => _connectionState == BleConnectionState.Connected;
public IObservable<BleConnectionState> ConnectionStateChanged => _connSubject.AsObservable();
public IObservable<DiagnosticsFrame> DiagnosticsFrames => _diagSubject.AsObservable();
public bool DiagnosticsRunning => _diagnosticsRunning;
// ────────────────────────────────────────────────────────────────────────
// SCANNING
// ────────────────────────────────────────────────────────────────────────
public IObservable<BleDeviceInfo> StartScan()
{
var seen = new Dictionary<ulong, string>();
_watcher = new BluetoothLEAdvertisementWatcher
{
ScanningMode = BluetoothLEScanningMode.Active
};
_watcher.SignalStrengthFilter.InRangeThresholdInDBm = -127;
_watcher.SignalStrengthFilter.OutOfRangeThresholdInDBm = -127;
_watcher.SignalStrengthFilter.OutOfRangeTimeout = null;
_watcher.Received += (_, args) =>
{
ulong addr = args.BluetoothAddress;
string name = args.Advertisement.LocalName?.Trim() ?? string.Empty;
bool hasName = !string.IsNullOrWhiteSpace(name);
lock (seen)
{
if (!seen.ContainsKey(addr))
{
seen[addr] = hasName ? name : $"Unknown [{new BleDeviceInfo(addr, "", 0).MacAddress}]";
_scanSubject.OnNext(new BleDeviceInfo(addr, seen[addr], args.RawSignalStrengthInDBm));
}
else if (hasName && seen[addr].StartsWith("Unknown"))
{
seen[addr] = name;
_scanSubject.OnNext(new BleDeviceInfo(addr, name, args.RawSignalStrengthInDBm));
}
}
};
_watcher.Start();
return _scanSubject.AsObservable();
}
public void StopScan()
{
_watcher?.Stop();
_watcher = null;
}
// ────────────────────────────────────────────────────────────────────────
// CONNECTION
// ────────────────────────────────────────────────────────────────────────
public async Task<bool> ConnectAsync(BleDeviceInfo device, CancellationToken ct = default)
{
SetState(BleConnectionState.Connecting);
try
{
// Step 1: Resolve device
_device = await BluetoothLEDevice.FromBluetoothAddressAsync(device.Address);
if (_device == null) return Fail("Could not resolve device from address.");
_device.ConnectionStatusChanged += OnDeviceConnectionStatusChanged;
// Step 2: Open GATT channel with retry
if (!await OpenGattChannelAsync(ct)) return Fail("Could not open GATT channel.");
// Step 3: Stabilize
await Task.Delay(1500, ct);
// Step 4: Get NUS service
_nusService = await GetServiceAsync(NusServiceUuid, ct);
if (_nusService == null) return Fail("NUS service not found.");
// Step 5: Get characteristic
_nusChar = await GetCharacteristicAsync(_nusService, NusCharUuid, ct);
if (_nusChar == null) return Fail("NUS characteristic not found.");
// Step 6: Enable notifications
_nusChar.ValueChanged += OnCharValueChanged;
await _nusChar.WriteClientCharacteristicConfigurationDescriptorAsync(
GattClientCharacteristicConfigurationDescriptorValue.Notify);
// Step 7: Start BLE processing loop
StartProcessingLoop();
SetState(BleConnectionState.Connected);
return true;
}
catch (OperationCanceledException) { return Fail("Connection cancelled."); }
catch (Exception ex) { return Fail($"Connection error: {ex.Message}"); }
}
public async Task DisconnectAsync()
{
SetState(BleConnectionState.Disconnecting);
if (_diagnosticsRunning)
await StopDiagnosticsAsync();
StopProcessingLoop();
if (_nusChar != null)
{
_nusChar.ValueChanged -= OnCharValueChanged;
try { await _nusChar.WriteClientCharacteristicConfigurationDescriptorAsync(
GattClientCharacteristicConfigurationDescriptorValue.None); } catch { }
}
_nusChar = null;
_nusService?.Dispose();
_nusService = null;
if (_device != null)
{
_device.ConnectionStatusChanged -= OnDeviceConnectionStatusChanged;
_device.Dispose();
_device = null;
}
SetState(BleConnectionState.Disconnected);
}
// ────────────────────────────────────────────────────────────────────────
// DEVICE INFO
// ────────────────────────────────────────────────────────────────────────
public async Task<EcuInfo?> ReadEcuInfoAsync(CancellationToken ct = default)
{
var frame = PacketBuilder.BuildReadInfo(NextSeq());
var result = await SendAndWaitAsync(frame, ct);
if (!result.Success) return null;
var info = EcuInfo.Parse(result.Payload);
// Store generation config for subsequent table operations
var gen = GenerationConfig.ResolveGeneration(info.AppInfoVersion);
_genConfig = GenerationConfig.For(gen);
return info;
}
// ────────────────────────────────────────────────────────────────────────
// AUTH
// ────────────────────────────────────────────────────────────────────────
public async Task<CommandResult> UnlockAsync(string password, CancellationToken ct = default)
{
var payload = BuildUnlockPayload(_genConfig?.UnlockCmd ?? Commands.APP_UNLOCK, password, isReset: false);
var frame = PacketBuilder.Build(Commands.TL_NONPOSTED, NextSeq(), payload);
return await SendAndWaitAsync(frame, ct);
}
public async Task<CommandResult> UnlockTunerAsync(string password, CancellationToken ct = default)
{
var payload = BuildUnlockPayload(Commands.APP_UNLOCK_TUNER, password, isReset: false);
var frame = PacketBuilder.Build(Commands.TL_NONPOSTED, NextSeq(), payload);
return await SendAndWaitAsync(frame, ct);
}
// ────────────────────────────────────────────────────────────────────────
// TABLE OPERATIONS
// ────────────────────────────────────────────────────────────────────────
public Task<CommandResult> ReadTable2DAsync(ushort address, byte lengthBytes, bool userTable = false, CancellationToken ct = default)
=> ReadTableAsync(
userTable ? (_genConfig?.ReadCmd2DUser ?? Commands.APP_MEMRD_2D_USER)
: (_genConfig?.ReadCmd2D ?? Commands.APP_MEMRD_2D),
address, lengthBytes, ct);
public Task<CommandResult> WriteTable2DAsync(ushort address, byte[] data, bool userTable = false, CancellationToken ct = default)
=> WriteTableAsync(
userTable ? (_genConfig?.WriteCmd2DUser ?? Commands.APP_MEMWR_2D_USER)
: (_genConfig?.WriteCmd2D ?? Commands.APP_MEMWR_2D),
address, data, ct);
public Task<CommandResult> ReadTable1DAsync(ushort address, byte lengthBytes, CancellationToken ct = default)
=> ReadTableAsync(_genConfig?.ReadCmd1D ?? Commands.APP_MEMRD_1D, address, lengthBytes, ct);
public Task<CommandResult> WriteTable1DAsync(ushort address, byte[] data, CancellationToken ct = default)
=> WriteTableAsync(_genConfig?.WriteCmd1D ?? Commands.APP_MEMWR_1D, address, data, ct);
public Task<CommandResult> ReadSubTableAsync(ushort address, CancellationToken ct = default)
=> ReadTableAsync(_genConfig?.ReadCmdSubT ?? Commands.APP_MEMRD_SUBT, address,
(byte)TuneBoss.Core.Models.SubTable.TotalBytes, ct);
public Task<CommandResult> WriteSubTableAsync(ushort address, byte[] data, CancellationToken ct = default)
=> WriteTableAsync(_genConfig?.WriteCmdSubT ?? Commands.APP_MEMWR_SUBT, address, data, ct);
public Task<CommandResult> ReadMiscAsync(ushort address, byte lengthBytes, CancellationToken ct = default)
=> ReadTableAsync(_genConfig?.ReadCmdMisc ?? Commands.APP_MEMRD_MISC, address, lengthBytes, ct);
public Task<CommandResult> WriteMiscAsync(ushort address, byte[] data, CancellationToken ct = default)
=> WriteTableAsync(_genConfig?.WriteCmdMisc ?? Commands.APP_MEMWR_MISC, address, data, ct);
// ────────────────────────────────────────────────────────────────────────
// FLASH WRITE
// ────────────────────────────────────────────────────────────────────────
public async Task<CommandResult> FlashWriteAsync(CancellationToken ct = default)
{
await StopDiagnosticsIfRunningAsync(ct);
var now = DateTime.Now;
var payload = new byte[]
{
Commands.APP_FLASH_WR,
(byte)'F', (byte)'S', (byte)'R',
(byte)now.Day,
(byte)now.Month,
(byte)(now.Year % 100),
0x00
};
var frame = PacketBuilder.Build(Commands.TL_NONPOSTED, NextSeq(), payload);
var result = await SendAndWaitAsync(frame, ct);
await RestartDiagnosticsIfStoppedAsync(ct);
return result;
}
// ────────────────────────────────────────────────────────────────────────
// FIRST-USE SETTINGS (APP_FIRSTUSE)
// ────────────────────────────────────────────────────────────────────────
public async Task<CommandResult> WriteFirstUseAsync(byte[] fourBytes, CancellationToken ct = default)
{
if (fourBytes is null || fourBytes.Length < 4)
return CommandResult.Fail(0x00, "First-use payload must be 4 bytes.");
// Legacy updateFirstUseSettings layout: [APP_FIRSTUSE, 0x00, 0x00, 0x00, b0, b1, b2, b3]
var payload = new byte[]
{
Commands.APP_FIRSTUSE, 0x00, 0x00, 0x00,
fourBytes[0], fourBytes[1], fourBytes[2], fourBytes[3],
};
var frame = PacketBuilder.Build(Commands.TL_NONPOSTED, NextSeq(), payload);
return await SendAndWaitAsync(frame, ct);
}
// ────────────────────────────────────────────────────────────────────────
// DIAGNOSTICS
// ────────────────────────────────────────────────────────────────────────
public async Task StartDiagnosticsAsync(CancellationToken ct = default)
{
if (_diagnosticsRunning) return;
_diagnosticsRunning = true;
Interlocked.Exchange(ref _lastDiagTickUtc, DateTime.UtcNow.Ticks);
await SendRawAsync(PacketBuilder.BuildMonStart());
}
public async Task StopDiagnosticsAsync(CancellationToken ct = default)
{
if (!_diagnosticsRunning) return;
_diagnosticsRunning = false;
await SendRawAsync(PacketBuilder.BuildMonStop());
// Wait for silence — device keeps sending 0x70s for a while after STOP
Interlocked.Exchange(ref _lastDiagTickUtc, DateTime.UtcNow.Ticks);
int waited = 0;
while (waited < MaxSilenceWaitMs)
{
await Task.Delay(100, ct);
waited += 100;
long elapsed = (DateTime.UtcNow.Ticks - Interlocked.Read(ref _lastDiagTickUtc))
/ TimeSpan.TicksPerMillisecond;
if (elapsed >= SilenceWindowMs) break;
}
// Flush residual 0x70 packets
_parser.Reset();
while (_bleQueue.TryDequeue(out byte[]? _)) { }
}
// ────────────────────────────────────────────────────────────────────────
// KEEPALIVE
// ────────────────────────────────────────────────────────────────────────
public void OnKeepaliveTimer()
{
if (!IsConnected) return;
long idleMs = (DateTime.UtcNow.Ticks - Interlocked.Read(ref _lastCommandTickUtc))
/ TimeSpan.TicksPerMillisecond;
if (idleMs >= KeepaliveIdleMs)
_ = SendRawAsync(PacketBuilder.BuildReadInfo(NextSeq()));
}
// ────────────────────────────────────────────────────────────────────────
// PRIVATE: Table helpers
// ────────────────────────────────────────────────────────────────────────
private async Task<CommandResult> ReadTableAsync(
byte cmd, ushort address, byte lengthBytes, CancellationToken ct)
{
await StopDiagnosticsIfRunningAsync(ct);
var addrBytes = BitConverter.GetBytes(address); // little-endian
var payload = new byte[] { cmd, lengthBytes, addrBytes[0], addrBytes[1] };
var frame = PacketBuilder.Build(Commands.TL_NONPOSTED, NextSeq(), payload);
// Flush residual diagnostic packets before sending
_parser.Reset();
while (_bleQueue.TryDequeue(out byte[]? _)) { }
var result = await SendAndWaitAsync(frame, ct);
await RestartDiagnosticsIfStoppedAsync(ct);
return result;
}
private async Task<CommandResult> WriteTableAsync(
byte cmd, ushort address, byte[] data, CancellationToken ct)
{
await StopDiagnosticsIfRunningAsync(ct);
var addrBytes = BitConverter.GetBytes(address);
var payload = new byte[4 + data.Length];
payload[0] = cmd;
// The length byte is the LAST inclusive offset the device writes (offset 0..N),
// exactly like the read commands — so N = data.Length - 1. Sending the raw count
// wrote one byte past the region and returned 0x54 (APP_MEMADDR_INV) — seen on the
// tightly-packed 1D tables and on 2D part-2 writes (100-byte tail region).
payload[1] = (byte)(data.Length - 1);
payload[2] = addrBytes[0];
payload[3] = addrBytes[1];
data.CopyTo(payload, 4);
var frame = PacketBuilder.Build(Commands.TL_NONPOSTED, NextSeq(), payload);
var result = await SendAndWaitAsync(frame, ct);
await RestartDiagnosticsIfStoppedAsync(ct);
return result;
}
private async Task StopDiagnosticsIfRunningAsync(CancellationToken ct)
{
if (_diagnosticsRunning)
await StopDiagnosticsAsync(ct);
}
private async Task RestartDiagnosticsIfStoppedAsync(CancellationToken ct)
{
// Intentionally does NOT auto-restart here. Resume is driven by the ViewModel
// layer (ResumeDiagnosticsIfLiveAsync) which knows whether the strip should be
// live. Restarting here as well caused a double MON_START and a frame storm that
// disrupted the next command's response matching (froze edits / writes).
}
// ────────────────────────────────────────────────────────────────────────
// PRIVATE: Send and wait for response
// ────────────────────────────────────────────────────────────────────────
private async Task<CommandResult> SendAndWaitAsync(byte[] frame, CancellationToken ct)
{
lock (_responseLock)
{
_responsePayload = null;
// drain any stale ready signal
while (_responseReady.CurrentCount > 0)
_responseReady.Wait(0);
}
await SendRawAsync(frame);
Interlocked.Exchange(ref _lastCommandTickUtc, DateTime.UtcNow.Ticks);
using var timeout = new CancellationTokenSource(CommandTimeoutMs);
using var linked = CancellationTokenSource.CreateLinkedTokenSource(ct, timeout.Token);
try
{
await _responseReady.WaitAsync(linked.Token);
}
catch (OperationCanceledException)
{
return timeout.IsCancellationRequested
? CommandResult.Timeout()
: CommandResult.Fail(0x00, "Cancelled");
}
var payload = _responsePayload;
if (payload == null || payload.Length == 0)
return CommandResult.Fail(0x00, "Empty response");
return payload[0] == 0x51
? CommandResult.Ok(payload)
: CommandResult.Fail(payload[0], $"Device returned 0x{payload[0]:X2}");
}
private async Task SendRawAsync(byte[] frame)
{
if (_nusChar == null) return;
var writer = new DataWriter();
writer.WriteBytes(frame);
var writeOption = _nusChar.CharacteristicProperties
.HasFlag(GattCharacteristicProperties.WriteWithoutResponse)
? GattWriteOption.WriteWithoutResponse
: GattWriteOption.WriteWithResponse;
await _nusChar.WriteValueAsync(writer.DetachBuffer(), writeOption);
}
// ────────────────────────────────────────────────────────────────────────
// PRIVATE: BLE receive path
// ────────────────────────────────────────────────────────────────────────
private void OnCharValueChanged(GattCharacteristic _, GattValueChangedEventArgs args)
{
try
{
var chunk = args.CharacteristicValue.ToArray();
if (chunk.Length == 0) return;
_bleQueue.Enqueue(chunk);
_bleSignal.Release();
}
catch { /* non-critical */ }
}
private void StartProcessingLoop()
{
_loopCts = new CancellationTokenSource();
var token = _loopCts.Token;
Task.Run(async () =>
{
while (!token.IsCancellationRequested)
{
await _bleSignal.WaitAsync(token);
while (_bleQueue.TryDequeue(out byte[]? chunk))
{
foreach (byte b in chunk)
_parser.ProcessByte(b);
}
}
}, token);
}
private void StopProcessingLoop()
{
_loopCts?.Cancel();
_loopCts?.Dispose();
_loopCts = null;
}
// ────────────────────────────────────────────────────────────────────────
// PRIVATE: Packet dispatch
// ────────────────────────────────────────────────────────────────────────
private void OnFullPacketReceived(PacketParser.ParsedPacket packet)
{
// ── Diagnostics frame ────────────────────────────────────────────────
if (packet.TlResponse == Commands.APP_MONITORING)
{
Interlocked.Exchange(ref _lastDiagTickUtc, DateTime.UtcNow.Ticks);
if (_diagnosticsRunning)
{
try
{
var frame = DiagnosticsFrame.Parse(packet.Payload, packet.SeqNum, DateTime.UtcNow);
_diagSubject.OnNext(frame);
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine($"[DIAG] Parse error: {ex.Message}");
}
}
return;
}
// ── Non-posted response ──────────────────────────────────────────────
lock (_responseLock)
{
_responsePayload = packet.Payload;
}
_responseReady.Release();
}
// ────────────────────────────────────────────────────────────────────────
// PRIVATE: GATT helpers
// ────────────────────────────────────────────────────────────────────────
private async Task<bool> OpenGattChannelAsync(CancellationToken ct, int maxAttempts = 6)
{
for (int i = 1; i <= maxAttempts; i++)
{
try
{
var result = await _device!.GetGattServicesAsync(BluetoothCacheMode.Uncached);
if (result.Status == GattCommunicationStatus.Success) return true;
if (result.Status == GattCommunicationStatus.AccessDenied)
await TrySilentPairAsync();
}
catch { }
if (i < maxAttempts) await Task.Delay(2000, ct);
}
return false;
}
private async Task<GattDeviceService?> GetServiceAsync(Guid uuid, CancellationToken ct, int maxAttempts = 4)
{
for (int i = 1; i <= maxAttempts; i++)
{
var result = await _device!.GetGattServicesAsync(BluetoothCacheMode.Uncached);
if (result.Status == GattCommunicationStatus.Success)
{
var svc = result.Services.FirstOrDefault(s => s.Uuid == uuid);
if (svc != null) return svc;
}
if (i < maxAttempts) await Task.Delay(1500, ct);
}
return null;
}
private async Task<GattCharacteristic?> GetCharacteristicAsync(
GattDeviceService service, Guid uuid, CancellationToken ct, int maxAttempts = 3)
{
for (int i = 1; i <= maxAttempts; i++)
{
var result = await service.GetCharacteristicsForUuidAsync(uuid, BluetoothCacheMode.Uncached);
if (result.Status == GattCommunicationStatus.Success && result.Characteristics.Count > 0)
return result.Characteristics[0];
if (i < maxAttempts) await Task.Delay(1000, ct);
}
return null;
}
private async Task TrySilentPairAsync()
{
var pairing = _device!.DeviceInformation.Pairing;
if (pairing.IsPaired || !pairing.CanPair) return;
await pairing.PairAsync(Windows.Devices.Enumeration.DevicePairingProtectionLevel.None);
await Task.Delay(800);
}
private void OnDeviceConnectionStatusChanged(BluetoothLEDevice sender, object _)
{
if (sender.ConnectionStatus == BluetoothConnectionStatus.Disconnected && IsConnected)
{
_diagnosticsRunning = false;
_parser.Reset();
while (_bleQueue.TryDequeue(out byte[]? _)) { }
SetState(BleConnectionState.Disconnected);
}
}
// ────────────────────────────────────────────────────────────────────────
// PRIVATE: Misc helpers
// ────────────────────────────────────────────────────────────────────────
private void SetState(BleConnectionState state)
{
_connectionState = state;
_connSubject.OnNext(state);
}
private bool Fail(string _) { SetState(BleConnectionState.Disconnected); return false; }
private byte NextSeq() => _seqNum == 0xFF ? (_seqNum = 1) : _seqNum++;
private static byte[] BuildUnlockPayload(byte unlockCmd, string password, bool isReset)
{
var now = DateTime.Now;
var pwd = System.Text.Encoding.ASCII.GetBytes(password.Trim());
var data = new List<byte>
{
unlockCmd, 0x00, 0x00, 0x00
};
// 16-byte password field (null-padded)
for (int i = 0; i < 16; i++)
data.Add(i < pwd.Length ? pwd[i] : (byte)0x00);
data.Add((byte)now.Day);
data.Add((byte)now.Month);
data.Add((byte)(now.Year % 100));
data.Add(0x00); // reserved
// Sentinel bytes matching original
data.AddRange(new byte[] { 0xF3, 0xF3, 0xF3, 0xF3 });
return data.ToArray();
}
public void Dispose()
{
StopProcessingLoop();
_nusService?.Dispose();
_device?.Dispose();
_diagSubject.Dispose();
_connSubject.Dispose();
_responseReady.Dispose();
_bleSignal.Dispose();
}
}