Create manager

Asleep.createSleepTrackingManager()

var config: Asleep.Config?
let delegate: AsleepSleepTrackingManagerDelegate = self
var manager: Asleep.SleepTrackingManager?

if let config {
    manager = Asleep.createSleepTrackingManager(config: config,
                                                delegate: delegate)
}

AsleepSleepTrackingManagerDelegate

protocol AsleepSleepTrackingManagerDelegate {
    func didCreate()
    func didUpload(sequence: Int)
    func didClose(sessionId: String)
    func didFail(error: Asleep.AsleepError)
    func didInterrupt()
    func didResume()
    func micPermissionWasDenied()
    func analysing(session: Asleep.Model.Session)
}

1. didCreate()
   Tracking is generated.

2. didUpload()
   Data is uploaded.

   Property Name	Type	Description
   sequence	Int	A value that starts from 0 and increases by 1 every 30 seconds

3. didClose()
   Tracking is terminated.

   Property Name	Type	Description
   sessionId	String	Report result id value

4. didFail()
   Due to error, tracking is ended

   Property Name	Type	Description
   error	Asleep.AsleepError	Error Codes

5. didInterrupt()
   Tracking is interrupted due to events such as calls.

6. didResume()
   Tracking resumes once the interrupting factor is resolved.

7. micPermissionWasDenied()
   Tracking cannot be started without microphone permission.

8. analysing()
   Latest session data

   Property Name	Type	Description
   session	Asleep.Model.Session	during analysis, tracking session information

AsleepCompletableTrackingDelegate

var config: Asleep.Config?
let delegate: AsleepCompletableTrackingDelegate = self
let recordingPath: URL?                 
let recordingType: Asleep.RecordingType
var manager: Asleep.SleepTrackingManager?

if let config {
    manager = Asleep.createSleepTrackingManager(config: config,
                                                delegate: delegate,
                                                recordingPath: recordingPath,
                                                recordingType: recordingType)
}

It inherits the existing AsleepSleepTrackingManagerDelegate and adds two methods.

protocol AsleepCompletableTrackingDelegate: AsleepSleepTrackingManagerDelegate {
    func didCreate(sessionId: String)
    func didComplete(session: Asleep.Model.Session)
}

• didCreate(sessionId:) — Called with the session id once the session is created. It is called instead of the existing didCreate(), so you do not need to implement didCreate().
  • sessionId: Generated session id
• didComplete(session:) — Called when the server analysis is finished after tracking is terminated and the result is ready to be retrieved.
  • session: The session whose analysis is complete. You can display the result right away with sleepStages and so on, and call Reports.report(sessionId:) if you also need the statistics (stat).

The other methods (didUpload, didClose, didFail, didInterrupt, didResume, micPermissionWasDenied, analysing) are the same as before.

From termination to analysis completion

When stopTracking() is called, the SDK closes the session first and then checks periodically whether the analysis is finished.

stopTracking()
  │
  ├ ① Session close request
  │     Success → didClose(sessionId:)
  │
  ├ ② Analysis completion check (every 3 seconds · up to 10 times, about 30 seconds)
  │
  ├ ③-a Analysis complete → didComplete(session:)
  │
  └ ③-b Not finished within 30 seconds → didFail(error: .completeTimeout)

Saving recording files (optional)

If you set recordingPath, the audio is temporarily saved in 30-second units during tracking, and once the analysis is complete, only the snoring and unstable-breathing segment files selected based on the analysis result are kept in {recordingPath}/audio/{sessionId}/.

Asleep.RecordingType

enum RecordingType {
    case all          // Snoring + unstable breathing (default)
    case snoringOnly  // Snoring segments only
    case breathOnly   // Unstable-breathing segments only
}

• recordingType does not turn on recordings for metrics that your plan does not provide. It is used to narrow the type within the scope of your plan.
• If the analysis completion is not received (completeTimeout), .all keeps every file saved during tracking without selecting any, and .snoringOnly / .breathOnly keep nothing.
• Sessions whose analysis result cannot be used, such as when the tracking time is too short, do not keep recording files.

Asleep.createRecordingFileManager()

Retrieves or deletes the saved recording files. You must pass the same recordingPath that was passed to createSleepTrackingManager. If you pass a different path, the result is empty.

let fileManager = Asleep.createRecordingFileManager(recordingPath: recordingPath)

// [String]
let sessionIds = fileManager.getSessions()

// Snoring files (in order of intensity) 
let snoringFiles = fileManager.getSnoringFiles(sessionId: sessionId) 

// Unstable-breathing files (in order of severity)
let breathFiles = fileManager.getBreathFiles(sessionId: sessionId)

// All 30-second segments (in order of segment index) 
let segments = fileManager.getAllSegments(sessionId: sessionId) 

try fileManager.deleteSession(sessionId: sessionId)
try fileManager.deleteAllSessions()

// Asleep.Model.RecordingFile
struct RecordingFile {
    let filePath: URL?        // nil for segments whose file was not saved
    let segmentIndex: Int     // 30-second segment index
    let maxDb: Float
    let isSnoringDetected: Bool
    let isBreathDetected: Bool
    let timestamp: String?
    let snoreIntensity: Float
    let breathSeverity: Float
}

Concurrent Audio Capture (optional)

Asleep.SleepTrackingManager.setDeliveryDelegate()

let trackingManager = Asleep.createSleepTrackingManager(config: config, delegate: delegate)
trackingManager.setDeliveryDelegate(self)

Asleep.AsleepAudioDeliveryManagerDelegate

protocol AsleepAudioDeliveryManagerDelegate: AnyObject {
    func deliveryAudio(didReceiveRawBuffer buffer: AVAudioPCMBuffer, 
										   at time: AVAudioTime)
}

Start sleep tracking

Asleep.SleepTrackingManager.startTracking()

var manager: Asleep.SleepTrackingManager?
manager?.startTracking()

Request the latest analyzed sleep data

Asleep.SleepTrackingManager.requestAnalysis()

var manager: Asleep.SleepTrackingManager?
manager?.requestAnalysis()

Stop sleep tracking

Asleep.SleepTrackingManager.stopTracking()

var manager: Asleep.SleepTrackingManager?
manager?.stopTracking()

Specifying the analysis range (v3.3.0)

When you stop tracking, you can directly specify the range (start and end time) that the server will analyze. For example, use it when you want to analyze only the "time the user fell asleep ~ time the user woke up" entered by the user.

var manager: Asleep.SleepTrackingManager?

// Analyze the whole tracking (existing)
manager?.stopTracking()

// Analyze only the specified range
manager?.stopTracking(analysisStartTime: analysisStartTime,
                      analysisEndTime: analysisEndTime)

• Always pass the two values together. To terminate without a range, call stopTracking().
• The flow after termination (didClose → didComplete) is the same as when no range is specified.

What changes when a range is specified

When an invalid range is passed

So that the session is not left open even if the range is invalid, the SDK terminates the session without the range.

You can check whether the range was actually applied by looking at Report.analysis in the result, or by comparing Session.startTime with measurementStartTime.

Get sleep tracking status

Asleep.SleepTrackingManager.getTrackingStatus()

var manager: Asleep.SleepTrackingManager?
let trackingStatus = manager?.getTrackingStatus()

Resume tracking

Asleep.SleepTrackingManager.resumeTracking()

• If a cannotActivateInBackground error occurs during sleep tracking, notify the user (e.g., through a notification), and run Asleep.SleepTrackingManager.resumeTracking() while the app is in the foreground.

var manager: Asleep.SleepTrackingManager?
manager?.resumeTracking()

Data Type

Asleep.SleepTrackingManager.TrackingStatus

struct TrackingStatus {
    var sessionId: String?
}

Asleep.Model.Session

struct Session {
    let id: String
    let state: State
    let startTime: Date
    let endTime: Date?
    let unexpectedEndTime: Date?
    let measurementStartTime: Date?
    let measurementEndTime: Date?
    let createdTimezone: String
    let sleepStages: [Int]?
    let breathStages: [Int]?
    let snoringStages: [Int]?
    let sleepStageProbs: [[Float]]?
    let breathStageProbs: [[Float]]?
    let snoringStageProbs: [[Float]]?
}

enum State {
    case open
    case closed
    case complete
}