@cometchat/skills 4.0.0 → 4.2.0

package/skills/cometchat-android-v5-calls/references/setup.md

@@ -0,0 +1,137 @@
+---
+name: setup
+description: Set up CometChat Calls SDK v5 for Android. Use when adding SDK dependencies, configuring Cloudsmith maven, CallAppSettings, init, permissions, or Jetifier. Triggers on "setup calls sdk", "add cometchat dependency", "initialize calls", "gradle setup".
+inclusion: manual
+---
+
+# CometChat Calls SDK v5 — Setup
+
+## Overview
+
+Install and initialize the CometChat Calls SDK v5 (beta) in an Android project. Covers Cloudsmith maven repository, Gradle dependencies, manifest permissions, Jetifier, and `CometChatCalls.init()`.
+
+## Prerequisites
+
+- Android project with minSdk 26+, compileSdk 35
+- App ID and Region from CometChat Dashboard
+
+## Key Imports
+
+```kotlin
+import com.cometchat.calls.core.CometChatCalls
+import com.cometchat.calls.core.CallAppSettings
+import com.cometchat.calls.exceptions.CometChatException
+```
+
+## Implementation
+
+### 1. Add Cloudsmith Maven Repository
+
+In project-level `settings.gradle.kts` (or `build.gradle`):
+
+```kotlin
+dependencyResolutionManagement {
+    repositories {
+        google()
+        mavenCentral()
+        maven { url = uri("https://dl.cloudsmith.io/public/cometchat/cometchat/maven/") }
+    }
+}
+```
+
+### 2. Add Dependencies
+
+In app-level `build.gradle.kts`:
+
+```kotlin
+dependencies {
+    // CometChat Calls SDK v5
+    implementation("com.cometchat:calls-sdk-android:5.0.0-beta.2")
+
+    // If using ringing (dual-SDK), also add Chat SDK:
+    // implementation("com.cometchat:chat-sdk-android:4.0.+")
+}
+```
+
+### 3. Enable Jetifier
+
+In `gradle.properties`:
+
+```properties
+android.useAndroidX=true
+android.enableJetifier=true
+```
+
+### 4. Java Compatibility
+
+In app-level `build.gradle.kts`:
+
+```kotlin
+android {
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_1_8
+        targetCompatibility = JavaVersion.VERSION_1_8
+    }
+}
+```
+
+### 5. Manifest Permissions
+
+In `AndroidManifest.xml`:
+
+```xml
+<uses-permission android:name="android.permission.INTERNET" />
+<uses-permission android:name="android.permission.CAMERA" />
+<uses-permission android:name="android.permission.RECORD_AUDIO" />
+<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
+<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+```
+
+### 6. Initialize SDK
+
+Call once in `Application.onCreate()` or main Activity:
+
+```kotlin
+val callAppSettings = CallAppSettings.CallAppSettingBuilder("APP_ID", "REGION").build()
+
+CometChatCalls.init(this, callAppSettings, object : CometChatCalls.CallbackListener<String>() {
+    override fun onSuccess(message: String) {
+        Log.d(TAG, "Calls SDK initialized")
+    }
+    override fun onError(e: CometChatException) {
+        Log.e(TAG, "Init failed: ${e.message}")
+    }
+})
+```
+
+### 7. Check Initialization
+
+```kotlin
+if (CometChatCalls.isInitialized()) { /* ready */ }
+```
+
+### 8. Authentication
+
+Login with UID + API Key (dev only) or Auth Token (production):
+
+```kotlin
+CometChatCalls.login(uid, apiKey, object : CometChatCalls.CallbackListener<CallUser>() {
+    override fun onSuccess(user: CallUser) { /* logged in */ }
+    override fun onError(e: CometChatException) { /* handle error */ }
+})
+```
+
+## Gotchas
+
+- `android.enableJetifier=true` is **required** in `gradle.properties` — builds fail without it
+- The maven URL must be `https://dl.cloudsmith.io/public/cometchat/cometchat/maven/` — no trailing path variations
+- Request CAMERA and RECORD_AUDIO permissions at runtime on Android 6.0+
+- Call `CometChatCalls.init()` before any other SDK method
+- If using both Chat SDK and Calls SDK, initialize both separately
+
+## Sample App Reference
+
+- `PublicSampleApps/calls-sdk-android/settings.gradle.kts` — Cloudsmith maven config
+- `PublicSampleApps/calls-sdk-android/samples/sample-app-ringing/build.gradle.kts` — dependency declarations
+- `PublicSampleApps/calls-sdk-android/gradle.properties` — Jetifier enabled
+- `PublicSampleApps/calls-sdk-android/samples/sample-app-ringing/src/main/kotlin/com/cometchat/samplecallsringing/RingingApplication.kt` — Application class

package/skills/cometchat-android-v5-calls/references/share-invite.md

@@ -0,0 +1,151 @@
+# Share invite on Android V5 (Views)
+
+Same SDK API. Android-specific: `Intent.createChooser(ACTION_SEND)` is the native share sheet pattern; App Links must be configured for the call URL to deep-link.
+
+**Canonical docs:** https://www.cometchat.com/docs/calls/android/share-invite
+**Read first:** `cometchat-react-calls/references/share-invite.md` — deep-link rule + UX.
+
+---
+
+## Hard rule: App Links
+
+Configure deep-link routing in `AndroidManifest.xml`:
+
+```xml
+<activity
+  android:name=".MainActivity"
+  android:launchMode="singleTask"
+  android:exported="true">
+
+  <intent-filter android:autoVerify="true">
+    <action android:name="android.intent.action.VIEW" />
+    <category android:name="android.intent.category.DEFAULT" />
+    <category android:name="android.intent.category.BROWSABLE" />
+    <data
+      android:scheme="https"
+      android:host="yourapp.com"
+      android:pathPrefix="/call" />
+  </intent-filter>
+</activity>
+```
+
+Host `assetlinks.json` at `https://yourapp.com/.well-known/assetlinks.json`:
+
+```json
+[{
+  "relation": ["delegate_permission/common.handle_all_urls"],
+  "target": {
+    "namespace": "android_app",
+    "package_name": "com.yourapp",
+    "sha256_cert_fingerprints": ["AB:CD:EF:..."]
+  }
+}]
+```
+
+Handle in MainActivity:
+
+```kotlin
+override fun onCreate(savedInstanceState: Bundle?) {
+  super.onCreate(savedInstanceState)
+  handleDeepLink(intent)
+}
+
+override fun onNewIntent(intent: Intent) {
+  super.onNewIntent(intent)
+  handleDeepLink(intent)
+}
+
+private fun handleDeepLink(intent: Intent?) {
+  val data = intent?.data ?: return
+  val segments = data.pathSegments
+  if (segments.size >= 2 && segments[0] == "call") {
+    val sessionId = segments[1]
+    router.routeToCall(sessionId)
+  }
+}
+```
+
+---
+
+## SDK API
+
+```kotlin
+val settings = CallSettingsBuilder(activity)
+  .setHideShareInviteButton(false)
+  .build()
+
+val callsEventsListener = object : CometChatCallsEventsListener {
+  override fun onShareInviteButtonClicked() {
+    activity.runOnUiThread {
+      shareCallInvite(sessionId)
+    }
+  }
+}
+```
+
+---
+
+## Intent.createChooser
+
+```kotlin
+fun Activity.shareCallInvite(sessionId: String) {
+  val url = "https://yourapp.com/call/$sessionId"
+  val intent = Intent(Intent.ACTION_SEND).apply {
+    type = "text/plain"
+    putExtra(Intent.EXTRA_SUBJECT, "Join my call")
+    putExtra(Intent.EXTRA_TEXT, "I'm on a call — tap to join.\n$url")
+  }
+  startActivity(Intent.createChooser(intent, "Share call invite"))
+}
+```
+
+`Intent.createChooser` always shows the picker (even if a default is set) — important when invitees commonly use multiple apps (WhatsApp, SMS, email).
+
+---
+
+## Clipboard fallback
+
+Some users prefer to copy the link explicitly:
+
+```kotlin
+fun Context.copyCallLink(sessionId: String) {
+  val url = "https://yourapp.com/call/$sessionId"
+  val clipboard = getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
+  clipboard.setPrimaryClip(ClipData.newPlainText("Call link", url))
+
+  // Android 13+ shows system toast automatically; older versions need explicit
+  if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
+    Toast.makeText(this, "Link copied", Toast.LENGTH_SHORT).show()
+  }
+}
+```
+
+---
+
+## Anti-patterns
+
+Web sister rules apply, plus Android-specific:
+
+1. **`Intent.ACTION_SEND` without `Intent.createChooser`.** Default app gets used silently — user may want a different app.
+2. **No `assetlinks.json` hosted.** App Links don't auto-verify, falls back to "Open with..." dialog.
+3. **Hard-coded URL string.** Use `BuildConfig.APP_URL` set via Gradle build flavors.
+4. **Copying URL to clipboard then showing manual toast on Android 13+.** Duplicate toast (system + manual).
+
+---
+
+## Verification checklist
+
+- [ ] `<intent-filter>` with `autoVerify="true"` for `/call/*`
+- [ ] `assetlinks.json` hosted + reachable
+- [ ] `handleDeepLink` covers both `onCreate` and `onNewIntent`
+- [ ] `Intent.createChooser` wraps the share intent
+- [ ] App URL via `BuildConfig.APP_URL` (not hard-coded)
+- [ ] Real-device smoke: share to WhatsApp → tap from another device → opens your app at the call
+
+---
+
+## Pointers
+
+- `cometchat-react-calls/references/share-invite.md` — sister
+- `cometchat-android-v5-calls` SKILL.md
+- Canonical docs: https://www.cometchat.com/docs/calls/android/share-invite

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

@@ -0,0 +1,87 @@
+---
+name: video-controls
+description: Control video during calls — pause/resume camera, switch front/back camera. Use when implementing camera toggle, camera switch, or custom video buttons. Triggers on "pause video", "resume video", "switch camera", "camera toggle", "video controls".
+inclusion: manual
+---
+
+# CometChat Calls SDK v5 — Video Controls
+
+## Overview
+
+Programmatically control the local camera (pause/resume) and switch between front/back cameras during an active call.
+
+## Key Imports
+
+```kotlin
+import com.cometchat.calls.core.CallSession
+import com.cometchat.calls.model.CameraFacing
+import com.cometchat.calls.listeners.MediaEventsListener
+```
+
+## Implementation
+
+### Pause / Resume Video
+
+```kotlin
+val callSession = CallSession.getInstance()
+
+callSession.pauseVideo()   // turn off camera
+callSession.resumeVideo()  // turn on camera
+```
+
+### Switch Camera
+
+```kotlin
+callSession.switchCamera()  // toggle front ↔ back
+```
+
+### Listen for Video Events
+
+```kotlin
+callSession.addMediaEventsListener(this, object : MediaEventsListener() {
+    override fun onVideoPaused() {
+        // Update video button to "off" state, show avatar
+    }
+    override fun onVideoResumed() {
+        // Update video button to "on" state, show video
+    }
+    override fun onCameraFacingChanged(facing: CameraFacing) {
+        when (facing) {
+            CameraFacing.FRONT -> { /* front camera active */ }
+            CameraFacing.BACK -> { /* rear camera active */ }
+        }
+    }
+    // ... other required overrides
+    override fun onAudioMuted() {}
+    override fun onAudioUnMuted() {}
+    override fun onRecordingStarted() {}
+    override fun onRecordingStopped() {}
+    override fun onScreenShareStarted() {}
+    override fun onScreenShareStopped() {}
+    override fun onAudioModeChanged(audioMode: AudioMode) {}
+})
+```
+
+### Initial Video Settings (Pre-Session)
+
+```kotlin
+val sessionSettings = CometChatCalls.SessionSettingsBuilder()
+    .setSessionType(SessionType.VIDEO)
+    .startVideoPaused(false)                        // start with camera on
+    .setInitialCameraFacing(CameraFacing.FRONT)     // start with front camera
+    .hideToggleVideoButton(false)                   // show video toggle
+    .hideSwitchCameraButton(false)                  // show camera switch
+    .build()
+```
+
+## Gotchas
+
+- `pauseVideo()` / `resumeVideo()` only work during an active session
+- `switchCamera()` toggles between front and back — no parameter needed
+- `CameraFacing` enum: `FRONT`, `BACK`
+- For voice calls (`SessionType.VOICE`), set `.startVideoPaused(true)`
+- Camera permissions must be granted at runtime before joining
+
+## Sample App Reference
+
+- `CallActivity.kt` — Sets `startVideoPaused(true)` for voice calls