Ce document explique comment intégrer et personnaliser le SDK dans votre application Android.
Commencer
Le SDK mobile sans interface graphique pour Android vous permet d'intégrer les fonctionnalités de centre de contact de CCAI Platform à votre propre UI Android intégrée.
Au lieu de présenter un widget aux couleurs de CCAI Platform, vous :
Ajoutez les modules du SDK Android CCAI en tant que dépendances.
Créez vos propres écrans, flux et conceptions visuelles en Kotlin (recommandé) ou en Java.
Utilisez le SDK pour :
Démarrer et gérer des sessions de chat et vocales.
Proposez des options d'e-mail, d'appel vocal et de déviation.
Prendre en charge les actions intelligentes, les pièces jointes et les flux post-session (CSAT, enquêtes, agent virtuel).
CCAI Platform gère la logique du centre de contact (routage, files d'attente, canaux, configuration, rapports). Vous êtes propriétaire de l'intégralité de l'expérience dans l'application (UI, flux et branding).
Si vous préférez une UI prédéfinie avec des thèmes configurables, utilisez le SDK mobile standard.
Configuration requise et environnements compatibles
Cette section décrit les exigences et les environnements compatibles avec le SDK Mobile sans interface graphique pour Android.
Exigences concernant la plate-forme Android
Les exigences de plate-forme suivantes s'appliquent à Android :
Version minimale d'Android : Android 6.0 (niveau d'API 23) ou version ultérieure
SDK de compilation : 36 (recommandé)
Langages compatibles : Kotlin (recommandé) ou Java
Compatibilité Java : Java 17 ou version ultérieure
Gradle/Android Studio : une version récente du plug-in Android Gradle et d'Android Studio compatible avec votre application et la version du SDK que vous utilisez
Version de Kotlin : 2.0 ou ultérieure
Exigences concernant les instances CCAI Platform
Vous devez accéder aux paramètres de développeur de votre instance CCAI Platform pour obtenir les éléments suivants :
Clé d'entreprise
Code secret de l'entreprise
URL de l'hôte : nom d'hôte de la plate-forme CCAI (par exemple, votre_sous-domaine.ccaiplatform.com)
Ces valeurs sont utilisées pour :
Clé d'entreprise et URL de l'hôte : dans votre application Android pour initialiser le SDK.
Code secret de l'entreprise : dans votre backend pour signer les jetons Web JSON (JWT) utilisés pour authentifier les utilisateurs.
Mise en réseau et autorisations
Votre application doit autoriser le trafic sortant vers les points de terminaison de la plate-forme CCAI et tous les points de terminaison de fournisseur de services vocaux que vous avez configurés.
Les autorisations Android standards incluent les éléments suivants (la liste réelle peut varier en fonction de la version du SDK et de votre ensemble de fonctionnalités) :
État d'Internet/du réseau : pour toutes les communications du SDK.
Micro : pour les appels vocaux.
Notifications : uniquement si vous utilisez les notifications push (voir Notifications push ci-dessous).
Stockage/Contenus multimédias : uniquement si votre application lit directement des photos, des vidéos ou des fichiers depuis un espace de stockage partagé. Les fichiers de votre application et le sélecteur de photos du système ne nécessitent pas d'autorisation.
Appareil photo : pour prendre des photos ou enregistrer des vidéos dans les actions intelligentes.
Capture d'écran : pour le partage d'écran (
MediaProjection).
Déclarez et demandez des autorisations d'exécution conformément aux consignes de l'OS Android.
Notifications push
Le SDK Android sans interface graphique utilise FCM pour diffuser :
Notifications d'appels entrants.
Certains messages liés aux actions intelligentes et aux appels.
Mises à jour pour aider à maintenir l'état lorsque l'application est en arrière-plan.
Vous avez alors besoin de :
Un projet Firebase.
Un fichier google-services.json valide dans le module de votre application.
Gestion et enregistrement des jetons FCM dans votre application.
Notification personnalisée et interface utilisateur en cours d'appel dans votre application.
Comment le SDK Android headless s'intègre à votre application
Le SDK mobile sans interface graphique pour Android peut être considéré comme composé de trois couches :
Plate-forme et SDK CCAI Platform (gérés par CCAI Platform)
Le SDK interagit de manière sécurisée avec la plate-forme CCAI Platform et fournit les éléments suivants :
S'authentifier avec des jetons Web JSON (JWT)
Métadonnées de routage des files d'attente et des canaux (chat, appel vocal, e-mail, liens de déviation externes).
Gestion de l'état des sessions en temps réel à l'aide d'objets de service (
chatService,queueMenuService, etc.).Pipeline de transport sécurisé pour les actions intelligentes, les pièces jointes et le partage d'écran.
Logique de déviation et évaluation de la hiérarchie après la session.
Votre application Android (UI et logique, gérées par vous)
Vous contrôlez l'ensemble de l'expérience visuelle et de navigation :
Points d'entrée : par exemple, un onglet Aide ou un bouton Nous contacter.
Menus : comment vous présentez les files d'attente (par exemple, Facturation, Assistance technique).
UI de session : vos bulles de chat, écrans d'appel et commandes personnalisés.
Ce que fait votre application : elle appelle les API du service SDK pour démarrer et terminer des sessions, observe les événements du SDK à l'aide des coroutines et des flux Kotlin, et gère la navigation entre les composants.
Configuration du portail d'administration CCAI Platform
Vos administrateurs CCAI Platform configurent les règles d'engagement (horaires d'ouverture, canaux disponibles, seuils de temps d'attente et enquêtes). Le SDK lit cette configuration et l'expose à votre application sous forme de données brutes et d'événements. Vous décidez comment dessiner cette configuration à l'écran.
Récupérer les identifiants de l'entreprise
Avant d'intégrer le SDK, obtenez les identifiants de votre instance CCAI Platform :
Connectez-vous au portail d'administration de CCAI Platform avec un compte administrateur.
Accédez à Paramètres > Paramètres pour les développeurs.
Sous Clé d'entreprise et code secret, copiez :
Clé d'entreprise
Code secret de l'entreprise
Notez l'URL de l'hôte, c'est-à-dire le nom d'hôte de la plate-forme CCAI (par exemple,
your_subdomain.ccaiplatform.com).
Vous utiliserez ces produits :
Dans votre application Android : Clé d'entreprise et URL de l'hôte.
Dans votre serveur backend : code secret de l'entreprise pour signer les jetons JWT pour l'authentification des utilisateurs finaux, et données et contexte personnalisés facultatifs utilisés par la plate-forme CCAI.
Ajouter le SDK à votre application Android
Le SDK sans interface graphique utilise une architecture modulaire. Vous installez le CCAIKit de base ainsi que les modules de fonctionnalités spécifiques requis par votre application (par exemple, CCAIChat ou CCAIScreenShare).
Ajouter le dépôt Maven CCAI
Ajoutez le dépôt Maven CCAI au fichier settings.gradle.kts (ou build.gradle racine) de votre projet :
// settings.gradle.kts
dependencyResolutionManagement {
repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
repositories {
google()
mavenCentral()
maven { url = uri("https://sdk.ujet.co/ccaip/android/") }
}
}
Configurer le catalogue de versions Gradle (recommandé)
Google Cloud recommande d'utiliser un catalogue de versions Gradle pour gérer les dépendances du SDK. Ajoutez le code suivant à votre 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" }
Ajouter des dépendances
Dans le fichier build.gradle.kts au niveau de l'application, ajoutez le SDK de base et les modules de fonctionnalités spécifiques :
// 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)
}
Si vous n'utilisez pas le catalogue de versions, vous pouvez déclarer les dépendances directement :
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
}
Initialisation et configuration
Initialisez le SDK au lancement de l'application. En raison de l'architecture modulaire du SDK, initialisez d'abord le système principal de la plate-forme CCAI, puis enregistrez les fournisseurs de canaux spécifiques (tels que chat ou screen share).
Implémenter l'interface CCAIDelegate
Le SDK utilise une interface CCAIDelegate pour les rappels d'authentification. La méthode clé est une fonction de suspension Kotlin ccaiShouldAuthenticate() que le SDK appelle lorsqu'il a besoin d'un jeton 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
}
}
}
L'extrait précédent montre le flux minimal en deux étapes (sign → authenticate → return).
Consultez Authentifier les utilisateurs finaux et transmettre des données personnalisées pour connaître l'intégralité du contrat d'authentification, y compris :
- comment signer le jeton JWT sur votre backend,
- comment
authenticate(jwt)l'échange contre un jeton d'authentification, - la mise en cache et l'invalidation des jetons, et
- des exemples concrets avec gestion des exceptions.
Initialiser le SDK dans votre classe d'application
Initialisez le SDK dans votre classe Application personnalisée à l'aide de l'objet 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
// )
// )
}
}
Documentation de référence sur la configuration de 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
)
Mise à jour de AndroidManifest.xml…
Assurez-vous que votre classe d'application personnalisée est enregistrée :
<application
android:name=".MainApplication"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:theme="@style/Theme.YourApp">
</application>
Services SDK disponibles
Après l'initialisation, vous pouvez accéder à différents services via l'objet 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()
Récupérer la configuration de l'entreprise
Après l'initialisation, vous pouvez récupérer la configuration au niveau de l'entreprise à l'aide de companyService. Cela est utile pour renseigner les outils de sélection de langue, afficher le nom de l'entreprise ou lire les coordonnées de l'assistance avant que l'utilisateur n'entre dans une file d'attente.
// 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?
// ...
Authentifier les utilisateurs finaux et transmettre des données personnalisées
Le SDK Headless Mobile pour Android utilise des jetons Web JSON (JWT) pour authentifier les utilisateurs et transmettre de manière sécurisée des informations contextuelles au CRM de l'agent.
Fonctionnement
Le SDK utilise un flux d'authentification asynchrone simplifié en deux étapes :
Le SDK détermine qu'il doit authentifier l'utilisateur.
Il appelle votre méthode
CCAIDelegate(ccaiShouldAuthenticate()), qui est une fonction de suspension.Votre application appelle votre serveur backend pour obtenir un jeton JWT signé.
Votre application transmet ensuite le jeton JWT signé à
CCAI.authService?.authenticate(jwt)pour l'échanger contre un jeton d'authentification.Le jeton d'authentification est renvoyé au SDK pour finaliser la connexion.
Implémenter CCAIDelegate pour l'authentification
Votre application doit implémenter l'interface CCAIDelegate. Le SDK appelle la première méthode de suspension lorsqu'il a besoin d'une authentification.
CCAIDelegate interface
interface CCAIDelegate {
suspend fun ccaiShouldAuthenticate(): String?
}
Exemple d'implémentation (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
}
}
}
Transmettre des données personnalisées au CRM
Si vous souhaitez transmettre des données contextuelles à l'agent (par exemple, l'OS de l'appareil, la position ou le niveau de compte de l'utilisateur), votre backend doit injecter un objet custom_data dans la charge utile du jeton JWT avant de le signer.
Chaque donnée client personnalisée doit être formatée en tant qu'objet JSON contenant un libellé (ce que l'agent voit), une valeur et un type.
Types de données acceptés
string: texte standard (par exemple, "Pixel 8 Pro").number: entiers ou nombres à virgule flottante (par exemple, 1234 ou 99,99).date: code temporel Unix UTC à 13 chiffres, millisecondes comprises (par exemple, 1537399655992).url: format d'URL HTTP/HTTPS standard.boolean: valeur booléenne standard (true ou false).
Visibilité de l'agent : vous pouvez éventuellement transmettre à la plate-forme CCAI Platform des données qui sont masquées pour l'agent humain, mais disponibles pour le routage ou l'analyse du backend. Pour ce faire, incluez "invisible_to_agent": true dans l'objet de données.
Clés CRM réservées
CCAI Platform accepte des clés réservées spécifiques qui déclenchent des comportements intégrés dans la plate-forme, comme le fait de signaler un utilisateur comme VIP ou d'avertir un agent d'un acteur malveillant. Ils doivent être au format boolean et ne seront acceptés que si la charge utile est signée à l'aide de la méthode JWT sécurisée.
reserved_verified_customer: indique si un client a été authentifié par vos systèmes internes.reserved_bad_actor: signale l'utilisateur à l'agent comme un spammeur ou un compte frauduleux potentiel.reserved_repeat_customer: indique si ce client a fréquemment contacté l'assistance récemment.
Exemple de charge utile avec des clés réservées
{
"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"
}
}
}
Gérer les jetons d'authentification
Le SDK fournit des méthodes pour mettre à jour ou effacer manuellement le jeton d'authentification mis en cache :
// Set a new auth token
CCAI.authService?.updateAuthToken("new_auth_token")
// Clear the current token (for example, on user logout)
CCAI.authService?.updateAuthToken(null)
Schéma de charge utile JWT des données personnalisées
Lorsque votre backend crée la charge utile finale à signer avec votre Company
Secret Code, il doit suivre strictement ce schéma. Notez les codes temporels obligatoires iat (date d'émission) et exp (date d'expiration).
{
"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"
}
}
}
Activer les notifications push
Le SDK utilise les notifications push pour :
Appels entrants.
Certaines actions intelligentes et certains événements liés aux appels.
Maintien de l'état lorsque l'application est exécutée en arrière-plan.
Configuration de Firebase
Créez un projet Firebase ou utilisez-en un existant.
Enregistrez votre application Android et téléchargez le fichier
google-services.json.Placez
google-services.jsondans le répertoire du module de votre application.Dans votre fichier
build.gradle.ktsracine, ajoutez le plug-in des services Google :// build.gradle.kts (Project) plugins { id("com.google.gms.google-services") version "4.4.2" apply false }Dans le fichier
build.gradle.ktsau niveau de l'application, appliquez le plug-in et ajoutez les dépendancesFirebase:// 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") }Synchronisez le projet.
Enregistrer le jeton FCM auprès du SDK
Enregistrez le jeton push FCM via pushNotificationService et transférez les charges utiles de données FCM entrantes au SDK. Votre application est chargée d'afficher les notifications destinées aux clients ou l'UI d'appel.
Implémenter onMessageReceived
Si vous utilisez FCM, implémentez un écouteur dans votre classe FirebaseMessagingService pour les notifications push. Si elles ne sont pas implémentées, le service ne fonctionnera pas correctement.
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)
}
}
}
Implémenter onNewToken
Implémentez également la méthode onNewToken pour gérer les mises à jour des jetons. Cela permet de s'assurer que le SDK mobile sans interface graphique pour Android reçoit le dernier jeton de notification push :
class MyFirebaseMessagingService : FirebaseMessagingService() {
// ...
override fun onNewToken(token: String) {
// Fetch the updated token from Firebase and update it in CCAI
CCAI.pushNotificationService?.updatePushToken(token)
}
}
Enregistrer le service dans AndroidManifest.xml
Ajoutez le service Firebase Messaging à votre fichier AndroidManifest.xml pour que le système puisse envoyer des messages push à votre service :
<application>
<service
android:name=".firebase.MyFirebaseMessagingService"
android:exported="true">
<intent-filter>
<action android:name="com.google.firebase.MESSAGING_EVENT" />
</intent-filter>
</service>
</application>
Enregistrement initial du jeton
Au démarrage de l'application (après l'initialisation du SDK), enregistrez de manière proactive le jeton FCM actuel :
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)
}
}
Gestion des autorisations de notification (Android 13 ou version ultérieure)
Sur Android 13 (niveau d'API 33) ou version ultérieure, votre application a besoin de l'autorisation d'exécution POST_NOTIFICATIONS pour afficher des notifications. Le SDK fournit un utilitaire intégré pour le demander :
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")
}
Appelez cette méthode au début du cycle de vie de votre application (par exemple, lors de l'intégration ou du premier lancement) avant d'enregistrer le jeton FCM, afin que les notifications push puissent être envoyées.