Compose Multiplatform SDK

The Encatch Compose Multiplatform SDK (com.encatch:compose-sdk) lets you collect in-app feedback and surveys from one shared commonMain Compose UI targeting Android and iOS. It depends on the Kotlin Multiplatform SDK (com.encatch:kmp-sdk) for the entire Encatch business-logic API — init, identify, track, show/dismiss forms, submit, sessions, events — and adds the one thing a pure KMP consumer wouldn't need: EncatchInlineForm, a composable that wraps the platform-native inline form view (AndroidView/UIKitView interop — no WebView reimplementation, no third-party dependency).

Under the hood, Encatch calls bridge to the two native Encatch SDKs (the Android SDK on Android, the pure-Swift iOS SDK on iOS) — a thin routing layer, not a third implementation.

Overview

• Package: com.encatch:compose-sdk (Maven Central)
• Version: 0.1.1
• Platforms: Android (minSdk 24), iOS (iosArm64, iosSimulatorArm64)
• Repository: github.com/get-encatch/encatch-android
• License: MIT

Installation

Add the dependency to your shared module's commonMain source set:

// build.gradle.kts (shared module)
kotlin {
    sourceSets {
        commonMain.dependencies {
            implementation("com.encatch:compose-sdk:0.1.1")
        }
    }
}

This transitively brings in com.encatch:kmp-sdk's Encatch API — no separate dependency needed. A Compose Multiplatform customer adds only compose-sdk.

Quick Start

1. Initialization

import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import com.encatch.sdk.Encatch

@Composable
fun App() {
    LaunchedEffect(Unit) {
        if (!Encatch.isInitialized) {
            Encatch.init("your-api-key")
        }
    }

    // ... your app UI ...
}

import com.encatch.sdk.Encatch
import com.encatch.sdk.EncatchConfig
import com.encatch.sdk.Theme

LaunchedEffect(Unit) {
    Encatch.init(
        "your-api-key",
        EncatchConfig(
            theme = Theme.SYSTEM,
            debugMode = true,
            isFullScreen = false,
            appVersion = "1.2.3",
            onBeforeShowForm = { payload ->
                // Return false to prevent the form from showing
                true
            },
        ),
    )
}

2. Identify users

Identify the current user. The userName is required (can be a username, email, or unique identifier). Traits and options are optional.

val scope = rememberCoroutineScope()

Button(onClick = {
    scope.launch { Encatch.identifyUser("user@example.com") }
}) { Text("Sign in") }

import com.encatch.sdk.UserTraits
import kotlinx.serialization.json.JsonPrimitive

scope.launch {
    Encatch.identifyUser(
        "user@example.com",
        traits = UserTraits(
            set = mapOf(
                "name" to JsonPrimitive("Alice"),
                "plan" to JsonPrimitive("team"),
            ),
        ),
    )
}

import com.encatch.sdk.UserTraits
import kotlinx.serialization.json.JsonPrimitive

scope.launch {
    Encatch.identifyUser(
        "user@example.com",
        traits = UserTraits(
            set = mapOf("name" to JsonPrimitive("Alice"), "plan" to JsonPrimitive("team")),
            setOnce = mapOf("firstSeen" to JsonPrimitive("2026-08-05T12:00:00Z")),
            increment = mapOf("loginCount" to 1.0),
            decrement = mapOf("credits" to 5.0),
            unset = listOf("trialEndDate"),
        ),
    )
}

import com.encatch.sdk.IdentifyOptions
import com.encatch.sdk.SecureOptions

scope.launch {
    Encatch.identifyUser(
        "user@example.com",
        options = IdentifyOptions(
            secure = SecureOptions(
                signature = "your-hmac-signature",
                generatedDateTimeInUtc = "1741867200000", // ms since epoch (2025-03-13T12:00:00Z)
            ),
        ),
    )
}

3. Show a form manually

Show a specific form by slug or ID. If a matching EncatchInlineForm is composed, the form renders inline there; otherwise it presents as a modal overlay.

import androidx.compose.runtime.rememberCoroutineScope
import com.encatch.sdk.Encatch
import kotlinx.coroutines.launch

@Composable
fun FeedbackButton() {
    val scope = rememberCoroutineScope()
    Button(onClick = {
        scope.launch { Encatch.showForm("feedback-form") }
    }) { Text("Give feedback") }
}

import com.encatch.sdk.ContextValue
import com.encatch.sdk.ResetMode
import com.encatch.sdk.ShowFormOptions

scope.launch {
    Encatch.showForm(
        "feedback-form",
        ShowFormOptions(
            reset = ResetMode.ALWAYS,
            context = mapOf(
                "plan" to ContextValue.StringValue("team"),
                "feature" to ContextValue.StringValue("checkout"),
            ),
        ),
    )
}

Other actions

Encatch.setLocale("fr")

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

import com.encatch.sdk.Theme

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

scope.launch { Encatch.trackEvent("button_clicked") }

@Composable
fun HomeScreen() {
    LaunchedEffect(Unit) { Encatch.trackScreen("Home") }
    // ...
}

import androidx.compose.runtime.DisposableEffect
import com.encatch.sdk.Encatch

@Composable
fun App() {
    DisposableEffect(Unit) {
        val unsubscribe = Encatch.on { eventType, payload ->
            println("Event: ${eventType.wireValue}, formId: ${payload.formId}")
        }
        onDispose { unsubscribe() }
    }

    // ...
}

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

DisposableEffect(Unit) {
    val unsubscribe = Encatch.on { eventType, payload ->
        if (eventType == EventType.FORM_CTA_TRIGGERED) {
            val action = (payload.data?.get("action") as? JsonPrimitive)?.contentOrNull
            val route = (payload.data?.get("route") as? JsonPrimitive)?.contentOrNull
            if (action == "app_navigate") {
                // Map route strings to your app's navigation state
                when (route) {
                    "billing", "billing/upgrade" -> currentScreen = Screen.Billing
                }
            }
        }
    }
    onDispose { unsubscribe() }
}

scope.launch {
    Encatch.addToResponse("question_id", "pre-filled value")
    Encatch.addToResponse("choice_question_id", listOf("option-a", "option-b"))
    Encatch.showForm("your-form-slug")
}

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

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
            }
        },
    ),
)

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

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

import com.encatch.sdk.StartSessionOptions

scope.launch {
    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().
scope.launch { Encatch.stopSession() }

scope.launch { Encatch.resetUser() }

scope.launch { Encatch.clearAll() }

Inline Forms

Inline forms are a way to show Encatch in-app feedback without a modal — the survey renders directly in your layout instead of as a full-screen overlay.

import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.verticalScroll
import com.encatch.sdk.Encatch
import com.encatch.sdk.compose.EncatchInlineForm

@Composable
fun FeedbackScreen() {
    val scope = rememberCoroutineScope()

    Column(Modifier.verticalScroll(rememberScrollState())) {
        // ... content above ...

        Button(onClick = {
            scope.launch { Encatch.showForm("your-form-slug") }
        }) { Text("Show form (renders inline below)") }

        EncatchInlineForm(
            formId = "your-form-slug", // exact match; omit for wildcard
            modifier = Modifier.fillMaxWidth(),
        )

        // ... content below ...
    }
}

// Exact slot — only showForm("nps-survey") renders here:
EncatchInlineForm(formId = "nps-survey", modifier = Modifier.fillMaxWidth())

// Wildcard slot — catches any form id not exactly claimed elsewhere:
EncatchInlineForm(modifier = Modifier.fillMaxWidth())

Column(Modifier.verticalScroll(rememberScrollState())) {
    EncatchInlineForm(
        formId = "my-form",
        modifier = Modifier
            .fillMaxWidth()
            .clip(RoundedCornerShape(16.dp)),
    )
}

Build Your Own Form UX & UI

If your feedback flow uses a fixed, predictable question set — the same fields and workflow every time — you can build the form with your own composables and submit responses through the SDK. That keeps typography, spacing, colors, and interaction patterns aligned with the rest of your app, so the survey feels like a native screen rather than an embedded web page.

The flow has three parts, all available from commonMain:

1. Intercept the form with onBeforeShowForm and return false. The ShowFormInterceptorPayload includes formConfigJson — the JSON encoding of the full form configuration (including questionnaireFields), so you can render your own UI from the real form definition.
2. Render your own Compose UI from the payload.
3. Submit with buildSubmitRequest + Encatch.submitForm.

import com.encatch.sdk.BuildSubmitRequestOptions
import com.encatch.sdk.Encatch
import com.encatch.sdk.EncatchConfig
import com.encatch.sdk.NativeFormResponse
import com.encatch.sdk.buildSubmitRequest

// 1. Intercept: queue the blocked form as Compose state instead of letting the SDK render it
var blockedForm by mutableStateOf<BlockedForm?>(null)

suspend fun initSdk() {
    Encatch.init(
        "your-api-key",
        EncatchConfig(
            onBeforeShowForm = { payload ->
                if (payload.formId == "my-native-form") {
                    blockedForm = BlockedForm(payload.formId, payload.formConfigJson)
                    false // block the SDK form — we render our own composable
                } else {
                    true
                }
            },
        ),
    )
}

// 2. Render: show your own composable when blockedForm != null
// (parse formConfigJson to build the question list)

// 3. Submit: convert your composable's answers and post them to Encatch
suspend fun submitNativeForm(formConfigurationId: String) {
    val responses = listOf(
        NativeFormResponse("q1", "rating", 5),
        NativeFormResponse("q2", "short_answer", "Great product!"),
        NativeFormResponse("q3", "multiple_choice_multiple", listOf("option-a", "option-b")),
    )

    val requestJson = buildSubmitRequest(
        BuildSubmitRequestOptions(formConfigurationId = formConfigurationId),
        responses,
    )
    Encatch.submitForm(requestJson)
}

NativeFormResponse.value's expected shape depends on the question type: numeric scales (rating, nps, csat, opinion_scale) take a Number or numeric String; text types take String; choice and ranking types take String or List<String>; boolean types (yes_no, consent) take Boolean. All 33 Encatch question types are supported; unknown types fall back to short_answer for forward-compatibility.

Support

• Maven Central: com.encatch:compose-sdk
• Issues: github.com/get-encatch/encatch-android/issues