Add remote sync option (#145)

Author: ps2

CGMBLEKit/TransmitterManager.swift

@@ -19,23 +19,29 @@ public struct TransmitterManagerState: RawRepresentable, Equatable {
     public var transmitterID: String
 
     public var passiveModeEnabled: Bool = true
+    
+    public var shouldSyncToRemoteService: Bool
 
-    public init(transmitterID: String) {
+    public init(transmitterID: String, shouldSyncToRemoteService: Bool = false) {
         self.transmitterID = transmitterID
+        self.shouldSyncToRemoteService = shouldSyncToRemoteService
     }
 
     public init?(rawValue: RawValue) {
         guard let transmitterID = rawValue["transmitterID"] as? String
         else {
             return nil
         }
+        
+        let shouldSyncToRemoteService = rawValue["shouldSyncToRemoteService"] as? Bool ?? false
 
-        self.init(transmitterID: transmitterID)
+        self.init(transmitterID: transmitterID, shouldSyncToRemoteService: shouldSyncToRemoteService)
     }
 
     public var rawValue: RawValue {
         return [
-            "transmitterID": transmitterID
+            "transmitterID": transmitterID,
+            "shouldSyncToRemoteService": shouldSyncToRemoteService,
         ]
     }
 }
@@ -50,14 +56,47 @@ public class TransmitterManager: TransmitterDelegate {
     private var state: TransmitterManagerState
 
     private let observers = WeakSynchronizedSet<TransmitterManagerObserver>()
+    
+    
 
     public required init(state: TransmitterManagerState) {
         self.state = state
         self.transmitter = Transmitter(id: state.transmitterID, passiveModeEnabled: state.passiveModeEnabled)
         self.shareManager = ShareClientManager()
 
         self.transmitter.delegate = self
+        
+        #if targetEnvironment(simulator)
+        setupSimulatedSampleGenerator()
+        #endif
+
+    }
+    
+    
+    #if targetEnvironment(simulator)
+    var simulatedSampleGeneratorTimer: DispatchSourceTimer?
+
+    private func setupSimulatedSampleGenerator() {
+
+        let timer = DispatchSource.makeTimerSource(queue: DispatchQueue(label: "com.loopkit.simulatedSampleGenerator"))
+        timer.schedule(deadline: .now() + .seconds(10), repeating: .minutes(5))
+        timer.setEventHandler(handler: { [weak self] in
+            self?.generateSimulatedSample()
+        })
+        self.simulatedSampleGeneratorTimer = timer
+        timer.resume()
+    }
+
+    private func generateSimulatedSample() {
+        let timestamp = Date()
+        let syncIdentifier =  "\(self.state.transmitterID) \(timestamp)"
+        let period = TimeInterval(hours: 3)
+        let glucoseValue = 100 + 20 * cos(Date().timeIntervalSinceReferenceDate.remainder(dividingBy: period) / period * Double.pi * 2)
+        let quantity = HKQuantity(unit: .milligramsPerDeciliter, doubleValue: glucoseValue)
+        let sample = NewGlucoseSample(date: timestamp, quantity: quantity, isDisplayOnly: false, syncIdentifier: syncIdentifier)
+        self.updateDelegate(with: .newData([sample]))
     }
+    #endif
 
     required convenience public init?(rawState: CGMManager.RawStateValue) {
         guard let state = TransmitterManagerState(rawValue: rawState) else {
@@ -71,7 +110,15 @@ public class TransmitterManager: TransmitterDelegate {
         return state.rawValue
     }
 
-    public let shouldSyncToRemoteService = false
+    public var shouldSyncToRemoteService: Bool {
+        get {
+            return state.shouldSyncToRemoteService
+        }
+        set {
+            self.state.shouldSyncToRemoteService = newValue
+            notifyDelegateOfStateChange()
+        }
+    }
 
     public var cgmManagerDelegate: CGMManagerDelegate? {
         get {
@@ -193,6 +240,15 @@ public class TransmitterManager: TransmitterDelegate {
 
         notifyObserversOfLatestReading()
     }
+    
+    private func notifyDelegateOfStateChange() {
+        if let manager = self as? CGMManager {
+            shareManager.delegate.notify { (delegate) in
+                delegate?.cgmManagerDidUpdateState(manager)
+            }
+        }
+    }
+
 
     // MARK: - TransmitterDelegate
 

CGMBLEKitUI/TransmitterSettingsViewController.swift

@@ -45,6 +45,7 @@ class TransmitterSettingsViewController: UITableViewController {
 
         tableView.register(SettingsTableViewCell.self, forCellReuseIdentifier: SettingsTableViewCell.className)
         tableView.register(TextButtonTableViewCell.self, forCellReuseIdentifier: TextButtonTableViewCell.className)
+        tableView.register(SwitchTableViewCell.self, forCellReuseIdentifier: SwitchTableViewCell.className)
         let button = UIBarButtonItem(barButtonSystemItem: .done, target: self, action: #selector(doneTapped(_:)))
         self.navigationItem.setRightBarButton(button, animated: false)
     }
@@ -74,6 +75,7 @@ class TransmitterSettingsViewController: UITableViewController {
 
     private enum Section: Int, CaseIterable {
         case transmitterID
+        case remoteDataSync
         case latestReading
         case latestCalibration
         case latestConnection
@@ -116,6 +118,8 @@ class TransmitterSettingsViewController: UITableViewController {
         switch Section(rawValue: section)! {
         case .transmitterID:
             return 1
+        case .remoteDataSync:
+            return 1
         case .latestReading:
             return LatestReadingRow.allCases.count
         case .latestCalibration:
@@ -169,6 +173,16 @@ class TransmitterSettingsViewController: UITableViewController {
             cell.detailTextLabel?.text = cgmManager.transmitter.ID
 
             return cell
+        case .remoteDataSync:
+            let switchCell = tableView.dequeueReusableCell(withIdentifier: SwitchTableViewCell.className, for: indexPath) as! SwitchTableViewCell
+
+            switchCell.selectionStyle = .none
+            switchCell.switch?.isOn = cgmManager.shouldSyncToRemoteService
+            switchCell.textLabel?.text = NSLocalizedString("Upload Readings", comment: "The title text for the upload glucose switch cell")
+
+            switchCell.switch?.addTarget(self, action: #selector(uploadEnabledChanged(_:)), for: .valueChanged)
+
+            return switchCell
         case .latestReading:
             let cell = tableView.dequeueReusableCell(withIdentifier: SettingsTableViewCell.className, for: indexPath) as! SettingsTableViewCell
             let glucose = cgmManager.latestReading
@@ -283,6 +297,8 @@ class TransmitterSettingsViewController: UITableViewController {
         switch Section(rawValue: section)! {
         case .transmitterID:
             return nil
+        case .remoteDataSync:
+            return LocalizedString("Remote Data Synchronization", comment: "Section title for remote data synchronization")
         case .latestReading:
             return LocalizedString("Latest Reading", comment: "Section title for latest glucose reading")
         case .latestCalibration:
@@ -302,6 +318,8 @@ class TransmitterSettingsViewController: UITableViewController {
         switch Section(rawValue: indexPath.section)! {
         case .transmitterID:
             return false
+        case .remoteDataSync:
+            return false
         case .latestReading:
             return false
         case .latestCalibration:
@@ -329,6 +347,8 @@ class TransmitterSettingsViewController: UITableViewController {
         switch Section(rawValue: indexPath.section)! {
         case .transmitterID:
             break
+        case .remoteDataSync:
+            break
         case .latestReading:
             break
         case .latestCalibration:
@@ -373,6 +393,8 @@ class TransmitterSettingsViewController: UITableViewController {
         switch Section(rawValue: indexPath.section)! {
         case .transmitterID:
             break
+        case .remoteDataSync:
+            break
         case .latestReading:
             break
         case .latestCalibration:
@@ -394,6 +416,10 @@ class TransmitterSettingsViewController: UITableViewController {
 
         return indexPath
     }
+    
+    @objc private func uploadEnabledChanged(_ sender: UISwitch) {
+        cgmManager.shouldSyncToRemoteService = sender.isOn
+    }
 }