במסמך הזה מוסבר איך להוסיף לאפליקציה נקודות כניסה לתמיכה (תורים וערוצים), ואיך לנהל את מחזור החיים המלא של הצ'אט: להתחיל, להמשיך, לשלוח הודעות וקבצים מצורפים, לציין הקלדה, לצנזר מידע אישי רגיש, להעביר לנציגים אנושיים ולסיים את הסשן.
לפני שמתחילים
מגדירים את ה-SDK. מידע נוסף זמין במאמר Headless mobile SDK for Android: Get started.
בחירת תורים וערוצים
תור מייצג בדרך כלל נקודת כניסה לתמיכה, כמו "חיוב", "תמיכה טכנית" או "תמיכת VIP".
כל תור יכול להציע אחד או יותר מהערוצים הבאים:
צ'אט
שיחה מיידית (קולית)
שיחה מתוזמנת
אימייל
קישורים להפניה החוצה (קישורים לדפי שירות עצמי או לערוצים אחרים)
האדמינים מגדירים את התורים ואת זמינות הערוצים בפורטל הניהול של Contact Center AI Platform.
איך זה נראה באפליקציה
באפליקציה, תהליך אופייני הוא:
אתם מוסיפים לאפליקציה נקודת כניסה לתמיכה (לדוגמה, כרטיסיית עזרה או לחצן יצירת קשר).
כשהמשתמש לוחץ עליו, אתם מאחזרים את תפריט התור באמצעות ה-SDK ומציגים את ממשק המשתמש של התפריט שלכם.
כשהמשתמש בוחר תור, אתם בודקים את הערוצים הזמינים שלו.
האפליקציה מציגה את הערוצים האלה למשתמש (לדוגמה, צ'אט עכשיו, שיחה עכשיו, קביעת שיחה, שליחת אימייל, כניסה למרכז העזרה).
כשהמשתמש בוחר ערוץ, אתם שולחים קריאה ל-SDK API המתאים.
אחזור תפריטי תורים מ-SDK
ערכת ה-SDK מספקת את queueMenuService כדי לאחזר תפריטי תורים. ה-method get מחזירה QueueMenuResult שמכיל את רשימת התורים (List<QueueMenu>) ודגל isDirectAccess. אתם יכולים לאחזר את עץ התפריטים המלא או להשתמש במקש גישה ישירה כדי לדלג ישירות לתור ספציפי:
import com.ccaiplatform.ccaikit.CCAI
import com.ccaiplatform.ccaikit.models.response.queuemenu.QueueMenuResult
import com.ccaiplatform.ccaikit.models.response.queuemenu.QueueMenu
// Fetch the full queue menu tree
val menuResult: QueueMenuResult? = CCAI.queueMenuService?.get()
// Or fetch a specific queue using a Direct Access Key
val menuResult: QueueMenuResult? = CCAI.queueMenuService?.get(key = "billing_vip")
הפרמטר האופציונלי key מאפשר לעקוף את תפריט התור המלא ולהעביר את המשתמש ישירות לתור ספציפי. בפלטפורמת CCAI, עושים את זה באמצעות נקודת גישה ישירה (DAP).
אדמינים יכולים להגדיר DAP בפורטל של פלטפורמת CCAI באופן הבא:
עוברים אל הגדרות > תור > בוחרים תור כלשהו ממבנה התפריט.
בקטע נקודת גישה, לוחצים על + יצירת נקודת גישה ישירה.
מזינים את המפתח בטופס הטקסט.
לוחצים על Save.
מבנה הנתונים של QueueMenu
כל QueueMenu מכיל:
| מאפיין (property) | סוג | תיאור |
|---|---|---|
id |
Int | המזהה הייחודי של התור הזה. |
name |
מחרוזת? | השם המוצג (לדוגמה, "תמיכה בנושאי חיוב"). |
children |
רשימה<תפריט תור> | תפריטי משנה (רשימה ריקה אם זהו צומת עלה). |
channels |
ערוצים? | הערוצים הזמינים לתור הזה. |
hidden |
בוליאני | אם התור הזה צריך להיות מוסתר מהצרכנים (מוגדר על ידי האדמין). |
position |
Int? | מיקום התצוגה שמוגדר בשרת – שומר על הסדר של פורטל האדמין. |
settings |
List<QueueMenuSetting>? | הגדרות ברמת התור שנקבעו בפורטל האדמין. |
redirectionExtra |
QueueMenuRedirection? | מטא-נתונים של הפניה אוטומטית, אם הוגדרו (ראו הפניה אוטומטית והסטה). |
deflectionFrom |
List<QueueMenuDeflection>? | התורים שהופנו לתור הזה. הפלטפורמה מחזירה את התור הזה במקומם, כך שרשימה לא ריקה מסבירה הפניה אוטומטית שכבר התרחשה (ראו הסטה) |
לסיווג הנתונים Channels יש את המאפיינים הבאים:
| מאפיין (property) | סוג | תיאור |
|---|---|---|
chat |
ChatChannel? | הגדרת ערוץ הצ'אט (null אם הצ'אט לא זמין לתור הזה). |
voiceCall |
VoiceCallChannel? | הגדרת ערוץ לשיחות טלפון (null אם שיחות טלפון לא זמינות). מכיל סימונים כמו scheduleEnabled והעדפות הקלטה. |
email |
EmailChannel? | הגדרת ערוץ האימייל (null אם האימייל לא זמין). נכנסים לכתובת באמצעות channels.email?.email. |
externalDeflectionLink |
ExternalDeflectionLink? | הגדרת קישור להפניה חיצונית (null אם לא זמין). ניגשים לכתובת ה-URL באמצעות המאפיינים של הסוג המובנה. |
VoiceCallChannel שדות (מטא-נתונים של יכולות והסטות)
// VoiceCallChannel.kt (simplified)
data class VoiceCallChannel(
val instantEnabled: Boolean, // Live voice call allowed now
val preSessionSmartAction: Boolean, // Per-channel pre-session smart action flag
val scheduleEnabled: Boolean, // Scheduled calls supported
val recordingOption: RecordingOption?, // ALWAYS / NEVER / ASK_USER
val voicemailReason: String?,
val phoneNumber: String?,
val scheduleDeflectionType: String?,
val deflected: Boolean?,
val deflectedReason: String?
)
דוגמה של הטמעה
fun showAvailableChannels(queueMenu: QueueMenu) {
val channels = queueMenu.channels
val voice = channels?.voiceCall
// Show only what the platform enabled, and hide everything else so
// nothing carries over from a previously selected queue
chatButton.isVisible = channels?.chat?.enabled == true
callButton.isVisible = voice != null && voice.instantEnabled && !voice.deflected
scheduleButton.isVisible = voice?.scheduleEnabled == true
emailButton.isVisible = channels?.email?.enabled == true
// External deflection links: the enabled entries that have a URL
val links = channels?.externalDeflectionLink
?.takeIf { it.enabled }
?.links.orEmpty()
.filter { it.enabled && it.url != null }
helpLinksButton.isVisible = links.isNotEmpty()
}
מאחזר את זמני ההמתנה
אפשר גם לאחזר את זמני ההמתנה המשוערים לתור ספציפי:
// Fetch wait time for a specific queue
val waitTime = CCAI.queueMenuService?.getWaitTimes(menuId = queueMenu.id)
// waitTime contains:
// - chat: estimated wait time for chat (in seconds)
// - voiceCall: estimated wait time for voice call (in seconds)
תורים בערוץ יחיד
אם בתור יש רק ערוץ אחד (לדוגמה, אימייל בלבד), אתם יכולים:
מדלגים על שלב בחירת הערוץ ועוברים ישירות לממשק המשתמש המתאים.
אפשר גם להציג את הערוץ הזמין באופן מפורש אם זה הגיוני יותר בממשק המשתמש.
ההגדרות והמטא-נתונים של ה-SDK מציינים אילו ערוצים מותרים, והאפליקציה קובעת איך להציג אותם.
הפניה והסטה
אדמינים יכולים להגדיר תור להפניית משתמשים במקום להציע ערוצים. כשהערך של QueueMenu.redirectionExtra מוגדר, צריך לפעול לפיו ברגע שהמשתמש בוחר את התור:
optionמציין מה לעשות: PHONE, MESSAGE, URL, VOICEMAIL, QUEUE, SIP או CONTACT.dataנושא את הערך, כמו המספר לחיוג, ההודעה שתוצג או כתובת ה-URL שתיפתח.
QueueMenu.deflectionFrom שונה. כשתור מופנה לתור אחר, הפלטפורמה מחזירה את תור היעד במקום התור שהמשתמש בחר, ומציגה את תורי המקור ב-deflectionFrom. הוא מסביר הפניה שכבר התרחשה, ולא מציע קבוצה של אפשרויות.
הדיווח על הפניות מחוץ לשעות הפעילות ובמקרים של עומס יתר מתבצע לפי ערוץ. במאמר Headless Mobile SDK for Android: Smart Actions, Attachments, and Deflection מוסבר איך לטפל בזה.
ערוצים
ב-Headless Mobile SDK, פורטל האדמין של פלטפורמת CCAI משמש כמקור המידע המהימן לפעולות התמיכה. האדמינים מגדירים אילו ערוצי תמיכה (כמו צ'אט, שיחה קולית, אימייל או קישורים מועילים) זמינים לתורי תמיכה שונים (כמו "חיוב" או "תמיכה טכנית").
התפקיד של ה-SDK הוא לאחזר את ההגדרות האישיות האלה בצורה מאובטחת ולהעביר אותן לאפליקציה. התפקיד של האפליקציה הוא לקרוא את ההגדרות האישיות האלה ולשרטט את ממשק המשתמש המתאים.
בדיקת הערוצים הזמינים
מה ה-SDK מספק: תמונת מצב בזמן אמת של ערוצי התמיכה הפעילים והזמינים לתור הספציפי שהמשתמש בחר, בהתאם לשעות הפעילות ולמגבלות הקיבולת של הפורטל.
מה אתם מפתחים: תפריט ממשק המשתמש (כפתורים, רשימות או כרטיסים) שמציג למשתמש את האפשרויות הזמינות.
דוגמה להטמעה: קוד Kotlin הבא מקבל את התור שהמשתמש לחץ עליו ובודק את מחלקת הנתונים Channels כדי לראות אילו ערוצים מופעלים. לאחר מכן, המערכת מחליטה אילו לחצנים להציג במסך.
// Assuming 'selectedMenu' is a QueueMenu returned by the SDK
fun setupChannelMenu(selectedMenu: QueueMenu) {
val channels = selectedMenu.channels
if (channels.chat != null) {
showChatNowButton()
}
if (channels.voiceCall != null) {
showCallNowButton()
}
if (channels.email != null) {
showEmailUsButton()
}
if (channels.externalDeflectionLink != null) {
showHelpCenterLinks()
}
}
בקטעים הבאים מוסבר בפירוט על הצ'אט. לגבי קישורים לשיחות קוליות, שיתוף מסך, שיחות מתוזמנות, אימיילים והפניות חיצוניות, אפשר לעיין במאמר Headless Mobile SDK ל-Android: שיחות קוליות, שיתוף מסך, שיחות מתוזמנות ואימיילים
Chat service API
ה-chatService מנהל את מחזור החיים המלא של הצ'אט. השיטות העיקריות שמשתמשים בהן הכי הרבה הן:
| Method | תיאור |
|---|---|
start |
התחלת שיחה חדשה עם ChatRequest. |
sendMessage |
שליחת הודעה (טקסט, תמונה, סרטון או אירוע בטופס). |
typing |
מעדכן את אינדיקטור ההקלדה. |
endChat |
סיום של שיחת הצ'אט הנוכחית. |
resumeChat |
ממשיך שיחת צ'אט קודמת. |
escalateToHumanAgent |
העברות מנציג וירטואלי לנציג אנושי. |
checkStatus |
מרענן את סטטוס הצ'אט הנוכחי מהשרת. |
מבני נתונים של ChatRequest ו-ChatResponse
מחלקת הנתונים ChatRequest מכילה את ההגדרות להתחלת צ'אט חדש:
data class ChatRequest(
val chat: Chat? = null, // The session configuration (always pass one)
val isScreenShareable: Boolean? = null, // Optional: enable screen share for this session
val isVerifiable: Boolean? = null // Optional: allow verification smart actions
)
data class Chat(
val menuId: Int, // Required: queue menu ID
val lang: String? = "en", // Optional: language code override (defaults to "en")
val ticketId: String? = null, // Optional: associate with existing ticket
val greeting: String? = null, // Optional: custom greeting message
val customData: CustomData? = null, // Optional: structured custom data
val displayOrderInAdapter: List<String>? = null,
val directAccessKeyId: Int? = null, // Optional: from QueueMenuResult (Direct Access Point)
val dapRequestId: String? = null // Optional: from QueueMenuResult (Direct Access Point)
)
אחרי שמתחילים או ממשיכים צ'אט, ה-SDK מעביר את ה-ChatResponse שלו בתהליך chatReceived (start() ו-resumeChat() לא מחזירים כלום). המאפיינים שמוזכרים הכי הרבה במדריך הזה הם:
id– המזהה הייחודי של סשן הצ'אט.status– הסטטוס הנוכחי של הצ'אט (בתור, פעיל, הסתיים וכו').
agent/virtualAgent– הנציג האנושי או הווירטואלי שהוקצה.
postSessionRequired– אם הוגדר נציג וירטואלי לסשן אחרי סיום השיחה. סקרים ו-CSAT מסומנים על ידיsurveyEnabledו-csatSetting.redactionEnabled– אם צנזור אוטומטי של פרטים אישיים מזהים פעיל בסשן הזה.
התחלת שיחת צ'אט
כדי להתחיל שיחת צ'אט, משתמשים ב-chatService עם ChatRequest שמציין את מזהה התפריט של התור.
דוגמה מינימלית
import android.util.Log
import androidx.lifecycle.lifecycleScope
import com.ccaiplatform.ccaichat.chatService
import com.ccaiplatform.ccaichat.model.Chat
import com.ccaiplatform.ccaichat.model.ChatRequest
import com.ccaiplatform.ccaikit.CCAI
import com.ccaiplatform.ccaiscreenshare.screenShareService
import kotlinx.coroutines.launch
// If screen share is initialized, pass isScreenShareable for agent visibility
val chatRequest = ChatRequest(
chat = Chat(menuId = 123),
isScreenShareable = CCAI.screenShareService != null
)
startOrResumeChat(chatRequest)
// Resumes an earlier chat if there is one; otherwise starts a new one
fun startOrResumeChat(chatRequest: ChatRequest) {
lifecycleScope.launch {
val chatService = CCAI.chatService ?: return@launch
try {
// Pre-flight check: resume an earlier chat instead of starting a second one
val existing = chatService.getLastChatInProgress()
if (existing != null) {
chatService.resumeChat(existing)
return@launch
}
chatService.start(chatRequest)
// Chat started - navigate to your custom chat screen
} catch (e: Exception) {
Log.e("CCAI", "Failed to start chat: ${e.message}")
}
}
}
אם האפליקציה לא כוללת את המודול CCAIScreenShare, צריך להסיר את הייבוא של screenShareService ואת הארגומנט isScreenShareable.
עם שפה גסה
val chatRequest = ChatRequest(
chat = Chat(menuId = 123, lang = "en")
)
startOrResumeChat(chatRequest) // Defined in the Minimal example
המשך שיחת צ'אט
כדי להמשיך שיחה קיימת, משתמשים באובייקט ChatResponse:
lifecycleScope.launch {
try {
CCAI.chatService?.resumeChat(chat)
} catch (e: Exception) {
Log.e("CCAI", "Failed to resume chat: ${e.message}")
}
}
ניהול תור הצ'אט
אתם יכולים להחזיר את הצ'אט הנוכחי לתור (הסטטוס שלו ישתנה ל"בתור") או לבדוק אם יש צ'אטים קיימים בתהליך:
// Enqueue the current chat (automatically calls checkStatus() after enqueuing)
lifecycleScope.launch {
try {
CCAI.chatService?.enqueueCurrentChat()
Log.d("CCAI", "Chat enqueued successfully")
} catch (e: Exception) {
Log.e("CCAI", "Failed to enqueue chat: ${e.message}")
}
}
// Check for an existing in-progress chat
lifecycleScope.launch {
try {
val chat = CCAI.chatService?.getLastChatInProgress()
if (chat != null) {
Log.d("CCAI", "Found ongoing chat: ${chat.id}")
} else {
Log.d("CCAI", "No ongoing chat found")
}
} catch (e: Exception) {
Log.e("CCAI", "Failed to get last chat: ${e.message}")
}
}
// Retrieve previous chat history with pagination
lifecycleScope.launch {
try {
val previousChats = CCAI.chatService?.getPreviousChats(currentPage = 1)
if (previousChats != null) {
Log.d("CCAI", "Found ${previousChats.messages.size} previous messages")
}
} catch (e: Exception) {
Log.e("CCAI", "Failed to get previous chats: ${e.message}")
}
}
שליחת הודעות
השיטה sendMessage תומכת בכמה סוגי הודעות באמצעות המחלקה האטום OutgoingMessageContent:
sealed class OutgoingMessageContent {
data class Text(val content: String) : OutgoingMessageContent()
data class Photos(
val images: List<UploadableImage>,
val smartAction: SmartAction? = null
) : OutgoingMessageContent()
data class Videos(
val video: UploadableVideo,
val smartAction: SmartAction? = null
) : OutgoingMessageContent()
data class FormComplete(
val type: String? = null,
val signature: String? = null,
val data: FormCompleteEventData
) : OutgoingMessageContent()
data class ScreenShare(
val event: String,
val detail: ScreenShareResponse? = null
) : OutgoingMessageContent()
}
הסוגים UploadableImage ו-UploadableVideo (ב-com.ccaiplatform.ccaikit.models.smartaction) כוללים מדיה להעלאה:
data class UploadableImage(
val data: ByteArray, // The binary data of the image
val mimeType: String, // For example, "image/jpeg" or "image/png"
val uri: Uri? = null // Optional URI for display and local file reference
)
data class UploadableVideo(
val uri: Uri, // The file URI of the video
val mimeType: String // For example, "video/mp4"
)
Photos מקבל רשימה של תמונות, ו-Videos מקבל סרטון אחד. אל תשמרו נכסי מדיה גדולים בזיכרון בזמן שהמשתמש ממתין בתור או בזמן שההעלאה בהמתנה.
דוגמאות לשימוש
// Send text message
lifecycleScope.launch {
try {
CCAI.chatService?.sendMessage(OutgoingMessageContent.Text("Hello world"))
} catch (e: Exception) {
Log.e("CCAI", "Failed to send message: ${e.message}")
}
}
// Send image message (read the file off the main thread)
lifecycleScope.launch {
try {
val imageData = withContext(Dispatchers.IO) {
requireNotNull(contentResolver.openInputStream(selectedImageUri)).use { it.readBytes() }
}
val images = listOf(
UploadableImage(data = imageData, mimeType = "image/jpeg", uri = selectedImageUri)
)
CCAI.chatService?.sendMessage(
OutgoingMessageContent.Photos(
images = images,
smartAction = null
)
)
} catch (e: Exception) {
Log.e("CCAI", "Failed to send image: ${e.message}")
}
}
// Send video message (one video per message)
val video = UploadableVideo(uri = selectedVideoUri, mimeType = "video/mp4")
lifecycleScope.launch {
try {
CCAI.chatService?.sendMessage(
OutgoingMessageContent.Videos(
video = video,
smartAction = null
)
)
} catch (e: Exception) {
Log.e("CCAI", "Failed to send video: ${e.message}")
}
}
// Send form completion event
// Note: status is a nullable String: "success", "error", or "cancelled".
val formCompleteData = FormCompleteEventData(
smartActionId = 123,
status = "success",
timestamp = "2024-01-01T12:00:00Z",
details = FormCompleteEventDetails(message = "Form submitted successfully")
)
lifecycleScope.launch {
try {
CCAI.chatService?.sendMessage(
OutgoingMessageContent.FormComplete(data = formCompleteData)
)
Log.d("CCAI", "Form completion event sent")
} catch (e: Exception) {
Log.e("CCAI", "Failed to send form completion: ${e.message}")
}
}
סוג ההודעה ScreenShare משמש לשליחת אירועים ותגובות של שיתוף מסך לשרת. אירועי שיתוף המסך הזמינים כוללים:
screenShareRequestedFromAgent– הנציג ביקש לשתף את המסךscreenShareRequestedFromEndUser– משתמש הקצה ביקש לשתף את המסךscreenShareCodeGenerated– נוצר קוד לשיתוף המסך
screenShareFailed– שיתוף המסך נכשל
screenShareStarted– התחיל סשן של שיתוף מסך
screenShareEnded– הסשן של שיתוף המסך הסתיים
סימני הקלדה ותצוגה מקדימה של הודעות
עדכון סטטוס ההקלדה ושליחת תצוגות מקדימות של ההודעות בזמן שהמשתמש מקליד:
// Update typing indicator
CCAI.chatService?.typing(true) // Start typing
CCAI.chatService?.typing(false) // Stop typing
// Send message preview
lifecycleScope.launch {
try {
CCAI.chatService?.sendMessagePreview("Typing...")
} catch (e: Exception) {
Log.e("CCAI", "Failed to send message preview: ${e.message}")
}
}
// Example: Send preview as user types
fun onTextChanged(text: String) {
lifecycleScope.launch {
try {
CCAI.chatService?.sendMessagePreview(text)
} catch (e: Exception) {
Log.e("CCAI", "Failed to send preview: ${e.message}")
}
}
}
צנזור הודעות
אפשר לצנזר באופן אוטומטי מידע רגיש (פרטים אישיים מזהים, מספרי כרטיסי אשראי וכו') בהודעות צ'אט בטקסט פשוט ובתצוגות מקדימות של הודעות.
הגדרת צנזור:
ההגדרה נקבעת על ידי המאפיין
redactionEnabledב-ChatResponse.אפשר להגדיר את זה בפורטל בקטע הגדרות > הגדרות צ'אט > צנזור אוטומטי.
כשהתכונה מופעלת, מידע אישי רגיש מוחלף באופן אוטומטי בפלייסהולדרים לפני שהוא נשלח לנציגים.
// Redaction is automatically handled, use sendMessage as usual
lifecycleScope.launch {
try {
CCAI.chatService?.sendMessage(
OutgoingMessageContent.Text("My phone number is 4155553423")
)
} catch (e: Exception) {
Log.e("CCAI", "Failed to send message: ${e.message}")
}
}
סיום והעברת שיחות צ'אט לטיפול ברמה גבוהה יותר
// End the current chat session
lifecycleScope.launch {
try {
CCAI.chatService?.endChat()
Log.d("CCAI", "Chat ended successfully")
} catch (e: Exception) {
Log.e("CCAI", "Failed to end chat: ${e.message}")
}
}
// Escalate to a human agent
lifecycleScope.launch {
try {
CCAI.chatService?.escalateToHumanAgent()
Log.d("CCAI", "Chat escalated to human agent")
} catch (e: Exception) {
Log.e("CCAI", "Failed to escalate chat: ${e.message}")
}
}
// Record the deflection channel the user chose for an existing escalation
// (the escalation must already exist; start one with escalateToHumanAgent())
val escalationOption = ChatEscalationOption(
escalationId = 123,
deflectionChannel = DeflectionChannel.Email
)
lifecycleScope.launch {
try {
CCAI.chatService?.updateEscalation(option = escalationOption)
Log.d("CCAI", "Escalation updated successfully")
} catch (e: Exception) {
Log.e("CCAI", "Failed to update escalation: ${e.message}")
}
}
// Check the current chat status
lifecycleScope.launch {
try {
CCAI.chatService?.checkStatus()
Log.d("CCAI", "Status check completed successfully")
} catch (e: Exception) {
Log.e("CCAI", "Failed to check status: ${e.message}")
}
}
אירועים ב-Chat
שליחת אירועי צ'אט לשרת כדי לעקוב אחרי אינטראקציות של משתמשים.
ChatEvent.payload הוא Map<String, String> שלא יכול להיות ריק – גם המפתחות וגם הערכים חייבים להיות מחרוזות.
val event = ChatEvent(
name = "form_received",
payload = mapOf("name" to "contact_form")
)
lifecycleScope.launch {
try {
CCAI.chatService?.sendEvent(event)
Log.d("CCAI", "Event sent successfully")
} catch (e: Exception) {
Log.e("CCAI", "Failed to send event: ${e.message}")
}
}
תרחישים נפוצים לדוגמה של אירועים כוללים אינטראקציות עם טפסים ("form_received", "form_clicked"), אירועים של פעולות חכמות ("smart_action_received", "smart_action_clicked") ואינטראקציות מותאמות אישית של משתמשים לצורכי ניתוח.
שיקולים ספציפיים למודול בבניית האפליקציה
כדאי להביא בחשבון את הדברים הבאים כשיוצרים build ספציפי למודול.
רמת SDK מינימלית
המודולים של שכבת המדיה CCAIChatRed ו-CCAICallRed דורשים min Sdk = 23 (Android 6.0). אם באפליקציה שלכם מוגדרת גרסה נמוכה יותר של minSdkVersion, Gradle לא יצליח למזג את המניפסטים. צריך להגדיל את min Sdk ל-23 לפחות ב-app/build.gradle.kts:
android {
defaultConfig {
minSdk = 23
}
}