@cometchat/skills 3.0.0 → 4.0.0

package/skills/cometchat-android-v6-kotlin-placement/SKILL.md

@@ -0,0 +1,248 @@
+---
+name: cometchat-android-v6-kotlin-placement
+description: "CometChat Android UIKit v6 Kotlin Views placement — Activity, Fragment, BottomSheet, Tab, and Intent navigation patterns"
+license: "MIT"
+compatibility: "Android 9.0+ (API 28); Kotlin 1.9+; com.cometchat:chatuikit-kotlin-android:6.x"
+allowed-tools: "executeBash, readFile, fileSearch, listDirectory"
+metadata:
+  author: "CometChat"
+  version: "3.0.1"
+  tags: "cometchat, android, kotlin-views, placement, activity, fragment, navigation, tabs"
+---
+
+> **Companion skills:** cometchat-android-v6-compose-placement (Compose equivalent), cometchat-android-v6-kotlin-components, cometchat-android-v6-kotlin-theming
+
+## Purpose
+
+Place CometChat Kotlin Views components into Activities, Fragments, BottomSheets, and Tab layouts. Patterns derived from `master-app-kotlin`.
+
+## Use this skill when
+
+- Adding CometChat Views to an Activity or Fragment
+- Setting up Intent-based navigation between chat screens
+- Building a tabbed layout with Conversations, Users, Groups, Calls tabs
+- Showing CometChat components in BottomSheets or Dialogs
+
+## Do not use this skill when
+
+- Working with Compose placement (use `cometchat-android-v6-compose-placement`)
+- Looking up component APIs (use `cometchat-android-v6-kotlin-components`)
+
+## 1. Activity-Based Placement
+
+### 1.1 Conversations Activity
+
+```kotlin
+class ConversationsActivity : AppCompatActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        val conversations = CometChatConversations(this)
+        conversations.setOnItemClick { conversation ->
+            val intent = Intent(this, MessagesActivity::class.java)
+            // Pass user or group via intent extras
+            startActivity(intent)
+        }
+        setContentView(conversations)
+    }
+}
+```
+
+### 1.2 Messages Activity
+
+Pattern from `master-app-kotlin/appflow/MessagesActivity.kt`:
+
+```kotlin
+class MessagesActivity : AppCompatActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_messages)
+
+        val header = findViewById<CometChatMessageHeader>(R.id.messageHeader)
+        val messageList = findViewById<CometChatMessageList>(R.id.messageList)
+        val composer = findViewById<CometChatMessageComposer>(R.id.messageComposer)
+
+        // Set user or group
+        header.setUser(user)
+        messageList.setUser(user)
+        composer.setUser(user)
+
+        // For groups:
+        // header.setGroup(group)
+        // messageList.setGroup(group)
+        // composer.setGroup(group)
+    }
+}
+```
+
+XML layout:
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="vertical">
+
+    <com.cometchat.uikit.kotlin.presentation.messageheader.ui.CometChatMessageHeader
+        android:id="@+id/messageHeader"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content" />
+
+    <com.cometchat.uikit.kotlin.presentation.messagelist.ui.CometChatMessageList
+        android:id="@+id/messageList"
+        android:layout_width="match_parent"
+        android:layout_height="0dp"
+        android:layout_weight="1" />
+
+    <com.cometchat.uikit.kotlin.presentation.messagecomposer.ui.CometChatMessageComposer
+        android:id="@+id/messageComposer"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content" />
+
+</LinearLayout>
+```
+
+## 2. Fragment-Based Placement
+
+```kotlin
+class ConversationsFragment : Fragment() {
+    override fun onCreateView(
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View {
+        val conversations = CometChatConversations(requireContext())
+        conversations.setOnItemClick { conversation ->
+            // Navigate using FragmentManager or Navigation Component
+        }
+        return conversations
+    }
+}
+```
+
+## 3. Tabbed Layout with ViewPager2
+
+```kotlin
+class HomeActivity : AppCompatActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_home)
+
+        val tabLayout = findViewById<TabLayout>(R.id.tabLayout)
+        val viewPager = findViewById<ViewPager2>(R.id.viewPager)
+
+        viewPager.adapter = object : FragmentStateAdapter(this) {
+            override fun getItemCount() = 4
+            override fun createFragment(position: Int): Fragment = when (position) {
+                0 -> ConversationsFragment()
+                1 -> UsersFragment()
+                2 -> GroupsFragment()
+                3 -> CallLogsFragment()
+                else -> ConversationsFragment()
+            }
+        }
+
+        TabLayoutMediator(tabLayout, viewPager) { tab, position ->
+            tab.text = when (position) {
+                0 -> "Chats"
+                1 -> "Users"
+                2 -> "Groups"
+                3 -> "Calls"
+                else -> ""
+            }
+        }.attach()
+    }
+}
+```
+
+## 4. BottomSheet Placement
+
+```kotlin
+// Show message info in a BottomSheet
+val bottomSheet = CometChatMessageInformationBottomSheet.newInstance(message)
+bottomSheet.show(supportFragmentManager, "messageInfo")
+```
+
+For custom BottomSheets:
+
+```kotlin
+class ReactionsBottomSheet : BottomSheetDialogFragment() {
+    override fun onCreateView(
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View {
+        val reactionList = CometChatReactionList(requireContext())
+        reactionList.setBaseMessage(message)
+        return reactionList
+    }
+}
+```
+
+## 5. Dialog Placement
+
+`CometChatFlagMessageDialog` is a regular Android `Dialog` (NOT a `DialogFragment`). The message is passed at construction; there is no `setMessage` setter and no `show(fm, tag)` overload.
+
+```kotlin
+// Flag/report message dialog
+val dialog = CometChatFlagMessageDialog(this, message)  // (context, BaseMessage)
+dialog.show()
+```
+
+## 6. App Flow Pattern
+
+From `master-app-kotlin/appflow/DefaultComponentAppFlowActivity.kt` — a single Activity hosts the full chat flow with Fragment transactions:
+
+```kotlin
+class AppFlowActivity : AppCompatActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_app_flow)
+
+        // Start with conversations
+        supportFragmentManager.beginTransaction()
+            .replace(R.id.container, ConversationsFragment())
+            .commit()
+    }
+
+    fun navigateToMessages(user: User) {
+        supportFragmentManager.beginTransaction()
+            .replace(R.id.container, MessagesFragment.newInstance(user))
+            .addToBackStack(null)
+            .commit()
+    }
+}
+```
+
+## Activity theme — REQUIRED parent
+
+V6 Kotlin Views components (`CometChatConversations`, `CometChatMessageList`, etc.) extend Material Components widgets (`MaterialCardView`, `MaterialButton`) and reference kit-specific theme attributes (`?attr/cometchatPrimaryColor`, `?attr/cometchatBackgroundColor01`, etc.). The kit ships its own pre-configured theme that supplies every required attribute.
+
+**Inherit your Activity theme from `CometChatTheme.DayNight`** (or `CometChatTheme.Light` / `CometChatTheme.Dark` for fixed-mode apps). Edit `app/src/main/res/values/themes.xml`:
+
+```xml
+<resources>
+    <style name="Theme.YourApp" parent="CometChatTheme.DayNight" />
+</resources>
+```
+
+Do **not** use any of these as the parent — they all crash at component inflation:
+
+- `Theme.AppCompat.*` — missing Material Components style attrs (`MaterialCardView` rejects with `IllegalArgumentException: requires Theme.MaterialComponents (or descendant)`)
+- `Theme.MaterialComponents.*.Bridge` — Bridge variants drop Material widget defaults (`MaterialButton` fails with `Failed to resolve attribute at index N`)
+- `Theme.MaterialComponents.*` (without the kit) — has Material attrs but missing `cometchat*` attrs (same `Failed to resolve attribute` crash)
+- `Theme.Material3.*` — Material 3 attrs don't satisfy the kit's MaterialComponents-based widgets
+- `android:Theme.Material.*` — predates AppCompat; AppCompatActivity rejects it
+
+`CometChatTheme.DayNight` itself parents `Theme.MaterialComponents.DayNight.NoActionBar`, so it remains AppCompat-compatible while supplying every `cometchat*` attr the components reference.
+
+To brand-customize colors, override `cometchat*` attrs in your Activity theme (see `cometchat-android-v6-kotlin-theming`), or call `CometChatTheme.setPrimaryColor(...)` programmatically.
+
+## Hard rules
+
+- ALWAYS set the user or group on messaging components (`setUser()` / `setGroup()`) before the component is displayed
+- Activity theme MUST inherit from `CometChatTheme.DayNight` / `.Light` / `.Dark` (see "Activity theme" section above) — vague guidance about "include CometChat attrs" is insufficient; use the kit's pre-configured theme
+- Ongoing calls MUST use `CometChatOngoingCallActivity.launchOngoingCallActivity(context, ...)` (in `com.cometchat.uikit.kotlin.presentation.ongoingcall.ui`) — they need a separate Activity for proper lifecycle / PiP management. `CometChatCallActivity` (in `com.cometchat.uikit.kotlin.calls`) handles outgoing/incoming/conference launches via `launchOutgoingCallScreen` / `launchIncomingCallScreen` / `launchConferenceCallScreen` — it has no `launchOngoingCallActivity` method.
+- When passing User/Group between Activities, serialize the UID/GUID and re-fetch, or use a shared cache — do NOT pass full SDK objects via Intent extras
+- Use `AppCompatActivity` (not plain `Activity`) to ensure proper theme attribute resolution

package/skills/cometchat-android-v6-kotlin-theming/SKILL.md

@@ -0,0 +1,202 @@
+---
+name: cometchat-android-v6-kotlin-theming
+description: "CometChat Android UIKit v6 Kotlin Views theming — CometChatTheme singleton, XML attributes, programmatic overrides, typography, and dark mode"
+license: "MIT"
+compatibility: "Android 9.0+ (API 28); Kotlin 1.9+; com.cometchat:chatuikit-kotlin-android:6.x"
+allowed-tools: "executeBash, readFile, fileSearch, listDirectory"
+metadata:
+  author: "CometChat"
+  version: "3.0.0"
+  tags: "cometchat, android, kotlin-views, theming, xml-attrs, colors, typography, dark-mode"
+---
+
+> **Companion skills:** cometchat-android-v6-compose-theming (Compose equivalent), cometchat-android-v6-kotlin-components, cometchat-android-v6-kotlin-customization
+
+## Purpose
+
+Apply and customize the CometChat theme in Kotlin Views — XML theme attributes, programmatic color/font overrides via the `CometChatTheme` singleton, dark mode support, and per-component style classes.
+
+## Use this skill when
+
+- Setting CometChat theme colors via XML attributes or programmatically
+- Overriding primary, neutral, alert, or button colors
+- Customizing typography and fonts
+- Implementing dark mode for Kotlin Views components
+- Clearing the theme cache after dynamic theme changes
+
+## Do not use this skill when
+
+- Working with Compose theming (use `cometchat-android-v6-compose-theming`)
+- Customizing bubble rendering (use `cometchat-android-v6-kotlin-customization`)
+
+## 1. CometChatTheme Singleton
+
+`CometChatTheme` is a Kotlin `object` in `com.cometchat.uikit.kotlin.theme` that provides `Context`-based getters and setters for all theme tokens.
+
+```kotlin
+import com.cometchat.uikit.kotlin.theme.CometChatTheme
+
+// Get a color (requires Context)
+val primaryColor: Int = CometChatTheme.getPrimaryColor(context)
+val textColor: Int = CometChatTheme.getTextColorPrimary(context)
+
+// Set a color programmatically (cached globally)
+CometChatTheme.setPrimaryColor(Color.parseColor("#6851D6"))
+CometChatTheme.setErrorColor(Color.RED)
+```
+
+## 2. XML Theme Attributes
+
+Define theme colors in your app's `styles.xml` or `themes.xml`:
+
+```xml
+<style name="AppTheme" parent="Theme.MaterialComponents.DayNight">
+    <!-- Primary -->
+    <item name="cometchatPrimaryColor">#6851D6</item>
+
+    <!-- Neutral scale -->
+    <item name="cometchatNeutralColor50">#FAFAFA</item>
+    <item name="cometchatNeutralColor100">#F5F5F5</item>
+    <item name="cometchatNeutralColor200">#E8E8E8</item>
+    <!-- ... through cometchatNeutralColor900 -->
+
+    <!-- Alert colors -->
+    <item name="cometchatSuccessColor">#34C759</item>
+    <item name="cometchatErrorColor">#FF3B30</item>
+    <item name="cometchatWarningColor">#FFCC00</item>
+    <item name="cometchatInfoColor">#007AFF</item>
+    <item name="cometchatMessageReadColor">#007AFF</item>
+
+    <!-- Background colors -->
+    <item name="cometchatBackgroundColor1">@color/bg1</item>
+    <!-- ... through cometchatBackgroundColor4 -->
+
+    <!-- Stroke/border colors -->
+    <item name="cometchatStrokeColorDefault">@color/stroke</item>
+    <item name="cometchatStrokeColorLight">@color/strokeLight</item>
+    <item name="cometchatStrokeColorDark">@color/strokeDark</item>
+    <item name="cometchatStrokeColorHighlight">@color/primary</item>
+
+    <!-- Text colors -->
+    <item name="cometchatTextColorPrimary">@color/textPrimary</item>
+    <item name="cometchatTextColorSecondary">@color/textSecondary</item>
+    <!-- ... -->
+
+    <!-- Icon tints -->
+    <item name="cometchatIconTintPrimary">@color/iconPrimary</item>
+    <!-- ... -->
+
+    <!-- Button colors -->
+    <item name="cometchatPrimaryButtonBackgroundColor">@color/primary</item>
+    <item name="cometchatPrimaryButtonIconTint">@color/white</item>
+    <item name="cometchatPrimaryButtonTextColor">@color/white</item>
+    <!-- ... -->
+</style>
+```
+
+## 3. Color Token Reference
+
+### 3.1 Primary Colors
+
+| Getter | Setter | XML Attr |
+|---|---|---|
+| `getPrimaryColor(ctx)` | `setPrimaryColor(color)` | `cometchatPrimaryColor` |
+
+### 3.2 Extended Primary (auto-generated from primary)
+
+| Getter | Setter | XML Attr |
+|---|---|---|
+| `getExtendedPrimaryColor50(ctx)` | `setExtendedPrimaryColor50(color)` | `cometchatExtendedPrimaryColor50` |
+| ... through 900 | ... | ... |
+
+Extended primary colors auto-generate by blending primary with white (day) or black (night) if not explicitly set.
+
+### 3.3 Neutral Colors
+
+`getNeutralColor50(ctx)` through `getNeutralColor900(ctx)` with corresponding setters and XML attrs `cometchatNeutralColor50` through `cometchatNeutralColor900`.
+
+### 3.4 Alert Colors
+
+| Getter | Setter | XML Attr |
+|---|---|---|
+| `getSuccessColor(ctx)` | `setSuccessColor(color)` | `cometchatSuccessColor` |
+| `getErrorColor(ctx)` | `setErrorColor(color)` | `cometchatErrorColor` |
+| `getWarningColor(ctx)` | `setWarningColor(color)` | `cometchatWarningColor` |
+| `getInfoColor(ctx)` | `setInfoColor(color)` | `cometchatInfoColor` |
+| `getMessageReadColor(ctx)` | `setMessageReadColor(color)` | `cometchatMessageReadColor` |
+
+### 3.5 Background, Stroke, Text, Icon, Button Colors
+
+All follow the same pattern: `get{Token}(ctx)` / `set{Token}(color)` / `cometchat{Token}` XML attr. Defaults fall back to neutral scale values if not explicitly set.
+
+Border color aliases: `getBorderColorLight()` = `getStrokeColorLight()`, etc.
+
+## 4. Typography
+
+```kotlin
+// Get text appearance resource IDs
+val titleBold: Int = CometChatTheme.getTextAppearanceTitleBold(context)
+val bodyRegular: Int = CometChatTheme.getTextAppearanceBodyRegular(context)
+val heading1Medium: Int = CometChatTheme.getTextAppearanceHeading1Medium(context)
+// ... all combinations: Title, Heading1-4, Body, Caption1-2, Button, Link × Regular/Medium/Bold
+
+// Get font resource IDs
+val regularFont: Int = CometChatTheme.getFontRegular(context)
+val mediumFont: Int = CometChatTheme.getFontMedium(context)
+val boldFont: Int = CometChatTheme.getFontBold(context)
+```
+
+Override via XML attrs: `cometchatTextAppearanceTitleBold`, `cometchatFontRegular`, etc.
+
+## 5. Dark Mode
+
+Dark mode is detected via `Configuration.UI_MODE_NIGHT_MASK`:
+
+```kotlin
+val nightMode = context.resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK
+val isDark = nightMode == Configuration.UI_MODE_NIGHT_YES
+```
+
+The theme automatically:
+- Uses day/night qualified XML resources
+- Blends extended primary colors with white (day) or black (night)
+- Falls back to appropriate neutral scale for each mode
+
+For programmatic overrides, set colors after detecting the mode:
+
+```kotlin
+if (isDark) {
+    CometChatTheme.setPrimaryColor(Color.parseColor("#BB86FC"))
+} else {
+    CometChatTheme.setPrimaryColor(Color.parseColor("#6851D6"))
+}
+```
+
+## 6. Theme Cache
+
+Programmatic overrides are cached in memory. Clear the cache when the theme changes:
+
+```kotlin
+CometChatTheme.clearCache()
+```
+
+Call this when:
+- The user switches between light and dark mode at runtime
+- You dynamically change the primary color
+- The Activity recreates with a new theme
+
+## 7. Static Colors
+
+```kotlin
+val white: Int = CometChatTheme.getColorWhite(context)
+val black: Int = CometChatTheme.getColorBlack(context)
+val transparent: Int = CometChatTheme.getColorTransparent(context)
+```
+
+## Hard rules
+
+- ALWAYS pass a valid `Context` to getter methods — they resolve XML attributes from the theme
+- Call `CometChatTheme.clearCache()` after programmatic theme changes to ensure fresh values
+- Programmatic setters (`setPrimaryColor()`, etc.) take priority over XML attributes
+- Extended primary colors auto-generate from the primary color — only override them if you need specific shades
+- Do NOT mix Compose `CometChatTheme.colorScheme` with Views `CometChatTheme.getPrimaryColor(ctx)` — they are separate theme systems in separate modules

package/skills/cometchat-android-v6-production/SKILL.md

@@ -0,0 +1,187 @@
+---
+name: cometchat-android-v6-production
+description: "CometChat Android UIKit v6 production readiness — token auth, ProGuard/R8, security checklist, release configuration"
+license: "MIT"
+compatibility: "Android 9.0+ (API 28); Kotlin 1.9+; com.cometchat:chatuikit-compose-android:6.x / com.cometchat:chatuikit-kotlin-android:6.x"
+allowed-tools: "executeBash, readFile, fileSearch, listDirectory"
+metadata:
+  author: "CometChat"
+  version: "3.0.0"
+  tags: "cometchat, android, production, security, proguard, release, auth-token"
+---
+
+> **Companion skills:** cometchat-android-v6-core (init/login), cometchat-android-v6-builder-settings (UIKitSettings), cometchat-android-v6-push (FCM)
+
+## Purpose
+
+Prepare a CometChat v6 Android app for production release — switch to token-based auth, configure ProGuard/R8, apply security best practices, and optimize the release build.
+
+## Use this skill when
+
+- Preparing an app for production/release
+- Switching from authKey to token-based authentication
+- Configuring ProGuard/R8 rules for CometChat
+- Reviewing security best practices
+
+## Do not use this skill when
+
+- Setting up for development (use `cometchat-android-v6-core`)
+- Debugging issues (use `cometchat-android-v6-troubleshooting`)
+
+## 1. Token-Based Authentication
+
+### 1.1 Never Ship authKey
+
+```kotlin
+// ❌ NEVER in production
+val settings = UIKitSettings.UIKitSettingsBuilder()
+    .setAppId("APP_ID")
+    .setRegion("us")
+    .setAuthKey("AUTH_KEY") // REMOVE THIS
+    .build()
+
+CometChatUIKit.login("uid", callback) // Uses authKey internally
+
+// ✅ Production pattern
+val settings = UIKitSettings.UIKitSettingsBuilder()
+    .setAppId("APP_ID")
+    .setRegion("us")
+    // No authKey
+    .build()
+
+// Get token from your backend server
+val authToken = yourServer.getAuthToken(userId)
+CometChatUIKit.loginWithAuthToken(authToken, callback)
+```
+
+### 1.2 Server-Side Token Generation
+
+Your backend generates auth tokens using the CometChat REST API:
+- Endpoint: `POST https://{appId}.api-{region}.cometchat.io/v3/users/{uid}/auth_tokens`
+- Header: `apiKey: YOUR_API_KEY` (server-side only)
+
+The auth token is then passed to the client for `loginWithAuthToken()`.
+
+## 2. ProGuard / R8 Configuration
+
+### 2.1 Consumer Rules
+
+CometChat UIKit modules include `consumer-rules.pro` that are automatically applied. Check that your app's `build.gradle.kts` has:
+
+```kotlin
+android {
+    buildTypes {
+        release {
+            isMinifyEnabled = true
+            proguardFiles(
+                getDefaultProguardFile("proguard-android-optimize.txt"),
+                "proguard-rules.pro"
+            )
+        }
+    }
+}
+```
+
+### 2.2 Additional ProGuard Rules
+
+If you encounter issues with minification, add these rules:
+
+```proguard
+# CometChat SDK
+-keep class com.cometchat.chat.** { *; }
+-keep class com.cometchat.calls.** { *; }
+
+# CometChat UIKit
+-keep class com.cometchat.uikit.** { *; }
+
+# Gson (used for FCM DTO parsing)
+-keep class com.google.gson.** { *; }
+-keepattributes Signature
+-keepattributes *Annotation*
+
+# Firebase
+-keep class com.google.firebase.** { *; }
+```
+
+## 3. Security Checklist
+
+| Item | Status | Notes |
+|---|---|---|
+| Remove `authKey` from client code | Required | Use `loginWithAuthToken()` |
+| Store `appId` securely | Recommended | Use BuildConfig or encrypted prefs |
+| Use HTTPS for all custom endpoints | Required | `overrideAdminHost` / `overrideClientHost` |
+| Validate auth tokens server-side | Required | Tokens should expire |
+| Do not log sensitive data | Required | Remove debug logs in release |
+| Enable R8/ProGuard | Recommended | Obfuscates code |
+| Pin SSL certificates | Optional | For high-security apps |
+
+## 4. Release Build Configuration
+
+```kotlin
+android {
+    compileSdk = 36
+
+    defaultConfig {
+        minSdk = 28
+        targetSdk = 36
+    }
+
+    buildTypes {
+        release {
+            isMinifyEnabled = true
+            isShrinkResources = true
+            proguardFiles(
+                getDefaultProguardFile("proguard-android-optimize.txt"),
+                "proguard-rules.pro"
+            )
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_11
+        targetCompatibility = JavaVersion.VERSION_11
+    }
+
+    kotlinOptions {
+        jvmTarget = "11"
+    }
+}
+```
+
+## 5. Dependency Management
+
+### 5.1 Compose BOM
+
+For Compose stack, use the BOM to align Compose library versions:
+
+```kotlin
+implementation(platform("androidx.compose:compose-bom:2024.x.x"))
+implementation("androidx.compose.ui:ui")
+implementation("androidx.compose.material3:material3")
+```
+
+### 5.2 Version Pinning
+
+Pin CometChat SDK versions explicitly:
+
+```kotlin
+implementation("com.cometchat:chatuikit-compose-android:6.0.0-beta2")
+// or
+implementation("com.cometchat:chatuikit-kotlin-android:6.0.0-beta2")
+```
+
+## 6. minSdk 28 Implications
+
+v6 requires `minSdk = 28` (Android 9.0 Pie). This means:
+- No support for Android 7.0-8.1 devices
+- Full TLS 1.3 support
+- Native BiometricPrompt API available
+- Adaptive icons required
+
+## Hard rules
+
+- NEVER ship `authKey` in production builds — it allows anyone to create users and login
+- ALWAYS use `loginWithAuthToken()` with server-generated tokens in production
+- ALWAYS test the release build with ProGuard/R8 enabled before shipping — CometChat uses reflection in some areas
+- `minSdk` must be 28 — do NOT lower it, v6 APIs depend on API 28+ features
+- Remove all `Log.d()` / debug logging in release builds — use `BuildConfig.DEBUG` guards