Implémenter les notifications push sur Android

Une fois que l'équipe Actito a effectué la configuration nécessaire et que vous avez récupéré le fichier SDK sur le dépôt Git pour l'application push sur Android, vous êtes maintenant prêt à implémentez la bibliothèque Android Notificare dans votre application. Notre bibliothèque prend en charge la version Android 6 et supérieure. Assurez-vous de toujours disposer du dernier SDK Android lorsque vous utilisez cette bibliothèque.

Dépendances

Pour votre commodité, nous avons créé un plugin Gradle qui simplifie la façon dont vous configurez le SDK Notificare. Ouvrez le fichier build.gradle de votre projet et ajoutez les entrées suivantes :

buildscript {
    repositories {
        maven { url 'https://maven.notifica.re/releases' }
    }
    dependencies {
        classpath 're.notifica.gradle:notificare-services:1.0.1'
    }
}

allprojects {
    repositories {
        maven { url 'https://maven.notifica.re/releases' }

        // Include the pre-releases repository to access beta builds.
        maven { url 'https://maven.notifica.re/prereleases' }
    }
}

Nous comprenons que toutes les applications ne profiteront pas de toutes les fonctionnalités fournies par notre plateforme. Pour vous aider à réduire la taille de votre application, l'empreinte de dépendance et les autorisations automatiquement incluses, vous pouvez sélectionner les modules que vous souhaitez inclure dans votre application.

Dans le app/build.gradle de votre application, ajoutez le plugin et les dépendances dont vous avez besoin.

plugins {
    // ...
    id 're.notifica.gradle.notificare-services'
}

dependencies {
    def notificare_version = 'REPLACE_WITH_LATEST_VERSION'
    implementation "re.notifica:notificare:$notificare_version"

    //
    // Optional modules
    //

    // Support for remote notifications
    implementation "re.notifica:notificare-push:$notificare_version"

    // Our standard UI for notification (recommended)
    implementation "re.notifica:notificare-push-ui:$notificare_version"

    // The tools to build a custom inbox UI
    // Choose one of the following modules depending on your use case
    implementation "re.notifica:notificare-inbox:$notificare_version"
    implementation "re.notifica:notificare-user-inbox:$notificare_version"

    // Automatically display in-app messages
    implementation "re.notifica:notificare-in-app-messaging:$notificare_version"

    // Location tracking and geofencing support
    implementation "re.notifica:notificare-geo:$notificare_version"
    implementation "re.notifica:notificare-geo-beacons:$notificare_version"     // Enable support for beacons detection.

    // Contextual storage
    implementation "re.notifica:notificare-assets:$notificare_version"

    // Enables native integration with Google Wallet
    implementation "re.notifica:notificare-loyalty:$notificare_version"

    // Handle NFC and QR-code scannables
    implementation "re.notifica:notificare-scannables:$notificare_version"
}

Ajouter Firebase Cloud Messaging

Android Studio facilite l'importation rapide du projet FCM que vous avez créé précédemment dans votre application. Déroulez simplement le menu Tools menu et cliquez sur Firebase:

Cela ouvrira une fenêtre Assistant comme celle ci-dessous :

Cliquez simplement sur Set up Firebase Cloud Messaging et suivez les guides dans l'écran suivant :

Completing the points above will prepare your app with everything needed to use the FCM project you've previously created.

Un fichier app/google-services.json devrait être créé. Ce fichier contiendra les informations sur l'ID de l'expéditeur de votre projet FCM.

Fichier de configuration

Afin de connecter votre application à Notificare, vous devez télécharger le fichier de configuration du SDK qui a été déposé dans la boîte de transfert par l'équipe Actito.

Pour votre information, voici à quoi devrait ressembler ce fichier :

{
  "project_info": {
    "application_id": "{{ YOUR APPLICATION ID }}",
    "application_key": "{{ YOUR APPLICATION KEY }}",
    "application_secret": "{{ YOUR APPLICATION SECRET }}"
  }
}

Par défaut, nous créerons deux applications différentes dans Notificare en utilisant des environnements séparés pour le développement et la production. Pour chaque application, vous disposerez d'un jeu de clés différent, ce qui entraînera deux fichiers de configuration différents. Nous vous recommandons d'exploiter les variantes de build/product flavors d'Android pour gérer quel fichier sera intégré dans l'application.

Créer un intent receiver

Bien qu'il s'agisse d'une étape facultative, en créant votre propre intent receiver, vous pouvez écouter les événements ready et device_registered. Vous pouvez en profiter pour effectuer des étapes supplémentaires lorsque Notificare est prêt ou lorsque l'appareil est mis à jour.

Kotlin

class CustomIntentReceiver : NotificareIntentReceiver() {

    override fun onReady(context: Context, application: NotificareApplication) {
        // At this point you have been assigned a temporary device identifier
        // All services subscribed can be used
    }

    override fun onDeviceRegistered(context: Context, device: NotificareDevice) {
        // At this point you know a device is registered with the Notificare API.
        // This method will be called once when the device is registered.
    }
}

Java

public class CustomIntentReceiver extends NotificareIntentReceiver {

    @Override
    protected void onReady(@NonNull Context context, @NonNull NotificareApplication application) {
        // At this point you have been assigned a temporary device identifier
        // All services subscribed can be used
    }

    @Override
    protected void onDeviceRegistered(@NonNull Context context, @NonNull NotificareDevice device) {
        // At this point you know a device is registered with the Notificare API.
        // This method will be called once when the device is registered.
    }
}

Pour informer Notificare de votre intent receiver, vous pouvez exécuter l'instruction suivante :

Kotlin

Notificare.intentReceiver = CustomIntentReceiver::class.java

Java

Notificare.setIntentReceiver(CustomIntentReceiver.class);

Lors de la création de votre intent receiver personnalisé, vous devez également le déclarer dans votre fichier AndroidManifest.xml.

<?xml version="1.0" encoding="utf-8"?>
<manifest>

    <application>

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

    </application>

</manifest>

Activité des notifications

Si vous prévoyez d'utiliser l'approche par défaut pour afficher les notifications, vous devez ajouter un thème translucide à NotificationActivity. Cela permet d'afficher des alertes flottantes sur votre contenu.

<application>
    <activity
        android:name="re.notifica.push.ui.NotificationActivity"
        android:theme="@style/Theme.App.Translucent" />
</application>

À titre de référence, vous pouvez utiliser l'exemple de thème ci-dessous. Cela doit être ajouté à votre dossier de ressources. Assurez-vous que le thème dont vous héritez est un thème AppCompat. Par exemple, Theme.AppCompat.Light.DarkActionBar.

<resources>
    <!-- adjust the name and parent to match your theme -->
    <style name="Theme.App.Translucent" parent="Theme.App">
        <item name="android:windowIsTranslucent">true</item>
        <item name="android:windowBackground">@android:color/transparent</item>
    </style>
</resources>

Vous pouvez trouver des informations supplémentaires sur le système de thèmes dans la documentation officielle d'Android située ici.

Lancer Notificare

Lancer Notificare est aussi simple que d'appeler Notificare.launch(). Cependant, avant de vous lancer, vous souhaiterez peut-être envisager de personnaliser certaines propriétés.

Si vous avez créé un intent receiver personnalisé, vous devez également définir la propriété Notificare.intentReceiver pour indiquer à Notificare quelle classe gérera les intentions.

Vous devez lancer Notificare lorsque l'application Android est créée. Un petit exemple de code peut être trouvé ci-dessous.

Kotlin

class MainApplication : Application() {
    private val applicationScope = MainScope()

    override fun onCreate() {
        super.onCreate()

        // In case you want to setup your custom intent receiver.
        Notificare.intentReceiver = CustomIntentReceiver::class.java

        applicationScope.launch {
            try {
                // Launch Notificare! 🚀
                Notificare.launch()

                // Notificare is now ready.
            } catch (e: Exception) {
                // Something went wrong ...
            }
        }
    }
}

Java

public class MainApplication extends Application {

    @Override
    public void onCreate() {
        super.onCreate();

        // In case you want to setup your custom intent receiver.
        Notificare.setIntentReceiver(CustomIntentReceiver.class);

        // Launch Notificare! 🚀
        Notificare.launch(new NotificareCallback<Unit>() {
            @Override
            public void onSuccess(Unit result) {
                // Notificare is now ready.
            }

            @Override
            public void onFailure(@NonNull Exception e) {
                // Something went wrong ...
            }
        });
    }
}

Vous pouvez retarder le lancement de Notificare pour la première fois. Sinon, assurez-vous de bien launch() pendant la phase d'initialisation de l'application pour éviter de manquer des mises à jour importantes lorsque l'application est créée en arrière-plan.

Bien que launch() soit une fonction de suspension (avec une alternative de rappel), vous pouvez également utiliser la méthode onReady() à partir d'un NotificareIntentReceiver personnalisé ou ajouter un écouteur comme indiqué ci-dessous lorsque vous le souhaitez. pour contrôler l’état des dépendances dans le flux d’initialisation de votre application.

Kotlin

class MainActivity : AppCompatActivity(), Notificare.Listener {
    override fun onCreate(savedInstanceState: Bundle?) {
        // more code ...

        Notificare.addListener(this)
    }

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

        Notificare.removeListener(this)
    }

    override fun onReady(application: NotificareApplication) {
        // Notificare is now safe to use.
    }
}

Java

public class MainActivity extends AppCompatActivity implements Notificare.Listener {
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        // more code ...

        Notificare.addListener(this);
    }

    @Override
    protected void onDestroy() {
        // more code ...

        Notificare.removeListener(this);
    }

    @Override
    public void onReady(@NonNull NotificareApplication application) {
        // Notificare is now safe to use.
    }
}

Annuler le lancement de Notificare

Il est possible de supprimer complètement toutes les données d'un appareil, aussi bien localement dans votre application qu'à distance sur nos serveurs. Vous souhaitez éviter de le faire, mais dans les cas où l'utilisateur demande la suppression de son compte, vous pouvez utiliser la méthode suivante :

Kotlin

Notificare.unlaunch()

Java

Notificare.unlaunch(new NotificareCallback<Unit>() {
    @Override
    public void onSuccess(Unit result) {

    }

    @Override
    public void onFailure(@NonNull Exception e) {

    }
});

Après avoir invoqué cette fonction, toutes les données de l'appareil seront détruites et ne pourront plus être annulées. Une fois le processus terminé, la méthode onUnlaunched de votre NotificareIntentReceiver personnalisé ou vos écouteurs seront exécutés.

Kotlin

class MainActivity : AppCompatActivity(), Notificare.Listener {
    override fun onCreate(savedInstanceState: Bundle?) {
        // more code ...

        Notificare.addListener(this)
    }

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

        Notificare.removeListener(this)
    }

    override fun onUnlaunched() {
        // All device data was deleted.
        // Notificare cannot be used until it's launched again.
    }
}

Java

public class MainActivity extends AppCompatActivity implements Notificare.Listener {
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        // more code ...

        Notificare.addListener(this);
    }

    @Override
    protected void onDestroy() {
        // more code ...

        Notificare.removeListener(this);
    }

    @Override
    public void onUnlaunched() {
        // All device data was deleted.
        // Notificare cannot be used until it's launched again.
    }
}

À ce stade, l'appel de toute autre méthode dans Notificare échouera, et la seule façon de recommencer à utiliser le SDK est d'invoquer son homologue, la méthode launch.