Merge remote-tracking branch 'ivalkou/dev-ivan' into dev-spike-microbolus-dt

* ivalkou/dev-ivan: (37 commits)
  MB with COB and without COB work independently
  revert notification names
  Cartfile.resolved
  Notification names changed in LoopKit (LoopKit#1165)
  Add ability to define a lower limit before performing the bolus (LoopKit#4)
  Fix texts
  Safe Mode refactored
  nonlinear-carb-model
  Revert "Carb Absorption Model UI"
  Carb Absorption Model UI
  Microboluses Safe Mode
  Add 15 min control clucose chek
  Fix MB without COM
  Bump version
  Microbolus screen (LoopKit#3)
  build version changed
  disable Microboluses if closed loop disabled
  misprint fixed
  little refactor
  fix 0 bolus bug
  ...

# Conflicts:
#	Cartfile
#	Loop.xcodeproj/project.pbxproj
#	Loop/Managers/CGMManager.swift

Author: dthornley

Cartfile

@@ -1,8 +1,9 @@
-github "LoopKit/LoopKit" "dev"
+github "dm61/LoopKit" "nonlinear-carb-model"
 github "LoopKit/CGMBLEKit" "dev"
 github "i-schuetz/SwiftCharts" == 0.6.5
 github "LoopKit/dexcom-share-client-swift" "dev"
 github "LoopKit/G4ShareSpy" "dev"
 github "ps2/rileylink_ios" "dev"
 github "LoopKit/Amplitude-iOS" "decreepify"
 github "dthornley/spike-client-swift-195" "dev-workspace"
+github "ivalkou/NightscoutAPIClient" "master"

Common/Models/WatchContext.swift

@@ -31,6 +31,7 @@ final class WatchContext: RawRepresentable {
     var lastNetTempBasalDose: Double?
     var lastNetTempBasalDate: Date?
     var recommendedBolusDose: Double?
+    var doNotOpenBolusScreenWithMicroboluses: Bool?
 
     var cob: Double?
     var iob: Double?
@@ -68,6 +69,7 @@ final class WatchContext: RawRepresentable {
         lastNetTempBasalDate = rawValue["bad"] as? Date
         recommendedBolusDose = rawValue["rbo"] as? Double
         cob = rawValue["cob"] as? Double
+        doNotOpenBolusScreenWithMicroboluses = rawValue["mb"] as? Bool
 
         cgmManagerState = rawValue["cgmManagerState"] as? CGMManager.RawStateValue
 
@@ -100,6 +102,7 @@ final class WatchContext: RawRepresentable {
         raw["r"] = reservoir
         raw["rbo"] = recommendedBolusDose
         raw["rp"] = reservoirPercentage
+        raw["mb"] = doNotOpenBolusScreenWithMicroboluses
 
         raw["pg"] = predictedGlucose?.rawValue
 

Loop.xcconfig

@@ -11,7 +11,7 @@
 MAIN_APP_BUNDLE_IDENTIFIER = com.${DEVELOPMENT_TEAM}.loopkit
 MAIN_APP_DISPLAY_NAME = Loop
 
-LOOP_MARKETING_VERSION = 1.10.1
+LOOP_MARKETING_VERSION = 1.10.1-microboluses
 
 APPICON_NAME = AppIcon
 

Loop.xcodeproj/project.pbxproj

@@ -37,6 +37,7 @@
 	<false/>
 	<key>LSApplicationQueriesSchemes</key>
 	<array>
+		<string>spikeapp</string>
 		<string>dexcomg6</string>
 		<string>dexcomcgm</string>
 		<string>dexcomshare</string>
@@ -92,6 +93,11 @@
 		<string>UIInterfaceOrientationLandscapeRight</string>
 		<string>UIInterfaceOrientationPortraitUpsideDown</string>
 	</array>
+	<key>NSAppTransportSecurity</key>
+	<dict>
+		<key>NSAllowsArbitraryLoads</key>
+		<true/>
+	</dict>
 	<key>UISupportedInterfaceOrientations~ipad</key>
 	<array>
 		<string>UIInterfaceOrientationPortrait</string>

Loop/Info.plist

@@ -11,13 +11,15 @@ import G4ShareSpy
 import ShareClient
 import MockKit
 import SpikeClient
+import NightscoutAPIClient
 
 
 let allCGMManagers: [CGMManager.Type] = [
     G6CGMManager.self,
     G5CGMManager.self,
     G4CGMManager.self,
     ShareClientManager.self,
+    NightscoutAPIManager.self,
     MockCGMManager.self,
     SpikeClientManager.self,
 ]

Loop/Managers/CGMManager.swift

@@ -672,6 +672,13 @@ extension DeviceDataManager: LoopDataManagerDelegate {
             }
         )
     }
+
+    func loopDataManager(_ manager: LoopDataManager, didRecommendMicroBolus bolus: (amount: Double, date: Date), completion: @escaping (_ error: Error?) -> Void) -> Void {
+        enactBolus(
+            units: bolus.amount,
+            at: bolus.date,
+            completion: completion)
+    }
 }
 
 

Loop/Managers/DeviceDataManager.swift

@@ -10,6 +10,7 @@ import Foundation
 import HealthKit
 import LoopKit
 import LoopCore
+import Combine
 
 
 final class LoopDataManager {
@@ -33,6 +34,8 @@ final class LoopDataManager {
 
     private let logger: CategoryLogger
 
+    private var loopSubscription: AnyCancellable?
+
     // References to registered notification center observers
     private var notificationObservers: [Any] = []
 
@@ -68,7 +71,8 @@ final class LoopDataManager {
             defaultAbsorptionTimes: LoopSettings.defaultCarbAbsorptionTimes,
             carbRatioSchedule: carbRatioSchedule,
             insulinSensitivitySchedule: insulinSensitivitySchedule,
-            overrideHistory: overrideHistory
+            overrideHistory: overrideHistory,
+            carbAbsorptionModel: .adaptiveRateNonlinear
         )
 
         doseStore = DoseStore(
@@ -636,41 +640,75 @@ extension LoopDataManager {
     /// Executes an analysis of the current data, and recommends an adjustment to the current
     /// temporary basal rate.
     func loop() {
-        self.dataAccessQueue.async {
-            self.logger.default("Loop running")
-            NotificationCenter.default.post(name: .LoopRunning, object: self)
+        let updatePublisher = Deferred {
+            Future<(), Error> { promise in
+                do {
+                    try self.update()
+                    promise(.success(()))
+                } catch let error {
+                    promise(.failure(error))
+                }
+            }
+        }
+        .subscribe(on: dataAccessQueue)
+        .eraseToAnyPublisher()
 
-            self.lastLoopError = nil
-            let startDate = Date()
+        let enactBolusPublisher = Deferred {
+            Future<Bool, Error> { promise in
+                self.calculateAndEnactMicroBolusIfNeeded { enacted, error in
+                    if let error = error {
+                        promise(.failure(error))
+                    }
+                    promise(.success(enacted))
+                }
+            }
+        }
+        .subscribe(on: dataAccessQueue)
+        .eraseToAnyPublisher()
 
-            do {
-                try self.update()
+        let setBasalPublisher = Deferred {
+            Future<(), Error> { promise in
+                guard self.settings.dosingEnabled else {
+                    return promise(.success(()))
+                }
 
-                if self.settings.dosingEnabled {
-                    self.setRecommendedTempBasal { (error) -> Void in
-                        self.lastLoopError = error
-
-                        if let error = error {
-                            self.logger.error(error)
-                        } else {
-                            self.loopDidComplete(date: Date(), duration: -startDate.timeIntervalSinceNow)
-                        }
-                        self.logger.default("Loop ended")
-                        self.notify(forChange: .tempBasal)
+                self.setRecommendedTempBasal { error in
+                    if let error = error {
+                        promise(.failure(error))
                     }
-
-                    // Delay the notification until we know the result of the temp basal
-                    return
-                } else {
-                    self.loopDidComplete(date: Date(), duration: -startDate.timeIntervalSinceNow)
+                    promise(.success(()))
                 }
-            } catch let error {
-                self.lastLoopError = error
-            }
 
-            self.logger.default("Loop ended")
-            self.notify(forChange: .tempBasal)
+            }
         }
+        .subscribe(on: dataAccessQueue)
+        .eraseToAnyPublisher()
+
+        logger.default("Loop running")
+        NotificationCenter.default.post(name: .LoopRunning, object: self)
+
+        loopSubscription?.cancel()
+
+        let startDate = Date()
+        loopSubscription = updatePublisher
+            .flatMap { _ in setBasalPublisher }
+            .flatMap { _ in enactBolusPublisher }
+            .receive(on: dataAccessQueue)
+        .sink(
+            receiveCompletion: { completion in
+                switch completion {
+                case .finished:
+                    self.lastLoopError = nil
+                    self.loopDidComplete(date: Date(), duration: -startDate.timeIntervalSinceNow)
+                case let .failure(error):
+                    self.lastLoopError = error
+                    self.logger.error(error)
+                }
+                self.logger.default("Loop ended")
+                self.notify(forChange: .tempBasal)
+        },
+            receiveValue: { _ in }
+        )
     }
 
     /// - Throws:
@@ -1030,6 +1068,120 @@ extension LoopDataManager {
         self.logger.debug("Recommending bolus: \(String(describing: recommendedBolus))")
     }
 
+    /// *This method should only be called from the `dataAccessQueue`*
+    private func calculateAndEnactMicroBolusIfNeeded(_ completion: @escaping (_ enacted: Bool, _ error: Error?) -> Void) {
+        dispatchPrecondition(condition: .onQueue(dataAccessQueue))
+
+        guard settings.dosingEnabled else {
+            logger.debug("Closed loop disabled. Cancel microbolus calculation.")
+            completion(false, nil)
+            return
+        }
+
+        let cob = carbsOnBoard?.quantity.doubleValue(for: .gram()) ?? 0
+        let cobChek = (cob > 0 && settings.microbolusesEnabled) || (cob == 0 && settings.microbolusesWithoutCarbsEnabled)
+
+        guard cobChek else {
+            logger.debug("Microboluses disabled.")
+            completion(false, nil)
+            return
+        }
+
+        let startDate = Date()
+
+        guard let recommendedBolus = recommendedBolus else {
+            logger.debug("No recommended bolus. Cancel microbolus calculation.")
+            completion(false, nil)
+            return
+        }
+
+        guard abs(recommendedBolus.date.timeIntervalSinceNow) < TimeInterval(minutes: 5) else {
+            completion(false, LoopError.recommendationExpired(date: recommendedBolus.date))
+            return
+        }
+
+        guard let currentBasalRate = basalRateScheduleApplyingOverrideHistory?.value(at: startDate) else {
+            logger.debug("Basal rates not configured. Cancel microbolus calculation.")
+            completion(false, nil)
+            return
+        }
+
+        let insulinReq = recommendedBolus.recommendation.amount
+        guard insulinReq > 0 else {
+            logger.debug("No microbolus needed.")
+            completion(false, nil)
+            return
+        }
+
+        guard let glucose = self.glucoseStore.latestGlucose, let predictedGlucose = predictedGlucose else {
+            logger.debug("Glucose data not found.")
+            completion(false, nil)
+            return
+        }
+
+        let controlDate = glucose.startDate.addingTimeInterval(.minutes(15 + 1)) // extra 1 min to find
+        var controlGlucoseQuantity: HKQuantity?
+
+        for prediction in predictedGlucose {
+            if prediction.startDate <= controlDate {
+                controlGlucoseQuantity = prediction.quantity
+                continue
+            }
+            break
+        }
+
+        let lowTrend = controlGlucoseQuantity.map { $0 < glucose.quantity } ?? true
+
+        let safetyCheck = !(lowTrend && settings.microbolusesSafeMode == .enabled)
+        guard safetyCheck else {
+            logger.debug("Control glucose is lower then current. Microbolus is not allowed.")
+            completion(false, nil)
+            return
+        }
+
+        let maxBasalMinutes: Double = {
+            switch (cob > 0, lowTrend, settings.microbolusesSafeMode == .disabled) {
+            case (true, false, _), (true, true, true):
+                return settings.microbolusesSize
+            case (false, false, _), (false, true, true):
+                return settings.microbolusesWithoutCarbsSize
+            default:
+                return 30
+            }
+        }()
+
+        let maxMicroBolus = currentBasalRate * maxBasalMinutes / 60
+
+        let volumeRounder = { (_ units: Double) in
+            self.delegate?.loopDataManager(self, roundBolusVolume: units) ?? units
+        }
+
+        let microBolus = volumeRounder(min(insulinReq / 2, maxMicroBolus))
+        guard microBolus > 0 else {
+            logger.debug("No microbolus needed.")
+            completion(false, nil)
+            return
+        }
+        guard microBolus >= settings.microbolusesMinimumBolusSize else {
+            logger.debug("Microbolus will not be enacted due to it being lower than the configured minimum bolus size. (\(String(describing: microBolus)) vs \(String(describing: settings.microbolusesMinimumBolusSize)))")
+            completion(false, nil)
+            return
+        }
+
+        let recommendation = (amount: microBolus, date: startDate)
+        logger.debug("Enact microbolus: \(String(describing: microBolus))")
+
+        self.delegate?.loopDataManager(self, didRecommendMicroBolus: recommendation) { [weak self] error in
+            if let error = error {
+                self?.logger.debug("Microbolus failed: \(error.localizedDescription)")
+                completion(false, error)
+            } else {
+                self?.logger.debug("Microbolus enacted")
+                completion(true, nil)
+            }
+        }
+    }
+
     /// *This method should only be called from the `dataAccessQueue`*
     private func setRecommendedTempBasal(_ completion: @escaping (_ error: Error?) -> Void) {
         dispatchPrecondition(condition: .onQueue(dataAccessQueue))
@@ -1302,6 +1454,14 @@ protocol LoopDataManagerDelegate: class {
     ///   - units: The recommended bolus in U
     /// - Returns: a supported bolus volume in U. The volume returned should not be larger than the passed in rate.
     func loopDataManager(_ manager: LoopDataManager, roundBolusVolume units: Double) -> Double
+
+    /// Informs the delegate that a micro bolus is recommended
+    ///
+    /// - Parameters:
+    ///   - manager: The manager
+    ///   - bolus: The new recommended micro bolus
+    ///   - completion: A closure called once on completion
+    func loopDataManager(_ manager: LoopDataManager, didRecommendMicroBolus bolus: (amount: Double, date: Date), completion: @escaping (_ error: Error?) -> Void) -> Void
 }
 
 private extension TemporaryScheduleOverride {

Loop/Managers/LoopDataManager.swift

@@ -155,6 +155,9 @@ final class WatchDataManager: NSObject {
             context.recommendedBolusDose = state.recommendedBolus?.recommendation.amount
             context.cob = state.carbsOnBoard?.quantity.doubleValue(for: HKUnit.gram())
             context.glucoseTrendRawValue = self.deviceManager.sensorState?.trendType?.rawValue
+            context.doNotOpenBolusScreenWithMicroboluses = loopManager.settings.dosingEnabled
+                && loopManager.settings.microbolusesEnabled
+                && !loopManager.settings.microbolusesOpenBolusScreen
 
             context.cgmManagerState = self.deviceManager.cgmManager?.rawValue
 

Loop/Managers/WatchDataManager.swift

@@ -0,0 +1,25 @@
+//
+//  MicrobolusViewController.swift
+//  Loop
+//
+//  Created by Ivan Valkou on 01.11.2019.
+//  Copyright © 2019 LoopKit Authors. All rights reserved.
+//
+
+import SwiftUI
+
+final class MicrobolusViewController: UIHostingController<MicrobolusView> {
+    init(viewModel: MicrobolusView.ViewModel) {
+        super.init(rootView: MicrobolusView(viewModel: viewModel))
+    }
+
+    @objc required dynamic init?(coder aDecoder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+
+    var onDeinit: (() -> Void)?
+
+    deinit {
+        onDeinit?()
+    }
+}