@cometchat/skills 4.0.0 → 4.2.0

package/skills/cometchat-android-v6-calls/references/call-session.md

@@ -0,0 +1,163 @@
+# Call session — joinSession with no ringing (Android V6 / Compose)
+
+V6 uses the same SDK (`com.cometchat.calls-sdk-android`) as V5. The canonical SDK API surface is documented in the V5 sister; this file documents only the Compose-specific delta (bridging `AndroidView` to the SDK's `RelativeLayout` container).
+
+**Read first:**
+- `cometchat-android-v5-calls/references/call-session.md` — canonical SDK API (single-call `joinSession`, `SessionSettingsBuilder`, `SessionStatusListener`, `CometChatOngoingCallService`)
+- `cometchat-react-calls/references/call-session.md` — cross-platform architecture
+
+**Source of truth:** `~/Downloads/calls-sdk/calls-sdk-android-5/samples/sample-app/src/main/kotlin/com/cometchat/samplecalls/ui/activity/CallActivity.kt` (no Compose-specific upstream sample exists; the SDK surface is identical).
+
+---
+
+## Hard rules
+
+All V5 rules apply (single-call `joinSession(sessionId, settings, container, callback)`, `CometChatCalls.SessionSettingsBuilder()`, `SessionStatusListener` on the `CallSession` instance, `CometChatOngoingCallService.launch/abort`, runtime permissions, no Chat SDK for session-only). The V6 Compose-specific deltas:
+
+1. **`AndroidView` with `remember`-stable factory** to host the SDK's `RelativeLayout` container. The factory MUST be wrapped in `remember { }` — re-creating the layout on every recomposition flickers / re-joins the session.
+2. **`LaunchedEffect(sessionId)` to fire `joinSession` once**, not in a Composable body. Composable bodies re-run on recomposition; the SDK would join multiple times.
+3. **`DisposableEffect` for cleanup**, NOT `LaunchedEffect`'s cleanup lambda. `LaunchedEffect`'s cleanup fires on key change too, not just final dispose. `DisposableEffect.onDispose` is the correct teardown hook.
+4. **State observation via `mutableStateOf` set from listener callbacks** — the listener callbacks must hop to `Main` dispatcher (or use `runOnUiThread` from a hosting activity ref) before touching Compose state.
+
+---
+
+## Compose CallRoom
+
+```kotlin
+@Composable
+fun CallRoom(sessionId: String, onLeft: () -> Unit) {
+  val context = LocalContext.current
+  val activity = context as Activity
+  val containerRef = remember { mutableStateOf<RelativeLayout?>(null) }
+  val joined = remember { mutableStateOf(false) }
+  val callSession = remember { mutableStateOf<CallSession?>(null) }
+
+  AndroidView(
+    factory = { ctx ->
+      RelativeLayout(ctx).apply {
+        layoutParams = ViewGroup.LayoutParams(MATCH_PARENT, MATCH_PARENT)
+        setBackgroundColor(android.graphics.Color.BLACK)
+        containerRef.value = this
+      }
+    },
+    modifier = Modifier.fillMaxSize(),
+  )
+
+  LaunchedEffect(sessionId) {
+    if (joined.value) return@LaunchedEffect
+    val container = containerRef.value ?: return@LaunchedEffect
+    joined.value = true
+
+    val sessionSettings = CometChatCalls.SessionSettingsBuilder()
+      .setTitle("CometChat Meeting")
+      .startVideoPaused(false)
+      .startAudioMuted(false)
+      .build()
+
+    CometChatCalls.joinSession(
+      sessionId,
+      sessionSettings,
+      container,
+      object : CometChatCalls.CallbackListener<CallSession>() {
+        override fun onSuccess(session: CallSession) {
+          callSession.value = session
+
+          // Single guarded termination handler — the v5 Calls SDK fires
+          // onSessionLeft + onConnectionClosed in sequence on every hangup.
+          // Without the guard, abort() + onLeft() fire 3 times (wasteful;
+          // can race the composable's exit transition).
+          val isTerminating = mutableStateOf(false)
+          fun handleTermination() {
+            if (isTerminating.value) return
+            isTerminating.value = true
+            activity.runOnUiThread {
+              CometChatOngoingCallService.abort(activity)
+              onLeft()
+            }
+          }
+
+          session.addSessionStatusListener(activity, object : SessionStatusListener() {
+            override fun onSessionJoined() {
+              CometChatOngoingCallService.launch(activity)
+            }
+
+            override fun onSessionLeft() = handleTermination()
+            override fun onConnectionClosed() = handleTermination()
+            override fun onSessionTimedOut() = handleTermination()
+
+            override fun onConnectionLost() {}
+            override fun onConnectionRestored() {}
+          })
+
+          session.addButtonClickListener(activity, object : ButtonClickListener() {
+            override fun onLeaveSessionButtonClicked() {
+              val active = CallSession.getInstance()
+              if (active.isSessionActive) active.leaveSession()
+              // The listener chain calls handleTermination().
+            }
+          })
+        }
+
+        override fun onError(e: CometChatException) {
+          activity.runOnUiThread {
+            Toast.makeText(activity, "Failed to join: ${e.message}", Toast.LENGTH_LONG).show()
+            onLeft()
+          }
+        }
+      }
+    )
+  }
+
+  DisposableEffect(sessionId) {
+    onDispose {
+      val active = CallSession.getInstance()
+      if (active.isSessionActive) active.leaveSession()
+      CometChatOngoingCallService.abort(activity)
+    }
+  }
+}
+```
+
+**Why this shape:**
+
+- **`AndroidView` factory wrapped in `remember`** — Compose otherwise re-creates the `RelativeLayout` on every recomposition; the SDK's video tile dies along with it.
+- **`LaunchedEffect(sessionId)` for the join call** — Composable body re-runs on every recomposition; `LaunchedEffect` runs once per key. The `joined` guard handles configuration changes (rotation re-keys the effect).
+- **`runOnUiThread` inside listener callbacks** — SDK callbacks fire on background threads; touching Compose state from them throws without the dispatcher hop.
+- **`DisposableEffect.onDispose` for `leaveSession`** — `LaunchedEffect`'s cleanup runs on key change too. `DisposableEffect.onDispose` only runs when the composable actually leaves composition.
+
+---
+
+## Anti-patterns
+
+V5 sister rules apply, plus V6 Compose-specific:
+
+1. **`AndroidView` without `remember { }` around the layout reference.** Each recomposition creates a new layout → call surface flickers, joinSession orphans previous container.
+2. **`leaveSession()` in `LaunchedEffect`'s cleanup lambda.** Fires on every key change, not just dispose. Use `DisposableEffect.onDispose`.
+3. **Skipping the `joined` guard.** Configuration changes (rotation) re-run `LaunchedEffect` with the same key (StrictMode-like behavior in dev); guard prevents double-join.
+4. **Touching `mutableStateOf` from listener callbacks without `runOnUiThread`.** Compose state isn't thread-safe; race conditions corrupt state.
+5. **Putting `joinSession` directly in the Composable body** (not in `LaunchedEffect`). Recomposition re-runs the call → multiple sessions.
+
+---
+
+## Verification checklist
+
+V5 checklist applies, plus Compose-specific:
+
+- [ ] `AndroidView` factory creates `RelativeLayout` once, stored via `remember { mutableStateOf<RelativeLayout?>(null) }`
+- [ ] `joinSession` fired inside `LaunchedEffect(sessionId)`, NOT in Composable body
+- [ ] `joined` flag guards re-entry on rotation / key re-trigger
+- [ ] `DisposableEffect.onDispose` calls `leaveSession` + `CometChatOngoingCallService.abort`
+- [ ] Listener callbacks use `activity.runOnUiThread { ... }` before touching Compose state
+- [ ] `onSessionLeft`, `onConnectionClosed`, `onSessionTimedOut` ALL fire the `onLeft` callback
+- [ ] **Standalone session-only:** no chat-sdk-android dependency
+- [ ] Real-device smoke: rotation doesn't double-join, dispose tears down cleanly, foreground-service notification clears
+
+---
+
+## Pointers
+
+- `cometchat-android-v5-calls/references/call-session.md` — canonical SDK API + Views patterns
+- `cometchat-android-v6-calls/SKILL.md` — V6 Compose architecture (W1–W5 workarounds for the kit)
+- `cometchat-android-v6-calls/references/share-invite.md` — App Links config
+- Upstream Android sample — `~/Downloads/calls-sdk/calls-sdk-android-5/samples/sample-app/src/main/kotlin/com/cometchat/samplecalls/ui/activity/CallActivity.kt`
+- Canonical docs: https://www.cometchat.com/docs/calls/android/join-session

package/skills/cometchat-android-v6-calls/references/device-management.md

@@ -0,0 +1,171 @@
+# Device management on Android V6
+
+V6 inherits the V5 SDK API for device management — `CallSession.muteAudio()` / `pauseVideo()` / `setAudioMode()` / camera flip. V5 has detailed audio-controls + video-controls references; this V6 reference covers the Compose-specific UI patterns.
+
+**Canonical docs:** https://www.cometchat.com/docs/calls/android/device-management
+**Read first:**
+- `cometchat-android-v5-calls/references/audio-controls.md` — full audio control SDK API (carries over)
+- `cometchat-android-v5-calls/references/video-controls.md` — camera flip + pause/resume
+
+---
+
+## Compose toggle controls
+
+```kotlin
+@Composable
+fun CallControls(viewModel: CallControlsViewModel = viewModel()) {
+  val state by viewModel.state.collectAsStateWithLifecycle()
+
+  Row(horizontalArrangement = Arrangement.spacedBy(16.dp)) {
+    IconButton(onClick = { viewModel.toggleMic() }) {
+      Icon(
+        imageVector = if (state.micMuted) Icons.Filled.MicOff else Icons.Filled.Mic,
+        contentDescription = if (state.micMuted) "Unmute microphone" else "Mute microphone",
+        tint = if (state.micMuted) Color.Red else Color.White,
+      )
+    }
+
+    IconButton(onClick = { viewModel.toggleCamera() }) {
+      Icon(
+        imageVector = if (state.cameraOff) Icons.Filled.VideocamOff else Icons.Filled.Videocam,
+        contentDescription = if (state.cameraOff) "Turn on camera" else "Turn off camera",
+        tint = if (state.cameraOff) Color.Red else Color.White,
+      )
+    }
+
+    IconButton(onClick = { viewModel.flipCamera() }) {
+      Icon(
+        imageVector = Icons.Filled.FlipCameraIos,
+        contentDescription = "Flip camera",
+        tint = Color.White,
+      )
+    }
+
+    IconButton(onClick = { viewModel.toggleSpeaker() }) {
+      Icon(
+        imageVector = when (state.audioMode) {
+          AudioMode.SPEAKER -> Icons.Filled.VolumeUp
+          AudioMode.EARPIECE -> Icons.Filled.PhoneInTalk
+          AudioMode.BLUETOOTH -> Icons.Filled.Bluetooth
+        },
+        contentDescription = "Audio output: ${state.audioMode.name}",
+        tint = Color.White,
+      )
+    }
+  }
+}
+```
+
+---
+
+## ViewModel
+
+```kotlin
+data class CallControlsState(
+  val micMuted: Boolean = false,
+  val cameraOff: Boolean = false,
+  val audioMode: AudioMode = AudioMode.SPEAKER,
+)
+
+class CallControlsViewModel : ViewModel() {
+  private val _state = MutableStateFlow(CallControlsState())
+  val state: StateFlow<CallControlsState> = _state
+
+  fun toggleMic() {
+    val callSession = CallSession.getInstance()
+    if (_state.value.micMuted) {
+      callSession.unMuteAudio()
+    } else {
+      callSession.muteAudio()
+    }
+    _state.update { it.copy(micMuted = !it.micMuted) }
+  }
+
+  fun toggleCamera() {
+    val callSession = CallSession.getInstance()
+    if (_state.value.cameraOff) {
+      callSession.resumeVideo()
+    } else {
+      callSession.pauseVideo()
+    }
+    _state.update { it.copy(cameraOff = !it.cameraOff) }
+  }
+
+  fun flipCamera() {
+    val callSession = CallSession.getInstance()
+    val newFacing = if (callSession.currentCameraFacing == CameraFacing.FRONT) {
+      CameraFacing.BACK
+    } else {
+      CameraFacing.FRONT
+    }
+    callSession.switchCamera(newFacing)
+  }
+
+  fun toggleSpeaker() {
+    val callSession = CallSession.getInstance()
+    val nextMode = when (_state.value.audioMode) {
+      AudioMode.SPEAKER -> AudioMode.EARPIECE
+      AudioMode.EARPIECE -> AudioMode.SPEAKER
+      AudioMode.BLUETOOTH -> AudioMode.SPEAKER
+    }
+    callSession.setAudioMode(nextMode)
+    _state.update { it.copy(audioMode = nextMode) }
+  }
+}
+```
+
+---
+
+## Bluetooth audio routing
+
+V6 still uses the V5 SDK's `MediaEventsListener` for audio mode change detection:
+
+```kotlin
+class CallControlsViewModel : ViewModel(), MediaEventsListener {
+  init {
+    CallSession.getInstance().addMediaEventsListener("controls", this)
+  }
+
+  override fun onAudioModeUpdated(mode: AudioMode) {
+    _state.update { it.copy(audioMode = mode) }
+  }
+
+  override fun onCleared() {
+    CallSession.getInstance().removeMediaEventsListener("controls")
+  }
+  // ... other MediaEventsListener methods
+}
+```
+
+When the user connects Bluetooth headphones mid-call, `onAudioModeUpdated(BLUETOOTH)` fires. Update the UI button accordingly.
+
+---
+
+## Anti-patterns
+
+V5 audio-controls + video-controls references list the SDK-level anti-patterns; V6 Compose-specific:
+
+1. **`Icons.Filled.MicOff` without `tint`.** Default tint is theme-dependent; on dark call surfaces, the icon may be invisible.
+2. **`collectAsState()` instead of `collectAsStateWithLifecycle()`.** State updates run while paused; CPU waste.
+3. **Camera flip without checking current facing.** SDK's `switchCamera()` (no arg) toggles, but `switchCamera(CameraFacing)` requires explicit value. Use the explicit-arg form for clarity.
+
+---
+
+## Verification checklist
+
+- [ ] ViewModel uses `StateFlow` + `collectAsStateWithLifecycle()`
+- [ ] All toggle buttons have `contentDescription` (a11y)
+- [ ] `MediaEventsListener` registered with stable ID
+- [ ] Listener cleaned up in `onCleared()`
+- [ ] Real-device smoke: mute / camera / flip / speaker all work
+- [ ] Bluetooth smoke: connect headphones → audio mode icon updates
+
+---
+
+## Pointers
+
+- `cometchat-android-v5-calls/references/audio-controls.md` — full audio SDK API (mute/audio mode)
+- `cometchat-android-v5-calls/references/video-controls.md` — camera pause/resume/flip
+- `cometchat-android-v6-calls` SKILL.md
+- `cometchat-android-v6-calls/references/raise-hand.md` — Compose pattern sibling
+- Canonical docs: https://www.cometchat.com/docs/calls/android/device-management

package/skills/cometchat-android-v6-calls/references/group-calls.md

@@ -0,0 +1,191 @@
+# Group calls — broadcast meeting pattern (Android V6)
+
+Group calls use a **different signaling channel than 1:1 user calls**. The Ringing flow (`CometChat.initiateCall` → `onIncomingCallReceived` on peer) is **1:1 user only**. For groups, the kit broadcasts a **custom message of type `"meeting"`** to the group; receivers see a "Join meeting" card in `CometChatMessageList` (kit) or need an explicit `MessageListener.onCustomMessageReceived` (custom UI).
+
+By-design kit behavior — same semantic across all CometChat kits.
+
+**Canonical docs:** https://www.cometchat.com/docs/calls/android/group-calls
+
+V6 specifics: this applies equally to Compose and Kotlin Views surfaces. Calls bundling into V6's chatuikit module doesn't change the signaling — the kit's `CometChatCallButtons` composable (or Views equivalent) sends the same meeting `CustomMessage` as V5.
+
+---
+
+## Architecture
+
+```
+Caller (uidA, member of groupX)        CometChat                Receivers (members of groupX)
+  │                                       │                              │
+  │ CometChatCallButtons sends            │                              │
+  │ CustomMessage(GUID, GROUP, "meeting", │                              │
+  │   { callType, sessionId })            │                              │
+  ├──────────────────────────────────────>│                              │
+  │                                       │ onCustomMessageReceived      │
+  │                                       ├─────────────────────────────>│
+  │  caller jumps to OngoingCall surface  │  receiver taps Join          │
+  │     sessionId = groupGuid             │  → joinSession(GUID)         │
+  ├──────────────────────────────────────>│ <─────────────────────────── │
+  │            ───── WebRTC session active (sessionId = group GUID) ─────│
+```
+
+| Channel | 1:1 user calls | Group calls |
+|---|---|---|
+| Signaling | `CometChat.initiateCall(call, callback)` | `CometChat.sendCustomMessage(message, callback)` (type="meeting") |
+| Receiver event | `CallListener.onIncomingCallReceived` | `MessageListener.onCustomMessageReceived` |
+| Session ID | server-generated unique | group's GUID (persistent) |
+| Ring/decline | yes — `acceptCall` / `rejectCall` | no — receivers join or ignore |
+
+---
+
+## Hard rules
+
+1. **Group calls broadcast a custom message; they do NOT use the call listener.** Add a `MessageListener` for custom UI.
+2. **Session ID = group GUID.** Persistent.
+3. **V6's "five required workarounds" (W1–W5 in SKILL.md) apply to group calls too** — same calls-sdk-android peer dep, same `Call` constructor arg order, same stub classes. Group calls share the underlying WebRTC layer.
+4. **No `CometChat.endCall` for groups.** Use `CallSession.getInstance().leaveSession()` only.
+
+---
+
+## Caller side — Compose (kit)
+
+```kotlin
+import com.cometchat.chatuikit.calls.callbuttons.CometChatCallButtons
+
+@Composable
+fun GroupHeader(group: Group) {
+    Row {
+        Text(group.name)
+        // ⚠️ V6 W4 — DO NOT use CometChatCallButtons composable for 1:1 user
+        // calls (broken in 6.0.0 — captures first-rendered user globally).
+        // For groups, the composable's same bug may or may not apply; check
+        // current chatuikit-compose-android version's release notes.
+        CometChatCallButtons(group = group)
+    }
+}
+```
+
+The kit's `CometChatCallButtons(group = group)` composable sends the same `CustomMessage` of type `"meeting"` as the Kotlin Views variant. V6 W4 (the per-row state-capture bug) primarily affects the `user` prop variant; group-targeted use may be safer but verify against the installed version.
+
+## Caller side — Kotlin Views (kit)
+
+```kotlin
+val callButtons = CometChatCallButtons(this).apply {
+    setGroup(group)
+}
+```
+
+Same behavior as V5.
+
+## Caller side — custom UI
+
+```kotlin
+import com.cometchat.chat.core.CometChat
+import com.cometchat.chat.models.CustomMessage
+import com.cometchat.chat.constants.CometChatConstants
+import org.json.JSONObject
+
+fun startGroupCall(groupGuid: String, callType: String) {
+    val sessionId = groupGuid
+    val customData = JSONObject().apply {
+        put("callType", callType)
+        put("sessionId", sessionId)
+    }
+    val meetingMessage = CustomMessage(
+        groupGuid,
+        CometChatConstants.RECEIVER_TYPE_GROUP,
+        "meeting",
+        customData,
+    ).apply {
+        category = CometChatConstants.CATEGORY_CUSTOM
+        metadata = JSONObject().apply {
+            put("incrementUnreadCount", true)
+            put("pushNotification", "meeting")
+            put("callType", callType)
+            put("sessionId", sessionId)
+        }
+    }
+    CometChat.sendCustomMessage(meetingMessage, object : CometChat.CallbackListener<CustomMessage>() {
+        override fun onSuccess(p0: CustomMessage) {
+            // navigate to your OngoingCall composable / Activity with sessionId
+        }
+        override fun onError(p0: CometChatException) { /* surface */ }
+    })
+}
+```
+
+---
+
+## Receiver side — kit-based (auto-renders meeting card)
+
+`CometChatMessageList(group = group)` (Compose) or the Kotlin Views equivalent renders the meeting message as a "Join meeting" card.
+
+## Receiver side — custom UI
+
+```kotlin
+private val GROUP_MEETING_LISTENER_ID = "APP_ROOT_GROUP_MEETING_LISTENER"
+
+CometChat.addMessageListener(GROUP_MEETING_LISTENER_ID, object : CometChat.MessageListener() {
+    override fun onCustomMessageReceived(msg: CustomMessage) {
+        if (msg.category != CometChatConstants.CATEGORY_CUSTOM) return
+        if (msg.type != "meeting") return
+        val customData = msg.customData ?: return
+        val sessionId = customData.optString("sessionId", msg.receiverUid)
+        val callType = customData.optString("callType", "video")
+        val fromUid = msg.sender.uid
+        val groupGuid = msg.receiverUid
+        // Compose: state.update { it.copy(incomingMeeting = ...) }
+        // Views: runOnUiThread { showIncomingMeetingDialog(...) }
+    }
+})
+
+// Cleanup:
+DisposableEffect(Unit) {
+    onDispose { CometChat.removeMessageListener(GROUP_MEETING_LISTENER_ID) }
+}
+```
+
+Wrap in `DisposableEffect` (Compose) or `onDestroy()` (Views).
+
+---
+
+## Edge cases
+
+### Late joining
+
+Meeting message persists in chat history. Tap to join — works hours after.
+
+### V6 calls-sdk-android peer dep
+
+Same W1 workaround applies to group calls — `com.cometchat:calls-sdk-android:5.0.+` must be an explicit peer dep in `app/build.gradle.kts`. Without it, group-call join fails the same way 1:1 join fails.
+
+### Push notifications
+
+Meeting `CustomMessage.metadata.pushNotification = "meeting"` — routed via regular FCM. No ConnectionService-ring out of the box.
+
+---
+
+## Anti-patterns
+
+1. **Registering `CometChat.addCallListener` only — expecting group ringing.** Won't fire.
+2. **Skipping the V6 W1–W5 workarounds for groups.** They apply equally — calls-sdk-android peer dep, annotations-java5 exclude, stub classes, Call constructor arg order, avoid V6 `CometChatCallButtons` composable per-row bug.
+3. **`CometChat.endCall(sessionId)` after group hangup.** No call entity. Use `CallSession.getInstance().leaveSession()`.
+4. **Treating sessionId as ephemeral.** It's the group GUID.
+
+---
+
+## Verification checklist
+
+- [ ] V6 workarounds W1–W5 applied (calls-sdk-android peer dep + manifest etc. — see SKILL.md §"Five required workarounds")
+- [ ] Kit caller: `CometChatCallButtons(group = ...)` / `setGroup(group)` initiates meeting message
+- [ ] Custom caller: `CometChat.sendCustomMessage` with `type="meeting"`, `category=CATEGORY_CUSTOM`
+- [ ] Kit receiver: `CometChatMessageList` renders meeting card
+- [ ] Custom receiver: `addMessageListener` registered with category+type filter
+- [ ] On hangup: `CallSession.getInstance().leaveSession()` only (no `endCall`)
+
+---
+
+## Pointers
+
+- `cometchat-android-v6-calls/SKILL.md` §"Five required workarounds" — V6 build prerequisites
+- `ringing-integration.md` — 1:1 user calls
+- Canonical docs: https://www.cometchat.com/docs/calls/android/group-calls
+- Cross-platform reference (semantic ground-truth): `cometchat-react-calls/references/group-calls.md`

package/skills/cometchat-android-v6-calls/references/idle-timeout.md

@@ -0,0 +1,107 @@
+# Idle timeout on Android V6 (Compose + Kotlin Views)
+
+Same SDK API as V5. V6-specific: Compose `AlertDialog` for new code, ViewModel + `collectAsStateWithLifecycle` (cf. `references/raise-hand.md` V6 sibling).
+
+**Canonical docs:** https://www.cometchat.com/docs/calls/android/idle-timeout
+**Read first:** `cometchat-android-v5-calls/references/idle-timeout.md` — V5 sister covers ViewModel pattern.
+
+---
+
+## SDK API (same as V5)
+
+```kotlin
+val settings = SessionSettingsBuilder(context, callContainer)
+  .setSessionType(SessionType.VIDEO)
+  .setIdleTimeoutPeriodBeforePrompt(60_000)
+  .setIdleTimeoutPeriodAfterPrompt(120_000)
+  .build()
+```
+
+---
+
+## Compose prompt
+
+```kotlin
+@Composable
+fun IdleTimeoutPrompt(
+  onStay: () -> Unit,
+  onEnd: () -> Unit,
+) {
+  AlertDialog(
+    onDismissRequest = { /* prevent backdrop dismiss */ },
+    title = { Text("Still there?") },
+    text = { Text("You're alone in this call. It'll end in 60 seconds.") },
+    confirmButton = {
+      Button(onClick = onStay) { Text("Stay") }
+    },
+    dismissButton = {
+      TextButton(onClick = onEnd) {
+        Text("End now", color = MaterialTheme.colorScheme.error)
+      }
+    },
+  )
+}
+```
+
+`onDismissRequest = { }` (empty) prevents backdrop dismiss — Compose's AlertDialog doesn't have a `setCancelable(false)` equivalent; you swallow the dismiss.
+
+---
+
+## Wiring in CallScreen
+
+```kotlin
+@Composable
+fun CallScreen(viewModel: CallViewModel = viewModel()) {
+  val state by viewModel.state.collectAsStateWithLifecycle()
+
+  Box(modifier = Modifier.fillMaxSize()) {
+    // CometChat call surface
+    CometChatOngoingCall(modifier = Modifier.fillMaxSize())
+
+    if (state.showIdlePrompt) {
+      IdleTimeoutPrompt(
+        onStay = { viewModel.dismissIdlePrompt() },
+        onEnd = { CallSession.getInstance().leaveSession() },
+      )
+    }
+
+    // Toast for actual timeout (after grace period)
+    val context = LocalContext.current
+    LaunchedEffect(state.timedOut) {
+      if (state.timedOut) {
+        Toast.makeText(context, "Call ended due to inactivity", Toast.LENGTH_LONG).show()
+      }
+    }
+  }
+}
+```
+
+`collectAsStateWithLifecycle()` (V6 pattern) replaces V5's manual `repeatOnLifecycle`.
+
+---
+
+## Anti-patterns
+
+V5 sister rules apply, plus V6-specific:
+
+1. **`AlertDialog` with `onDismissRequest = { onEnd() }`.** Wrong — backdrop tap accidentally ends the call. Empty body or explicit no-op.
+2. **`LaunchedEffect(state)` instead of `LaunchedEffect(state.timedOut)`.** Re-fires on every state change.
+
+---
+
+## Verification checklist
+
+- [ ] SessionSettingsBuilder sets both idle periods
+- [ ] Compose AlertDialog `onDismissRequest = { }` (empty)
+- [ ] `collectAsStateWithLifecycle()` for state binding
+- [ ] LaunchedEffect on specific field, not whole state
+- [ ] Real-device smoke: same as V5
+
+---
+
+## Pointers
+
+- `cometchat-android-v5-calls/references/idle-timeout.md` — V5 sister
+- `cometchat-android-v6-calls` SKILL.md
+- `cometchat-android-v6-calls/references/raise-hand.md` — Compose pattern sibling
+- Canonical docs: https://www.cometchat.com/docs/calls/android/idle-timeout