Guide étape par étape des notifications push Android

Les notifications push jouent un rôle important dans l'engagement et la fidélisation des utilisateurs dans votre application mobile, en les tenant informés et en créant un sentiment d'urgence qui conduit à des achats. Et sous Android, nous bénéficions de l’avantage supplémentaire du service de notification Firebase Cloud Messaging (FCM), qui agit comme intermédiaire entre le serveur d’applications et l’appareil Android de l’utilisateur. Cela facilite l'envoi de notifications push, même si l'application n'est pas active ou si l'utilisateur utilise une autre application sur son appareil.

Firebase Cloud Messaging (FCM) est utilisé pour envoyer des messages de données et des alertes aux utilisateurs, grâce à son système de messagerie croisée robuste. Les plateformes iOS, Web et Android sont toutes prises en charge par FCM. Les messages avec une charge utile de données allant jusqu'à 4 Ko peuvent être envoyés à l'aide des notifications push FCM.

Dans cet article, nous explorerons l'intégration étape par étape des notifications push dans les applications Android et discuterons des aspects critiques de la mise en œuvre. Nous présenterons également plusieurs produits et outils susceptibles de simplifier et d'amplifier l'engagement des utilisateurs.

Comprendre les notifications push Android

Les notifications push mobiles contribuent à améliorer l'engagement des utilisateurs, la fidélisation des clients et l'expérience utilisateur globale dans vos applications. Lorsque les notifications push sont utilisées correctement, elles peuvent améliorer considérablement l'efficacité des applications mobiles dans divers domaines commerciaux.

Les notifications push peuvent être utilisées pour différents cas d'utilisation et à différentes fins dans votre application Android, notamment :

i) Mettre à jour un utilisateur sur l'état de sa réservation ou de son emploi du temps en ligne.

ii) Fournir des clarifications et des mises à jour pour une commande en ligne que l'utilisateur a passée.

iii) Conseiller les utilisateurs des modifications apportées au back-end et les aider à suivre leur colis.

iv) Créer un battage médiatique autour des événements liés à l'application et présenter à un utilisateur de nouvelles offres, promotions et opportunités.

v) Encourager les utilisateurs à essayer de nouvelles fonctionnalités de l'application avec des messages taquins et les informer des mises à jour du serveur et d'autres modifications back-end.

Approche de mise en œuvre des notifications push dans l'application Android

Conditions préalables

Vous devez disposer de ces outils et services pour réussir à implémenter les notifications push dans votre application Android FCM :

i) Android Studio – Il s'agit de l'IDE utilisé pour le développement Android.

ii) Connaissances et compréhension de base – Vous avez besoin d'une compréhension de base du développement et de la structure des projets Android, ainsi que de la configuration des fichiers manifestes.

iii) Un compte Firebase – Vous devez disposer d'un compte Firebase pour créer et gérer les paramètres de votre projet.

iv) Disponibilité Internet – Les tests d'intégration et la configuration de Firebase nécessitent une connexion Internet.

Étape 1. Configurez votre projet Firebase

Visitez la console Firebase.

Créez votre projet en lui donnant un nom et cliquez sur Continuer.

Pour une configuration plus poussée, vous pouvez activer ou désactiver le service Google Analytics pour obtenir les analyses de données pour votre application.

Pour terminer la configuration, vous devez revoir les paramètres du projet ; alors vous pouvez créer votre projet.

Après avoir créé votre projet, vous devez effectuer une configuration de projet supplémentaire pour les implémentations de notifications push.

Enregistrement de votre application dans le tableau de bord du projet

Vous devez cliquer sur l'icône Android dans le tableau de bord pour ajouter une application Android. Ensuite, entrez un nom de package Android. Ce nom de package doit être le même que le nom du package dans votre projet (c'est-à-dire com.app.demoapp).

Vous pouvez également saisir le pseudo de votre application pour identifier votre application dans la console.

Ajoutez la clé SHA-1 pour votre application. Vous devez utiliser cette commande pour générer votre clé SHA-1 dans votre terminal : copiez maintenant la clé SHA-1 et collez-la dans la console Firebase.

./gradlew signingReport

Enfin, cliquez sur « Enregistrer l'application » pour terminer la configuration.

Configurer les services Google

Une fois l'enregistrement de votre application terminé, vous pouvez télécharger le fichier google-services.json et l'enregistrer sur votre ordinateur.

Vous devez maintenant ajouter google-services.json à votre projet Android, déposer dans le répertoire d'applications de votre projet Android.

MyApp/
├── app/
│ ├── src/
│ ├── build.gradle
│ ├── google-services.json
├── build.gradle
├── settings.gradle

Ajouter le SDK Firebase

Ensuite, ajoutez le SDK Firebase à votre projet, dans build.gradle, ajoutez le chemin de classe des services Google :

buildscript {
    repositories {
        google()
        mavenCentral()
    }
    dependencies {
        // Add this line
        classpath 'com.google.gms:google-services:4.3.10'
    }
}

dans app/build.gradle, ajoutez les dépendances suivantes :-

apply plugin: 'com.android.application'
apply plugin: 'com.google.gms.google-services'

android {
    // ...
}

dependencies {
    // Add these lines
    implementation platform('com.google.firebase:firebase-bom:29.0.4')
    implementation 'com.google.firebase:firebase-analytics'
    implementation 'com.google.firebase:firebase-messaging'
}

Après avoir terminé ces étapes, vous pouvez cliquer sur « Synchroniser maintenant » dans Android Studio pour synchroniser votre projet avec Firebase.

Étape 2. Configurez votre projet Android

build.gradle au niveau du projet

Ouvrez build.gradle au niveau de votre projet : Accédez au répertoire racine de votre projet Android et localisez le fichier build.gradle.

Assurez-vous que les référentiels google() et mavenCentral() sont inclus dans la section référentiels.

buildscript {
    repositories {
        // Check that you have these lines
        google()
        mavenCentral()
    }
    dependencies {
        // Add this line
        classpath 'com.google.gms:google-services:4.3.10'
    }
}

allprojects {
    repositories {
        // Check that you have these lines
        google()
        mavenCentral()
    }
}

Apporter des modifications dans le build.gradle

Recherchez et localisez le fichier build.gradle dans le répertoire de votre application de projet, puis ajoutez le plugin google-services à la fin du fichier et ajoutez la dépendance Firebase et Firebase Messaging dans la section dépendances.

./gradlew signingReport

Une fois ces étapes terminées, votre projet est configuré avec les dépendances Firebase, y compris Firebase Messaging pour les notifications push. Passons maintenant à la configuration du service de messagerie Firebase et à la gestion des notifications dans votre application.

Étape 3. Mettre en œuvre le FCM

Ajouter un service pour gérer les messages FCM

Créez une nouvelle classe nommée MyMessagingService qui étend FirebaseMessagingService.

Vous devez remplacer la méthode onMessageReceived pour gérer les messages entrants lorsque votre application est au premier plan. Implémentez ensuite une logique pour gérer la notification et éventuellement la montrer à l'utilisateur.

MyApp/
├── app/
│ ├── src/
│ ├── build.gradle
│ ├── google-services.json
├── build.gradle
├── settings.gradle

Inscrivez-vous dans le fichier AndroidManifest.xml

Ouvrez le fichier AndroidManifest.xml dans votre projet.

Vous devez maintenant enregistrer MyMessagingService dans le manifeste pour gérer les messages FCM.

buildscript {
    repositories {
        google()
        mavenCentral()
    }
    dependencies {
        // Add this line
        classpath 'com.google.gms:google-services:4.3.10'
    }
}

Étape 4 : Obtenez le jeton d'enregistrement FCM

Pour recevoir des notifications push, votre application doit obtenir le jeton d'enregistrement FCM. Ce jeton identifie de manière unique l'instance d'application sur l'appareil.

Exemple de code pour récupérer le jeton de périphérique

Vous pouvez récupérer le jeton d'enregistrement FCM dans votre FirebaseMessagingService ou à tout autre endroit approprié de votre application. Voyons comment procéder dans FirebaseMessagingService.

Mettre à jour MyMessagingService :

apply plugin: 'com.android.application'
apply plugin: 'com.google.gms.google-services'

android {
    // ...
}

dependencies {
    // Add these lines
    implementation platform('com.google.firebase:firebase-bom:29.0.4')
    implementation 'com.google.firebase:firebase-analytics'
    implementation 'com.google.firebase:firebase-messaging'
}

Vous pouvez récupérer le jeton dans une activité ou un fragment, et le stocker ou l'utiliser selon vos besoins.

buildscript {
    repositories {
        // Check that you have these lines
        google()
        mavenCentral()
    }
    dependencies {
        // Add this line
        classpath 'com.google.gms:google-services:4.3.10'
    }
}

allprojects {
    repositories {
        // Check that you have these lines
        google()
        mavenCentral()
    }
}

En utilisant ces méthodes, vous pouvez obtenir le jeton d'enregistrement FCM dans votre application Android. Le jeton peut être récupéré soit dans FirebaseMessagingService, soit dans n'importe quelle activité ou fragment. Ce jeton est important pour envoyer des notifications push ciblées à des appareils spécifiques.

Étape 5 : Envoyer des notifications push

Si vous souhaitez envoyer des notifications depuis un serveur, vous devez faire une requête POST à ​​l'API FCM.

Vous devez obtenir une clé de serveur

• Dans la console Firebase → Paramètres du projet → « Présentation du projet » → « Messagerie cloud ».
• Dans « Identifiants du projet », vous trouverez la clé du serveur.

Requête cURL : Cette commande cURL sera utilisée pour envoyer des notifications. Remplacez avec votre clé de serveur actuelle et avec le jeton FCM de l'appareil cible.

./gradlew signingReport

• https://fcm.googleapis.com/fcm/send Point de terminaison de l'API.
• H "Authorization: key=": Il s'agit d'un en-tête d'autorisation avec la clé de votre serveur.
• H « Content-Type : application/json » : en-tête de type de contenu.
• d '{ ... }' : il s'agit de la charge utile JSON qui contient votre notification et vos données.

Sujets avancés

Gestion des messages de données

Les messages de données sont un type de message qui peut contenir des paires clé-valeur personnalisées et sont traités différemment des messages de notification. Les messages de données sont reçus dans la méthode onMessageReceived de FirebaseMessagingService , que l'application soit au premier plan ou en arrière-plan.

Exemple de gestion des messages de données

Mettre à jour MyMessagingService

MyApp/
├── app/
│ ├── src/
│ ├── build.gradle
│ ├── google-services.json
├── build.gradle
├── settings.gradle

Gestion des canaux de notification

À partir d'Android 8.0 (API niveau 26), toutes les notifications doivent être attribuées à un canal. Cela permet aux utilisateurs de contrôler les paramètres de notification pour chaque chaîne.

Exemple de création de canaux de notification

Créez une méthode pour configurer les canaux de notification :

buildscript {
    repositories {
        google()
        mavenCentral()
    }
    dependencies {
        // Add this line
        classpath 'com.google.gms:google-services:4.3.10'
    }
}

Appelez cette méthode dans votre classe MainActivity ou Application :

apply plugin: 'com.android.application'
apply plugin: 'com.google.gms.google-services'

android {
    // ...
}

dependencies {
    // Add these lines
    implementation platform('com.google.firebase:firebase-bom:29.0.4')
    implementation 'com.google.firebase:firebase-analytics'
    implementation 'com.google.firebase:firebase-messaging'
}

Vous pouvez également appeler NotificationUtils.createNotificationChannel(this); dans votre classe Application si vous en avez une :

buildscript {
    repositories {
        // Check that you have these lines
        google()
        mavenCentral()
    }
    dependencies {
        // Add this line
        classpath 'com.google.gms:google-services:4.3.10'
    }
}

allprojects {
    repositories {
        // Check that you have these lines
        google()
        mavenCentral()
    }
}

Mettez à jour votre générateur de notifications pour utiliser l'ID de chaîne :

apply plugin: 'com.android.application'

android {
    compileSdkVersion 33
    defaultConfig {
        applicationId "com.example.myandroidapp"
        minSdkVersion 21
        targetSdkVersion 33
        versionCode 1
        versionName "1.0"

        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
}

dependencies {
    implementation 'androidx.appcompat:appcompat:1.6.1'
    implementation 'com.google.android.material:material:1.8.0'
    implementation 'androidx.constraintlayout:constraintlayout:2.1.4'
    implementation 'androidx.legacy:legacy-support-v4:1.0.0'
    testImplementation 'junit:junit:4.13.2'
    androidTestImplementation 'androidx.test.ext:junit:1.1.5'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.5.1'

    // Add Firebase BOM
    implementation platform('com.google.firebase:firebase-bom:29.0.4')
    // Add Firebase Messaging dependency
    implementation 'com.google.firebase:firebase-messaging'
}

// Add this line at the bottom of the file
apply plugin: 'com.google.gms.google-services'

Test des notifications push

Lorsque les notifications push sont mises en œuvre, nous devons effectuer des tests pour nous assurer qu'elles sont correctement mises en œuvre.

Dans Android Studio, vous pouvez ouvrir le logcat, Afficher > Outil Fenêtres > Logcat.

Nous pouvons également filtrer la sortie logcat en utilisant la balise que nous avons utilisée dans la classe FirebaseMessagingService. L'application doit être exécutée sur l'appareil ou via un émulateur.

Lorsque la notification est reçue, nous pouvons voir les données dans logcat comme ceci :

import android.app.NotificationChannel;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import android.os.Build;
import androidx.core.app.NotificationCompat;
import com.google.firebase.messaging.FirebaseMessagingService;
import com.google.firebase.messaging.RemoteMessage;

public class MyMessagingService extends FirebaseMessagingService {

    @Override
    public void onMessageReceived(RemoteMessage remoteMessage) {
        // Handle the received message
        if (remoteMessage.getNotification() != null) {
            // Get the message body
            String messageBody = remoteMessage.getNotification().getBody();
            // Send a notification
            sendNotification(messageBody);
        }
    }

    private void sendNotification(String messageBody) {
        Intent intent = new Intent(this, MainActivity.class);
        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
        PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, intent, PendingIntent.FLAG_ONE_SHOT);

        String channelId = getString(R.string.default_notification_channel_id);
        NotificationCompat.Builder notificationBuilder = new NotificationCompat.Builder(this, channelId)
                .setSmallIcon(R.drawable.ic_notification)
                .setContentTitle(getString(R.string.app_name))
                .setContentText(messageBody)
                .setAutoCancel(true)
                .setContentIntent(pendingIntent);

        NotificationManager notificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            NotificationChannel channel = new NotificationChannel(channelId, "Channel human readable title", NotificationManager.IMPORTANCE_DEFAULT);
            notificationManager.createNotificationChannel(channel);
        }

        notificationManager.notify(0, notificationBuilder.build());
    }
}

Les données des messages peuvent être vues comme ceci :

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.myandroidapp">

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">

        <!-- Add this service -->
        <service
            android:name=".MyMessagingService"
            android:exported="false">
            <intent-filter>
                <action android:name="com.google.firebase.MESSAGING_EVENT" />
            </intent-filter>
        </service>

        <!-- Other activities and services -->
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

Conclusion

Dans cet article, nous avons découvert les notifications push, ainsi qu'une approche étape par étape de leur mise en œuvre. Nous avons appris comment configurer un projet dans la console Firebase et comment effectuer la configuration requise dans les paramètres du projet Firebase, afin que vous puissiez commencer à envoyer des notifications Android à vos utilisateurs Android.

Vous devez commencer par configurer un projet Firebase et télécharger le fichier google-services.json. Après cela, vous devez placer le répertoire de cette application de fichiers et modifier les fichiers build.gradle pour inclure les dépendances Firebase.

Ensuite, vous devez créer une classe qui gérera les messages entrants et enregistrer cette classe de service dans AndroidManifest.xml. Après avoir ajouté le service dans le fichier manifeste, vous devez récupérer le jeton FCM utilisé pour identifier de manière unique votre application, afin qu'une notification puisse être envoyée à l'appareil ciblé.

Les notifications peuvent être testées en envoyant des messages depuis la console Firebase et en utilisant le logcat d'Android Studio pour confirmer la livraison. Pour activer les notifications côté serveur, utilisez une requête cURL avec votre clé de serveur Firebase et le jeton FCM de l'appareil.

Pour maintenir la compatibilité avec les versions ultérieures d'Android, vous devrez traiter les messages de données dans votre « FirebaseMessagingService » et gérer les canaux de notification pour les configurations sophistiquées.

Les notifications push, qui offrent des mises à jour pertinentes et des informations personnalisées – et peuvent augmenter la fidélisation des utilisateurs et les taux de conversion – sont cruciales pour encourager l'engagement des utilisateurs.

Lisez la documentation officielle du SDK Firebase et Android pour plus d'informations et des instructions détaillées. Ces sites Web fournissent des conseils détaillés et les meilleures pratiques du secteur pour intégrer des notifications push dans votre application.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!