@cometchat/skills 4.4.2 → 5.0.1

package/skills/cometchat-android-v5-calls/references/add-calls-to-existing-chat.md

@@ -1,197 +0,0 @@
-# Adding calls to an existing chat integration (Android V5)
-
-You have `chatuikit-android` (V5 cohort) working. Adding calls = `calls-sdk-android` + ConnectionService + foreground service permissions.
-
-**Read first:** `cometchat-android-v5-calls/SKILL.md` — seven hard rules (init order, ConnectionService, foreground service type, hangup teardown).
-
----
-
-## Step 1 — Install Calls SDK from Cloudsmith
-
-```kotlin
-// settings.gradle.kts (or settings.gradle)
-dependencyResolutionManagement {
-  repositories {
-    maven { url = uri("https://dl.cloudsmith.io/public/cometchat/cometchat/maven/") }
-    google()
-    mavenCentral()
-  }
-}
-
-// app/build.gradle.kts
-dependencies {
-  implementation("com.cometchat:calls-sdk-android:5.+")
-  // existing chat-uikit dependency stays
-}
-```
-
-```bash
-./gradlew :app:dependencies | grep calls-sdk-android
-```
-
-Should resolve to `5.x.x`.
-
----
-
-## Step 2 — Permissions + manifest
-
-```xml
-<!-- AndroidManifest.xml -->
-<uses-permission android:name="android.permission.RECORD_AUDIO"/>
-<uses-permission android:name="android.permission.CAMERA"/>
-<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS"/>
-<uses-permission android:name="android.permission.BLUETOOTH"/>
-<uses-permission android:name="android.permission.BLUETOOTH_CONNECT"/>
-<uses-permission android:name="android.permission.MANAGE_OWN_CALLS"/>
-<uses-permission android:name="android.permission.FOREGROUND_SERVICE"/>
-<uses-permission android:name="android.permission.FOREGROUND_SERVICE_MICROPHONE"/>
-<uses-permission android:name="android.permission.FOREGROUND_SERVICE_CAMERA"/>
-
-<application ...>
-  <service
-    android:name=".AppConnectionService"
-    android:permission="android.permission.BIND_TELECOM_CONNECTION_SERVICE"
-    android:foregroundServiceType="microphone|camera"
-    android:exported="true">
-    <intent-filter>
-      <action android:name="android.telecom.ConnectionService"/>
-    </intent-filter>
-  </service>
-</application>
-```
-
-`foregroundServiceType="microphone|camera"` is mandatory on Android 14+.
-
----
-
-## Step 3 — Init order: chat → calls
-
-In your existing `Application.onCreate` or your init activity:
-
-```kotlin
-import com.cometchat.calls.core.CometChatCalls
-import com.cometchat.calls.core.CallAppSettings
-
-// Existing chat init
-CometChatUIKit.init(this, uikitSettings, object : CometChat.CallbackListener<String>() {
-  override fun onSuccess(s: String) {
-    // NEW: Calls init AFTER chat init
-    val callsSettings = CallAppSettings(appId = APP_ID, region = REGION)
-    CometChatCalls.init(callsSettings, object : CometChatCalls.CallbackListener<String>() {
-      override fun onSuccess(s: String) { /* both initialized */ }
-      override fun onError(e: CometChatException) { Log.e("App", "Calls init failed", e) }
-    })
-  }
-
-  override fun onError(e: CometChatException) {}
-})
-```
-
----
-
-## Step 4 — Login both SDKs
-
-After your existing login flow:
-
-```kotlin
-CometChat.login(uid, authKey, object : CometChat.CallbackListener<User>() {
-  override fun onSuccess(user: User) {
-    // Calls SDK login uses the SAME uid + authKey (the chat `User` has no
-    // `authToken` accessor — if you need a token it's the static
-    // `CometChat.getUserAuthToken()`). Callback type is CallUser, not User.
-    CometChatCalls.login(uid, authKey, object : CometChatCalls.CallbackListener<CallUser>() {
-      override fun onSuccess(callUser: CallUser) { /* calls SDK ready */ }
-      override fun onError(e: com.cometchat.calls.exceptions.CometChatException) {}
-    })
-  }
-  override fun onError(e: CometChatException) {}
-})
-```
-
----
-
-## Step 5 — IncomingCall via ConnectionService
-
-Implement `AppConnectionService` (see `cometchat-android-v5-calls/SKILL.md` rule 4). The ConnectionService receives FCM data-message → calls `addNewIncomingCall` → OS shows incoming-call UI.
-
-Plus an `IncomingCallActivity` that handles user action (accept/reject) and routes to your chat UI's call surface:
-
-```kotlin
-class IncomingCallActivity : AppCompatActivity() {
-  override fun onCreate(savedInstanceState: Bundle?) {
-    super.onCreate(savedInstanceState)
-    // Show over lock screen
-    setShowWhenLocked(true)
-    setTurnScreenOn(true)
-    // ... bind your incoming-call layout
-  }
-}
-```
-
----
-
-## Step 6 — FCM token registration
-
-Add a `FirebaseMessagingService` subclass and POST tokens to your server (see `cometchat-android-v5-calls/references/server-fcm-voip.md`):
-
-```kotlin
-class VoipMessagingService : FirebaseMessagingService() {
-  override fun onNewToken(token: String) {
-    // POST to your server, keyed to current user UID
-    api.registerCallToken(currentUid, "android-fcm", token)
-  }
-
-  override fun onMessageReceived(message: RemoteMessage) {
-    if (message.data["type"] != "incoming_call") return
-    // Hand off to ConnectionService — see V5 server-fcm-voip reference
-  }
-}
-```
-
-Register in manifest:
-```xml
-<service
-  android:name=".VoipMessagingService"
-  android:exported="false">
-  <intent-filter>
-    <action android:name="com.google.firebase.MESSAGING_EVENT" />
-  </intent-filter>
-</service>
-```
-
----
-
-## Step 7 — Hangup teardown
-
-```kotlin
-fun endCall(sessionId: String) {
-  CometChatCalls.endSession()  // static teardown (there is NO static CometChatCalls.leaveSession() — leaveSession is instance-only on CallSession.getInstance())
-  CometChat.endCall(sessionId, object : CometChat.CallbackListener<Call>() { /* ... */ })
-  // ConnectionService disconnect
-  activeConnection?.setDisconnected(DisconnectCause(DisconnectCause.LOCAL))
-  activeConnection?.destroy()
-}
-```
-
----
-
-## Verification checklist
-
-- [ ] Cloudsmith Maven repo added
-- [ ] `calls-sdk-android:5.+` in app/build.gradle
-- [ ] Manifest permissions: RECORD_AUDIO, CAMERA, MANAGE_OWN_CALLS, FOREGROUND_SERVICE_MICROPHONE/CAMERA
-- [ ] AppConnectionService declared with `foregroundServiceType` + permission
-- [ ] Calls init runs AFTER chat init's onSuccess
-- [ ] Calls login runs AFTER chat login's onSuccess
-- [ ] FCM token registered + POSTed to server
-- [ ] Hangup tears down all 3: leaveSession, endCall, ConnectionService disconnect
-- [ ] Real-device smoke: app killed → caller dials → recipient phone rings on lock screen
-- [ ] Run `cometchat verify --calls` — should pass
-
----
-
-## Pointers
-
-- `cometchat-react-calls/references/add-calls-to-existing-chat.md` — canonical
-- `cometchat-android-v5-calls/SKILL.md` — seven hard rules
-- `cometchat-android-v5-calls/references/server-fcm-voip.md` — server-side FCM

package/skills/cometchat-android-v5-calls/references/audio-controls.md

@@ -1,91 +0,0 @@
----
-name: audio-controls
-description: Control audio during calls — mute/unmute microphone, switch audio output device (speaker, earpiece, bluetooth). Use when implementing audio toggle, audio mode switching, or custom mute buttons. Triggers on "mute audio", "unmute", "audio mode", "speaker", "earpiece", "bluetooth audio".
-inclusion: manual
----
-
-# CometChat Calls SDK v5 — Audio Controls
-
-## Overview
-
-Programmatically control the local microphone (mute/unmute) and audio output device (speaker, earpiece, Bluetooth, headphones) during an active call.
-
-## Key Imports
-
-```kotlin
-import com.cometchat.calls.core.CallSession
-import com.cometchat.calls.model.AudioMode
-import com.cometchat.calls.listeners.MediaEventsListener
-```
-
-## Implementation
-
-### Mute / Unmute
-
-```kotlin
-val callSession = CallSession.getInstance()
-
-callSession.muteAudio()    // mute microphone
-callSession.unmuteAudio()  // unmute microphone
-```
-
-### Switch Audio Output
-
-```kotlin
-callSession.setAudioMode(AudioMode.SPEAKER)     // loudspeaker
-callSession.setAudioMode(AudioMode.EARPIECE)     // phone earpiece
-callSession.setAudioMode(AudioMode.BLUETOOTH)    // connected Bluetooth device
-callSession.setAudioMode(AudioMode.HEADPHONES)   // wired headphones
-```
-
-### Listen for Audio Events
-
-```kotlin
-callSession.addMediaEventsListener(this, object : MediaEventsListener() {
-    override fun onAudioMuted() {
-        // Update mute button to "muted" state
-    }
-    override fun onAudioUnMuted() {
-        // Update mute button to "unmuted" state
-    }
-    override fun onAudioModeChanged(audioMode: AudioMode) {
-        when (audioMode) {
-            AudioMode.SPEAKER -> { /* update icon */ }
-            AudioMode.EARPIECE -> { /* update icon */ }
-            AudioMode.BLUETOOTH -> { /* update icon */ }
-            AudioMode.HEADPHONES -> { /* update icon */ }
-        }
-    }
-    // ... other required overrides
-    override fun onVideoPaused() {}
-    override fun onVideoResumed() {}
-    override fun onRecordingStarted() {}
-    override fun onRecordingStopped() {}
-    override fun onCameraFacingChanged(facing: CameraFacing) {}
-})
-// Screen-share is observed via ParticipantEventListener.onParticipantStartedScreenShare /
-// onParticipantStoppedScreenShare — NOT MediaEventsListener.
-```
-
-### Initial Audio Settings (Pre-Session)
-
-```kotlin
-val sessionSettings = CometChatCalls.SessionSettingsBuilder()
-    .startAudioMuted(true)              // join muted
-    .setAudioMode(AudioMode.SPEAKER)    // initial output device
-    .hideToggleAudioButton(false)       // show mute button
-    .hideAudioModeButton(false)         // show audio mode button
-    .build()
-```
-
-## Gotchas
-
-- `muteAudio()` / `unmuteAudio()` only work during an active session
-- Audio mode changes trigger `onAudioModeChanged()` on `MediaEventsListener`
-- `AudioMode` enum: `SPEAKER`, `EARPIECE`, `BLUETOOTH`, `HEADPHONES`
-- For voice calls, default to `AudioMode.EARPIECE`; for video calls, default to `AudioMode.SPEAKER`
-- Bluetooth audio mode only works when a Bluetooth device is connected
-
-## Sample App Reference
-
-- `CallActivity.kt` — Sets `AudioMode.EARPIECE` for voice calls, `AudioMode.SPEAKER` for video calls

package/skills/cometchat-android-v5-calls/references/background-handling.md

@@ -1,168 +0,0 @@
----
-name: background-handling
-description: Keep calls alive in background using CometChatOngoingCallService foreground service. Use when handling home button press during calls, ongoing call notifications, or preventing call termination. Triggers on "background handling", "foreground service", "ongoing call", "CometChatOngoingCallService", "keep call alive".
-inclusion: manual
----
-
-# CometChat Calls SDK v5 — Background Handling
-
-## Overview
-
-`CometChatOngoingCallService` is a foreground service that keeps calls alive when users press HOME or switch apps. Shows an ongoing notification with tap-to-return and hangup actions.
-
-## Prerequisites
-
-- Active call session
-- Foreground service permissions in manifest
-
-## Key Imports
-
-```kotlin
-import com.cometchat.calls.services.CometChatOngoingCallService
-import com.cometchat.calls.utils.OngoingNotification
-import com.cometchat.calls.core.CallSession
-import com.cometchat.calls.listeners.SessionStatusListener
-import com.cometchat.calls.listeners.ButtonClickListener
-```
-
-## Implementation
-
-### 1. Manifest Permissions
-
-```xml
-<uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
-<uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PLAYBACK" />
-<uses-permission android:name="android.permission.FOREGROUND_SERVICE_MICROPHONE" />
-<uses-permission android:name="android.permission.FOREGROUND_SERVICE_CAMERA" />
-<uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PROJECTION" />
-<uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
-```
-
-### 2. Start/Stop Service
-
-```kotlin
-callSession.addSessionStatusListener(this, object : SessionStatusListener() {
-    override fun onSessionJoined() {
-        CometChatOngoingCallService.launch(this@CallActivity)
-    }
-    override fun onSessionLeft() {
-        CometChatOngoingCallService.abort(this@CallActivity)
-        finish()
-    }
-    override fun onConnectionClosed() {
-        CometChatOngoingCallService.abort(this@CallActivity)
-        finish()
-    }
-    override fun onSessionTimedOut() {
-        CometChatOngoingCallService.abort(this@CallActivity)
-        finish()
-    }
-    override fun onConnectionLost() {}
-    override fun onConnectionRestored() {}
-})
-```
-
-### 3. Handle Leave Button
-
-```kotlin
-callSession.addButtonClickListener(this, object : ButtonClickListener() {
-    override fun onLeaveSessionButtonClicked() {
-        endCall()
-    }
-})
-```
-
-### 4. Handle Remote Call End
-
-Register a `CometChat.CallListener` to detect when the remote party ends the call, then clean up the foreground service:
-
-```kotlin
-CometChat.addCallListener(LISTENER_ID, object : CometChat.CallListener() {
-    override fun onCallEndedMessageReceived(call: Call?) {
-        val session = CallSession.getInstance()
-        if (session.isSessionActive) {
-            session.leaveSession()
-        }
-        CometChatOngoingCallService.abort(this@CallActivity)
-        runOnUiThread { finish() }
-    }
-    override fun onIncomingCallReceived(call: Call?) {}
-    override fun onOutgoingCallAccepted(call: Call?) {}
-    override fun onOutgoingCallRejected(call: Call?) {}
-    override fun onIncomingCallCancelled(call: Call?) {}
-})
-```
-
-### 5. Always Stop in onDestroy
-
-```kotlin
-override fun onDestroy() {
-    super.onDestroy()
-    CometChat.removeCallListener(LISTENER_ID)
-    CometChatOngoingCallService.abort(this)
-}
-```
-
-### 6. Custom Notification (Optional)
-
-```kotlin
-private fun buildCustomNotification(): Notification {
-    val channelId = "CometChat_Call_Ongoing_Conference"  // must use this ID
-    val intent = Intent(this, CallActivity::class.java).apply {
-        flags = Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP
-    }
-    val pendingIntent = PendingIntent.getActivity(
-        this, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
-    )
-    return NotificationCompat.Builder(this, channelId)
-        .setSmallIcon(R.drawable.ic_call)
-        .setContentTitle("Ongoing Call")
-        .setContentText("Tap to return to your call")
-        .setPriority(NotificationCompat.PRIORITY_HIGH)
-        .setContentIntent(pendingIntent)
-        .setOngoing(true)
-        .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
-        .build()
-}
-
-// Set before launching service
-OngoingNotification.buildOngoingConferenceNotification(buildCustomNotification())
-CometChatOngoingCallService.launch(this)
-```
-
-### 7. VoIP Integration — Additional Cleanup (Optional)
-
-When using background handling with VoIP calling (ConnectionService + TelecomManager), also disconnect the `CallConnection` and cancel any VoIP notifications on every terminal state:
-
-```kotlin
-// In each terminal callback (onSessionLeft, onSessionTimedOut, onConnectionClosed, onCallEndedMessageReceived):
-CometChatOngoingCallService.abort(this@CallActivity)
-CallConnectionHolder.endCall()
-CallNotificationManager.cancelNotification(this@CallActivity)
-finish()
-```
-
-See the `sample-app-voip` CallActivity for the full VoIP-integrated pattern.
-
-## API Reference
-
-| Method | Description |
-|--------|-------------|
-| `CometChatOngoingCallService.launch(context)` | Start foreground service |
-| `CometChatOngoingCallService.abort(context)` | Stop foreground service |
-| `OngoingNotification.buildOngoingConferenceNotification(notification)` | Set custom notification (call before `launch()`) |
-
-## Gotchas
-
-- The notification channel ID **must** be `"CometChat_Call_Ongoing_Conference"`
-- Always call `abort()` in `onDestroy()` to prevent leaked services
-- Always remove `CometChat.CallListener` in `onDestroy()` to prevent leaks
-- This is for keeping **active** calls alive — for receiving calls when app is killed, use VoIP Calling
-- Call `launch()` only after `onSessionJoined()` — not before joining
-- Custom notification must be set **before** calling `launch()`
-- When using VoIP (ConnectionService), also call `CallConnectionHolder.endCall()` in every terminal state to properly disconnect the Telecom connection
-
-## Sample App Reference
-
-- `sample-app-ringing` — `CallActivity.kt` — basic foreground service pattern with `launch()` in `onSessionJoined()`, `abort()` in `onSessionLeft()` and `onDestroy()`
-- `sample-app-voip` — `CallActivity.kt` — full VoIP-integrated pattern with foreground service + CallConnection cleanup + notification cancellation on every terminal state

package/skills/cometchat-android-v5-calls/references/call-layouts.md

@@ -1,131 +0,0 @@
-# Call layouts on Android V5 (Views)
-
-Same three layouts (TILE/SIDEBAR/SPOTLIGHT). Android V5 uses Java/Kotlin builders + `MaterialButtonToggleGroup` for the switcher (Material Components for Android).
-
-**Canonical docs:** https://www.cometchat.com/docs/calls/android/call-layouts
-**Read first:** `cometchat-react-calls/references/call-layouts.md` — layout matrix + when to lock.
-
----
-
-## SDK API
-
-```kotlin
-import com.cometchat.calls.core.CometChatCalls
-import com.cometchat.calls.listeners.LayoutListener
-import com.cometchat.calls.model.SessionType
-import com.cometchat.calls.model.LayoutType
-
-val settings = CometChatCalls.SessionSettingsBuilder()
-  .setSessionType(SessionType.VIDEO)
-  .setLayout(LayoutType.TILE)        // TILE | SIDEBAR | SPOTLIGHT
-  .hideChangeLayoutButton(false)
-  .build()
-
-// There is no static mid-call setter in v5. Layout is set at join via
-// SessionSettingsBuilder.setLayout(...); to change it mid-call, re-join the
-// session with a new SessionSettingsBuilder. Layout CHANGES are observed
-// via LayoutListener.onCallLayoutChanged(layoutType) — register on the
-// CallSession instance returned from joinSession's onSuccess callback.
-callSession.addLayoutListener(this, object : LayoutListener() {
-  override fun onCallLayoutChanged(layoutType: LayoutType) {
-    activity.runOnUiThread {
-      // Update segmented button state
-    }
-  }
-})
-```
-
----
-
-## XML — MaterialButtonToggleGroup
-
-```xml
-<com.google.android.material.button.MaterialButtonToggleGroup
-    android:id="@+id/layoutToggle"
-    android:layout_width="wrap_content"
-    android:layout_height="wrap_content"
-    app:singleSelection="true"
-    app:selectionRequired="true"
-    android:contentDescription="@string/call_layout">
-
-  <com.google.android.material.button.MaterialButton
-      android:id="@+id/layoutTile"
-      style="@style/Widget.Material3.Button.OutlinedButton"
-      android:text="@string/layout_tile" />
-
-  <com.google.android.material.button.MaterialButton
-      android:id="@+id/layoutSidebar"
-      style="@style/Widget.Material3.Button.OutlinedButton"
-      android:text="@string/layout_sidebar" />
-
-  <com.google.android.material.button.MaterialButton
-      android:id="@+id/layoutSpotlight"
-      style="@style/Widget.Material3.Button.OutlinedButton"
-      android:text="@string/layout_spotlight" />
-</com.google.android.material.button.MaterialButtonToggleGroup>
-```
-
----
-
-## Wire-up in Activity
-
-```kotlin
-binding.layoutToggle.addOnButtonCheckedListener { _, checkedId, isChecked ->
-  if (!isChecked) return@addOnButtonCheckedListener
-
-  val layout = when (checkedId) {
-    R.id.layoutTile -> LayoutType.TILE
-    R.id.layoutSidebar -> LayoutType.SIDEBAR
-    R.id.layoutSpotlight -> LayoutType.SPOTLIGHT
-    else -> return@addOnButtonCheckedListener
-  }
-  // v5 has no static mid-call setter — re-join the session with new settings
-  // to apply the chosen layout.
-  val settings = CometChatCalls.SessionSettingsBuilder()
-    .setSessionType(SessionType.VIDEO)
-    .setLayout(layout)
-    .build()
-  // CometChatCalls.joinSession(sessionId, callToken, settings, ...) — see join-session.md
-}
-
-// Sync from kit's switcher — observed via LayoutListener.onCallLayoutChanged
-override fun onCallLayoutChanged(layoutType: LayoutType) {
-  runOnUiThread {
-    val id = when (layoutType) {
-      LayoutType.TILE -> R.id.layoutTile
-      LayoutType.SIDEBAR -> R.id.layoutSidebar
-      LayoutType.SPOTLIGHT -> R.id.layoutSpotlight
-      else -> return@runOnUiThread
-    }
-    binding.layoutToggle.check(id)
-  }
-}
-```
-
----
-
-## Anti-patterns
-
-Web sister rules apply, plus Android-specific:
-
-1. **`Spinner` instead of `MaterialButtonToggleGroup`.** Spinner hides options; toggle group is the radio-group native pattern in Material.
-2. **`onCheckedChange` without `isChecked` guard.** Fires twice (once for unchecked, once for checked) — spurious `setLayout` calls.
-3. **Forgetting `runOnUiThread` in the listener.** Crash on view updates from background thread.
-
----
-
-## Verification checklist
-
-- [ ] Initial layout via `setLayout(LayoutType.X)` on `SessionSettingsBuilder`
-- [ ] `MaterialButtonToggleGroup` with `singleSelection="true"`
-- [ ] `addOnButtonCheckedListener` guards on `isChecked`
-- [ ] `onCallLayoutChanged` updates toggle group on UI thread
-- [ ] Real-device smoke: switcher cycles all 3, kit's switcher syncs custom UI
-
----
-
-## Pointers
-
-- `cometchat-react-calls/references/call-layouts.md` — sister
-- `cometchat-android-v5-calls` SKILL.md
-- Canonical docs: https://www.cometchat.com/docs/calls/android/call-layouts

package/skills/cometchat-android-v5-calls/references/call-logs.md

@@ -1,113 +0,0 @@
----
-name: call-logs
-description: Fetch call history using CallLogRequest with pagination and filters. Use when displaying call logs, filtering by type/status/recording, or accessing recordings. Triggers on "call logs", "call history", "CallLogRequest", "fetch recordings".
-inclusion: manual
----
-
-# CometChat Calls SDK v5 — Call Logs
-
-## Overview
-
-Retrieve call history using `CallLogRequest` with pagination, filtering by type, status, direction, recordings, and specific users/groups.
-
-## Key Imports
-
-```kotlin
-import com.cometchat.calls.core.CometChatCalls
-import com.cometchat.calls.model.CallLog
-import com.cometchat.calls.model.CallLogRequest
-import com.cometchat.calls.model.Recording
-import com.cometchat.calls.exceptions.CometChatException
-```
-
-## Implementation
-
-### Basic Fetch
-
-```kotlin
-val callLogRequest = CallLogRequest.CallLogRequestBuilder()
-    .setLimit(30)
-    .build()
-
-callLogRequest.fetchNext(object : CometChatCalls.CallbackListener<List<CallLog>>() {
-    override fun onSuccess(callLogs: List<CallLog>) {
-        for (log in callLogs) {
-            Log.d(TAG, "Session: ${log.sessionID}, Duration: ${log.totalDuration}, Status: ${log.status}")
-        }
-    }
-    override fun onError(e: CometChatException) {
-        Log.e(TAG, "Error: ${e.message}")
-    }
-})
-```
-
-### Filtered Queries
-
-```kotlin
-// Video calls only
-CallLogRequest.CallLogRequestBuilder().setSessionType("video").setLimit(20).build()
-
-// Calls with recordings
-CallLogRequest.CallLogRequestBuilder().setHasRecording(true).build()
-
-// Missed incoming calls
-CallLogRequest.CallLogRequestBuilder().setCallStatus("missed").setCallDirection("incoming").build()
-
-// Calls with a specific user
-CallLogRequest.CallLogRequestBuilder().setUid("user_id").build()
-
-// Meeting calls only
-CallLogRequest.CallLogRequestBuilder().setCallCategory("meet").build()
-```
-
-### Pagination
-
-```kotlin
-// Forward pagination
-callLogRequest.fetchNext(listener)
-
-// Backward pagination
-callLogRequest.fetchPrevious(listener)
-```
-
-### Access Recordings
-
-```kotlin
-for (callLog in callLogs) {
-    if (callLog.isHasRecording) {
-        callLog.recordings?.forEach { recording ->
-            Log.d(TAG, "URL: ${recording.recordingURL}")
-            Log.d(TAG, "Duration: ${recording.duration} seconds")
-        }
-    }
-}
-```
-
-### CallLog Properties
-
-| Property | Type | Description |
-|----------|------|-------------|
-| `sessionID` | String | Session identifier |
-| `type` | String | `video` or `audio` |
-| `status` | String | `ended`, `missed`, `rejected`, `cancelled`, etc. |
-| `callCategory` | String | `call` or `meet` |
-| `totalDuration` | String | Human-readable duration |
-| `totalParticipants` | int | Participant count |
-| `hasRecording` | boolean | Whether recorded |
-| `recordings` | List\<Recording\> | Recording objects |
-| `initiator` | CallEntity | Who started the call |
-| `receiver` | CallEntity | Who received the call |
-
-## Gotchas
-
-- `CallLogRequest` is from the **Calls SDK**, not the Chat SDK
-- `setSessionType()` takes lowercase strings: `"video"` or `"audio"`
-- `setCallDirection()` takes `"incoming"` or `"outgoing"`
-- `setCallCategory()` takes `"call"` or `"meet"`
-- Create a new `CallLogRequest` to reset pagination
-- The sample app uses Chat SDK's `MessagesRequest` for call logs — the Calls SDK's `CallLogRequest` provides richer data
-
-## Sample App Reference
-
-- `Repository.kt` — `fetchCallLogs()` (uses Chat SDK approach)
-- For Calls SDK approach, use `CallLogRequest` as shown above