diff --git a/PayfritBeacon/BeaconProvisioner.swift b/PayfritBeacon/BeaconProvisioner.swift index a36b34a..8d101df 100644 --- a/PayfritBeacon/BeaconProvisioner.swift +++ b/PayfritBeacon/BeaconProvisioner.swift @@ -85,6 +85,10 @@ struct BeaconCheckResult { } /// Handles GATT connection and provisioning of beacons +/// +/// v2: Prevention over recovery. Instead of layers of retry/reconnect/resume logic, +/// we ensure a solid connection and confirmed characteristics before ever writing. +/// No extra frame overwriting — only configure Frame 1 (device info) and Frame 2 (iBeacon). class BeaconProvisioner: NSObject, ObservableObject { // MARK: - DX-Smart CP28 GATT Characteristics @@ -148,7 +152,6 @@ class BeaconProvisioner: NSObject, ObservableObject { private var configService: CBService? private var characteristics: [CBUUID: CBCharacteristic] = [:] private var passwordIndex = 0 - private var writeQueue: [(CBCharacteristic, Data)] = [] // DX-Smart provisioning state private var dxSmartAuthenticated = false @@ -156,10 +159,7 @@ class BeaconProvisioner: NSObject, ObservableObject { private var dxSmartCommandQueue: [Data] = [] private var dxSmartWriteIndex = 0 private var provisioningMacAddress: String? - private var awaitingDeviceInfoForProvisioning = false - private var skipDeviceInfoRead = false // set after disconnect during device info — skip MAC read on reconnect private var isTerminating = false // guards against re-entrant disconnect handling - private var resumeWriteAfterDisconnect = false // when true, skip queue rebuild on reconnect and resume from saved index // Read config mode private enum OperationMode { case provisioning, readingConfig } @@ -177,42 +177,31 @@ class BeaconProvisioner: NSObject, ObservableObject { private var dxReadQueryIndex = 0 private var responseBuffer: [UInt8] = [] - // Connection retry state + // Connection state private var connectionRetryCount = 0 - private var deviceInfoRetryCount = 0 - private var disconnectRetryCount = 0 - private static let MAX_CONNECTION_RETRIES = 3 - private static let MAX_DEVICE_INFO_RETRIES = 2 - private static let MAX_DISCONNECT_RETRIES = 5 + private static let MAX_CONNECTION_RETRIES = 2 private var currentBeacon: DiscoveredBeacon? - // Per-write timeout (matches Android's 5-second per-write timeout) - // If a write callback doesn't come back in time, we retry or fail gracefully - // instead of hanging until the 30s global timeout + // Per-write timeout — if beacon doesn't ACK within this time, fail cleanly private var writeTimeoutTimer: DispatchWorkItem? - private var charRediscoveryCount = 0 - private static let MAX_CHAR_REDISCOVERY = 2 private static let WRITE_TIMEOUT_SECONDS: Double = 5.0 - private var writeRetryCount = 0 - private static let MAX_WRITE_RETRIES = 1 // Retry once per command before failing - // Response gating — wait for beacon's FFE1 notification response after each - // write before sending the next command. Android does this with a 1000ms - // responseChannel.receive() after every FFE2 write. Without this gate, iOS - // hammers the beacon's MCU faster than it can process, causing supervision - // timeout disconnects. + // Response gating — wait for beacon's FFE1 notification after each write + // before sending next command. Matches Android's responseChannel.receive(1000ms). + // This is the KEY prevention mechanism: we never blast commands faster than + // the beacon can process them. private var awaitingCommandResponse = false private var responseGateTimer: DispatchWorkItem? - private static let RESPONSE_GATE_TIMEOUT: Double = 1.0 // 1s matches Android's withTimeoutOrNull(1000L) + private static let RESPONSE_GATE_TIMEOUT: Double = 1.0 - // Adaptive inter-command delays to prevent BLE supervision timeouts. - // DX-Smart CP28 beacons have tiny MCU buffers and share radio time between - // advertising and GATT — rapid writes cause the beacon to miss connection - // events, triggering link-layer supervision timeouts (the "unexpected disconnect" - // that was happening 4x during provisioning). - private static let BASE_WRITE_DELAY: Double = 0.5 // Default delay between commands (was 0.3) - private static let HEAVY_WRITE_DELAY: Double = 1.0 // After frame select/type commands (MCU state change) - private static let LARGE_PAYLOAD_DELAY: Double = 0.8 // After UUID/large payload writes + // Inter-command delay — gives the beacon MCU breathing room between commands. + // Prevention > recovery: generous delays prevent supervision timeouts. + private static let INTER_COMMAND_DELAY: Double = 0.5 + private static let HEAVY_COMMAND_DELAY: Double = 1.0 // After frame select/type changes + private static let POST_AUTH_DELAY: Double = 1.5 // After auth, before first write + + // Readiness gate — don't start writing until we've confirmed all 3 chars + private var requiredCharsConfirmed = false override init() { super.init() @@ -242,22 +231,16 @@ class BeaconProvisioner: NSObject, ObservableObject { self.operationMode = .provisioning self.passwordIndex = 0 self.characteristics.removeAll() - self.writeQueue.removeAll() self.dxSmartAuthenticated = false self.dxSmartNotifySubscribed = false self.dxSmartCommandQueue.removeAll() self.dxSmartWriteIndex = 0 self.provisioningMacAddress = nil - self.awaitingDeviceInfoForProvisioning = false - self.skipDeviceInfoRead = false self.isTerminating = false - self.resumeWriteAfterDisconnect = false self.awaitingCommandResponse = false + self.requiredCharsConfirmed = false cancelResponseGateTimeout() self.connectionRetryCount = 0 - self.deviceInfoRetryCount = 0 - self.disconnectRetryCount = 0 - self.writeRetryCount = 0 self.currentBeacon = beacon state = .connecting @@ -265,10 +248,13 @@ class BeaconProvisioner: NSObject, ObservableObject { centralManager.connect(resolvedPeripheral, options: nil) - // Timeout after 90 seconds (increased to accommodate 5 disconnect retries with resume) - DispatchQueue.main.asyncAfter(deadline: .now() + 90) { [weak self] in - if self?.state != .success && self?.state != .idle { - self?.fail("Connection timeout", code: .connectionTimeout) + // Global timeout: 45 seconds — if we haven't succeeded by then, something is fundamentally wrong. + // No infinite retry loops. Fail fast, let the user retry. + DispatchQueue.main.asyncAfter(deadline: .now() + 45) { [weak self] in + guard let self = self else { return } + if self.state != .success && self.state != .idle { + if case .failed = self.state { return } + self.fail("Operation timed out after 45s", code: .timeout) } } } @@ -305,8 +291,6 @@ class BeaconProvisioner: NSObject, ObservableObject { self.dxReadQueryIndex = 0 self.allDiscoveredServices.removeAll() self.connectionRetryCount = 0 - self.deviceInfoRetryCount = 0 - self.disconnectRetryCount = 0 self.isTerminating = false self.currentBeacon = beacon self.servicesToExplore.removeAll() @@ -337,21 +321,14 @@ class BeaconProvisioner: NSObject, ObservableObject { completion = nil configService = nil characteristics.removeAll() - writeQueue.removeAll() dxSmartAuthenticated = false dxSmartNotifySubscribed = false dxSmartCommandQueue.removeAll() dxSmartWriteIndex = 0 provisioningMacAddress = nil - awaitingDeviceInfoForProvisioning = false - skipDeviceInfoRead = false isTerminating = false - resumeWriteAfterDisconnect = false + requiredCharsConfirmed = false connectionRetryCount = 0 - deviceInfoRetryCount = 0 - disconnectRetryCount = 0 - writeRetryCount = 0 - charRediscoveryCount = 0 currentBeacon = nil state = .idle progress = "" @@ -363,7 +340,7 @@ class BeaconProvisioner: NSObject, ObservableObject { return } isTerminating = true - DebugLog.shared.log("BLE: Failed [\(code?.rawValue ?? "UNTYPED")] - \(message)") + DebugLog.shared.log("BLE: FAIL [\(code?.rawValue ?? "UNTYPED")] - \(message)") state = .failed(message) if let peripheral = peripheral, peripheral.state == .connected { centralManager.cancelPeripheralConnection(peripheral) @@ -382,7 +359,7 @@ class BeaconProvisioner: NSObject, ObservableObject { return } isTerminating = true - DebugLog.shared.log("BLE: Success! MAC=\(provisioningMacAddress ?? "unknown")") + DebugLog.shared.log("BLE: SUCCESS! MAC=\(provisioningMacAddress ?? "unknown")") state = .success if let peripheral = peripheral, peripheral.state == .connected { centralManager.cancelPeripheralConnection(peripheral) @@ -401,7 +378,7 @@ class BeaconProvisioner: NSObject, ObservableObject { } state = .discoveringServices - progress = "Discovering DX-Smart characteristics..." + progress = "Discovering characteristics..." peripheral?.discoverCharacteristics([ BeaconProvisioner.DXSMART_NOTIFY_CHAR, @@ -410,11 +387,27 @@ class BeaconProvisioner: NSObject, ObservableObject { ], for: service) } - /// Subscribe to FFE1 notifications, then authenticate on FFE3 - private func dxSmartStartAuth() { - if let notifyChar = characteristics[BeaconProvisioner.DXSMART_NOTIFY_CHAR] { - DebugLog.shared.log("BLE: Subscribing to DX-Smart FFE1 notifications") - peripheral?.setNotifyValue(true, for: notifyChar) + /// Verify all 3 required characteristics are present before proceeding. + /// This is PREVENTION: we confirm readiness upfront instead of discovering + /// missing chars mid-write and trying to recover. + private func verifyCharacteristicsAndProceed() { + let hasFFE1 = characteristics[BeaconProvisioner.DXSMART_NOTIFY_CHAR] != nil + let hasFFE2 = characteristics[BeaconProvisioner.DXSMART_COMMAND_CHAR] != nil + let hasFFE3 = characteristics[BeaconProvisioner.DXSMART_PASSWORD_CHAR] != nil + + DebugLog.shared.log("BLE: Char check — FFE1=\(hasFFE1) FFE2=\(hasFFE2) FFE3=\(hasFFE3)") + + guard hasFFE2 && hasFFE3 else { + fail("Required characteristics not found (FFE2=\(hasFFE2) FFE3=\(hasFFE3))", code: .serviceNotFound) + return + } + + requiredCharsConfirmed = true + + // Subscribe to FFE1 notifications first (if available), then authenticate + if hasFFE1 { + DebugLog.shared.log("BLE: Subscribing to FFE1 notifications") + peripheral?.setNotifyValue(true, for: characteristics[BeaconProvisioner.DXSMART_NOTIFY_CHAR]!) } else { DebugLog.shared.log("BLE: FFE1 not found, proceeding to auth directly") dxSmartNotifySubscribed = true @@ -425,7 +418,7 @@ class BeaconProvisioner: NSObject, ObservableObject { /// Write password to FFE3 (tries multiple passwords in sequence) private func dxSmartAuthenticate() { guard let passwordChar = characteristics[BeaconProvisioner.DXSMART_PASSWORD_CHAR] else { - fail("DX-Smart password characteristic (FFE3) not found", code: .serviceNotFound) + fail("FFE3 not found", code: .serviceNotFound) return } @@ -436,10 +429,10 @@ class BeaconProvisioner: NSObject, ObservableObject { state = .authenticating let currentPassword = BeaconProvisioner.DXSMART_PASSWORDS[passwordIndex] - progress = "Authenticating (attempt \(passwordIndex + 1)/\(BeaconProvisioner.DXSMART_PASSWORDS.count))..." + progress = "Authenticating (\(passwordIndex + 1)/\(BeaconProvisioner.DXSMART_PASSWORDS.count))..." let passwordData = Data(currentPassword.utf8) - DebugLog.shared.log("BLE: Writing password \(passwordIndex + 1)/\(BeaconProvisioner.DXSMART_PASSWORDS.count) to FFE3 (\(passwordData.count) bytes)") + DebugLog.shared.log("BLE: Auth attempt \(passwordIndex + 1)/\(BeaconProvisioner.DXSMART_PASSWORDS.count)") peripheral?.writeValue(passwordData, for: passwordChar, type: .withResponse) } @@ -447,36 +440,26 @@ class BeaconProvisioner: NSObject, ObservableObject { private func dxSmartRetryNextPassword() { passwordIndex += 1 if passwordIndex < BeaconProvisioner.DXSMART_PASSWORDS.count { - DebugLog.shared.log("BLE: Password rejected, trying next (\(passwordIndex + 1)/\(BeaconProvisioner.DXSMART_PASSWORDS.count))") + DebugLog.shared.log("BLE: Password rejected, trying next") DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { [weak self] in self?.dxSmartAuthenticate() } } else { - fail("Authentication failed - all \(BeaconProvisioner.DXSMART_PASSWORDS.count) passwords rejected", code: .authFailed) + fail("All \(BeaconProvisioner.DXSMART_PASSWORDS.count) passwords rejected", code: .authFailed) } } - /// Read device info (MAC address) before writing config - /// NOTE: Device info read (0x30 query) is SKIPPED during provisioning because DX-Smart - /// beacons frequently drop the BLE connection during this optional query, causing - /// provisioning to fail. The MAC address is nice-to-have but not required — the API - /// falls back to iBeacon UUID as hardware ID when MAC is unavailable. - /// Device info is still read in readConfig/check mode where it doesn't block provisioning. - private func dxSmartReadDeviceInfoBeforeWrite() { - DebugLog.shared.log("BLE: Skipping device info read — proceeding directly to config write (MAC is optional)") - dxSmartWriteConfig() - } - - /// Build the full command sequence and start writing - /// New 24-step write sequence for DX-Smart CP28: - /// 1. DeviceName 0x71 [name bytes] — service point name (max 20 ASCII chars) + /// Build the command queue and start writing. + /// + /// v2 command sequence — only Frame 1 + Frame 2, no extra frame overwrites: + /// 1. DeviceName 0x71 [name bytes] — service point name (max 20 ASCII) /// 2. Frame1_Select 0x11 — select frame 1 - /// 3. Frame1_Type 0x61 — enable as device info (broadcasts name) - /// 4. Frame1_RSSI 0x77 [measuredPower] — RSSI@1m for frame 1 - /// 5. Frame1_AdvInt 0x78 [advInterval] — adv interval for frame 1 - /// 6. Frame1_TxPow 0x79 [txPower] — tx power for frame 1 + /// 3. Frame1_Type 0x61 — device info (broadcasts name) + /// 4. Frame1_RSSI 0x77 [measuredPower] + /// 5. Frame1_AdvInt 0x78 [advInterval] + /// 6. Frame1_TxPow 0x79 [txPower] /// 7. Frame2_Select 0x12 — select frame 2 - /// 8. Frame2_Type 0x62 — set as iBeacon + /// 8. Frame2_Type 0x62 — iBeacon /// 9. UUID 0x74 [16 bytes] /// 10. Major 0x75 [2 bytes BE] /// 11. Minor 0x76 [2 bytes BE] @@ -484,8 +467,9 @@ class BeaconProvisioner: NSObject, ObservableObject { /// 13. AdvInterval 0x78 [advInterval] /// 14. TxPower 0x79 [txPower] /// 15. TriggerOff 0xA0 - /// 16-23. Frames 3-6 select + 0xFF (disable each) - /// 24. SaveConfig 0x60 — persist to flash + /// 16. SaveConfig 0x60 — persist to flash + /// + /// Frames 3-6 are left untouched (not disabled/overwritten). private func dxSmartWriteConfig() { guard let config = config else { fail("No config provided", code: .noConfig) @@ -493,166 +477,105 @@ class BeaconProvisioner: NSObject, ObservableObject { } state = .writing - progress = "Writing DX-Smart configuration..." + progress = "Writing configuration..." dxSmartCommandQueue.removeAll() dxSmartWriteIndex = 0 - // Convert measuredPower (signed Int8) to unsigned byte for transmission let measuredPowerByte = UInt8(bitPattern: config.measuredPower) - // 1. DeviceName (0x71) — service point name (max 20 ASCII chars) + // 1. DeviceName (0x71) if let name = config.deviceName, !name.isEmpty { let truncatedName = String(name.prefix(20)) let nameBytes = Array(truncatedName.utf8) dxSmartCommandQueue.append(buildDXPacket(cmd: .deviceNameWrite, data: nameBytes)) } - // --- Frame 1: Device Info (broadcasts name) --- - // 2. Frame1_Select (0x11) - dxSmartCommandQueue.append(buildDXPacket(cmd: .frameSelectSlot0, data: [])) - // 3. Frame1_Type (0x61) — device info - dxSmartCommandQueue.append(buildDXPacket(cmd: .deviceInfoType, data: [])) - // 4. Frame1_RSSI (0x77) - dxSmartCommandQueue.append(buildDXPacket(cmd: .rssiAt1m, data: [measuredPowerByte])) - // 5. Frame1_AdvInt (0x78) - dxSmartCommandQueue.append(buildDXPacket(cmd: .advInterval, data: [config.advInterval])) - // 6. Frame1_TxPow (0x79) - dxSmartCommandQueue.append(buildDXPacket(cmd: .txPower, data: [config.txPower])) + // --- Frame 1: Device Info --- + dxSmartCommandQueue.append(buildDXPacket(cmd: .frameSelectSlot0, data: [])) // 2. Select frame 1 + dxSmartCommandQueue.append(buildDXPacket(cmd: .deviceInfoType, data: [])) // 3. Device info type + dxSmartCommandQueue.append(buildDXPacket(cmd: .rssiAt1m, data: [measuredPowerByte])) // 4. RSSI + dxSmartCommandQueue.append(buildDXPacket(cmd: .advInterval, data: [config.advInterval])) // 5. Adv interval + dxSmartCommandQueue.append(buildDXPacket(cmd: .txPower, data: [config.txPower])) // 6. TX power // --- Frame 2: iBeacon --- - // 7. Frame2_Select (0x12) - dxSmartCommandQueue.append(buildDXPacket(cmd: .frameSelectSlot1, data: [])) - // 8. Frame2_Type (0x62) — iBeacon - dxSmartCommandQueue.append(buildDXPacket(cmd: .iBeaconType, data: [])) + dxSmartCommandQueue.append(buildDXPacket(cmd: .frameSelectSlot1, data: [])) // 7. Select frame 2 + dxSmartCommandQueue.append(buildDXPacket(cmd: .iBeaconType, data: [])) // 8. iBeacon type - // 9. UUID (0x74) [16 bytes] + // 9. UUID (16 bytes) if let uuidData = hexStringToData(config.uuid) { dxSmartCommandQueue.append(buildDXPacket(cmd: .uuid, data: Array(uuidData))) } - // 10. Major (0x75) [2 bytes big-endian] + // 10. Major (2 bytes BE) let majorHi = UInt8((config.major >> 8) & 0xFF) let majorLo = UInt8(config.major & 0xFF) dxSmartCommandQueue.append(buildDXPacket(cmd: .major, data: [majorHi, majorLo])) - // 11. Minor (0x76) [2 bytes big-endian] + // 11. Minor (2 bytes BE) let minorHi = UInt8((config.minor >> 8) & 0xFF) let minorLo = UInt8(config.minor & 0xFF) dxSmartCommandQueue.append(buildDXPacket(cmd: .minor, data: [minorHi, minorLo])) - // 12. RSSI@1m (0x77) + // 12-14. RSSI, AdvInterval, TxPower for frame 2 dxSmartCommandQueue.append(buildDXPacket(cmd: .rssiAt1m, data: [measuredPowerByte])) - // 13. AdvInterval (0x78) dxSmartCommandQueue.append(buildDXPacket(cmd: .advInterval, data: [config.advInterval])) - // 14. TxPower (0x79) dxSmartCommandQueue.append(buildDXPacket(cmd: .txPower, data: [config.txPower])) - // 15. TriggerOff (0xA0) + + // 15. TriggerOff dxSmartCommandQueue.append(buildDXPacket(cmd: .triggerOff, data: [])) - // --- Frames 3-6: Disable each --- - // 16-17. Frame 3: select (0x13) + disable (0xFF) - dxSmartCommandQueue.append(buildDXPacket(cmd: .frameSelectSlot2, data: [])) - dxSmartCommandQueue.append(buildDXPacket(cmd: .frameDisable, data: [])) - // 18-19. Frame 4: select (0x14) + disable (0xFF) - dxSmartCommandQueue.append(buildDXPacket(cmd: .frameSelectSlot3, data: [])) - dxSmartCommandQueue.append(buildDXPacket(cmd: .frameDisable, data: [])) - // 20-21. Frame 5: select (0x15) + disable (0xFF) - dxSmartCommandQueue.append(buildDXPacket(cmd: .frameSelectSlot4, data: [])) - dxSmartCommandQueue.append(buildDXPacket(cmd: .frameDisable, data: [])) - // 22-23. Frame 6: select (0x16) + disable (0xFF) - dxSmartCommandQueue.append(buildDXPacket(cmd: .frameSelectSlot5, data: [])) - dxSmartCommandQueue.append(buildDXPacket(cmd: .frameDisable, data: [])) - - // 24. SaveConfig (0x60) — persist to flash + // 16. SaveConfig — persist to flash dxSmartCommandQueue.append(buildDXPacket(cmd: .saveConfig, data: [])) - DebugLog.shared.log("BLE: DX-Smart command queue built with \(dxSmartCommandQueue.count) commands") + DebugLog.shared.log("BLE: Command queue built: \(dxSmartCommandQueue.count) commands (no extra frame overwrites)") dxSmartSendNextCommand() } - /// Send the next command in the DX-Smart queue + /// Send the next command in the queue private func dxSmartSendNextCommand() { guard dxSmartWriteIndex < dxSmartCommandQueue.count else { cancelWriteTimeout() - DebugLog.shared.log("BLE: All DX-Smart commands written!") + DebugLog.shared.log("BLE: All commands written successfully!") progress = "Configuration saved!" succeed() return } - let packet = dxSmartCommandQueue[dxSmartWriteIndex] - let total = dxSmartCommandQueue.count - let current = dxSmartWriteIndex + 1 - progress = "Writing config (\(current)/\(total))..." - guard let commandChar = characteristics[BeaconProvisioner.DXSMART_COMMAND_CHAR] else { - // After disconnect+reconnect, characteristic discovery may return incomplete results. - // Re-discover characteristics instead of hard-failing. - if charRediscoveryCount < BeaconProvisioner.MAX_CHAR_REDISCOVERY, let service = configService { - charRediscoveryCount += 1 - DebugLog.shared.log("BLE: FFE2 missing — re-discovering characteristics (attempt \(charRediscoveryCount)/\(BeaconProvisioner.MAX_CHAR_REDISCOVERY))") - progress = "Re-discovering characteristics..." - state = .discoveringServices - DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) { [weak self] in - self?.peripheral?.discoverCharacteristics([ - BeaconProvisioner.DXSMART_NOTIFY_CHAR, - BeaconProvisioner.DXSMART_COMMAND_CHAR, - BeaconProvisioner.DXSMART_PASSWORD_CHAR - ], for: service) - } - } else { - fail("DX-Smart command characteristic (FFE2) not found after \(charRediscoveryCount) rediscovery attempts", code: .serviceNotFound) - } + // If FFE2 is gone after we already confirmed it, something went very wrong. + // Don't try to re-discover — fail cleanly. Prevention means we don't get here. + fail("FFE2 characteristic lost during write", code: .writeFailed) return } - // Reset rediscovery counter on successful characteristic access - charRediscoveryCount = 0 + let packet = dxSmartCommandQueue[dxSmartWriteIndex] + let current = dxSmartWriteIndex + 1 + let total = dxSmartCommandQueue.count + progress = "Writing config (\(current)/\(total))..." - DebugLog.shared.log("BLE: Writing command \(current)/\(total): \(packet.map { String(format: "%02X", $0) }.joined(separator: " "))") - writeRetryCount = 0 + DebugLog.shared.log("BLE: Write \(current)/\(total): \(packet.map { String(format: "%02X", $0) }.joined(separator: " "))") scheduleWriteTimeout() peripheral?.writeValue(packet, for: commandChar, type: .withResponse) } - /// Schedule a per-write timeout — if the write callback doesn't come back - /// within WRITE_TIMEOUT_SECONDS, retry the write once or skip if non-fatal. - /// This matches Android's 5-second per-write timeout via withTimeoutOrNull(5000L). + /// Per-write timeout — fail cleanly if beacon doesn't ACK private func scheduleWriteTimeout() { cancelWriteTimeout() let timer = DispatchWorkItem { [weak self] in - guard let self = self else { return } - guard self.state == .writing else { return } + guard let self = self, self.state == .writing else { return } let current = self.dxSmartWriteIndex + 1 let total = self.dxSmartCommandQueue.count - let isNonFatal = self.dxSmartWriteIndex < 6 - let isSaveConfig = self.dxSmartWriteIndex >= self.dxSmartCommandQueue.count - 1 + let isSaveConfig = self.dxSmartWriteIndex >= total - 1 if isSaveConfig { - // SaveConfig may not get a callback — beacon reboots. Treat as success. - DebugLog.shared.log("BLE: SaveConfig write timeout (beacon likely rebooted) — treating as success") + // SaveConfig may not ACK — beacon reboots. That's success. + DebugLog.shared.log("BLE: SaveConfig timeout (beacon rebooted) — success") self.succeed() - } else if self.writeRetryCount < BeaconProvisioner.MAX_WRITE_RETRIES { - // Retry the write once - self.writeRetryCount += 1 - DebugLog.shared.log("BLE: Write timeout for command \(current)/\(total) — retrying (\(self.writeRetryCount)/\(BeaconProvisioner.MAX_WRITE_RETRIES))") - if let commandChar = self.characteristics[BeaconProvisioner.DXSMART_COMMAND_CHAR] { - let packet = self.dxSmartCommandQueue[self.dxSmartWriteIndex] - self.scheduleWriteTimeout() - self.peripheral?.writeValue(packet, for: commandChar, type: .withResponse) - } - } else if isNonFatal { - // Non-fatal commands (first 6) — skip and continue - DebugLog.shared.log("BLE: Write timeout for non-fatal command \(current)/\(total) — skipping") - self.dxSmartWriteIndex += 1 - DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { [weak self] in - self?.dxSmartSendNextCommand() - } } else { - // Fatal command timed out after retry — fail - DebugLog.shared.log("BLE: Write timeout for critical command \(current)/\(total) — failing") + // Any other command timing out is a real problem + DebugLog.shared.log("BLE: Write timeout at step \(current)/\(total)") self.fail("Write timeout at step \(current)/\(total)", code: .writeFailed) } } @@ -660,49 +583,35 @@ class BeaconProvisioner: NSObject, ObservableObject { DispatchQueue.main.asyncAfter(deadline: .now() + BeaconProvisioner.WRITE_TIMEOUT_SECONDS, execute: timer) } - /// Cancel any pending write timeout private func cancelWriteTimeout() { writeTimeoutTimer?.cancel() writeTimeoutTimer = nil } - /// Calculate adaptive delay after writing a command. - /// Frame selection (0x11-0x16) and type commands (0x61, 0x62) trigger internal - /// state changes on the beacon MCU that need extra processing time. - /// UUID writes are the largest payload (21 bytes) and also need breathing room. - /// Without adaptive delays, the beacon's radio gets overwhelmed and drops the - /// BLE connection (supervision timeout). + /// Calculate delay for the command we just wrote. + /// Frame selection and type commands need extra time (MCU state change). private func delayForCommand(at index: Int) -> Double { - guard index < dxSmartCommandQueue.count else { return BeaconProvisioner.BASE_WRITE_DELAY } + guard index < dxSmartCommandQueue.count else { return BeaconProvisioner.INTER_COMMAND_DELAY } let packet = dxSmartCommandQueue[index] - guard packet.count >= 3 else { return BeaconProvisioner.BASE_WRITE_DELAY } + guard packet.count >= 3 else { return BeaconProvisioner.INTER_COMMAND_DELAY } - let cmd = packet[2] // Command byte is at offset 2 (after 4E 4F header) + let cmd = packet[2] switch DXCmd(rawValue: cmd) { - case .frameSelectSlot0, .frameSelectSlot1, .frameSelectSlot2, - .frameSelectSlot3, .frameSelectSlot4, .frameSelectSlot5: - // Frame selection changes internal state — beacon needs time to switch context - return BeaconProvisioner.HEAVY_WRITE_DELAY - case .deviceInfoType, .iBeaconType: - // Frame type assignment — triggers internal config restructuring - return BeaconProvisioner.HEAVY_WRITE_DELAY + case .frameSelectSlot0, .frameSelectSlot1, + .deviceInfoType, .iBeaconType: + return BeaconProvisioner.HEAVY_COMMAND_DELAY case .uuid: - // Largest payload (16 bytes + header = 21 bytes) — give extra time - return BeaconProvisioner.LARGE_PAYLOAD_DELAY - case .saveConfig: - // Save to flash — beacon may reboot, no point waiting long - return BeaconProvisioner.BASE_WRITE_DELAY + return BeaconProvisioner.HEAVY_COMMAND_DELAY // Large payload default: - return BeaconProvisioner.BASE_WRITE_DELAY + return BeaconProvisioner.INTER_COMMAND_DELAY } } - // MARK: - Response Gating (matches Android responseChannel.receive pattern) + // MARK: - Response Gating - /// After a successful write, advance to the next command with the appropriate delay. - /// Called either when FFE1 response arrives or when the 1s response gate timeout fires. + /// After a successful write, wait for FFE1 response then advance. private func advanceToNextCommand() { let justWritten = dxSmartWriteIndex dxSmartWriteIndex += 1 @@ -712,23 +621,19 @@ class BeaconProvisioner: NSObject, ObservableObject { } } - /// Schedule a 1s timeout for beacon response. If the beacon doesn't send an FFE1 - /// notification within 1s, advance anyway (some commands don't produce responses). - /// Matches Android's: withTimeoutOrNull(1000L) { responseChannel.receive() } + /// Wait up to 1s for beacon FFE1 response. If none, advance anyway. private func scheduleResponseGateTimeout() { cancelResponseGateTimeout() let timer = DispatchWorkItem { [weak self] in - guard let self = self else { return } - guard self.awaitingCommandResponse else { return } + guard let self = self, self.awaitingCommandResponse else { return } self.awaitingCommandResponse = false - DebugLog.shared.log("BLE: No FFE1 response within 1s for command \(self.dxSmartWriteIndex + 1) — advancing (OK)") + DebugLog.shared.log("BLE: No FFE1 response within 1s for cmd \(self.dxSmartWriteIndex + 1) — advancing") self.advanceToNextCommand() } responseGateTimer = timer DispatchQueue.main.asyncAfter(deadline: .now() + BeaconProvisioner.RESPONSE_GATE_TIMEOUT, execute: timer) } - /// Cancel any pending response gate timeout private func cancelResponseGateTimeout() { responseGateTimer?.cancel() responseGateTimer = nil @@ -744,7 +649,6 @@ class BeaconProvisioner: NSObject, ObservableObject { packet.append(UInt8(data.count)) packet.append(contentsOf: data) - // XOR checksum: CMD ^ LEN ^ each data byte var checksum: UInt8 = cmd.rawValue ^ UInt8(data.count) for byte in data { checksum ^= byte @@ -756,7 +660,6 @@ class BeaconProvisioner: NSObject, ObservableObject { // MARK: - Read Config: Service Exploration - /// Explore all services on the device, then attempt DX-Smart read protocol private func startReadExplore() { guard let services = peripheral?.services, !services.isEmpty else { readFail("No services found on device") @@ -778,7 +681,6 @@ class BeaconProvisioner: NSObject, ObservableObject { private func exploreNextService() { guard !servicesToExplore.isEmpty else { - // All services explored — start DX-Smart read protocol if FFE0 is present DebugLog.shared.log("BLE: All services explored, starting DX-Smart read") startDXSmartRead() return @@ -792,30 +694,25 @@ class BeaconProvisioner: NSObject, ObservableObject { // MARK: - Read Config: DX-Smart Protocol - /// After exploration, start DX-Smart read if FFE0 chars are present private func startDXSmartRead() { guard characteristics[BeaconProvisioner.DXSMART_PASSWORD_CHAR] != nil, characteristics[BeaconProvisioner.DXSMART_COMMAND_CHAR] != nil else { - // Not a DX-Smart beacon — finish with just the service/char listing DebugLog.shared.log("BLE: No FFE0 service — not a DX-Smart beacon") progress = "No DX-Smart service found" finishRead() return } - // Subscribe to FFE1 for responses if let notifyChar = characteristics[BeaconProvisioner.DXSMART_NOTIFY_CHAR] { - DebugLog.shared.log("BLE: Read mode — subscribing to FFE1 notifications") + DebugLog.shared.log("BLE: Read mode — subscribing to FFE1") progress = "Subscribing to notifications..." peripheral?.setNotifyValue(true, for: notifyChar) } else { - // No FFE1 — try auth anyway DebugLog.shared.log("BLE: FFE1 not found, attempting auth without notifications") dxSmartReadAuth() } } - /// Authenticate on FFE3 for read mode (uses same multi-password fallback) private func dxSmartReadAuth() { guard let passwordChar = characteristics[BeaconProvisioner.DXSMART_PASSWORD_CHAR] else { DebugLog.shared.log("BLE: No FFE3 for auth, finishing") @@ -831,26 +728,24 @@ class BeaconProvisioner: NSObject, ObservableObject { state = .authenticating let currentPassword = BeaconProvisioner.DXSMART_PASSWORDS[passwordIndex] - progress = "Authenticating (attempt \(passwordIndex + 1)/\(BeaconProvisioner.DXSMART_PASSWORDS.count))..." + progress = "Authenticating (\(passwordIndex + 1)/\(BeaconProvisioner.DXSMART_PASSWORDS.count))..." let passwordData = Data(currentPassword.utf8) - DebugLog.shared.log("BLE: Read mode — writing password \(passwordIndex + 1)/\(BeaconProvisioner.DXSMART_PASSWORDS.count) to FFE3") + DebugLog.shared.log("BLE: Read mode — auth attempt \(passwordIndex + 1)") peripheral?.writeValue(passwordData, for: passwordChar, type: .withResponse) } - /// After auth, send read query commands private func dxSmartReadQueryAfterAuth() { dxReadQueries.removeAll() dxReadQueryIndex = 0 responseBuffer.removeAll() - // Read commands: send with LEN=0 (no data) to request current config values - dxReadQueries.append(buildDXPacket(cmd: .frameTable, data: [])) // 0x10: frame assignment table - dxReadQueries.append(buildDXPacket(cmd: .iBeaconType, data: [])) // 0x62: iBeacon UUID/Major/Minor/etc - dxReadQueries.append(buildDXPacket(cmd: .deviceInfo, data: [])) // 0x30: battery, MAC, firmware - dxReadQueries.append(buildDXPacket(cmd: .deviceName, data: [])) // 0x43: device name + dxReadQueries.append(buildDXPacket(cmd: .frameTable, data: [])) // Frame table + dxReadQueries.append(buildDXPacket(cmd: .iBeaconType, data: [])) // iBeacon config + dxReadQueries.append(buildDXPacket(cmd: .deviceInfo, data: [])) // Device info + dxReadQueries.append(buildDXPacket(cmd: .deviceName, data: [])) // Device name - DebugLog.shared.log("BLE: Sending \(dxReadQueries.count) DX-Smart read queries") + DebugLog.shared.log("BLE: Sending \(dxReadQueries.count) read queries") state = .verifying progress = "Reading config..." dxSmartSendNextReadQuery() @@ -858,7 +753,7 @@ class BeaconProvisioner: NSObject, ObservableObject { private func dxSmartSendNextReadQuery() { guard dxReadQueryIndex < dxReadQueries.count else { - DebugLog.shared.log("BLE: All read queries sent, waiting 2s for final responses") + DebugLog.shared.log("BLE: All read queries sent, waiting 2s for responses") progress = "Collecting responses..." DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) { [weak self] in guard let self = self, self.operationMode == .readingConfig else { return } @@ -883,22 +778,18 @@ class BeaconProvisioner: NSObject, ObservableObject { // MARK: - Read Config: Response Parsing - /// Process incoming FFE1 notification data — accumulate and parse DX-Smart response frames private func processFFE1Response(_ data: Data) { let hex = data.map { String(format: "%02X", $0) }.joined(separator: " ") DebugLog.shared.log("BLE: FFE1 raw: \(hex)") responseBuffer.append(contentsOf: data) - // Try to parse complete frames from buffer - while responseBuffer.count >= 5 { // Minimum frame: 4E 4F CMD 00 XOR = 5 bytes - // Find 4E 4F header + while responseBuffer.count >= 5 { guard let headerIdx = findDXHeader() else { responseBuffer.removeAll() break } - // Discard bytes before header if headerIdx > 0 { responseBuffer.removeFirst(headerIdx) } @@ -907,18 +798,13 @@ class BeaconProvisioner: NSObject, ObservableObject { let cmd = responseBuffer[2] let len = Int(responseBuffer[3]) - let frameLen = 4 + len + 1 // header(2) + cmd(1) + len(1) + data(len) + xor(1) + let frameLen = 4 + len + 1 - guard responseBuffer.count >= frameLen else { - // Incomplete frame — wait for more data - break - } + guard responseBuffer.count >= frameLen else { break } - // Extract frame let frame = Array(responseBuffer[0.. Int? { guard responseBuffer.count >= 2 else { return nil } for i in 0..<(responseBuffer.count - 1) { @@ -947,7 +832,6 @@ class BeaconProvisioner: NSObject, ObservableObject { return nil } - /// Parse a complete DX-Smart response by command type private func parseResponseCmd(cmd: UInt8, data: [UInt8]) { let dataHex = data.map { String(format: "%02X", $0) }.joined(separator: " ") DebugLog.shared.log("BLE: Response cmd=0x\(String(format: "%02X", cmd)) len=\(data.count) data=[\(dataHex)]") @@ -955,15 +839,14 @@ class BeaconProvisioner: NSObject, ObservableObject { switch DXCmd(rawValue: cmd) { - case .frameTable: // 0x10: Frame assignment table (one byte per slot) + case .frameTable: readResult.frameSlots = data DebugLog.shared.log("BLE: Frame slots: \(data.map { String(format: "0x%02X", $0) })") - case .iBeaconType: // 0x62: iBeacon config data + case .iBeaconType: guard data.count >= 2 else { return } - var offset = 1 // Skip type echo byte + var offset = 1 - // UUID: 16 bytes if data.count >= offset + 16 { let uuidBytes = Array(data[offset..<(offset + 16)]) let uuidHex = uuidBytes.map { String(format: "%02X", $0) }.joined() @@ -971,39 +854,34 @@ class BeaconProvisioner: NSObject, ObservableObject { offset += 16 } - // Major: 2 bytes big-endian if data.count >= offset + 2 { readResult.major = UInt16(data[offset]) << 8 | UInt16(data[offset + 1]) offset += 2 } - // Minor: 2 bytes big-endian if data.count >= offset + 2 { readResult.minor = UInt16(data[offset]) << 8 | UInt16(data[offset + 1]) offset += 2 } - // RSSI@1m: 1 byte signed if data.count >= offset + 1 { readResult.rssiAt1m = Int8(bitPattern: data[offset]) offset += 1 } - // Advertising interval: 1 byte (raw value) if data.count >= offset + 1 { readResult.advInterval = UInt16(data[offset]) offset += 1 } - // TX power: 1 byte if data.count >= offset + 1 { readResult.txPower = data[offset] offset += 1 } - DebugLog.shared.log("BLE: Parsed iBeacon — UUID=\(readResult.uuid ?? "?") Major=\(readResult.major ?? 0) Minor=\(readResult.minor ?? 0)") + DebugLog.shared.log("BLE: iBeacon — UUID=\(readResult.uuid ?? "?") Major=\(readResult.major ?? 0) Minor=\(readResult.minor ?? 0)") - case .deviceInfo: // 0x30: Device info (battery, MAC, manufacturer, firmware) + case .deviceInfo: if data.count >= 1 { readResult.battery = data[0] } @@ -1013,14 +891,13 @@ class BeaconProvisioner: NSObject, ObservableObject { } DebugLog.shared.log("BLE: Device info — battery=\(readResult.battery ?? 0)% MAC=\(readResult.macAddress ?? "?")") - case .deviceName: // 0x43: Device name + case .deviceName: readResult.deviceName = String(bytes: data, encoding: .utf8)?.trimmingCharacters(in: .controlCharacters) DebugLog.shared.log("BLE: Device name = \(readResult.deviceName ?? "?")") - case .authCheck: // 0x25: Auth check response + case .authCheck: if data.count >= 1 { - let authRequired = data[0] != 0x00 - DebugLog.shared.log("BLE: Auth required: \(authRequired)") + DebugLog.shared.log("BLE: Auth required: \(data[0] != 0x00)") } default: @@ -1071,8 +948,6 @@ class BeaconProvisioner: NSObject, ObservableObject { configService = nil characteristics.removeAll() connectionRetryCount = 0 - deviceInfoRetryCount = 0 - disconnectRetryCount = 0 currentBeacon = nil operationMode = .provisioning state = .idle @@ -1120,19 +995,17 @@ extension BeaconProvisioner: CBCentralManagerDelegate { DebugLog.shared.log("BLE: Connected to \(peripheral.name ?? "unknown")") peripheral.delegate = self - // Log negotiated MTU — CoreBluetooth auto-negotiates, but we need to verify - // the max write length can handle our largest packet (UUID write = ~21 bytes) let maxWriteLen = peripheral.maximumWriteValueLength(for: .withResponse) - DebugLog.shared.log("BLE: Max write length (withResponse): \(maxWriteLen) bytes") + DebugLog.shared.log("BLE: Max write length: \(maxWriteLen) bytes") if maxWriteLen < 21 { - DebugLog.shared.log("BLE: WARNING — max write length \(maxWriteLen) may be too small for UUID packet (21 bytes)") + DebugLog.shared.log("BLE: WARNING — max write \(maxWriteLen) < 21 bytes needed for UUID packet") } state = .discoveringServices progress = "Discovering services..." if operationMode == .readingConfig { - peripheral.discoverServices(nil) // Discover all for exploration + peripheral.discoverServices(nil) } else { peripheral.discoverServices([BeaconProvisioner.DXSMART_SERVICE]) } @@ -1140,18 +1013,18 @@ extension BeaconProvisioner: CBCentralManagerDelegate { func centralManager(_ central: CBCentralManager, didFailToConnect peripheral: CBPeripheral, error: Error?) { let errorMsg = error?.localizedDescription ?? "unknown error" - DebugLog.shared.log("BLE: Connection failed (attempt \(connectionRetryCount + 1)): \(errorMsg)") + DebugLog.shared.log("BLE: Connection failed: \(errorMsg)") - // Retry logic: up to 3 retries with increasing delay (1s, 2s, 3s) + // Simple retry: up to 2 attempts with short delay if connectionRetryCount < BeaconProvisioner.MAX_CONNECTION_RETRIES { connectionRetryCount += 1 - let delay = Double(connectionRetryCount) // 1s, 2s, 3s + let delay = Double(connectionRetryCount) progress = "Connection failed, retrying (\(connectionRetryCount)/\(BeaconProvisioner.MAX_CONNECTION_RETRIES))..." - DebugLog.shared.log("BLE: Retrying connection in \(delay)s...") + DebugLog.shared.log("BLE: Retrying connection in \(delay)s") DispatchQueue.main.asyncAfter(deadline: .now() + delay) { [weak self] in guard let self = self, let beacon = self.currentBeacon else { return } - guard self.state == .connecting else { return } // Don't retry if cancelled + guard self.state == .connecting else { return } let resolvedPeripheral = self.resolvePeripheral(beacon) self.peripheral = resolvedPeripheral @@ -1168,9 +1041,9 @@ extension BeaconProvisioner: CBCentralManagerDelegate { } func centralManager(_ central: CBCentralManager, didDisconnectPeripheral peripheral: CBPeripheral, error: Error?) { - DebugLog.shared.log("BLE: Disconnected from \(peripheral.name ?? "unknown") | state=\(state) mode=\(operationMode) writeIdx=\(dxSmartWriteIndex) queueCount=\(dxSmartCommandQueue.count) terminating=\(isTerminating) error=\(error?.localizedDescription ?? "none")") + DebugLog.shared.log("BLE: Disconnected | state=\(state) mode=\(operationMode) writeIdx=\(dxSmartWriteIndex) queueCount=\(dxSmartCommandQueue.count) error=\(error?.localizedDescription ?? "none")") - // If we already called succeed() or fail(), this disconnect is expected cleanup — ignore it + // Expected cleanup disconnect if isTerminating { DebugLog.shared.log("BLE: Disconnect during termination, ignoring") return @@ -1183,100 +1056,26 @@ extension BeaconProvisioner: CBCentralManagerDelegate { return } - // Already in a terminal state — nothing to do - if state == .success || state == .idle { - return - } - if case .failed = state { - DebugLog.shared.log("BLE: Disconnect after failure, ignoring") - return - } + // Already terminal + if state == .success || state == .idle { return } + if case .failed = state { return } - // SaveConfig (last command) was sent — beacon rebooted to apply config - // Check: writing state AND at or past the last command in queue + // SaveConfig was the last command — beacon rebooted. That's success. if state == .writing && dxSmartCommandQueue.count > 0 && dxSmartWriteIndex >= dxSmartCommandQueue.count - 1 { - DebugLog.shared.log("BLE: Disconnect after SaveConfig (idx=\(dxSmartWriteIndex)/\(dxSmartCommandQueue.count)) — treating as success") + DebugLog.shared.log("BLE: Disconnect after SaveConfig — treating as success") succeed() return } - // NOTE: Device info read is now skipped entirely during provisioning - // (see dxSmartReadDeviceInfoBeforeWrite). This guard is kept as a safety net - // in case device info is re-enabled in the future. - if state == .authenticating && awaitingDeviceInfoForProvisioning && dxSmartAuthenticated { - DebugLog.shared.log("BLE: Disconnect during device info read — proceeding without MAC (device info is optional)") - awaitingDeviceInfoForProvisioning = false - skipDeviceInfoRead = true - - // Reconnect and skip device info on next attempt - dxSmartAuthenticated = false - dxSmartNotifySubscribed = false - dxSmartCommandQueue.removeAll() - dxSmartWriteIndex = 0 - passwordIndex = 0 - characteristics.removeAll() - responseBuffer.removeAll() - state = .connecting - - DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) { [weak self] in - guard let self = self, let beacon = self.currentBeacon else { return } - guard self.state == .connecting else { return } - let resolvedPeripheral = self.resolvePeripheral(beacon) - self.peripheral = resolvedPeripheral - resolvedPeripheral.delegate = self - self.centralManager.connect(resolvedPeripheral, options: nil) - } - return - } - - // Cancel any pending timers — disconnect supersedes them + // Cancel pending timers cancelWriteTimeout() cancelResponseGateTimeout() awaitingCommandResponse = false - // Unexpected disconnect during any active provisioning phase — retry with full reconnect - let isActivePhase = (state == .discoveringServices || state == .authenticating || state == .writing || state == .verifying) - if isActivePhase && disconnectRetryCount < BeaconProvisioner.MAX_DISCONNECT_RETRIES { - disconnectRetryCount += 1 - let wasWriting = (state == .writing && !dxSmartCommandQueue.isEmpty) - DebugLog.shared.log("BLE: Disconnect during \(state) — reconnecting (attempt \(disconnectRetryCount)/\(BeaconProvisioner.MAX_DISCONNECT_RETRIES)) wasWriting=\(wasWriting) writeIdx=\(dxSmartWriteIndex)") - progress = "Beacon disconnected, reconnecting (\(disconnectRetryCount)/\(BeaconProvisioner.MAX_DISCONNECT_RETRIES))..." - - // Reset connection-level state, but PRESERVE command queue and write index - // so we can resume from where we left off instead of starting over - dxSmartAuthenticated = false - dxSmartNotifySubscribed = false - passwordIndex = 0 - characteristics.removeAll() - responseBuffer.removeAll() - - if wasWriting { - // Resume mode: keep the command queue and write index intact - resumeWriteAfterDisconnect = true - DebugLog.shared.log("BLE: Will resume writing from command \(dxSmartWriteIndex + 1)/\(dxSmartCommandQueue.count) after reconnect") - } else { - // Full reset for non-writing phases - dxSmartCommandQueue.removeAll() - dxSmartWriteIndex = 0 - resumeWriteAfterDisconnect = false - } - state = .connecting - - let delay = Double(disconnectRetryCount) + 2.0 // 3s, 4s, 5s, 6s, 7s backoff — give BLE time to settle - DispatchQueue.main.asyncAfter(deadline: .now() + delay) { [weak self] in - guard let self = self, let beacon = self.currentBeacon else { return } - guard self.state == .connecting else { return } - let resolvedPeripheral = self.resolvePeripheral(beacon) - self.peripheral = resolvedPeripheral - resolvedPeripheral.delegate = self - self.centralManager.connect(resolvedPeripheral, options: nil) - } - return - } - - // All retries exhausted or disconnect in unexpected state — fail - DebugLog.shared.log("BLE: UNEXPECTED disconnect — state=\(state) writeIdx=\(dxSmartWriteIndex) queueCount=\(dxSmartCommandQueue.count) authenticated=\(dxSmartAuthenticated) disconnectRetries=\(disconnectRetryCount)") - fail("Beacon disconnected \(disconnectRetryCount + 1) times during \(state). Move closer to the beacon and try again.", code: .disconnected) + // Any other disconnect during active work = fail immediately. + // Prevention philosophy: if the connection dropped, something is wrong. + // Don't try to reconnect and resume — let the user retry cleanly. + fail("Beacon disconnected during \(state). Move closer and try again.", code: .disconnected) } } @@ -1304,9 +1103,6 @@ extension BeaconProvisioner: CBPeripheralDelegate { } DebugLog.shared.log("BLE: Discovered \(services.count) services") - for service in services { - NSLog(" Service: \(service.uuid)") - } if operationMode == .readingConfig { startReadExplore() @@ -1327,7 +1123,6 @@ extension BeaconProvisioner: CBPeripheralDelegate { func peripheral(_ peripheral: CBPeripheral, didDiscoverCharacteristicsFor service: CBService, error: Error?) { if let error = error { if operationMode == .readingConfig { - // Don't fail entirely — skip this service DebugLog.shared.log("BLE: Char discovery failed for \(service.uuid): \(error.localizedDescription)") exploreNextService() } else { @@ -1355,7 +1150,7 @@ extension BeaconProvisioner: CBPeripheralDelegate { props.contains(.notify) ? "N" : "", props.contains(.indicate) ? "I" : "" ].filter { !$0.isEmpty }.joined(separator: ",") - NSLog(" Char: \(char.uuid) [\(propStr)]") + DebugLog.shared.log(" Char: \(char.uuid) [\(propStr)]") characteristics[char.uuid] = char if operationMode == .readingConfig { @@ -1364,80 +1159,66 @@ extension BeaconProvisioner: CBPeripheralDelegate { } if operationMode == .readingConfig { - // Continue exploring next service exploreNextService() - } else if charRediscoveryCount > 0 && dxSmartAuthenticated && !dxSmartCommandQueue.isEmpty { - // Rediscovery during active write — resume writing directly (already authenticated) - DebugLog.shared.log("BLE: Characteristics re-discovered after FFE2 miss — resuming write") - state = .writing - DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { [weak self] in - self?.dxSmartSendNextCommand() - } } else { - // Provisioning: DX-Smart auth flow - dxSmartStartAuth() + // PREVENTION: verify all required chars exist before proceeding + verifyCharacteristicsAndProceed() } } func peripheral(_ peripheral: CBPeripheral, didWriteValueFor characteristic: CBCharacteristic, error: Error?) { - cancelWriteTimeout() // Write callback received — cancel the per-write timeout + cancelWriteTimeout() if let error = error { DebugLog.shared.log("BLE: Write failed for \(characteristic.uuid): \(error.localizedDescription)") + // Password rejected if characteristic.uuid == BeaconProvisioner.DXSMART_PASSWORD_CHAR { - // Password rejected — try next password in the list if passwordIndex + 1 < BeaconProvisioner.DXSMART_PASSWORDS.count { - DebugLog.shared.log("BLE: Password \(passwordIndex + 1) rejected, trying next...") dxSmartRetryNextPassword() } else if operationMode == .readingConfig { readFail("Authentication failed - all passwords rejected") } else { - fail("Authentication failed - all \(BeaconProvisioner.DXSMART_PASSWORDS.count) passwords rejected", code: .authFailed) + fail("All passwords rejected", code: .authFailed) } return } + // Command write failed if characteristic.uuid == BeaconProvisioner.DXSMART_COMMAND_CHAR { if operationMode == .readingConfig { - DebugLog.shared.log("BLE: Read query failed, skipping") dxReadQueryIndex += 1 DispatchQueue.main.asyncAfter(deadline: .now() + 0.4) { [weak self] in self?.dxSmartSendNextReadQuery() } } else { - // Device name (0x71) and Frame 1 commands (steps 1-6) may be rejected by some firmware - // Treat these as non-fatal: log and continue to next command - let isNonFatalCommand = dxSmartWriteIndex < 6 // First 6 commands are optional let isSaveConfig = dxSmartWriteIndex >= dxSmartCommandQueue.count - 1 + let isFrame1Command = dxSmartWriteIndex < 6 // Frame 1 commands are non-fatal + if isSaveConfig { - // SaveConfig (0x60) write "error" is expected — beacon reboots immediately - // after processing the save, which kills the BLE connection before the - // ATT write response can be delivered. This is success, not failure. - DebugLog.shared.log("BLE: SaveConfig write error (beacon rebooted) — treating as success") + // SaveConfig write "error" = beacon rebooted mid-ACK. Success. + DebugLog.shared.log("BLE: SaveConfig write error (beacon rebooted) — success") succeed() - } else if isNonFatalCommand { - DebugLog.shared.log("BLE: Non-fatal command failed at step \(dxSmartWriteIndex + 1), continuing...") + } else if isFrame1Command { + // Frame 1 (device info) commands are optional — skip and continue + DebugLog.shared.log("BLE: Non-fatal command failed at step \(dxSmartWriteIndex + 1), skipping") dxSmartWriteIndex += 1 DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { [weak self] in self?.dxSmartSendNextCommand() } } else { - fail("Command write failed at step \(dxSmartWriteIndex + 1)/\(dxSmartCommandQueue.count): \(error.localizedDescription)", code: .writeFailed) + fail("Write failed at step \(dxSmartWriteIndex + 1)/\(dxSmartCommandQueue.count): \(error.localizedDescription)", code: .writeFailed) } } return } - if operationMode == .readingConfig { - DebugLog.shared.log("BLE: Write failed in read mode, ignoring: \(error.localizedDescription)") - return - } + if operationMode == .readingConfig { return } fail("Write failed: \(error.localizedDescription)", code: .writeFailed) return } - DebugLog.shared.log("BLE: Write succeeded for \(characteristic.uuid)") + DebugLog.shared.log("BLE: Write OK for \(characteristic.uuid)") // Password auth succeeded if characteristic.uuid == BeaconProvisioner.DXSMART_PASSWORD_CHAR { @@ -1445,38 +1226,25 @@ extension BeaconProvisioner: CBPeripheralDelegate { dxSmartAuthenticated = true if operationMode == .readingConfig { dxSmartReadQueryAfterAuth() - } else if resumeWriteAfterDisconnect { - // Reconnected after disconnect during writing — resume from saved position - resumeWriteAfterDisconnect = false - state = .writing - DebugLog.shared.log("BLE: Resuming write from command \(dxSmartWriteIndex + 1)/\(dxSmartCommandQueue.count) after reconnect") - progress = "Resuming config write..." - // Longer delay after reconnect — give the beacon's BLE stack time to stabilize - // before resuming writes (prevents immediate re-disconnect) - DispatchQueue.main.asyncAfter(deadline: .now() + 1.5) { [weak self] in - self?.dxSmartSendNextCommand() - } } else { - // Read device info first to get MAC address, then write config - dxSmartReadDeviceInfoBeforeWrite() + // Give the beacon breathing room after auth before we start writing + DebugLog.shared.log("BLE: Waiting \(BeaconProvisioner.POST_AUTH_DELAY)s before writing...") + progress = "Authenticated, preparing to write..." + DispatchQueue.main.asyncAfter(deadline: .now() + BeaconProvisioner.POST_AUTH_DELAY) { [weak self] in + self?.dxSmartWriteConfig() + } } return } - // Command write succeeded → wait for beacon response before sending next - // (matches Android: writeCharacteristic → responseChannel.receive(1000ms) → delay → next) + // Command write succeeded — gate on FFE1 response if characteristic.uuid == BeaconProvisioner.DXSMART_COMMAND_CHAR { if operationMode == .readingConfig { dxReadQueryIndex += 1 DispatchQueue.main.asyncAfter(deadline: .now() + 0.4) { [weak self] in self?.dxSmartSendNextReadQuery() } - } else if awaitingDeviceInfoForProvisioning { - // Device info query was sent - wait for response on FFE1, don't process as normal command - DebugLog.shared.log("BLE: Device info query sent, waiting for response...") } else { - // Gate on FFE1 response — don't fire next command until beacon responds - // or 1s timeout elapses (some commands don't send responses) awaitingCommandResponse = true scheduleResponseGateTimeout() } @@ -1494,10 +1262,8 @@ extension BeaconProvisioner: CBPeripheralDelegate { if characteristic.uuid == BeaconProvisioner.DXSMART_NOTIFY_CHAR { dxSmartNotifySubscribed = true if operationMode == .readingConfig { - // After subscribing FFE1 in read mode → authenticate dxSmartReadAuth() } else { - // Provisioning mode → authenticate dxSmartAuthenticate() } } @@ -1513,38 +1279,26 @@ extension BeaconProvisioner: CBPeripheralDelegate { if operationMode == .readingConfig { if characteristic.uuid == BeaconProvisioner.DXSMART_NOTIFY_CHAR { - // DX-Smart response data — parse protocol frames processFFE1Response(data) } else { - // Log other characteristic updates let hex = data.map { String(format: "%02X", $0) }.joined(separator: " ") DebugLog.shared.log("BLE: Read \(characteristic.uuid): \(hex)") } } else { - // Provisioning mode + // Provisioning mode — FFE1 notification if characteristic.uuid == BeaconProvisioner.DXSMART_NOTIFY_CHAR { let hex = data.map { String(format: "%02X", $0) }.joined(separator: " ") DebugLog.shared.log("BLE: FFE1 notification: \(hex)") - // If awaiting device info for MAC address, process the response - if awaitingDeviceInfoForProvisioning { - processDeviceInfoForProvisioning(data) - } else if awaitingCommandResponse { - // Beacon responded to our command — check for rejection and advance + if awaitingCommandResponse { awaitingCommandResponse = false cancelResponseGateTimeout() - // Check for rejection: 4E 4F 00 means command rejected (matches Android check) + // Check for rejection (4E 4F 00 = command rejected) let bytes = [UInt8](data) if bytes.count >= 3 && bytes[0] == 0x4E && bytes[1] == 0x4F && bytes[2] == 0x00 { - let isNonFatal = dxSmartWriteIndex < 6 - if isNonFatal { - DebugLog.shared.log("BLE: Command \(dxSmartWriteIndex + 1) rejected by beacon (non-fatal, continuing)") - } else { - DebugLog.shared.log("BLE: Command \(dxSmartWriteIndex + 1) REJECTED by beacon") - // Don't fail here — let the advance logic handle it like Android does - // (Android logs rejection but continues for most commands) - } + let isFrame1 = dxSmartWriteIndex < 6 + DebugLog.shared.log("BLE: Command \(dxSmartWriteIndex + 1) rejected\(isFrame1 ? " (non-fatal)" : "")") } advanceToNextCommand() @@ -1552,43 +1306,4 @@ extension BeaconProvisioner: CBPeripheralDelegate { } } } - - /// Process device info response during provisioning to extract MAC address - private func processDeviceInfoForProvisioning(_ data: Data) { - responseBuffer.append(contentsOf: data) - - // Look for complete frame: 4E 4F 30 LEN DATA XOR - guard responseBuffer.count >= 5 else { return } - - // Find header - guard let headerIdx = findDXHeader() else { - responseBuffer.removeAll() - return - } - - if headerIdx > 0 { - responseBuffer.removeFirst(headerIdx) - } - - guard responseBuffer.count >= 5 else { return } - - let cmd = responseBuffer[2] - let len = Int(responseBuffer[3]) - let frameLen = 4 + len + 1 - - guard responseBuffer.count >= frameLen else { return } - - // Check if this is device info response (0x30) - if cmd == DXCmd.deviceInfo.rawValue && len >= 7 { - // Parse MAC address from bytes 1-6 (byte 0 is battery) - let macBytes = Array(responseBuffer[5..<11]) - provisioningMacAddress = macBytes.map { String(format: "%02X", $0) }.joined(separator: ":") - DebugLog.shared.log("BLE: Got MAC address for provisioning: \(provisioningMacAddress ?? "nil")") - } - - // Clear buffer and proceed to write config - responseBuffer.removeAll() - awaitingDeviceInfoForProvisioning = false - dxSmartWriteConfig() - } }