Create manager

Asleep.createSleepTrackingManager

• Create SleepTrackingManager that manages Sleep Tracking Feature.

fun createSleepTrackingManager(
    asleepConfig: AsleepConfig?,
    trackingListener: SleepTrackingManager.TrackingListener
): SleepTrackingManager?

Asleep.SleepTrackingManager.TrackingListener

interface TrackingListener {
    fun onCreate()
    fun onUpload(sequence: Int)
    fun onClose(sessionId: String)
    fun onFail(errorCode: Int, detail: String)
}

• When Sleep Tracking starts, onCreate() is called, and onUpload() is called every 30 seconds.

• When Sleep Tracking is ended, onClose()is called.

• If failure, onFail() is called.

Receiving the analysis complete notification (v3.3.0)

If you create the tracking manager with a CompletableTrackingListener, the SDK notifies you through onComplete when the server analysis is finished after you stop tracking. The app does not have to check whether the report is ready by itself.

Optional parameters (recordingPath, recordingType) for saving the recording files of snoring · unstable-breathing sections have been added together.

val recordingPath = context.getExternalFilesDir(null)?.absolutePath + "/recordings"

val trackingManager = Asleep.createSleepTrackingManager(
    asleepConfig,
    object : SleepTrackingManager.CompletableTrackingListener {
        override fun onCreate(sessionId: String) { }
        override fun onUpload(sequence: Int) { }
        override fun onClose(sessionId: String) { }
        override fun onComplete(session: Session?) { }
        override fun onFail(errorCode: Int, detail: String) { }
    },
    recordingPath = recordingPath,
    recordingType = RecordingType.ALL
)

The existing way of passing a TrackingListener still works. The listener type decides the notification, and recordingPath decides the recording files.

Asleep.SleepTrackingManager.CompletableTrackingListener

interface CompletableTrackingListener {
    fun onCreate(sessionId: String)
    fun onUpload(sequence: Int)
    fun onClose(sessionId: String)
    fun onComplete(session: Session?)
    fun onFail(errorCode: Int, detail: String)
}

• onCreate(sessionId) — Called with the session ID when the session is created. It replaces the existing TrackingListener.onCreate().
• onComplete(session) — Called when the server analysis is finished after tracking is stopped and the result can be retrieved. You can display the result right away with sleepStages and so on, and if you also need the statistics, call Reports.getReport(sessionId).
• The other callbacks, onUpload, onClose and onFail, are the same as before.

From stop to analysis complete

When you call stopSleepTracking(), the SDK first closes the session and then checks periodically whether the analysis is finished.

stopSleepTracking()
  │
  ├ ① Request to close the session → onClose(sessionId)
  │
  ├ ② Check for analysis completion (every 3 seconds · up to 10 times, about 30 seconds)
  │
  ├ ③-a Analysis complete → onComplete(session)
  │
  └ ③-b Not finished within 30 seconds → onFail(28000)

Saving recording files (optional)

If you set recordingPath, the SDK temporarily saves the audio in 30 second units while tracking, and when the analysis is complete it keeps only the files of the snoring · unstable-breathing sections selected based on the analysis result in {recordingPath}/audio/{sessionId}/.

Asleep.RecordingType

enum class RecordingType { ALL, SNORING_ONLY, BREATH_ONLY }

• Recording of an indicator that your plan does not provide cannot be turned on with recordingType. It is meant for narrowing down the types within the range of your plan.
• If the analysis result has no basis for the decision (including 28000, when the analysis complete notification was not received), ALL keeps every file saved during tracking, while SNORING_ONLY / BREATH_ONLY keep nothing. Tracking itself is still closed normally in this case.
• Sessions whose analysis result cannot be used, for example when the tracking time is too short, keep no recording files.

Asleep.createRecordingFileManager()

Retrieves or deletes the saved recording files. You must pass the same recordingPath that you passed to the tracking manager.

val manager = Asleep.createRecordingFileManager(recordingPath)

val sessions = manager.getSessions()                  // List<String>, in time order
val snoringFiles = manager.getSnoringFiles(sessionId) // Snoring files (highest intensity first)
val breathFiles = manager.getBreathFiles(sessionId)   // Unstable-breathing files (highest severity first)
val allSegments = manager.getAllSegments(sessionId)   // All 30 second sections (in section index order)

manager.deleteSession(sessionId)
manager.deleteAllSessions()

data class RecordingFile(
    val filePath: String?,          // null for sections whose file was not saved
    val segmentIndex: Int,          // 30 second section index (from 0)
    val maxDb: Float,               // 0~100
    val isSnoringDetected: Boolean,
    val isBreathDetected: Boolean,
    val timestamp: String?,         // ISO 8601
    val snoreIntensity: Float,
    val breathSeverity: Float
)

Start sleep tracking

Asleep.SleepTrackingManager.startSleepTracking

• Start Sleep Tracking.

fun startSleepTracking()

Sleep Analysis

Asleep.SleepTrackingManager.requestAnalysis()

• Received the sleep data measured to date.

fun requestAnalysis(analysisListener: SleepTrackingManager.AnalysisListener)

Asleep.SleepTrackingManager.AnalysisListener

interface AnalysisListener {
    fun onSuccess(session: Session)
    fun onFail(errorCode: Int, detail: String)
}

• If success, onSuccess() is called.

Session data type

data class Session(
    val id: String,
    val state: String,
    val startTime: String,
    val endTime: String?,
    val sleepStages: List<Int?>?,
    val breathStages: List<Int>?,
    val snoringStages: List<Int?>?,
    val createdTimezone: String,
    val unexpectedEndTime: String?,
    val sleepStageProbs: List<List<Float>>?,
    val snoringStageProbs: List<List<Float>>?,
    val breathStageProbs: List<List<Float>>?,
    val measurementStartTime: String?,
    val measurementEndTime: String?
)

• If failure, onFail() is called.

Stop sleep tracking

Asleep.SleepTrackingManager.stopSleepTracking

• Stop Sleep Tracking.

fun stopSleepTracking()

Specifying the analysis range (v3.3.0)

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

// Analyze the whole tracking (existing)
trackingManager?.stopSleepTracking()

// Analyze only the specified range
trackingManager?.stopSleepTracking(analysisStartTime, analysisEndTime)

• The two values are always passed together. To stop without a range, call stopSleepTracking().
• The flow after stopping (onClose → onComplete) is the same as when no range is specified.

What changes when a range is specified

When an invalid range is passed

Even if the range is invalid, the SDK closes the session without a range so that the session is not left open.

Asleep.SleepTrackingManager.forceStopSleepTracking

• Stops Sleep Tracking immediately. It closes the session without an analysis range, and the calling thread waits until the stop processing is finished.

fun forceStopSleepTracking()

Get sleep tracking status

Asleep.SleepTrackingManager.getTrackingStatus()

fun getTrackingStatus(): TrackingStatus

Asleep.SleepTrackingManager.TrackingStatus

class TrackingStatus (var sessionId: String? = null)