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:
Login ke Portal Admin CCAI Platform dengan akun administrator.
Buka Setelan > Setelan developer.
Di bagian Kunci perusahaan & kode rahasia, salin:
Kunci perusahaan
Kode rahasia perusahaan
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:
SDK menentukan bahwa SDK perlu mengautentikasi pengguna.
Fungsi ini memanggil metode
CCAIDelegateAnda -ccaiShouldAuthenticate()- yang merupakan fungsi penangguhan.Aplikasi Anda memanggil server backend untuk mendapatkan JWT yang ditandatangani.
Kemudian, aplikasi Anda meneruskan JWT yang ditandatangani ke
CCAI.authService?.authenticate(jwt)untuk ditukar dengan token autentikasi.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
Buat atau gunakan project Firebase yang ada.
Daftarkan aplikasi Android Anda dan download file
google-services.json.Tempatkan
google-services.jsondi direktori modul aplikasi Anda.Dalam
build.gradle.ktslevel root, tambahkan plugin layanan Google:// build.gradle.kts (Project) plugins { id("com.google.gms.google-services") version "4.4.2" apply false }Di
build.gradle.ktslevel aplikasi, terapkan plugin dan tambahkan dependensiFirebase:// 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") }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.