iOS quickstart

import NeurofitVitals

do {
  let status = try VitalsSDK.activate(licenseKey: Secrets.neurofitVitalsLicenseKey)
  print("Licensed to \(status.licensee), updates until \(status.updatesUntil)")
  for warning in status.warnings { print("License warning: \(warning)") }
} catch let error as VitalsError {
  // .licenseInvalid, .licenseNotValidForApp(appId:), .licenseUpdatesExpired(updatesUntil:)
  print("Activation failed: \(error.code): \(error.localizedDescription)")
} catch {
  print("Activation failed: \(error)")
}

let support = VitalsSDK.deviceSupport()
guard support.isSupported else {
  // support.reason explains why: no rear camera, no torch, or no capture format at a usable frame rate.
  return
}

switch VitalsSDK.cameraAuthorization {
case .authorized:
  break
case .notDetermined:
  let granted = await VitalsSDK.requestCameraAccess()
  guard granted else { return }
case .denied, .restricted:
  // Send the user to Settings; start() would throw .cameraDenied / .cameraRestricted.
  return
}

@MainActor
final class ReadingModel: ObservableObject {
  @Published var guidance: Guidance = .noContact
  @Published var startProgress: Double = 0
  @Published var preview: LivePreview?
  @Published var result: VitalsResult?
  @Published var failure: VitalsError?

  private var session: VitalsSession?
  private var eventTask: Task<Void, Never>?

  func begin() async {
    do {
      let session = try VitalsSession(configuration: VitalsConfiguration())
      self.session = session
      eventTask = Task { [weak self] in
        for await event in session.events {
          self?.handle(event)
        }
      }
      try await session.start()
    } catch let error as VitalsError {
      failure = error
    } catch {
      failure = .internalError(String(describing: error))
    }
  }

  private func handle(_ event: VitalsEvent) {
    switch event {
    case .guidance(let guidance, let startProgress):
      self.guidance = guidance
      self.startProgress = startProgress
    case .started:
      startProgress = 1
      preview = nil
    case .preview(let preview):
      // preview.rmssdMs is nil until about 20 s; preview.breathingRate until about 30 s.
      self.preview = preview
    case .heartbeat:
      // Optional: a light haptic per detected beat.
      break
    case .cancelled(let reason, _):
      // The session returns to positioning and re-arms by itself. Show a short note if you like.
      print("Reading restarted: \(reason.token)")
    case .reconfiguringCamera(let lowPowerMode):
      // iOS drops to a lower frame-rate tier in place. Tell the user to turn off Low Power Mode when true.
      print("Reconfiguring camera, low power mode: \(lowPowerMode)")
    case .recoverableError(let kind):
      // One automatic recovery per session; a second recoverable error fails the session.
      print("Recovering from \(kind)")
    case .measurementComplete:
      // 60 s captured; the result follows within a few seconds.
      break
    case .completed(let result):
      self.result = result
    case .failed(let error):
      failure = error
    case .state:
      // Transitions only; the measuring clock is in preview.elapsed (and session.state), not here.
      break
    }
  }

  func cancelAttempt() {
    session?.cancelReading(reason: "user_tapped_cancel")   // no-op unless measuring
  }

  func stop() {
    eventTask?.cancel()
    session?.stop()
  }
}

final class PreviewView: UIView {
  func attach(_ session: VitalsSession) {
    guard let layer = session.previewLayer else { return }
    layer.videoGravity = .resizeAspectFill
    layer.frame = bounds
    self.layer.addSublayer(layer)
  }
}

func show(_ result: VitalsResult) {
  switch result.quality {
  case .withheld:
    // Metrics may be nil. Offer a retry rather than showing numbers.
    return
  case .usable, .clean:
    break
  }
  let hr = result.heartRateBpm.map { "\(Int($0.rounded())) bpm" } ?? "n/a"
  let rmssd = result.rmssdMs.map { "\(Int($0.rounded())) ms" } ?? "n/a"
  let rr = result.breathingRateBrpm.map { String(format: "%.1f brpm", $0) } ?? "n/a"
  let rrNote = (result.breathingRateConfidence ?? 0) < 0.5 ? " (estimate)" : ""
  print("HR \(hr), HRV (RMSSD) \(rmssd), breathing \(rr)\(rrNote)")
}