Headless Mobile SDK untuk Android: Mulai

Dokumen ini menjelaskan cara mengintegrasikan dan menyesuaikan SDK di aplikasi Android Anda.

Mulai

Headless Mobile SDK untuk Android memungkinkan Anda mengintegrasikan kemampuan pusat kontak CCAI Platform ke dalam UI Android bawaan Anda sendiri.

Alih-alih menampilkan widget bermerek CCAI Platform, Anda:

  • Tambahkan modul CCAI Android SDK sebagai dependensi.

  • Bangun layar, alur, dan desain visual Anda sendiri di Kotlin (direkomendasikan) atau Java.

  • Gunakan SDK untuk:

    • Memulai dan mengelola sesi chat dan suara.

    • Menawarkan opsi email, panggilan suara, dan pengalihan.

    • Mendukung tindakan cerdas, lampiran, dan alur pasca-sesi (CSAT, survei, agen virtual).

Platform CCAI menangani logika pusat kontak (perutean, antrean, saluran, konfigurasi, pelaporan). Anda memiliki seluruh pengalaman aplikasi (UI, alur, dan branding).

Jika Anda lebih suka UI bawaan dengan tema yang dapat dikonfigurasi, gunakan SDK seluler standar.

Persyaratan dan lingkungan yang didukung

Bagian ini menjelaskan persyaratan dan lingkungan yang didukung untuk Headless Mobile SDK for Android.

Persyaratan platform Android

Persyaratan platform berikut berlaku untuk Android:

  • Versi Android minimum: Android 6.0 (API level 23) atau yang lebih baru

  • Compile SDK: 36 (direkomendasikan)

  • Bahasa yang didukung: Kotlin (direkomendasikan) atau Java

  • Kompatibilitas Java: Java 17+

  • Gradle/Android Studio: Plugin Android Gradle dan versi Android Studio terbaru yang kompatibel dengan aplikasi Anda dan rilis SDK yang Anda gunakan

  • Versi Kotlin: 2.0 atau yang lebih tinggi

Persyaratan instance CCAI Platform

Anda memerlukan akses ke Setelan developer instance CCAI Platform untuk mendapatkan:

  • Kunci perusahaan

  • Kode rahasia perusahaan

  • URL Host — nama host untuk platform CCAI (misalnya, your_subdomain.ccaiplatform.com)

Nilai ini digunakan untuk:

  • Kunci perusahaan dan URL Host — di aplikasi Android Anda untuk melakukan inisialisasi SDK.

  • Kode rahasia perusahaan — di backend Anda untuk menandatangani Token Web JSON (JWT) yang digunakan untuk mengautentikasi pengguna.

Jaringan dan izin

Aplikasi Anda harus mengizinkan traffic keluar ke endpoint CCAI Platform dan endpoint penyedia suara yang telah Anda konfigurasi.

Izin Android standar mencakup (daftar sebenarnya dapat bervariasi menurut versi SDK dan set fitur Anda):

  • Status internet/jaringan: untuk semua komunikasi SDK.

  • Mikrofon: untuk panggilan suara.

  • Notifikasi: hanya jika Anda menggunakan notifikasi push (lihat Notifikasi push di bawah).

  • Penyimpanan/media: hanya jika aplikasi Anda membaca foto, video, atau file dari penyimpanan bersama secara langsung. File aplikasi Anda sendiri dan pemilih foto sistem tidak memerlukan izin.

  • Kamera: untuk pengambilan foto atau video dalam tindakan cerdas.

  • Screenshot: untuk berbagi layar (MediaProjection).

Mendeklarasikan dan meminta izin runtime sesuai dengan panduan Android OS.

Notifikasi push

Headless Android SDK menggunakan FCM untuk mengirimkan:

  • Notifikasi panggilan masuk.

  • Pesan tertentu terkait tindakan cerdas dan panggilan.

  • Update untuk membantu mempertahankan status saat aplikasi berjalan di latar belakang.

Anda akan memerlukan:

  • Project Firebase.

  • google-services.json yang valid di modul aplikasi Anda.

  • Penanganan dan pendaftaran token FCM di aplikasi Anda.

  • UI notifikasi dan dalam panggilan kustom di aplikasi Anda.

Cara kerja Android SDK headless di aplikasi Anda

Headless Mobile SDK untuk Android dapat dilihat sebagai tiga lapisan:

Platform dan SDK CCAI Platform (ditangani oleh CCAI Platform)

SDK berinteraksi secara aman dengan platform CCAI Platform dan menyediakan:

  • Autentikasi menggunakan Token Web JSON (JWT).

  • Metadata pemilihan rute antrean dan saluran (chat, panggilan suara, email, link pengalihan eksternal).

  • Pengelolaan status sesi real-time menggunakan objek layanan (chatService, queueMenuService, dan lainnya).

  • Pipeline transpor yang aman untuk tindakan cerdas, lampiran file, dan berbagi layar.

  • Logika pengalihan dan evaluasi hierarki pasca-sesi.

Aplikasi Android Anda (UI dan logika - ditangani oleh Anda)

Anda mengontrol seluruh pengalaman visual dan navigasi:

  • Titik entri: misalnya, tab Bantuan atau tombol Hubungi kami.

  • Menu: cara Anda menampilkan antrean (misalnya, Penagihan, Dukungan teknis).

  • UI dalam sesi: balon chat, layar panggilan, dan kontrol kustom Anda.

  • Fungsi aplikasi Anda: memanggil API layanan SDK untuk memulai dan mengakhiri sesi, mengamati peristiwa SDK menggunakan Coroutine dan Flow Kotlin, serta mengarahkan navigasi komponen.

Konfigurasi Portal Admin CCAI Platform

Admin CCAI Platform Anda mengonfigurasi aturan interaksi (jam buka, saluran yang tersedia, batas waktu tunggu, dan survei). SDK akan membaca konfigurasi ini dan mengeksposnya ke aplikasi Anda sebagai data mentah dan peristiwa. Anda yang memutuskan cara menggambar konfigurasi tersebut di layar.

Mengambil kredensial perusahaan

Sebelum mengintegrasikan SDK, dapatkan kredensial dari instance CCAI Platform Anda:

  1. Login ke Portal Admin CCAI Platform dengan akun administrator.

  2. Buka Setelan > Setelan developer.

  3. Di bagian Kunci perusahaan & kode rahasia, salin:

    • Kunci perusahaan

    • Kode rahasia perusahaan

  4. Catat URL Host Anda — nama host untuk platform CCAI (misalnya, your_subdomain.ccaiplatform.com).

Anda akan menggunakan:

  • Di aplikasi Android Anda: Kunci perusahaan dan URL Host.

  • Di server backend Anda: Kode rahasia perusahaan untuk menandatangani JWT untuk autentikasi pengguna akhir serta data dan konteks kustom opsional yang digunakan oleh CCAI Platform.

Menambahkan SDK ke aplikasi Android Anda

SDK Headless menggunakan arsitektur modular. Anda menginstal CCAIKit inti bersama dengan modul fitur tertentu yang diperlukan aplikasi Anda (misalnya, CCAIChat atau CCAIScreenShare).

Menambahkan repositori Maven CCAI

Tambahkan repositori Maven CCAI ke settings.gradle.kts (atau build.gradle root) project Anda:

// settings.gradle.kts
dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
        maven { url = uri("https://sdk.ujet.co/ccaip/android/") }
    }
}

Mengonfigurasi katalog versi Gradle (direkomendasikan)

Google Cloud merekomendasikan penggunaan katalog versi Gradle untuk mengelola dependensi SDK. Tambahkan kode berikut ke gradle/libs.versions.toml:

[versions]
ccaiVersion = "3.5.0"

[libraries]
ccai-kit       = { group = "com.ccaiplatform.android", name = "CCAIKit",        version.ref = "ccaiVersion" }
ccai-chat      = { group = "com.ccaiplatform.android", name = "CCAIChat",       version.ref = "ccaiVersion" }
ccai-chat-red  = { group = "com.ccaiplatform.android", name = "CCAIChatRed",    version.ref = "ccaiVersion" }
ccai-call      = { group = "com.ccaiplatform.android", name = "CCAICall",       version.ref = "ccaiVersion" }
ccai-call-red  = { group = "com.ccaiplatform.android", name = "CCAICallRed",    version.ref = "ccaiVersion" }
ccai-screenshare = { group = "com.ccaiplatform.android", name = "CCAIScreenShare", version.ref = "ccaiVersion" }

Menambahkan dependensi

Di build.gradle.kts level aplikasi, tambahkan SDK inti dan modul fitur tertentu:

// app/build.gradle.kts
android {
    compileSdk = 36

    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_17
        targetCompatibility = JavaVersion.VERSION_17
    }

    kotlinOptions {
        jvmTarget = "17"
    }
}

dependencies {
    // 1. Core (always required)
    implementation(libs.ccai.kit)

    // 2. Chat (required for chat sessions)
    implementation(libs.ccai.chat)
    implementation(libs.ccai.chat.red)   // media layer paired with CCAIChat

    // 3. Voice (required for instant calls, voicemail, and scheduled calls)
    implementation(libs.ccai.call)
    implementation(libs.ccai.call.red)   // media/transport layer paired with CCAICall

    // 4. Screen Share (optional)
    // implementation(libs.ccai.screenshare)
}

Jika tidak menggunakan katalog versi, Anda dapat mendeklarasikan dependensi secara langsung:

val ccaiVersion = "3.3.1"

dependencies {
    implementation("com.ccaiplatform.android:CCAIKit:$ccaiVersion")
    implementation("com.ccaiplatform.android:CCAIChat:$ccaiVersion")
    implementation("com.ccaiplatform.android:CCAIChatRed:$ccaiVersion")
    implementation("com.ccaiplatform.android:CCAICall:$ccaiVersion")        // Voice calls
    implementation("com.ccaiplatform.android:CCAICallRed:$ccaiVersion")     // Twilio VoIP backend
    implementation("com.ccaiplatform.android:CCAIScreenShare:$ccaiVersion") // Optional, for screen share
}

Inisialisasi dan penyiapan

Lakukan inisialisasi SDK selama peluncuran aplikasi. Karena arsitektur modular SDK, inisialisasi sistem CCAI Platform inti terlebih dahulu, lalu daftarkan penyedia saluran tertentu (seperti chat atau screen share).

Mengimplementasikan antarmuka CCAIDelegate

SDK menggunakan antarmuka CCAIDelegate untuk callback autentikasi. Metode kunci adalah fungsi penangguhan Kotlin ccaiShouldAuthenticate() yang dipanggil SDK saat memerlukan JWT.

import com.ccaiplatform.ccaikit.CCAI
import com.ccaiplatform.ccaikit.CCAIDelegate
import kotlinx.coroutines.CancellationException

class MyCCAIDelegate : CCAIDelegate {

    /**
     * Called by the SDK when it needs a signed JWT for authentication.
     * This is a suspend function - you can make network calls here.
     *
     * @return The auth token returned by `authService.authenticate(jwt)`,
     *         or null on failure. This is what the SDK expects - not the raw JWT.
     */
    override suspend fun ccaiShouldAuthenticate(): String? {
        return try {
            // 1. Call your backend server to get a signed JWT
            val jwt = MyBackendApi.getSignedJwt() ?: return null

            // 2. Exchange the JWT for an auth token using authService - this is
            //    what the SDK expects to be returned (not the raw JWT).
            CCAI.authService?.authenticate(jwt)
        } catch (e: CancellationException) {
            throw e
        } catch (e: Throwable) {
            // Includes NetworkError, which extends Error rather than Exception
            null // Return null to signal authentication failure
        }
    }
}

Cuplikan sebelumnya menunjukkan alur dua langkah minimal (tanda tangan → autentikasi → kembali).

Lihat Mengautentikasi pengguna akhir dan meneruskan data kustom untuk kontrak autentikasi lengkap, termasuk:

  • cara menandatangani JWT di backend,
  • cara authenticate(jwt) menukarnya dengan token autentikasi,
  • token caching dan invalidation, serta
  • contoh yang berfungsi dengan penanganan error.

Melakukan inisialisasi SDK di class aplikasi Anda

Lakukan inisialisasi SDK di class Application kustom Anda menggunakan objek singleton CCAI:

import android.app.Application
import com.ccaiplatform.ccaikit.CCAI
import com.ccaiplatform.ccaikit.InitOptions
import com.ccaiplatform.ccaichat.initializeChat
import com.ccaiplatform.ccaichat.model.ChatOptions
import com.ccaiplatform.ccaicall.initializeCall
// import com.ccaiplatform.ccaiscreenshare.initializeScreenShare  // If using screen share
import com.ccaiplatform.ccaikit.models.screenShare.ScreenShareOptions

class MainApplication : Application() {

    private val delegate = MyCCAIDelegate()

    override fun onCreate() {
        super.onCreate()

        // 1. Build InitOptions
        val initOptions = InitOptions(
            key = "YOUR_COMPANY_KEY",
            urlHost = "your_subdomain.ccaiplatform.com",
            delegate = delegate            // Your CCAIDelegate implementation
        )

        // 2. Initialize the Core SDK
        CCAI.initialize(
            context = this,
            options = initOptions
        )

        // Optional: set the SDK language (ISO 639 code). See Languages and localization
        // in Headless Mobile SDK v3 for Android: Advanced Topics, Localization, and Post-Session Flows.
        CCAI.languageService?.languageCode = "en"

        // 3. Initialize Chat - minimal
        CCAI.initializeChat(context = this)

        // Initialize Chat - with optional configuration
        // val chatOptions = ChatOptions(
        //     webFormHandler = null,                // Optional suspend handler that renders web forms in your own UI
        //     downloadTranscriptVisibility = DownloadTranscriptVisibility.SHOW_ALL
        // )
        // To set a chat greeting, pass Chat(greeting = ...) in the ChatRequest
        // CCAI.initializeChat(
        //     context = this,
        //     options = chatOptions
        // )

        // 4. Initialize call (required whenever your app uses voice or scheduled calls)
        CCAI.initializeCall(context = this)

        // 5. Initialize screen share (optional)
        // CCAI.initializeScreenShare(
        //     context = this,
        //     options = ScreenShareOptions(
        //         key = "YOUR_SCREEN_SHARE_LICENSE_KEY",   // License Key (Settings > Developer Settings > Screen Share)
        //         domain = "https://your-screen-share-domain.example.com" // Optional: the Screen Share Domain URL
        //     )
        // )
    }
}

Referensi konfigurasi InitOptions

data class InitOptions(
    /// The company key used for authentication
    var key: String,

    /// The host URL for CCAI platform (for example, "my-unique-instance.uc1.ccaiplatform.com")
    var urlHost: String,

    /// The preferred language code for localization (defaults to "en")
    var languageCode: String? = "en",

    /// Listener that handles authentication
    var delegate: CCAIDelegate? = null,

    /// Whether to cache the authentication token (defaults to true)
    var cacheAuthToken: Boolean = true
)

Update AndroidManifest.xml

Pastikan class aplikasi kustom Anda terdaftar:

<application
    android:name=".MainApplication"
    android:icon="@mipmap/ic_launcher"
    android:label="@string/app_name"
    android:theme="@style/Theme.YourApp">
</application>

Layanan SDK yang tersedia

Setelah inisialisasi, Anda dapat mengakses berbagai layanan melalui objek singleton CCAI:

val authService = CCAI.authService
val companyService = CCAI.companyService
val queueMenuService = CCAI.queueMenuService
val languageService = CCAI.languageService
val pushNotificationService = CCAI.pushNotificationService
val smartActionService = CCAI.smartActionService
val endUserService = CCAI.endUserService
val chatService = CCAI.chatService              // Only available after initializeChat()
val screenShareService = CCAI.screenShareService // Only available after initializeScreenShare()
val rateService = CCAI.rateService              // For CSAT ratings and survey submission
val callService = CCAI.callService              // Only available after initializeCall()

Mengambil konfigurasi perusahaan

Setelah inisialisasi, Anda dapat mengambil konfigurasi tingkat perusahaan menggunakan companyService. Hal ini berguna untuk mengisi pemilih bahasa, menampilkan nama perusahaan, atau membaca detail kontak dukungan sebelum pengguna memasuki antrean.

// Fetch company details
val company = CCAI.companyService?.get()

// CompanyResponse contains:
// - displayName: String?
// - supportEmail: String?
// - languages: List<LanguageSetting>? (each with lang, name, and enabled)
// - phoneNumber: String?
// ...

Mengautentikasi pengguna akhir dan meneruskan data kustom

Headless Mobile SDK untuk Android menggunakan token web JSON (JWT) untuk mengautentikasi pengguna dan meneruskan informasi kontekstual dengan aman ke CRM agen.

Cara kerjanya

SDK ini menggunakan alur autentikasi asinkron dua langkah yang disederhanakan:

  1. SDK menentukan bahwa SDK perlu mengautentikasi pengguna.

  2. Fungsi ini memanggil metode CCAIDelegate Anda - ccaiShouldAuthenticate() - yang merupakan fungsi penangguhan.

  3. Aplikasi Anda memanggil server backend untuk mendapatkan JWT yang ditandatangani.

  4. Kemudian, aplikasi Anda meneruskan JWT yang ditandatangani ke CCAI.authService?.authenticate(jwt) untuk ditukar dengan token autentikasi.

  5. Token autentikasi ditampilkan ke SDK untuk menyelesaikan koneksi.

Menerapkan CCAIDelegate untuk autentikasi

Aplikasi Anda harus mengimplementasikan antarmuka CCAIDelegate. SDK memanggil metode penangguhan pertama saat memerlukan autentikasi.

Antarmuka CCAIDelegate

interface CCAIDelegate {
    suspend fun ccaiShouldAuthenticate(): String?
}

Contoh penerapan (Kotlin)

class MyCCAIDelegate : CCAIDelegate {
    override suspend fun ccaiShouldAuthenticate(): String? {
        // 1. Sign JWT remotely on your backend server
        val jwt = signJWTRemotely() ?: return null

        // 2. Authenticate JWT using authService to get an auth token
        return try {
            CCAI.authService?.authenticate(jwt)
        } catch (e: CancellationException) {
            throw e
        } catch (e: Throwable) {
            // Includes NetworkError, which extends Error rather than Exception
            null
        }
    }
}

Meneruskan data kustom ke CRM

Jika Anda ingin meneruskan data kontekstual ke agen (misalnya, OS perangkat, lokasi, atau tingkat akun pengguna saat ini), backend Anda harus memasukkan objek custom_data ke dalam payload JWT sebelum menandatanganinya.

Setiap bagian data kustom harus diformat sebagai objek JSON yang berisi label (yang dilihat agen), nilai, dan jenis.

Jenis data yang didukung

  • string: teks standar (misalnya, "Pixel 8 Pro").

  • number: bilangan bulat atau float (misalnya, 1234 atau 99,99).

  • date: stempel waktu Unix UTC 13 digit termasuk milidetik (misalnya, 1537399655992).

  • url: format URL HTTP/HTTPS standar.

  • boolean: nilai benar atau salah standar.

Visibilitas agen: Anda dapat secara opsional meneruskan data ke platform CCAI Platform yang disembunyikan dari agen manusia, tetapi tersedia untuk perutean atau analisis backend. Untuk melakukannya, sertakan "invisible_to_agent": true dalam objek data.

Kunci CRM yang dicadangkan

CCAI Platform mendukung kunci khusus yang memicu perilaku bawaan di platform, seperti menandai pengguna sebagai VIP atau memperingatkan agen tentang pelaku kejahatan. Ini harus diformat sebagai jenis boolean dan hanya akan diterima jika payload ditandatangani menggunakan metode JWT yang aman.

  • reserved_verified_customer: menunjukkan apakah pelanggan telah berhasil diautentikasi oleh sistem internal Anda.

  • reserved_bad_actor: menandai pengguna kepada agen sebagai akun yang berpotensi spam atau bersifat menipu.

  • reserved_repeat_customer: menunjukkan apakah pelanggan ini sering menghubungi dukungan akhir-akhir ini.

Contoh payload dengan kunci yang dicadangkan

{
  "iat": 1537399656,
  "exp": 1537400256,
  "custom_data": {
    "reserved_verified_customer": {
      "label": "Verified Customer",
      "value": true,
      "type": "boolean"
    },
    "reserved_bad_actor": {
      "label": "Bad Actor",
      "value": false,
      "type": "boolean"
    },
    "reserved_repeat_customer": {
      "label": "Repeat Customer",
      "value": false,
      "type": "boolean"
    }
  }
}

Mengelola token autentikasi

SDK menyediakan metode untuk memperbarui atau menghapus token autentikasi yang di-cache secara manual:

// Set a new auth token
CCAI.authService?.updateAuthToken("new_auth_token")

// Clear the current token (for example, on user logout)
CCAI.authService?.updateAuthToken(null)

Skema payload JWT data kustom

Saat backend Anda membuat payload akhir yang akan ditandatangani dengan Company Secret Code, backend harus benar-benar mengikuti skema ini. Perhatikan stempel waktu iat (diterbitkan pada) dan exp (masa berlaku) yang wajib ada.

{
  "iat": 1537399656,
  "exp": 1537400256,
  "custom_data": {
    "os_version": {
      "label": "OS Version",
      "value": "14.0",
      "type": "string"
    },
    "membership_tier": {
      "label": "Membership Tier",
      "value": "Platinum",
      "type": "string"
    },
    "ssn_last_four": {
      "label": "SSN",
      "value": "1234",
      "type": "string",
      "invisible_to_agent": true
    },
    "reserved_verified_customer": {
      "label": "Verified Customer",
      "value": true,
      "type": "boolean"
    }
  }
}

Aktifkan notifikasi push

SDK menggunakan notifikasi push untuk:

  • Panggilan masuk.

  • Smart action tertentu dan peristiwa terkait panggilan.

  • Mempertahankan status saat aplikasi berada di latar belakang.

Penyiapan Firebase

  1. Buat atau gunakan project Firebase yang ada.

  2. Daftarkan aplikasi Android Anda dan download file google-services.json.

  3. Tempatkan google-services.json di direktori modul aplikasi Anda.

  4. Dalam build.gradle.kts level root, tambahkan plugin layanan Google:

    // build.gradle.kts (Project)
    plugins {
        id("com.google.gms.google-services") version "4.4.2" apply false
    }
    
  5. Di build.gradle.kts level aplikasi, terapkan plugin dan tambahkan dependensi Firebase:

    // app/build.gradle.kts
    plugins {
        id("com.google.gms.google-services")
    }
    
    dependencies {
        // Firebase BoM for version management
        implementation(platform("com.google.firebase:firebase-bom:33.5.1"))
        implementation("com.google.firebase:firebase-messaging")
    }
    
  6. Sinkronkan project.

Mendaftarkan token FCM ke SDK

Daftarkan token push FCM melalui pushNotificationService dan teruskan payload data FCM yang masuk ke SDK. Aplikasi Anda bertanggung jawab untuk merender UI dalam panggilan atau notifikasi yang ditampilkan kepada pelanggan.

Menerapkan onMessageReceived

Jika Anda menggunakan FCM, terapkan pemroses di class FirebaseMessagingService untuk notifikasi push. Jika tidak diterapkan, layanan tidak akan berfungsi dengan baik.

import com.google.firebase.messaging.FirebaseMessagingService
import com.google.firebase.messaging.RemoteMessage
import com.ccaiplatform.ccaikit.CCAI
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch

class MyFirebaseMessagingService : FirebaseMessagingService() {

    private val scope = CoroutineScope(Dispatchers.IO)

    override fun onMessageReceived(remoteMessage: RemoteMessage) {
        scope.launch {
            // Forward CCAI platform push notifications to the SDK.
            CCAI.pushNotificationService?.handlePushNotification(remoteMessage.data)

            // Render any customer-facing notification UI in your own app code.
            MyNotificationRenderer.showIfNeeded(application, remoteMessage.data)
        }
    }
}

Menerapkan onNewToken

Terapkan juga metode onNewToken untuk menangani update token. Hal ini memastikan bahwa Headless Mobile SDK untuk Android menerima token notifikasi push terbaru:

class MyFirebaseMessagingService : FirebaseMessagingService() {
    // ...
    override fun onNewToken(token: String) {
        // Fetch the updated token from Firebase and update it in CCAI
        CCAI.pushNotificationService?.updatePushToken(token)
    }
}

Daftarkan layanan di AndroidManifest.xml

Tambahkan Firebase Messaging Service ke AndroidManifest.xml Anda agar sistem dapat mengirimkan pesan push ke layanan Anda:

<application>
    <service
        android:name=".firebase.MyFirebaseMessagingService"
        android:exported="true">
        <intent-filter>
            <action android:name="com.google.firebase.MESSAGING_EVENT" />
        </intent-filter>
    </service>
</application>

Pendaftaran token awal

Saat aplikasi dimulai (setelah inisialisasi SDK), daftarkan token FCM saat ini secara proaktif:

import com.google.firebase.messaging.FirebaseMessaging

// In your Application.onCreate(), after CCAI.initialize()
FirebaseMessaging.getInstance().token.addOnCompleteListener { task ->
    if (task.isSuccessful) {
        val token = task.result
        CCAI.pushNotificationService?.updatePushToken(token)
    }
}

Penanganan izin notifikasi (Android 13+)

Di Android 13 (level API 33) dan yang lebih tinggi, aplikasi Anda memerlukan izin runtime POST_NOTIFICATIONS untuk menampilkan notifikasi. SDK menyediakan utilitas bawaan untuk memintanya:

import com.ccaiplatform.ccaikit.util.PermissionUtil

// Request notification permissions from the user
PermissionUtil.requestPermissionsForNotifications(activity)

// Check if permissions have been granted
val isGranted = PermissionUtil.isPermissionsForNotificationsGranted(context)
if (isGranted) {
    Log.d("CCAI", "Push notifications permitted")
}

Panggil metode ini di awal siklus proses aplikasi Anda (misalnya, selama orientasi atau peluncuran pertama) sebelum mendaftarkan token FCM, sehingga notifikasi push dapat dikirim.