Aller au contenu principal

Android - Implémenter les notifications à distance

Dans cette page, vous découvrirez comment les notifications sont gérées dans votre application et quelles sont toutes les options à votre disposition pour créer une excellente expérience de messagerie pour vos utilisateurs.

avertissement

Notificare prend en charge plusieurs types de notifications interactives et exploitables qui seront traitées pour vous sans aucun développement supplémentaire. Si vous souhaitez empêcher ce comportement par défaut, veuillez noter que vous devrez soit gérer toutes les fonctionnalités vous-même (enregistrement des métriques, présentation de l'interface utilisateur ou collecte des réponses), ou si vous ne le faites pas, vous comprenez que certaines fonctionnalités ne fonctionneront pas comme annoncé. .

Demander l'autorisation​

Depuis Android 13, l’autorisation de notification n’est pas accordée par défaut et doit être demandée. Nous avons recommandé de cibler Android 13 pour avoir plus de contrôle sur la demande.

Lorsqu’ils exécutent Android 13 et ciblent Android 12 ou une version antérieure, les utilisateurs seront invités à fournir l’autorisation lors de la création du canal de notification. Généralement, au démarrage de l'application.

Bien que les demandes d'autorisation doivent suivre une norme recommandée, le contrôle de l'expérience globale est quelque chose de propre à chaque application. Cependant, vous pouvez utiliser le code suivant comme source d'inspiration pour votre implémentation.

class MainActivity : AppCompatActivity() {

    private val notificationsPermissionLauncher = registerForActivityResult(
        ActivityResultContracts.RequestPermission()
    ) { granted ->
        if (!granted) {
            // User denied notifications permissions
            return@registerForActivityResult
        }

        // You can enable remote notifications

        lifecycleScope.launch {
            try {
                Notificare.push().enableRemoteNotifications()
            } catch (e: Exception) {
                // ...
            }
        }
    }

    private fun onEnableRemoteNotificationsClicked() {
        // Ensure we have sufficient permissions
        if (!ensureNotificationsPermission()) return

        // We have sufficient permissions to enable remote notifications

        lifecycleScope.launch {
            try {
                Notificare.push().enableRemoteNotifications()
            } catch (e: Exception) {
                // ...
            }
        }
    }

    private fun ensureNotificationsPermission(): Boolean {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) return true

        val permission = android.Manifest.permission.POST_NOTIFICATIONS
        val granted = ContextCompat.checkSelfPermission(this, permission) == PackageManager.PERMISSION_GRANTED
        if (granted) return true

        if (shouldShowRequestPermissionRationale(permission)) {
            AlertDialog.Builder(this)
                .setTitle(R.string.app_name)
                .setMessage(R.string.notifications_permission_rationale)
                .setPositiveButton(android.R.string.ok) { _, _ ->
                    notificationsPermissionLauncher.launch(permission)
                }
                .show()

            return false
        }

        notificationsPermissionLauncher.launch(permission)
        return false
    }
}

Activer les notifications​

Pour permettre à l'appareil de recevoir des notifications, il vous suffit d'invoquer une seule méthode.

// Check if the user has previously enabled remote notifications.
Notificare.push().hasRemoteNotificationsEnabled

En règle générale, l'étape ci-dessus est effectuée lors d'une certaine forme d'intégration des utilisateurs. Lorsque l'utilisateur a déjà suivi ce flux, nous activons automatiquement les notifications au lancement de Notificare.

Vous pouvez également vérifier si l'utilisateur s'est inscrit aux notifications à distance.

// Check if the user has previously enabled remote notifications.
Notificare.push().hasRemoteNotificationsEnabled

De plus, vous pouvez vérifier si l'utilisateur a désactivé les notifications dans les paramètres système.

Notificare.push().allowedUI

Si vous souhaitez également donner accès à la vue des paramètres de votre application à partir des paramètres de notification dans les paramètres de l'appareil, vous pouvez écouter l'intention NOTIFICATION_PREFERENCES. Cela ajoutera un lien vers votre activité dans les paramètres de l'appareil.

<activity android:name=".SettingsActivity">
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.NOTIFICATION_PREFERENCES" />
    </intent-filter>
</activity>

alt text

Désactiver les notifications à distance​

La désactivation des notifications à distance peut être réalisée de la même manière que leur activation.

Notificare.push().disableRemoteNotifications()

Lorsque cette méthode est appelée, nous enregistrerons automatiquement votre appareil pour ne jamais recevoir de notifications à distance, même si vous conserverez toujours le même profil utilisateur, les mêmes messages de boîte de réception et profiterez de tous les autres services pris en charge par votre forfait. Vous pouvez à tout moment demander une réinscription aux notifications push si vous le souhaitez.

Recevoir des notifications​

En raison des changements apportés à Android 12 en matière de gestion des notifications, votre activité doit devenir le trampoline. . En supposant que vous laissez votre MainActivity recevoir les intentions de notification, vous devez déclarer le intent-filter suivant dans votre AndroidManifest.xml.

<activity android:name=".MainActivity" android:launchMode="singleTask">
    <intent-filter>
        <action android:name="re.notifica.intent.action.RemoteMessageOpened" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>

Vous devez configurer l'activité recevant ces intentions avec android:launchMode="singleTask" pour éviter de la recréer plusieurs fois lors du traitement de la série d'intentions déclenchées lors de l'ouverture d'une notification depuis le tiroir de notifications. Vous pouvez également utiliser android:launchMode="singleTop", mais sachez que le système d'exploitation le recréera lors du traitement des liens profonds déclenchés par NotificationActivity. Pour plus d'informations sur les modes de lancement, reportez-vous à la documentation Android.

De plus, afin de traiter ces intentions, vous devez en prendre soin dans votre MainActivity comme indiqué ci-dessous.

override fun onCreate(savedInstanceState: Bundle?) {
    // more code ...

    if (intent != null) handleIntent(intent)
}

override fun onNewIntent(intent: Intent?) {
    // more code ...

    if (intent != null) handleIntent(intent)
}

private fun handleIntent(intent: Intent) {
    if (Notificare.push().handleTrampolineIntent(intent)) {
        Log.d(TAG, "Trampoline intent handled.")
        return
    }

    // more code ...
}

Écouter les notifications reçues​

Une fois que vous recevez des notifications dans votre application, nous pouvons approfondir et comprendre pleinement comment elles sont traitées. Notre bibliothèque se charge de placer une notification dans le centre de notifications afin que les développeurs n'aient besoin d'aucune action pour afficher les notifications. Si vous souhaitez être averti des notifications entrantes dans votre propre Intent Receiver, par exemple pour ajouter un badge à l'icône de votre lanceur d'application, vous pouvez utiliser NotificarePushIntentReceiver.

Commencez par créer une sous-classe de ce Intent Receiver et en remplaçant la méthode onNotificationReceived().

class CustomPushIntentReceiver: NotificarePushIntentReceiver() {
    override fun onNotificationReceived(
        context: Context,
        notification: NotificareNotification,
        deliveryMechanism: NotificareNotificationDeliveryMechanism
    ) {
        // more code ...
    }
}

Afin de recevoir ces intentions dans votre intent receiver, vous devez informer Notificare de votre classe.

Notificare.push().intentReceiver = CustomPushIntentReceiver::class.java

Enfin, déclarez votre récepteur d'intention personnalisé dans votre AndroidManifest.xml.

<receiver
    android:name=".CustomPushIntentReceiver"
    android:exported="false" />

Présenter les notifications​

Une notification peut être ouverte en appuyant soit sur la notification elle-même, soit en appuyant sur une action dans la notification. Nous émettrons une intention dans chaque cas vers une Activity qui déclare les intent-filters appropriés. Pour recevoir ces intentions, ajoutez ce qui suit à votre MainActivity dans AndroidManifest.xml.

<activity android:name=".MainActivity">
    <intent-filter>
        <action android:name="re.notifica.intent.action.NotificationOpened" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
    <intent-filter>
        <action android:name="re.notifica.intent.action.ActionOpened" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>

Pour gérer les intentions ci-dessus, vous pouvez adopter l'approche gérée et utiliser notre module NotificarePushUI qui prend en charge tous les événements et types d'interface utilisateur ainsi que les actions, ou vous pouvez les prendre entièrement en charge et les présenter comme vous le souhaitez. Cependant, soyez conscient si vous adoptez une approche non gérée, car vous devrez gérer tous les aspects et types de présentation des notifications, y compris les événements nécessaires pour montrer l'engagement de l'utilisateur dans notre tableau de bord.

Le code ci-dessous illustre comment cela fonctionne lors de l'utilisation de l'approche gérée.

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    // more code ...

    if (intent != null) handleIntent(intent)
}

override fun onNewIntent(intent: Intent?) {
    super.onNewIntent(intent)
    // more code ...

    if (intent != null) handleIntent(intent)
}

private fun handleIntent(intent: Intent) {
    if (NotificarePushCompat.handleTrampolineIntent(intent)) return;

    Notificare.push().parseNotificationOpenedIntent(intent)?.also { result ->
        Notificare.pushUI().presentNotification(this, result.notification)
        return
    }

    Notificare.push().parseNotificationActionOpenedIntent(intent)?.also { result ->
        Notificare.pushUI().presentAction(this, result.notification, result.action)
        return
    }

    // more code ...
}

De plus, lorsque vous utilisez l’approche gérée, vous pouvez écouter les événements du cycle de vie des notifications et effectuer toutes les étapes supplémentaires dont vous pourriez avoir besoin. Laissez votre Activity implémenter NotificarePushUI.NotificationLifecycleListener et ajoutez les méthodes suivantes si nécessaire.

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    // more code ...

    Notificare.pushUI().addLifecycleListener(this)
}

override fun onDestroy() {
    super.onDestroy()
    // more code ...

    Notificare.pushUI().removeLifecycleListener(this)
}

override fun onNotificationWillPresent(notification: NotificareNotification) {

}

override fun onNotificationPresented(notification: NotificareNotification) {

}

override fun onNotificationFinishedPresenting(notification: NotificareNotification) {

}

override fun onNotificationFailedToPresent(notification: NotificareNotification) {

}

override fun onNotificationUrlClicked(notification: NotificareNotification, uri: Uri) {

}

override fun onActionWillExecute(notification: NotificareNotification, action: NotificareNotification.Action) {

}

override fun onActionExecuted(notification: NotificareNotification, action: NotificareNotification.Action) {

}

override fun onActionFailedToExecute(
    notification: NotificareNotification,
    action: NotificareNotification.Action,
    error: Exception?
) {

}

override fun onCustomActionReceived(
    notification: NotificareNotification,
    action: NotificareNotification.Action,
    uri: Uri,
) {

}