Ambient Interoperability

let sessionInfo: [String: AnyHashable] = [
    SukiAmbientConstant.kEmrEncounterId: "6ec3920f-b0b1-499d-a4e9-889bf788e5ab",
    // Session Group ID (Ambient API encounter_id):
    SukiAmbientConstant.kSessionId: existingSessionGroupId,
]

SukiAmbientCoreManager.shared.createSession(with: sessionInfo, onCompletion: { result in
    switch result {
    case .success(let sessionResponse):
        let sessionId = sessionResponse.sessionId
        let compositionId = sessionResponse.compositionId // optional; online only
        // Store sessionId for recording and session content.
        // Store compositionId for note-level reads.
    case .failure(let error):
        // Handle remoteSessionConflict, SukiStatus, or other create errors.
        print(error)
    }
})

SukiAmbientCoreManager.shared.createSession(with: sessionInfo, onCompletion: { result in
    switch result {
    case .success(let sessionResponse):
        // Proceed with recording using sessionResponse.sessionId
        break
    case .failure(let error):
        if let coreError = error as? SukiAmbientCoreError,
           case .remoteSessionConflict(let blockingSessionId) = coreError {
            // CancelSession for the other modality's active session:
            SukiAmbientCoreManager.shared.cancelRemoteAmbientSession(
                ambientSessionId: blockingSessionId,
                onCompletion: { cancelResult in
                    // After success, retry createSession with the same kEmrEncounterId.
                }
            )
            // Or EndSession:
            // SukiAmbientCoreManager.shared.endSessionRemotely(
            //     sessionId: blockingSessionId,
            //     onCompletion: { endResult in /* then retry create */ }
            // )
            return
        }
        print(error)
    }
})

case .sessionTerminatedByPeer(let reason):
    switch reason {
    case .cancelled, .ended, .unknown:
        // Update UI only. Local mic, stream, and session are already cleared.
        break
    }

SukiAmbientCoreManager.shared.listEncounterNotes(emrEncounterId: emrEncounterId) { result in
    switch result {
    case .success(let summaries):
        for summary in summaries {
            let noteId = summary.compositionId
            SukiAmbientCoreManager.shared.getNoteContext(noteId: noteId) { contextResult in
                switch contextResult {
                case .success(let context):
                    print(context)
                case .failure(let error):
                    print(error)
                }
            }
        }
    case .failure(let error):
        print(error)
    }
}

// Pass the Session Group ID as encounterId:
SukiAmbientCoreManager.shared.encounterContent(encounterId: sessionGroupId) { result in
    switch result {
    case .success(let suggestions):
        print(suggestions)
    case .failure(let error):
        print(error)
    }
}