Kotlin Multiplatform SDK

Set the user's preferred language.

Encatch.setLocale("fr")

Set the user's country.

Encatch.setCountry("FR") // ISO 3166 country code

Set the theme for forms and surveys.

import com.encatch.sdk.Theme

Encatch.setTheme(Theme.DARK)
Encatch.setTheme(Theme.LIGHT)
Encatch.setTheme(Theme.SYSTEM) // Follows system preference

Subscribe to form lifecycle events. on returns an unsubscribe function — there is no separate off in the KMP API; call the returned function instead.

val unsubscribe = Encatch.on { eventType, payload ->
    println("Event: ${eventType.wireValue}, formId: ${payload.formId}")
}

// Later, to unsubscribe:
unsubscribe()

Handle completion CTAs (in-app navigation, internal redirect, or external browser) via FORM_CTA_TRIGGERED. Configure actions in the form builder — see Call to action. The SDK closes the form overlay after emitting the event — your app handles in-app navigation. Event payload data is a Map<String, JsonElement>:

import com.encatch.sdk.EventType
import kotlinx.serialization.json.JsonPrimitive
import kotlinx.serialization.json.contentOrNull

Encatch.on { eventType, payload ->
    if (eventType != EventType.FORM_CTA_TRIGGERED) return@on

    val action = (payload.data?.get("action") as? JsonPrimitive)?.contentOrNull
    if (action != "app_navigate") return@on

    val route = (payload.data?.get("route") as? JsonPrimitive)?.contentOrNull
    // Map route strings to your app's navigation paths
    when (route) {
        "billing", "billing/upgrade" -> navigateTo("/billing")
    }
}

For in-app navigation, the SDK closes the form overlay after emitting the event and expects your app to perform navigation. For URL redirect actions, the SDK opens the URL and closes the form automatically.

Pre-fill a form response before showing a form. questionId may be a question UUID or a question slug.

Encatch.addToResponse("question_id", "pre-filled value")
Encatch.addToResponse("choice_question_id", listOf("option-a", "option-b"))

Encatch.showForm("your-form-slug")

Inspect or clear pending pre-fills:

val pending: Map<String, Any?> = Encatch.getPendingResponses()
Encatch.clearPendingResponses()

Dismiss the currently displayed form.

Encatch.dismissForm()
// Or dismiss a specific form configuration:
Encatch.dismissForm(formConfigurationId = "config-id")

Use onBeforeShowForm in EncatchConfig to conditionally block forms from showing. The interceptor is a suspend lambda, so it may await anything — user input, a coroutine, a network check — before answering.

import com.encatch.sdk.EncatchConfig
import com.encatch.sdk.TriggerType

Encatch.init(
    "your-api-key",
    EncatchConfig(
        onBeforeShowForm = { payload ->
            // Inspect payload.formId, payload.triggerType, payload.formConfigJson, etc.
            if (payload.triggerType == TriggerType.AUTOMATIC && someCondition) {
                false // Block this form
            } else {
                true // Allow
            }
        },
    ),
)

Register a debug hook that receives every completed SDK HTTP call (request + response). Only fires when EncatchConfig.debugMode is enabled; the API key header is always masked to its last 5 characters. Assignment-style (last caller wins) and survives re-init() — set it once at app startup for in-app network inspectors.

Encatch.setOnNetworkLog { entry ->
    println("${entry.method} ${entry.endpoint} -> ${entry.status} in ${entry.durationMs}ms")
}

// Pass null to clear:
Encatch.setOnNetworkLog(null)

Control session lifecycle manually:

import com.encatch.sdk.StartSessionOptions

Encatch.startSession()

// Skip the immediate ping or screen re-track on start:
Encatch.startSession(
    StartSessionOptions(
        skipImmediatePing = true,
        skipImmediateTrackScreen = true,
    ),
)

// Temporarily stop the 30-second background ping (not persisted)
Encatch.pauseSession()

// Resume the ping interval after pauseSession()
Encatch.resumeSession()

// Fully suspend SDK activity — stops ping and dismisses open forms.
// Persists across app restarts. Re-enable with startSession().
Encatch.stopSession()

Encatch.resetUser()

Encatch.clearAll()

The SDK sends a background ping every 30 seconds (configurable via server response) to maintain engagement sessions and check for triggered forms. Ping is suppressed while a form is visible.

Embed the native inline view directly in your platform UI code. Routing (exact formId match, wildcard, modal fallback) is resolved by the platform SDK the same way on both platforms:

1. Exact match — an inline view whose formId matches the showForm payload wins.
2. Wildcard — an inline view with no formId catches anything not exact-matched.
3. Modal fallback — the modal overlay presents the form when no inline slot is registered or none match.

import com.encatch.android.EncatchInlineFormView

// In your Activity/Fragment or view code:
val inlineForm = EncatchInlineFormView(context).apply {
    formId = "your-form-slug" // exact match; null = wildcard
}
container.addView(inlineForm)

Encatch.showForm("your-form-slug")

import Encatch

// UIKit:
let inlineForm = EncatchInlineFormView()
inlineForm.formId = "your-form-slug" // exact match; nil = wildcard
stackView.addArrangedSubview(inlineForm)

Encatch.showForm("your-form-slug")

The KMP module does not yet expose a commonMain accessor for the inline view type itself (a known gap) — the views above are used from each platform's own UI layer, while all business-logic calls stay in commonMain.

Read-only getters: apiKey, baseUrl, webHost, isFullScreen, theme, locale, deviceId, sessionId, userName, userId, debugMode.

• Compose Multiplatform SDK — this module plus an EncatchInlineForm composable; the form host installs itself, so there is no per-platform setup.
• Android SDK — the native Android SDK this module forwards to on Android.
• iOS SDK — the native Swift SDK this module forwards to on iOS.