Cometchat Android V6 Core

Ground truth: com.cometchat:chatuikit-{kotlin,compose}-android@6 + catalog android-v6.json (287 public symbols, generated from the INSTALLED 6.0.5 source) + features.android-v6.json. Official docs: https://www.cometchat.com/docs/ui-kit/android/overview · scoped index …/ui-kit/android/llms-android-v6.md. Verify every symbol against the catalog; fetch signatures from docs (references/docs-map.md); never trust memory.

⚠️ ONE kit, TWO cohorts. chatuikit-kotlin-android (XML Views) and chatuikit-compose-android (Jetpack Compose) are different artifacts with different namespaces. Component NAMES are shared, the wiring is not — Views uses setOnX(...) setters, Compose uses onX = params. Never install both. v5 Java snippets do not compile against v6 (com.cometchat.chatuikit.* → com.cometchat.uikit.*); that migration is cometchat-android-v6-migration.

⚠️ Some docs snippets are ahead of / behind the shipped kit. Where a baked signature here differs from a docs page, the baked one was verified against the installed 6.0.5 source (gap logged internally). Compile before you trust a docs fence.

<!-- core is the companion the other android v6 skills read; it has no Companion block of its own. -->

Use this skill when

"add chat to my Android app", "set up CometChat credentials", "integrate CometChat in Kotlin/Compose", "show a conversations + messages screen", "build a chat app". An unscoped "add chat" means the production-ready core chat surface below — not a bare list, and not the whole tab-based app (that grows via cometchat-android-v6-{kotlin,compose}-placement).

Prerequisites & install

Pick ONE cohort — the app's existing UI stack decides:

// settings.gradle.kts → dependencyResolutionManagement.repositories
maven("https://dl.cloudsmith.io/public/cometchat/cometchat/maven/")

// app/build.gradle.kts — repo/exclude/compileOptions are COHORT-NEUTRAL (the duplicate-class
// collision comes via chatuikit-core-android, which BOTH cohorts pull); only the artifact differs
configurations.all {
    // REQUIRED — without it the first build fails at dexing with ~40
    // "Duplicate class org.jetbrains.annotations.*" errors (docs getting-started-{kotlin,jetpack}).
    exclude(group = "org.jetbrains", module = "annotations-java5")
}

// gradle.properties — REQUIRED, both lines (why: dexing dup-class; references/troubleshooting.md):
//   android.useAndroidX=true   android.enableJetifier=true

dependencies {
    implementation("com.cometchat:chatuikit-kotlin-android:6.0.5")
    // implementation("com.cometchat:calls-sdk-android:5.0.4")   // only for voice/video
}
android {
    buildFeatures { viewBinding = true }
    compileOptions { sourceCompatibility = JavaVersion.VERSION_11; targetCompatibility = JavaVersion.VERSION_11 }
}
// JVM 11 (Kotlin 2.2+ rejects kotlinOptions{}). Fully-qualified: a mid-file .kts import won't compile.
kotlin { compilerOptions { jvmTarget.set(org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_11) } }

Theme kit views under a CometChatTheme.DayNight-derived theme — REQUIRED (Views), not cosmetic. Kit views resolve ?attr/cometchat* at inflate time; outside such a theme the FIRST kit view crashes (IllegalArgumentException/InflateException on ?attr/cometchatPrimaryColor — verified on device). Greenfield → re-parent app-wide: <style name="AppTheme" parent="CometChatTheme.DayNight" /> + <application android:theme="@style/AppTheme">. Brownfield (app HAS its own theme) → do NOT re-parent (CometChatTheme.DayNight parents MaterialComponents, so Material3-only host attrs stop resolving — you'd break their screens); scope a derived style to the chat Activities (manifest android:theme) + ContextThemeWrapper for fragment/tab-embedded views — recipe: kotlin-placement Placement 2.

Compose cohort: swap the artifact for com.cometchat:chatuikit-compose-android:6.0.5 and use buildFeatures { compose = true } + the Kotlin Compose plugin. Build floors — all forced by the transitive androidx.core:core:1.18.0 and all failing with the SAME opaque checkDebugAarMetadata error, so bump them together: minSdk 28 · compileSdk 36 · AGP ≥ 8.9.1 · Gradle ≥ 8.11 · Kotlin ≥ 2.1 (exact error strings + fixes in -troubleshooting; verified on device). chatuikit-core-android and chat-sdk-android arrive transitively — never add the UI Kit twice, and never mix a v5 chat-uikit-android into the tree (version_conflict — STOP).

Setup & credentials (essentials — full detail: references/setup-credentials.md)

1. Detect the project AND pick the cohort — never guess. npx @cometchat/skills detect --json (or READ the gradle files). The signals are android_variant ∈ compose · views · mixed · unknown (both Groovy and Kotlin DSL): compose → use Compose, don't offer Views · views → use Views · mixed/unknown → ASK and WAIT (recommend Compose for greenfield). Announce the cohort and why before writing code — the cohorts are different artifacts that must not coexist, so it is the one choice the user cannot cheaply undo. If existing_cometchat is true, resolve version_conflict FIRST (v4/v5 kit present ⇒ STOP + offer cometchat-android-v6-migration). Decision table + signals: references/setup-credentials.md §1.
2. Credentials — OFFER to fetch from the dashboard FIRST, never default to "paste it yourself": (a) load the CometChat CLI on demand (npx @cometchat/skills-cli@3 auth login, provision list --json → ask which app, provision use --app-id <id> --json); or (b) manual paste from Dashboard → Your App → Credentials. Ask & wait — never guess.
3. Write app/src/main/assets/cometchat-settings.json (the file initFromSettings reads) and gitignore it:

{ "appId": "APP_ID", "region": "REGION", "credentials": { "authKey": "AUTH_KEY" },
  "uiKit": { "subscribePresenceForAllUsers": true, "enableCalling": false } }

⚠️ enableCalling: true and the calls artifact go together or not at all — the flag without com.cometchat:calls-sdk-android crashes the app at launch. Why and symptoms: docs getting-started-{kotlin,jetpack} + calling-integration. Leave the flag false in an app without calling.

appId + region required (else ERR_SETTINGS_INVALID); missing file → ERR_SETTINGS_FILE_NOT_FOUND. Auth Key is dev-only — omit it in release builds and log in with a server-minted token (cometchat-android-v6-production).

Integration ordering (BAKED — invariant)

Docs warning, verbatim: "init() must resolve before you call login(). Calling login() before init completes will fail silently."

import com.cometchat.chat.core.CometChat
import com.cometchat.chat.exceptions.CometChatException
import com.cometchat.chat.models.User
import com.cometchat.uikit.core.CometChatUIKit

// initFromSettings reads assets/cometchat-settings.json, persists integrationSource="ai-agent"
// for telemetry attribution, and auto-inits the Calls SDK when uiKit.enableCalling is true.
// Do NOT default to the classic UIKitSettingsBuilder + init() — it loses attribution.
CometChatUIKit.initFromSettings(this, object : CometChat.CallbackListener<String>() {
    override fun onSuccess(result: String) {                     // init resolved — only now login
        if (CometChatUIKit.getLoggedInUser() == null) {
            CometChatUIKit.login(uid, object : CometChat.CallbackListener<User>() {
                // ⚠️ inside this object, `this` is the LISTENER, not the Activity — navigating
                // with `Intent(this, …)` does not compile. Qualify it: `this@YourActivity`.
                override fun onSuccess(user: User) {
                    startActivity(Intent(this@MainActivity, ConversationActivity::class.java)); finish()
                }
                override fun onError(e: CometChatException) { /* render an error state */ }
            })
        } else { /* session already live — unlock */ }
    }
    override fun onError(e: CometChatException?) { /* render an error state; do NOT open chat */ }
})

Init once (Application or a splash gate), never per Activity. Which UID? login() needs a user that ALREADY exists — never invent one; take it from Dashboard → Users (fresh apps seed cometchat-uid-1…). Prod → loginWithAuthToken. Detail: references/lifecycle.md.

Sizing — fill the parent, handle insets and the keyboard

The kit fills the box you give it — a collapsed surface is a HOST sizing defect, never a kit bug. Four invariants (full recipe: references/layout.md):

• Fill: match_parent / 0dp+layout_weight (Views) — never wrap_content for a list or the chat surface.
• Insets: enableEdgeToEdge() plus consuming the insets. enableEdgeToEdge() ALONE draws the kit under the status bar — the toolbar title then collides with the clock (verified on device). Give the layout root an id and pad it:

  ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.root)) { v, insets ->
      val bars = insets.getInsets(WindowInsetsCompat.Type.systemBars())
      val ime  = insets.getInsets(WindowInsetsCompat.Type.ime())      // message screen only
      v.setPadding(bars.left, bars.top, bars.right, maxOf(bars.bottom, ime.bottom))
      insets
  }

• Keyboard: windowSoftInputMode="adjustResize" (Views) so the composer stays visible while typing.
• Embedded in a host you do NOT own (a tab, a fragment, someone else's container): set the listener on YOUR subtree root, not the Activity root, and skip enableEdgeToEdge() — the host owns the window. Still consume insets: skipping them because "the host owns it" puts the toolbar back under the clock.
• No load-transition reflow: the surface is full-size from frame 1; the kit renders its own loading/empty state inside it.

Component / API map (BAKED closed list — from catalogs/android-v6.json)

The closed list of shipped components lives in references/component-props.md (and catalogs/android-v6.json is the oracle). Emit ONLY symbols that appear there.

Import paths

…kotlin.presentation.<area>.ui.<Component> — except the 3 calling components (no .ui) and formatters (…kotlin.shared.formatters.*). Full table: references/component-props.md.

Callback names — Views uses setOnX(...), Compose uses onX =

Same component, same intent, different wiring. Full signature table (verified vs 6.0.5): references/component-props.md § Callback shapes.

⚠️ Docs drift — trust references/component-props.md, not the docs pages for callback shapes (the 3-arg thread callback and setParentMessage on the list are both wrong upstream).

Golden path — the production-ready core surface (Kotlin XML Views)

The default for an unscoped "add chat". One screen per Activity with a real back stack — never a web-style two-pane split. Host Activities must be lifecycle-aware (AppCompatActivity/ComponentActivity/FragmentActivity) and manifest-registered.

// ConversationActivity.kt — the list, wired to open the message screen
class ConversationActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContentView(R.layout.activity_conversation)          // hosts CometChatConversations at match_parent

        val conversations = findViewById<CometChatConversations>(R.id.conversations)
        conversations.setTitle("Chats")
        conversations.setOnItemClick { conversation ->
            val intent = Intent(this, MessageActivity::class.java)
            when (val entity = conversation.conversationWith) {
                is User -> intent.putExtra("user", entity)
                is Group -> intent.putExtra("group", entity)
            }
            startActivity(intent)
        }
        conversations.setOnSearchClick { startActivity(Intent(this, SearchActivity::class.java)) }
    }
}

// MessageActivity.kt — header + list + composer, all bound to the SAME target
class MessageActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContentView(R.layout.activity_message)               // vertical LinearLayout, list = 0dp + weight 1

        val header = findViewById<CometChatMessageHeader>(R.id.message_header)
        val list = findViewById<CometChatMessageList>(R.id.message_list)
        val composer = findViewById<CometChatMessageComposer>(R.id.message_composer)

        val user = intent.getParcelableExtra<User>("user")
        val group = intent.getParcelableExtra<Group>("group")
        user?.let { header.setUser(it); list.setUser(it); composer.setUser(it) }
        group?.let { header.setGroup(it); list.setGroup(it); composer.setGroup(it) }

        header.setBackButtonVisibility(View.VISIBLE)   // the callback is inert without this
        header.setOnBackPress { finish() }
        list.setOnThreadRepliesClick { parent ->                 // ONE arg (verified vs 6.0.5)
            startActivity(Intent(this, ThreadActivity::class.java).apply {
                putExtra("raw_json", parent.rawMessage.toString())
                user?.let { putExtra("user", it) }; group?.let { putExtra("group", it) }
            })
        }
    }
}