Bugfixes and interface improvements

Author: liamcharger

InfiniLink.xcodeproj/project.pbxproj

@@ -338,13 +338,13 @@
 			path = InfiniLinkUITests;
 			sourceTree = "<group>";
 		};
-		E02C62102CD05D8E00C4D19B /* Software Update */ = {
+		E02C62102CD05D8E00C4D19B /* Update */ = {
 			isa = PBXGroup;
 			children = (
 				E0A7C08A2CB1E4CC0042A12D /* SoftwareUpdateView.swift */,
 				E02C62112CD05DA900C4D19B /* CurrentUpdateView.swift */,
 			);
-			path = "Software Update";
+			path = Update;
 			sourceTree = "<group>";
 		};
 		E03C30B32CC7030A00DD8363 /* Notifications */ = {
@@ -509,7 +509,7 @@
 		E0A7C0892CB1E4BF0042A12D /* General */ = {
 			isa = PBXGroup;
 			children = (
-				E02C62102CD05D8E00C4D19B /* Software Update */,
+				E02C62102CD05D8E00C4D19B /* Update */,
 				E0599A052CB4C75500D64E0B /* Filesystem */,
 				E05999B62CB2FC6400D64E0B /* About */,
 				E0A7C0872CB1BBE70042A12D /* GeneralSettingsView.swift */,

InfiniLink/BLE/BLECharacteristicHandler.swift

@@ -78,14 +78,12 @@ struct BLECharacteristicHandler {
             BLEWriteManager().setTime(characteristic: characteristic)
         case bleManager.cbuuidList.weather:
             bleManager.weatherCharacteristic = characteristic
-            
         case bleManager.cbuuidList.dfuControlPoint:
             bleManager.dfuControlPointCharacteristic = characteristic
             peripheral.setNotifyValue(true, for: characteristic)
         case bleManager.cbuuidList.dfuPacket:
             bleManager.dfuPacketCharacteristic = characteristic
             peripheral.setNotifyValue(true, for: characteristic)
-            
         case bleManager.cbuuidList.navigationFlags:
             bleManager.navigationFlagsCharacteristic = characteristic
         case bleManager.cbuuidList.navigationNarrative:

InfiniLink/BLE/BLEManager.swift

@@ -144,7 +144,7 @@ class BLEManager: NSObject, ObservableObject, CBCentralManagerDelegate, CBPeriph
 
             if let peripheral = peripherals.first, !isConnectedToPinetime {
                 // FIXME: should we add a check to confirm the watch is already not connected to the system (state != .connected), or let it pair this way?
-                connect(peripheral: peripheral) {}
+                connect(peripheral: peripheral)
             } else {
                 scanForNewDevices()
             }
@@ -161,20 +161,19 @@ class BLEManager: NSObject, ObservableObject, CBCentralManagerDelegate, CBPeriph
     func connect(peripheral: CBPeripheral, completion: (() -> Void)? = nil) {
         guard isBluetoothOn else { return }
 
-        if peripheral.name == "InfiniTime" {
-            isConnecting = true
-            peripheralToConnect = peripheral
-            central.connect(peripheralToConnect, options: nil)
-            
-            completion?()
-        }
+        isConnecting = true
+        peripheralToConnect = peripheral
+        central.connect(peripheralToConnect, options: nil)
+        
+        completion?()
     }
 
-    func onConnect() {
+    func onConnect(_ peripheral: CBPeripheral) {
         stopScanning()
 
+//        downloadManager.clearUpdate()
+        
         isConnecting = false
-        downloadManager.updateAvailable = false
         pairedDeviceID = peripheralToConnect.identifier.uuidString
         pairedDevice = deviceManager.fetchDevice(with: peripheralToConnect.identifier.uuidString)
         hasDisconnectedForUpdate = false
@@ -183,11 +182,14 @@ class BLEManager: NSObject, ObservableObject, CBCentralManagerDelegate, CBPeriph
         infiniTime?.delegate = self
         infiniTime.discoverServices(nil)
         isConnectedToPinetime = true
+        peripheralToConnect = nil // We're done using this, so set it to nil
 
         log("Connected to \(pairedDevice?.name ?? "InfiniTime")", type: .info, caller: "BLEManager", target: .ble)
     }
 
     func unpair(device: Device? = nil) {
+        // We need to disconnect first because BLE updateInfo methods will be called when Core Data doesn't have an object to update
+        disconnect()
         // Delete the device object we have said for this watch
         deviceManager.removeDevice(device ?? pairedDevice!)
         // FIXME: Better way to do this? We have to give core data some time to update
@@ -204,7 +206,6 @@ class BLEManager: NSObject, ObservableObject, CBCentralManagerDelegate, CBPeriph
                     pairedDeviceID = nil
                     // This only disconnects and removes the watch from the recognized device list in the app. If using secure pairing, iOS will still keep the bond
                     // and we have no way to remove it
-                    disconnect()
                     startScanning()
                 }
 
@@ -233,7 +234,6 @@ class BLEManager: NSObject, ObservableObject, CBCentralManagerDelegate, CBPeriph
         // We just switched devices, update the UI
         self.pairedDeviceID = device.uuid
         self.pairedDevice = deviceManager.fetchDevice()
-        self.deviceManager.getSettings()
 
         self.disconnect()
         self.startScanning()
@@ -276,7 +276,7 @@ class BLEManager: NSObject, ObservableObject, CBCentralManagerDelegate, CBPeriph
 
     func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeripheral) {
         // The connection was successfully, update state vars and start service discovery
-        onConnect()
+        onConnect(peripheral)
     }
 
     func centralManager(_ central: CBCentralManager, didDisconnectPeripheral peripheral: CBPeripheral, error: Error?) {

InfiniLink/BLE/DeviceManager.swift

@@ -9,18 +9,17 @@ import SwiftUI
 import CoreData
 import CoreBluetooth
 
+struct CharacteristicIdentifier {
+    static let modelNumber = CBUUID(string: "2A24")
+    static let serial = CBUUID(string: "2A25")
+    static let firmware = CBUUID(string: "2A26")
+    static let hardwareRevision = CBUUID(string: "2A27")
+    static let softwareRevision = CBUUID(string: "2A28")
+    static let manufacturer = CBUUID(string: "2A29")
+    static let blefsVersion = CBUUID(string: "adaf0100-4669-6c65-5472-616e73666572")
+}
+
 class DeviceManager: ObservableObject {
-    struct cbuuid {
-        let modelNumber = CBUUID(string: "2A24")
-        let serial = CBUUID(string: "2A25")
-        let firmware = CBUUID(string: "2A26")
-        let hardwareRevision = CBUUID(string: "2A27")
-        let softwareRevision = CBUUID(string: "2A28")
-        let manufacturer = CBUUID(string: "2A29")
-        let blefsVersion = CBUUID(string: "adaf0100-4669-6c65-5472-616e73666572")
-    }
-    let cbuuids = cbuuid()
-    
     let persistenceController = PersistenceController.shared
     let bleManager = BLEManager.shared
 
@@ -61,9 +60,9 @@ class DeviceManager: ObservableObject {
     @Published var settings = Settings()
     @Published var watches = [Device]()
 
-    // Get persisted settings, before settings.dat has loaded
-    func getSettings() {
-        guard let device = bleManager.pairedDevice else { return }
+    // Update persisted settings, before settings.dat has loaded
+    func setSettings(_ device: Device? = nil) {
+        let device = device ?? fetchDevice()!
 
         DispatchQueue.main.async {
             self.settings = Settings(
@@ -88,19 +87,20 @@ class DeviceManager: ObservableObject {
     func fetchDevice(with uuid: String? = nil) -> Device? {
         guard let id = uuid ?? bleManager.pairedDeviceID else { return nil }
 
+        let context = persistenceController.container.viewContext
         let fetchRequest: NSFetchRequest<Device> = Device.fetchRequest()
         fetchRequest.predicate = NSPredicate(format: "uuid == %@", id)
 
         do {
-            let existingDevices = try persistenceController.container.viewContext.fetch(fetchRequest)
+            let existingDevices = try context.fetch(fetchRequest)
 
             // There's already a paired watch
             if let existingDevice = existingDevices.first {
+                setSettings(existingDevice)
                 return existingDevice
             }
 
             // There's not already a paired watch, create a new object to save
-            let context = persistenceController.container.newBackgroundContext()
             let newDevice = Device(context: context)
             context.perform {
                 newDevice.uuid = id
@@ -120,6 +120,8 @@ class DeviceManager: ObservableObject {
                 }
             }
 
+            setSettings(newDevice)
+            
             return newDevice
         } catch {
             log("Error fetching or saving device: \(error)", caller: "DeviceManager")
@@ -133,7 +135,7 @@ class DeviceManager: ObservableObject {
         let context = persistenceController.container.viewContext
 
         // MARK: - Crash
-        // Crashes happening when creating watch face objects from the viewContext
+        // Crashes occasionally happening when creating watch face objects from the viewContext
         context.perform {
             device.brightLevel = Int16(settings.brightLevel.rawValue)
             device.chimesOption = Int16(settings.chimesOption.rawValue)
@@ -164,12 +166,13 @@ class DeviceManager: ObservableObject {
                 log("Error saving settings: \(error.localizedDescription)", caller: "DeviceManager - updateSettings")
             }
         }
-        getSettings()
+        
+        // We've gotten the settings from the watch, now set our variables
+        setSettings(device)
     }
 
-    func updateName(name: String, for device: Device) {
-        guard let uuid = device.uuid else { return }
-        guard let device = fetchDevice(with: uuid) else { return }
+    func updateName(name: String, for id: String) {
+        guard let device = fetchDevice(with: id) else { return }
 
         device.name = name
 
@@ -196,49 +199,63 @@ class DeviceManager: ObservableObject {
     func fetchAllDevices() {
         let fetchRequest: NSFetchRequest<Device> = Device.fetchRequest()
 
-        do {
-            self.watches = try self.persistenceController.container.viewContext.fetch(fetchRequest)
-        } catch {
-            log("Error fetching devices: \(error.localizedDescription)", caller: "DeviceManager")
+        DispatchQueue.main.async {
+            do {
+                self.watches = try self.persistenceController.container.viewContext.fetch(fetchRequest)
+            } catch {
+                log("Error fetching devices: \(error.localizedDescription)", caller: "DeviceManager")
+            }
         }
     }
 }
 
 extension DeviceManager {
     func updateInfo(characteristic: CBCharacteristic) {
         guard let value = characteristic.value else { return }
-        guard bleManager.pairedDevice != nil else { return }
-        
-        bleManager.pairedDevice.bleUUID = characteristic.uuid.uuidString
-        
-        switch characteristic.uuid {
-        case cbuuids.modelNumber:
-            bleManager.pairedDevice.modelNumber = String(data: value, encoding: .utf8) ?? ""
-        case cbuuids.serial:
-            bleManager.pairedDevice.serial = String(data: value, encoding: .utf8) ?? ""
-        case cbuuids.firmware:
-            bleManager.pairedDevice.firmware = String(data: value, encoding: .utf8) ?? ""
-        case cbuuids.hardwareRevision:
-            bleManager.pairedDevice.hardwareRevision = String(data: value, encoding: .utf8) ?? ""
-        case cbuuids.softwareRevision:
-            bleManager.pairedDevice.softwareRevision = String(data: value, encoding: .utf8) ?? ""
-        case cbuuids.manufacturer:
-            bleManager.pairedDevice.manufacturer = String(data: value, encoding: .utf8) ?? ""
-        case cbuuids.blefsVersion:
-            let byteArray = [UInt8](value)
-            if byteArray.count >= 2 {
-                bleManager.pairedDevice.blefsVersion = "\(Int(byteArray[1]))\(Int(byteArray[0]))"
-            } else {
-                bleManager.pairedDevice.blefsVersion = "00" // or some fallback
+        guard let objectID = bleManager.pairedDevice?.objectID else { return }
+
+        let context = persistenceController.container.viewContext
+
+        context.perform {
+            do {
+                guard let device = try context.existingObject(with: objectID) as? Device else { return }
+                
+                device.bleUUID = characteristic.uuid.uuidString
+
+                switch characteristic.uuid {
+                case CharacteristicIdentifier.modelNumber:
+                    device.modelNumber = String(data: value, encoding: .utf8) ?? ""
+                case CharacteristicIdentifier.serial:
+                    device.serial = String(data: value, encoding: .utf8) ?? ""
+                case CharacteristicIdentifier.firmware:
+                    device.firmware = String(data: value, encoding: .utf8) ?? ""
+                case CharacteristicIdentifier.hardwareRevision:
+                    device.hardwareRevision = String(data: value, encoding: .utf8) ?? ""
+                case CharacteristicIdentifier.softwareRevision:
+                    device.softwareRevision = String(data: value, encoding: .utf8) ?? ""
+                case CharacteristicIdentifier.manufacturer:
+                    device.manufacturer = String(data: value, encoding: .utf8) ?? ""
+                case CharacteristicIdentifier.blefsVersion:
+                    let byteArray = [UInt8](value)
+                    if byteArray.count >= 2 {
+                        device.blefsVersion = "\(Int(byteArray[1]))\(Int(byteArray[0]))"
+                    } else {
+                        device.blefsVersion = "00"
+                    }
+                default:
+                    break
+                }
+
+                try context.save()
+            } catch {
+                log("Failed to update paired device: \(error)", caller: "DeviceManager", target: .ble)
             }
-        default:
-            break
         }
     }
 
     func readInfoCharacteristics(characteristic: CBCharacteristic, peripheral: CBPeripheral) {
         switch characteristic.uuid {
-        case cbuuids.modelNumber, cbuuids.serial, cbuuids.firmware, cbuuids.hardwareRevision, cbuuids.softwareRevision, cbuuids.manufacturer, cbuuids.blefsVersion: peripheral.readValue(for: characteristic)
+        case CharacteristicIdentifier.modelNumber, CharacteristicIdentifier.serial, CharacteristicIdentifier.firmware, CharacteristicIdentifier.hardwareRevision, CharacteristicIdentifier.softwareRevision, CharacteristicIdentifier.manufacturer, CharacteristicIdentifier.blefsVersion: peripheral.readValue(for: characteristic)
         default:
             break
         }

InfiniLink/ContentView.swift

@@ -9,26 +9,14 @@ import SwiftUI
 import EventKit
 
 struct ContentView: View {
-    @ObservedObject var bleManager = BLEManager.shared
-    @ObservedObject var remindersManager = RemindersManager.shared
-    @ObservedObject var personalizationController = PersonalizationController.shared
-    @ObservedObject var notificationManager = NotificationManager.shared
+    @ObservedObject private var bleManager = BLEManager.shared
 
-    @AppStorage("pairedDeviceID") var pairedDeviceID: String?
+    @AppStorage("pairedDeviceID") private var pairedDeviceID: String?
 
     var body: some View {
         Group {
             if pairedDeviceID != nil {
                 DeviceView()
-                    .onChange(of: bleManager.weatherCharacteristic) { _ in
-                        WeatherController.shared.fetchWeatherData()
-                    }
-                    .onChange(of: bleManager.batteryLevel) { bat in
-                        notificationManager.checkToSendLowBatteryNotification()
-                    }
-                    .sheet(isPresented: $personalizationController.showSetupSheet) {
-                        SetUpDetailsView()
-                    }
             } else {
                 WelcomeView()
             }

InfiniLink/Core/Components/WatchFaceView.swift

@@ -16,12 +16,11 @@ struct WatchFaceView: View {
 
     let date = Date()
 
-    @Binding var watchface: UInt8?
-    
+    let watchface: UInt8?
     let device: Device?
 
-    init(watchface: Binding<UInt8?>, device: Device? = nil) {
-        self._watchface = watchface
+    init(watchface: UInt8? = nil, device: Device? = nil) {
+        self.watchface = watchface
         self.device = device
     }