Kindly Android SDK — Events Reference

KindlySDK.events: Flow<KindlyEvent>            // all events
KindlySDK.state:  Flow<KindlyEventState>       // state-only convenience

import kotlinx.coroutines.flow.collect
import kotlinx.coroutines.launch
import no.kindly.chatsdk.chat.models.*

lifecycleScope.launch {
    KindlySDK.events.collect { event ->
        when (val detail = event.detail) {
            is KindlyEventDetail.Load        -> handleLoad(detail.settings)
            is KindlyEventDetail.Message     -> handleMessage(detail.newMessage, detail.chatLog)
            is KindlyEventDetail.ButtonClick -> handleButton(detail.button, detail.buttonType,
                                                             detail.chatLog, detail.lastMessage)
            is KindlyEventDetail.UI          -> handleUI(detail.action)
            is KindlyEventDetail.GlobalIcon  -> handleGlobalIcon(detail.action)
            is KindlyEventDetail.State       -> handleState(detail.state)
        }
    }
}

data class KindlyEvent(
    val type: KindlyEventType,
    val detail: KindlyEventDetail,
    val timestamp: Date = Date(),
)

sealed class KindlyEventDetail {
    data class Load(val settings: KindlyEventSettings) : KindlyEventDetail()

    data class Message(
        val newMessage: KindlyEventMessage,
        val chatLog: List<KindlyEventMessage>,
    ) : KindlyEventDetail()

    data class ButtonClick(
        val button: KindlyEventButton,
        val buttonType: String,
        val chatLog: List<KindlyEventMessage>,
        val lastMessage: KindlyEventMessage,
    ) : KindlyEventDetail()

    data class UI(val action: KindlyEventUIAction) : KindlyEventDetail()

    data class GlobalIcon(val action: KindlyEventGlobalIcon) : KindlyEventDetail()

    data class State(val state: KindlyEventState) : KindlyEventDetail()
}

data class KindlyEventMessage(
    val id: String,
    val text: String? = null,
    val sender: KindlyEventMessageSender,
    val created: Date? = null,
    val isFromUser: Boolean,
    val exchangeID: String? = null,
    val videoSource: String? = null,
    val exchangeType: KindlyEventExchangeType? = null,
    val buttons: List<KindlyEventButton> = emptyList(),
    val images: List<KindlyEventImage> = emptyList(),
    val attachments: List<KindlyEventAttachment> = emptyList(),
)

data class KindlyEventButton(
    val id: String? = null,
    val type: String,                  // e.g. "quickreply", "postback", "url"
    val label: String,                 // text shown on the button
    val value: String? = null,         // payload; interpretation depends on `type`
    val index: Int? = null,            // position in the button list
    val hasBeenSelected: Boolean = false,
    val context: Map<String, Any>? = null,
)

data class KindlyEventUIAction(
    val type: KindlyUIActionType,
    val source: String = "user",       // "user" or "programmatic"
    val chatId: String,
    val value: Map<String, Any>? = null,
    val feedbackType: String? = null,         // SHOW/SUBMIT/DISMISS_FEEDBACK only
    val feedbackValue: Map<String, Any>? = null,
    val languageCode: String? = null,         // CHANGE_LANGUAGE only
    val languageName: String? = null,
    val previousLanguageCode: String? = null,
    val previousLanguageName: String? = null,
    val nextPage: String? = null,
)

data class KindlyEventGlobalIcon(
    val type: String,
    val source: String = "user",
    val value: Map<String, Any>? = null,
)

data class KindlyEventState(
    val isChatDisplayed: Boolean,      // chat UI is on screen
    val isStarted: Boolean,            // KindlySDK.start(...) completed
    val isSocketConnected: Boolean,    // Pusher WebSocket is live
    val isConnected: Boolean,          // isStarted && isSocketConnected
    val connectionState: String,       // "connected", "connecting", "disconnected", etc.
)

data class KindlyEventLanguage(
    val code: String,         // "en", "sv", "fr", ...
    val name: String,         // "English", "Swedish", ...
    val isDefault: Boolean = false,
)

data class KindlyEventImage(
    val url: String,
    val altText: String? = null,
    val id: String? = null,
)

data class KindlyEventAttachment(
    val id: String,
    val name: String,
    val format: String,         // e.g. "pdf", "png"
    val status: String,         // e.g. "uploaded", "pending"
    val sender: String,
    val storagePath: String,    // remote storage path
)

lifecycleScope.launch {
    KindlySDK.events
        .mapNotNull { event ->
            (event.detail as? KindlyEventDetail.Message)
                ?.takeIf { it.newMessage.sender == KindlyEventMessageSender.BOT }
                ?.newMessage
        }
        .collect { botMessage ->
            Log.d("Kindly", "Bot: ${botMessage.text.orEmpty()}")
        }
}

lifecycleScope.launch {
    KindlySDK.events.collect { event ->
        val click = event.detail as? KindlyEventDetail.ButtonClick ?: return@collect
        Log.d("Kindly",
            "User tapped [${click.buttonType}] ${click.button.label} → value=${click.button.value}"
        )
    }
}

lifecycleScope.launch {
    KindlySDK.events
        .mapNotNull { (it.detail as? KindlyEventDetail.UI)?.action }
        .filter { it.type == KindlyUIActionType.CHANGE_LANGUAGE }
        .collect { action ->
            val from = action.previousLanguageCode ?: return@collect
            val to = action.languageCode ?: return@collect
            analytics.log("language_changed", mapOf("from" to from, "to" to to))
        }
}

lifecycleScope.launch {
    KindlySDK.state
        .filter { it.isConnected }
        .first()
    KindlySDK.triggerDialogue(id = "welcome_flow")
}

lifecycleScope.launch {
    KindlySDK.events
        .mapNotNull { (it.detail as? KindlyEventDetail.Message)?.chatLog }
        .collect { transcript ->
            currentTranscript = transcript
        }
}

lifecycleScope.launch {
    KindlySDK.state.collect { state ->
        statusTextView.text = state.connectionState
    }
}