Was sind Push-Benachrichtigungen?

Push-Benachrichtigungen sind ein leistungsstarker Kommunikationskanal, der 2009 von Apple eingeführt wurde. Seitdem haben sie an Popularität gewonnen und sind ein wesentlicher Bestandteil der meisten Marketingkampagnen geworden. Benachrichtigungen können verwendet werden, um das Engagement zu steigern, die App-Nutzung zu erhöhen, Konversionen zu beeinflussen und vieles mehr!

In diesem Artikel erfahren wir mehr über Push-Benachrichtigungen, ihre Vorteile, Anwendungsfälle, Arten von Benachrichtigungen und ihre Vor- und Nachteile. Darüber hinaus sehen wir uns an, wie man Push-Benachrichtigungen mit Back4app – einem der besten mBaaS-Anbieter – an Android-Geräte sendet.

Was ist eine Push-Benachrichtigung?

Eine Push-Benachrichtigung ist eine Kurznachricht oder eine Warnung, die direkt an das Mobilgerät, den Webbrowser, das Wearable oder ein anderes Gerät Ihres Kunden gesendet werden kann, das Benachrichtigungen unterstützt. Sie werden als schneller Kommunikationskanal verwendet, der es Unternehmen ermöglicht, Erinnerungen, Aktualisierungen, zeitkritische Nachrichten, Werbeaktionen und mehr zu senden.

Push-Benachrichtigungen sind ein Opt-in-Dienst, d. h. der Kunde muss zustimmen, um Benachrichtigungen zu erhalten. Die Zustimmung wird in der Regel durch eine einfache Pop-up-Nachricht oder durch die Installation der mobilen App des Herausgebers eingeholt.

Push-Benachrichtigungen setzen sich aus mehreren Elementen zusammen. Ihre Struktur und ihr Aussehen variieren leicht, je nach Gerät und Betriebssystem des Kunden. Sie können im Allgemeinen Text, Emojis, Bilder und Schaltflächen oder sogenannte CTAs enthalten, die bei einem Klick eine bestimmte Aktion ausführen.

Ein Beispiel für eine Push-Benachrichtigung auf einem Android-Gerät sieht so aus:

Warum Push-Benachrichtigungen verwenden?

Push-Benachrichtigungen sind ein vielseitiges Werkzeug. Sie können für Marketing, zeitkritische Nachrichten, Sicherheitswarnungen, Updates und mehr verwendet werden. Schauen wir uns einige der häufigsten Anwendungsfälle an.

Werbeaktionen und Angebote

Unternehmen können Push-Benachrichtigungen nutzen, um Werbeangebote und Rabatte an Nutzer zu senden und sie so zum Kauf zu animieren. Darüber hinaus können sie Push-Benachrichtigungen personalisieren, um sie relevanter und effektiver zu machen.

Verringern von abgebrochenen Warenkörben

Wenn Sie einen E-Commerce-Shop besitzen, können Push-Benachrichtigungen dazu beitragen, die Zahl der abgebrochenen Einkäufe zu verringern. Nachdem ein Einkaufswagen ein paar Tage lang nicht benutzt wurde, können Sie den Benutzer mit einer Push-Benachrichtigung anstupsen und ihm einen zusätzlichen Rabatt anbieten.

Soziale Interaktionen

Push-Benachrichtigungen sind ideal für die Benutzerbindung. Die meisten sozialen Anwendungen wie Facebook, Instagram und Twitter senden Ihnen jedes Mal eine Benachrichtigung, wenn ein anderer Nutzer mit Ihnen interagiert. Zum Beispiel: Ihr Beitrag gefällt, Ihr Beitrag wird kommentiert, Sie erhalten eine Nachricht usw.

Aktualisierungen und Mahnungen

Push-Benachrichtigungen können ein nützliches Werkzeug sein, um Aktualisierungen und Erinnerungen für Ereignisse, Termine und Fristen zu erhalten.

Sicherheit

Push-Benachrichtigungen können auch zu Sicherheitszwecken eingesetzt werden. Einige Unternehmen senden ihren Kunden jedes Mal eine Push-Benachrichtigung, wenn sich jemand bei ihrem Konto anmeldet. Außerdem können Sie Push-Benachrichtigungen verwenden, um eine 2FA-Bestätigung zu initiieren.

Was sind die Vorteile von Push-Benachrichtigungen?

Im vorigen Abschnitt haben wir bereits viele der Vorteile von Push-Benachrichtigungen erwähnt. Zusammenfassend kann man sagen, dass die Vorteile folgende sind:

• Erhöhtes Engagement der Nutzer
• Höhere Nutzerbindung
• Höhere Konversionsraten
• Verbesserte Kundenbetreuung
• Gesteigerte Verkäufe und Einnahmen
• Verbesserte Benutzerfreundlichkeit

Welche Arten von Push-Benachrichtigungen gibt es?

Es gibt drei Arten von Push-Benachrichtigungen: mobile Benachrichtigungen, Web-Benachrichtigungen und Desktop-Benachrichtigungen.

Mobile Push-Benachrichtigung

Mobile Push-Benachrichtigungen sind der am häufigsten verwendete und bekannteste Typ von Push-Benachrichtigungen. Sie können in verschiedenen Formen erscheinen, z. B. in der Statusleiste, in der Benachrichtigungsschublade, als Heads-up-Benachrichtigung und auf dem Sperrbildschirm.

Sie können ein kleines Symbol, den Namen der Anwendung, einen Zeitstempel, ein großes Symbol, einen Titel, Text und Schaltflächen enthalten. Mobile Benachrichtigungen können je nach Inhalt und Wichtigkeit in verschiedenen Kanälen organisiert werden.

Mobile Push-Benachrichtigungen werden in der Regel über einen Push-Benachrichtigungsdienst gesendet, z. B. Apple Push Notification Service (APNS) für iOS-Geräte und Firebase Cloud Messaging (FCM) für Android-Geräte. Mehr über Push-Benachrichtigungsdienste erfahren Sie später in diesem Tutorial.

Web-Push-Benachrichtigung

Webbasierte Push-Benachrichtigungen sind Benachrichtigungen, die von Websites an den Browser des Benutzers gesendet werden können, auch wenn der Browser nicht geöffnet ist. Sie erscheinen in der Desktop-Benachrichtigungsschublade und auf dem Startbildschirm des Browsers.

Die erste Version von Web-Push-Benachrichtigungen wurde 2014 von Google veröffentlicht. Mittlerweile werden sie von den meisten modernen Webbrowsern unterstützt, darunter Google Chrome, Mozilla Firefox und Microsoft Edge.

Im Gegensatz zu mobilen Benachrichtigungen werden diese Benachrichtigungen über die Push-API des Browsers übermittelt.

Desktop-Push-Benachrichtigung

Desktop-Push-Benachrichtigungen sind ähnlich wie Web-Push-Benachrichtigungen. Der Hauptunterschied zwischen ihnen besteht darin, wie sie gesendet werden. Während Web-Benachrichtigungen von einer Website oder einer Web-App gesendet werden, werden Desktop-Benachrichtigungen von einer auf dem Computer installierten Anwendung gesendet.

Sie erscheinen in der Benachrichtigungsleiste und werden von den meisten modernen Betriebssystemen unterstützt.

Was macht eine gute Push-Benachrichtigung aus?

Im Jahr 2023 erhält ein typischer Smartphone-Nutzer etwa 50 Benachrichtigungen pro Tag. Die meisten dieser Benachrichtigungen werden ungelesen weggewischt. Wenn Sie möchten, dass Ihre Push-Benachrichtigungskampagne erfolgreicher wird, beachten Sie die folgenden Tipps.

Personalisierung

Durch die Anpassung von Benachrichtigungen an die Interessen und Vorlieben der Nutzer können die Benachrichtigungen relevanter und aufmerksamkeitsstärker werden. Dies kann die Nutzerbindung, das Engagement und die Loyalität verbessern. Darüber hinaus können Sie Ihren Umsatz steigern, indem Sie die Nutzer dazu ermutigen, die gewünschten Aktionen über CTAs durchzuführen.

Rich Media und Emojis verwenden

Um Ihre Benachrichtigungen ansprechender und interessanter zu gestalten, sollten Sie relevante Bilder und Emojis einfügen. Studien haben gezeigt, dass Bilder und Emojis die Klickraten erheblich steigern können.

Wenn Sie sich für Emojis entscheiden, achten Sie darauf, dass Sie diese nicht übermäßig verwenden. Verwenden Sie höchstens ein oder zwei Emojis entweder am Anfang oder am Ende der Benachrichtigung.

Den richtigen Zeitpunkt abpassen

Es ist wichtig, dass Sie Ihre Push-Benachrichtigungen richtig timen. Vergewissern Sie sich vor dem Versand von Benachrichtigungen, dass Sie Ihren Kundenstamm kennen. Wenn Ihre Kunden in verschiedenen Zeitzonen leben, können Sie sie je nach Zeitzone in mehrere Gruppen aufteilen und die Benachrichtigungen dann gruppenweise versenden.

Die Untersuchung von Notix hat ergeben, dass Benachrichtigungen zwischen:

1. 8:00 Uhr und 11:00 Uhr haben eine Klickrate von 5,55%.
2. 11:00 Uhr und 20:00 Uhr haben eine Klickrate von 7%.
3. 20:00 und 23:00 Uhr haben eine Klickrate von 10,4%.

CTAs einbeziehen

Push-Benachrichtigungen sollten klar kommunizieren, was sie bezwecken und was der Nutzer als nächstes tun sollte. Beispiel: Wenn Sie gerade einen neuen Artikel veröffentlicht haben, sollten Sie den Link zum Artikel angeben, wenn ein neues Produkt in Ihrem Shop verfügbar ist, sollten Sie eine Schaltfläche “Jetzt kaufen” hinzufügen.

Denken Sie daran: Eine gute Push-Benachrichtigung ist relevant, fesselt den Nutzer und bietet ihm einen Mehrwert.

Was ist beim Versand von Push-Benachrichtigungen zu vermeiden?

Auch wenn Push-Benachrichtigungen ein leistungsfähiges Instrument sind, um Nutzer zu binden und Konversionen zu fördern, gibt es einige Situationen, in denen sie vermieden werden sollten. Achten Sie darauf, dies nicht zu tun:

1. Für ein anderes Produkt werben
2. Zu viele Benachrichtigungen senden
3. Unwichtige oder sinnlose Benachrichtigungen senden
4. Versuchen Sie, Nutzer über Benachrichtigungen zu gewinnen
5. Überwältigen Sie Ihre Nutzer

Was ist ein Push-Benachrichtigungsdienst?

Ein Push-Benachrichtigungsdienst ist ein Dienst, der es Entwicklern von Drittanbietern ermöglicht, über eine API oder ein Dashboard Push-Benachrichtigungen an die Geräte ihrer Kunden zu senden. Dazu wird eine Verbindung zwischen der Anwendung oder Website und dem Gerät des Kunden hergestellt. Der Push-Benachrichtigungsdienst verwendet eine eindeutige Kennung für jedes Gerät, um sicherzustellen, dass die Nachricht nur dem vorgesehenen Empfänger zugestellt wird.

Zu den typischen Funktionen von Push-Benachrichtigungsdiensten gehören die Verwaltung von Kunden und Zielgruppen, die Verwaltung von Benachrichtigungen (einschließlich früherer Push-Nachrichten), die Planung von Benachrichtigungen und die Analyse (Klickrate, Zustellungen usw.).

Einige Beispiele für Push-Benachrichtigungsdienste sind:

1. Firebase Cloud Messaging (FCM)
2. Apple Push Notification Service (APNS)
3. Amazon Simple Notification Service (SNS)
4. Back4app (Parse) Push Notifications
5. OneSignal

Wie sende ich eine Push-Benachrichtigung?

In diesem Abschnitt des Artikels geht es darum, wie man mit Back4app Push-Benachrichtigungen an Android-Geräte sendet.

Voraussetzungen

• Sie müssen Android Studio installiert haben
• Grundlegendes Verständnis der Entwicklung von Android-Anwendungen
• Ein Gradle-basiertes Android Studio-Projekt

Zielsetzungen

1. Erstellen Sie eine Back4app-Anwendung
   • Parse SDK für Android installieren und konfigurieren
   • Parse mit Anwendungs-ID und Client-Schlüssel initialisieren
2. Erstellen Sie ein Firebase-Projekt und eine Anwendung
   • Firebase SDK installieren
3. Verknüpfung von Firebase und Back4app über GCM-Absender-ID und GCM-Serverschlüssel
4. Konfigurieren Sie die Android-Berechtigungen, und registrieren Sie einen Dienst und einen Empfänger für Benachrichtigungen.
5. Senden Sie Push-Benachrichtigungen über das Back4app-Dashboard oder Cloud Code

Was ist Back4app?

Back4app ist ein großartiger Backend-as-a-Service (BaaS)-Anbieter, der es den Entwicklern ermöglicht, sich auf ihre App zu konzentrieren, ohne sich um das Backend oder die zugrunde liegende Infrastruktur zu kümmern. Es basiert auf Open-Source-Technologie wie Parse, GraphQL, Node.js und Redis.

Back4app ist einfach zu bedienen, verfügt über ein elegantes Dashboard und eine Befehlszeilenschnittstelle (CLI) für fortgeschrittene Benutzer und Aufgabenautomatisierung.

Die Plattform verfügt über mehrere integrierte Funktionen, darunter:

• Tabellenkalkulationsähnliche Datenbank
• Authentifizierung und soziale Authentifizierung
• Push- und E-Mail-Benachrichtigungen
• Cloud-Code und Arbeitsplätze
• Benutzerverwaltung
• Sicherheitsmerkmale

Back4app hat ein einfaches Preismodell. Sie bieten auch eine großzügige kostenlose Stufe an, die zum Ausprobieren ihrer Plattform oder sogar zum Hosten kleiner Anwendungen verwendet werden kann.

Um mehr über Back4app zu erfahren, lesen Sie bitte Warum Back4app?

Back4app App erstellen

Wenn Sie bereits eine Back4app-Anwendung erstellt, das Parse SDK installiert und Ihr Android-Projekt konfiguriert haben, können Sie den Abschnitt überspringen!

Um mit Back4app zu arbeiten, müssen wir zunächst eine App erstellen. Wenn Sie sich in Ihr Dashboard einloggen, sehen Sie die Liste Ihrer Apps. Klicken Sie auf “Neue App erstellen”, um den App-Erstellungsprozess zu starten.

Wählen Sie “Backend as a Service”, geben Sie den Namen Ihrer Anwendung ein, wählen Sie “NoSQL Database” als Datenbank und klicken Sie abschließend auf “Create”.

Back4app nimmt sich einige Augenblicke Zeit, um alles vorzubereiten, was für Ihre App erforderlich ist, wie z. B. Datenbank, Anwendungsschicht, Skalierung, Backups und Sicherheit.

Sobald Ihre Anwendung fertig ist, werden Sie zum Dashboard Ihrer Anwendung weitergeleitet.

Wählen Sie dann “App-Einstellungen > Sicherheit & Schlüssel” in der Seitenleiste und notieren Sie sich Ihre “Anwendungs-ID” und Ihren “Client-Schlüssel”. Wir benötigen sie, um unsere Android-App mit den Back4app-Servern zu verbinden.

Parse SDK installieren

Damit unsere App mit den Back4app-Servern kommunizieren kann, müssen wir das Parse SDK installieren.

Der Prozess, den wir verwenden werden, erfordert Android SDK 27 oder höher. Navigieren Sie vor der Installation von Parse zu Ihrer app/build.gradle und stellen Sie sicher, dass compileSdk und targetSdk auf die richtigen Versionen eingestellt sind:

// app/build.gradle

android {
    namespace "com.back4app.push"
    compileSdk 33  // <-- check this line

    defaultConfig {
        applicationId "com.back4app.push"
        minSdk 27
        targetSdk 33   // <-- check this line
        versionCode 1
        versionName "1.0"

        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }
    // ...
}

Um auf die neuesten Softwarepakete zugreifen zu können, installieren wir das JitPack-Paket-Repository.

Navigieren Sie zu Ihrer settings.gradle und fügen Sie JitPack Repo zu dependencyResolutionManagement wie folgt hinzu:

// settings.gradle

dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
        maven { url "https://jitpack.io" }   // new
    }
}
rootProject.name = "back4app-push-notifications"
include ":app"

Navigieren Sie anschließend zu app/build.gradle und fügen Sie die folgenden Abhängigkeiten hinzu:

// app/build.gradle

dependencies {
    implementation "com.parse.bolts:bolts-android:1.4.0"
    implementation "com.github.parse-community.Parse-SDK-Android:parse:4.2.0"
    implementation "com.github.parse-community.Parse-SDK-Android:fcm:4.2.0"
    // ...
}

Prüfen Sie, ob eine neuere Version auf JitPack verfügbar ist, und wenn ja, verschieben Sie sie.

Damit Parse funktioniert, müssen wir den Internetzugang in unserer Anwendung aktivieren. Darüber hinaus müssen wir unsere “Anwendungs-ID” und den “Client-Schlüssel” aus dem vorherigen Abschnitt bereitstellen. Navigieren Sie zu AndroidManifest.xml und ändern Sie es wie folgt:

<!-- app/src/main/AndroidManifest.xml -->

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">

    <!-- new -->
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
    <uses-permission android:name="android.permission.INTERNET"/>
    <!-- end of new -->

    <application>
        <activity
            android:name=".MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>

            <meta-data
                android:name="android.app.lib_name"
                android:value="" />

            <!-- new -->
            <meta-data
                android:name="com.parse.SERVER_URL"
                android:value="@string/back4app_server_url" />
            <meta-data
                android:name="com.parse.APPLICATION_ID"
                android:value="@string/back4app_app_id" />
            <meta-data
                android:name="com.parse.CLIENT_KEY"
                android:value="@string/back4app_client_key" />
            <!-- end of new -->

        </activity>
    </application>
</manifest>

Schließlich fügen Sie in der Datei strings.xml die soeben verwendeten Zeichenketten hinzu:

<!-- app/src/main/res/values/strings.xml -->

<resources>
    <string name="app_name">back4app-push-notifications</string>
    <string name="back4app_server_url">https://parseapi.back4app.com</string>
    <string name="back4app_app_id">YOUR_PARSE_APP_ID</string>
    <string name="back4app_client_key">YOUR_PARSE_CLIENT_KEY</string>
</resources>

Stellen Sie sicher, dass Sie YOUR_PARSE_APP_ID und YOUR_PARSE_CLIENT_KEY durch Ihre tatsächliche ID und Ihren Schlüssel ersetzen.

Parsen initialisieren

Um Parse zu initialisieren, verwenden wir die Anwendungsklasse von Android.

Die Klasse Application bietet globalen Zugriff auf anwendungsweite Ressourcen und den Status. Sie wird vor jeder anderen Klasse instanziiert, wenn der Anwendungsprozess gestartet wird, und kann verwendet werden, um Ereignisse im Lebenszyklus der Anwendung zu verwalten, globale Variablen zu initialisieren und benutzerdefiniertes Verhalten zu implementieren

Um mehr über die Klasse Application zu erfahren, schauen Sie sich die offiziellen Dokumente an.

Navigieren Sie zu dem Ordner, in dem sich Ihre MainActivity.kt befindet, und erstellen Sie eine neue Datei namens App.kt mit dem folgenden Inhalt:

// app/src/main/java/.../App.kt

package com.back4app.push

import android.app.Application
import com.parse.Parse

class App : Application() {
    override fun onCreate() {
        super.onCreate()

        Parse.initialize(
            Parse.Configuration.Builder(this)
                .applicationId(getString(R.string.back4app_app_id))
                .clientKey(getString(R.string.back4app_client_key))
                .server(getString(R.string.back4app_server_url))
                .build()
        )
    }
}

Als Nächstes weisen Sie Android an, die neu erstellte Anwendungsklasse zu verwenden, indem Sie den android:name der Anwendung in AndroidManifest.xml wie folgt festlegen:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">

    <application
        android:name=".App"
    >
        <!-- ... -->
    </application>
</manifest>

Ihre Anwendung sollte nun mit Back4app verbunden sein. Um sicherzugehen, dass alles funktioniert, führen Sie die Anwendung aus und überprüfen Sie die Protokolle auf eventuelle Fehler.

Firebase Projekt und App erstellen

Für die folgenden Schritte benötigen Sie ein Firebase-Konto. Wenn Sie noch keines haben, melden Sie sich einfach mit Ihrem Google-Konto an.

Navigieren Sie zu Ihrer Firebase-Konsole und klicken Sie auf “Ein Projekt erstellen”.

Geben Sie ihm einen eigenen Namen, ich werde meinen back4app-push-notifications nennen.

Akzeptieren Sie die Allgemeinen Geschäftsbedingungen, aktivieren Sie Google Analytics und klicken Sie auf “Projekt erstellen”.

Warten Sie darauf, dass Firebase Ihr Projekt bereitstellt und alles Notwendige vorbereitet. Sobald dies erledigt ist, werden Sie zu Ihrem Projekt-Dashboard weitergeleitet.

Erstellen Sie nun eine neue Anwendung, indem Sie auf das Android-Symbol klicken.

Geben Sie die folgenden Angaben ein:

1. Android-Paketname: Verwenden Sie Ihren Paketnamen (z. B. com.back4app.push)
2. App-Spitzname (optional): Geben Sie einen benutzerdefinierten Spitznamen ein
3. Debug-Signierschlüssel: Leer lassen (oder den Schlüssel mit Hilfe dieses Artikels beziehen)

Laden Sie abschließend die Datei google-services.json herunter und platzieren Sie sie in Ihrem App-Ordner.

Überspringen Sie die Punkte “Firebase SDK hinzufügen” und “Nächste Schritte”, da wir dies im nächsten Abschnitt des Artikels tun werden.

Firebase SDK installieren

Um das Firebase SDK zu installieren, navigieren Sie zu Ihrer build.gradle auf Projektebene und fügen Sie die Eigenschaft buildscript wie folgt hinzu:

// build.gradle

buildscript {
    dependencies {
        classpath "com.google.gms:google-services:4.3.15"
    }
}

Als nächstes fügen Sie die folgenden Plugins und Abhängigkeiten zu Ihrer app/build.gradle hinzu:

// app/build.gradle

plugins {
    id "com.android.application"
    id "org.jetbrains.kotlin.android"
    id "com.google.gms.google-services"  // new
}

dependencies {
    implementation platform("com.google.firebase:firebase-bom:31.2.2")  // new
    implementation "com.google.firebase:firebase-analytics-ktx"  // new
    // ....
}

Synchronisieren Sie Ihre Gradle-Einstellungen.

Firebase Projekt mit Back4app App verknüpfen

Um das Firebase-Projekt mit der Back4app-App zu verknüpfen, müssen wir zunächst die GCM-Sender-ID und den GCM-Serverschlüssel abrufen. Öffnen Sie dazu Ihre Firebase-Konsole, klicken Sie auf das Zahnradsymbol und dann auf “Projekteinstellungen”.

Wählen Sie in der oberen Navigation “Cloud Messaging”.

Das Parsen von Push-Benachrichtigungen erfordert die Cloud Messaging API, die standardmäßig deaktiviert ist. Um sie zu aktivieren, verwenden Sie die Option “Mehr” und klicken Sie dann auf “API in der Google Cloud Console verwalten”. Klicken Sie auf “Enable API” und warten Sie ein paar Sekunden, bis Google sie aktiviert hat.

Sobald die API erfolgreich aktiviert wurde, schließen Sie die aktuelle Registerkarte und navigieren Sie zurück zu Ihren Cloud Messaging-Einstellungen. Notieren Sie sich Ihre “Sender ID” und Ihren “Server Key”.

Navigieren Sie dann zu Ihrem Back4app-App-Dashboard und wählen Sie in der Seitenleiste “App-Einstellungen > Server-Einstellungen”. Scrollen Sie nach unten, bis Sie “Android Push-Benachrichtigung” sehen und klicken Sie auf “Einstellungen”.

Klicken Sie auf “Bearbeiten”, geben Sie Ihre “Absender-ID” und Ihren “Serverschlüssel” ein und speichern Sie.

Ihr Firebase-Projekt und die Back4app-App sind nun verbunden.

App für Push-Benachrichtigungen konfigurieren

Das letzte, was wir tun müssen, bevor wir Benachrichtigungen senden können, ist die Konfiguration unserer Android-App. Das müssen wir tun:

1. Legen Sie die GCM-Absender-ID fest und fügen Sie Berechtigungen in AndroidManifest.xml hinzu
2. Hinzufügen eines Dienstes und eines Empfängers zu AndroidManifest.xml
3. Erstellen einer ParseInstallation in App.kt

Navigieren Sie zu Ihrer AndroidManifest.xml und ändern Sie sie wie folgt:

<!-- app/src/main/AndroidManifest.xml -->

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">

    <!-- new -->
    <uses-permission android:name="android.permission.WAKE_LOCK" />
    <uses-permission android:name="android.permission.VIBRATE" />
    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
    <uses-permission android:name="android.permission.GET_ACCOUNTS" />
    <uses-permission android:name="com.google.android.c2dm.permission.RECEIVE" />
    <!-- end of new -->

    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
    <uses-permission android:name="android.permission.INTERNET" />

    <application>
        <activity
            android:name=".MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>

            <meta-data
                android:name="android.app.lib_name"
                android:value="" />
            <meta-data
                android:name="com.parse.SERVER_URL"
                android:value="@string/back4app_server_url" />
            <meta-data
                android:name="com.parse.APPLICATION_ID"
                android:value="@string/back4app_app_id" />
            <meta-data
                android:name="com.parse.CLIENT_KEY"
                android:value="@string/back4app_client_key" />

            <!-- new -->
            <meta-data
                android:name="com.parse.push.gcm_sender_id"
                android:value="YOUR_GCM_SENDER_ID" />
            <!-- end of new -->

        </activity>

        <!-- new -->
        <service
            android:name="com.parse.fcm.ParseFirebaseMessagingService"
            android:exported="false">
            <intent-filter>
                <action android:name="com.google.firebase.MESSAGING_EVENT" />
            </intent-filter>
        </service>

        <receiver
            android:name="com.parse.ParsePushBroadcastReceiver"
            android:exported="false">
            <intent-filter>
                <action android:name="com.parse.push.intent.RECEIVE" />
                <action android:name="com.parse.push.intent.OPEN" />
                <action android:name="com.parse.push.intent.DELETE" />
            </intent-filter>
        </receiver>
        <!-- end of new -->
    </application>
</manifest>

Stellen Sie sicher, dass Sie YOUR_GCM_SENDER_ID durch Ihre tatsächliche GCM-Sender-ID ersetzen.

Ihre endgültige AndroidManifest.xml sollte wie folgt aussehen.

Navigieren Sie dann zu Ihrer App.kt und fügen Sie den folgenden Code am Ende von onCreate() ein:

// app/src/main/java/.../App.kt

import com.parse.ParseInstallation

class App : Application() {
    override fun onCreate() {
        // ...

        val installation = ParseInstallation.getCurrentInstallation()
        installation.put("GCMSenderId", "YOUR_GCM_SENDER_ID")
        installation.put("channels", listOf("news", "updates"))
        installation.saveInBackground()
    }
}

Stellen Sie sicher, dass Sie Ihre tatsächliche GCM-Sender-ID eingeben. Sie können auch die Kanalnamen ändern.

Dieser Code erstellt eine ParseInstallation und speichert sie in der DB. Außerdem konfiguriert er die Benachrichtigungskanäle, in unserem Fall News und Updates. Diese Kanäle können verwendet werden, um verschiedene Arten von Benachrichtigungen über Cloud Code zu senden.

Großartig, wir haben unsere Android-App erfolgreich für Push-Benachrichtigungen konfiguriert.

Push-Benachrichtigungen senden

Back4app Dashboard

Das Versenden einer Push-Benachrichtigung über das Back4app-Dashboard ist einfach. Dieser Ansatz eignet sich für das manuelle Versenden einmaliger Push-Benachrichtigungen.

Wählen Sie zunächst “Mehr > Push > Neuen Push senden” in der Seitenleiste und füllen Sie dann das Formular aus.

Klicken Sie abschließend auf die Schaltfläche “Push senden”.

Ich schlage vor, dass Sie das JSON-Format verwenden, da es Ihnen erlaubt, den Titel der Benachrichtigung über title und den Textkörper über alert anzugeben.

Wolken-Code

Cloud Code kann zum programmgesteuerten Senden von Push-Benachrichtigungen verwendet werden. Darüber hinaus können Sie damit Push-Benachrichtigungen planen oder Push-Benachrichtigungen zu bestimmten Ereignissen senden.

Um eine Push-Benachrichtigung über Cloud Code zu senden, wählen Sie in der Seitenleiste “Cloud Code > Funktionen & Webhosting” und fügen Sie dann den folgenden Code in main.js ein:

// cloud/main.js

Parse.Cloud.define("pushTest", (request) => {
    return Parse.Push.send({
        channels: ["news"],
        data: {
            title: "Cloud Code",
            alert: "This push notification was sent via Cloud Code.",
        }
    }, { useMasterKey: true });
});

Stellen Sie den Code bereit, indem Sie auf die Schaltfläche “Bereitstellen” klicken.

Zum Schluss lösen Sie die Cloud-Funktion über einen REST-Aufruf aus:

curl --location --request POST 'https://parseapi.back4app.com/functions/pushTest' \
--header 'X-Parse-Application-Id: YOUR_APPLICATION_ID' \
--header 'X-Parse-REST-API-Key: YOUR_REST_KEY' \
--header 'Content-Type: application/json'

Die Anwendungs-ID und der REST-Schlüssel können unter “App Settings > Security & Keys” abgerufen werden.

Um Push-Benachrichtigungen zu planen, werfen Sie einen Blick auf Cloud Jobs.

Schlussfolgerung

In diesem Artikel haben wir über Push-Benachrichtigungen, ihre Vorteile, Benachrichtigungstypen und ihre Do’s und Don’ts gesprochen. Außerdem haben Sie erfahren, wie Sie Ihre Android-Anwendung so konfigurieren, dass sie Push-Benachrichtigungen über Back4app sendet.

Der endgültige Quellcode ist in einem GitHub-Repository verfügbar.

Künftige Schritte

1. Wenn Sie Ihre Benachrichtigungen planen oder bestimmte Benutzer ansprechen möchten, schauen Sie sich die Parse-Dokumente an.
2. Wie Sie Push-Benachrichtigungen an iOS-Geräte senden können, erfahren Sie in den offiziellen Dokumenten.
3. Um mehr über Cloud Code zu erfahren, lesen Sie bitte Was ist FaaS im Cloud Computing?

FAQ