Schritt-für-Schritt-Anleitung für Android-Push-Benachrichtigungen

Push-Benachrichtigungen spielen eine wichtige Rolle bei der Benutzerinteraktion und -bindung in Ihrer mobilen App, indem sie Benutzer auf dem Laufenden halten und ein Gefühl der Dringlichkeit erzeugen, das zu Käufen führt. Und in Android erhalten wir den zusätzlichen Vorteil des Firebase Cloud Messaging (FCM)-Benachrichtigungsdienstes, der als Vermittler zwischen dem App-Server und dem Android-Gerät des Benutzers fungiert. Es unterstützt die Zustellung von Push-Benachrichtigungen, auch wenn die App nicht aktiv ist oder der Benutzer eine andere App auf seinem Gerät verwendet.

Firebase Cloud Messaging (FCM) wird dank seines robusten Cross-Messaging-Systems zum Senden von Datennachrichten und Warnungen an Benutzer verwendet. iOS-, Web- und Android-Plattformen werden alle von FCM unterstützt. Nachrichten mit einer Datennutzlast von bis zu 4 KB können mithilfe von FCM-Push-Benachrichtigungen gesendet werden.

In diesem Artikel gehen wir Schritt für Schritt auf die Integration von Push-Benachrichtigungen in Android-Apps ein und diskutieren die kritischen Aspekte der Implementierung. Wir werden außerdem mehrere Produkte und Tools vorstellen, die die Benutzereinbindung vereinfachen und verstärken können.

Android-Push-Benachrichtigungen verstehen

Mobile Push-Benachrichtigungen tragen dazu bei, die Benutzereinbindung, die Kundenbindung und das allgemeine Benutzererlebnis in Ihren Anwendungen zu verbessern. Wenn Push-Benachrichtigungen richtig eingesetzt werden, können sie die Effektivität mobiler Apps in verschiedenen Geschäftsbereichen erheblich steigern.

Push-Benachrichtigungen können für verschiedene Anwendungsfälle und Zwecke in Ihrer Android-App verwendet werden, darunter:

i) Aktualisieren eines Benutzers über den Status seiner Online-Buchung oder seines Zeitplans.

ii) Bereitstellung von Erläuterungen und Aktualisierungen für eine Online-Bestellung, die der Benutzer aufgegeben hat.

iii) Benutzer über Änderungen im Backend informieren und ihnen helfen, ihr Paket zu verfolgen.

iv) Einen Hype um mit der App verknüpfte Ereignisse erzeugen und einem Benutzer neue Angebote, Werbeaktionen und Möglichkeiten vorstellen.

v) Ermutigen Sie Benutzer, neue App-Funktionen auszuprobieren, indem Sie neckende Nachrichten senden und sie über Serveraktualisierungen und andere Back-End-Änderungen informieren.

Implementierungsansatz von Push-Benachrichtigungen in Android-Anwendungen

Voraussetzungen

Sie benötigen diese Tools und Dienste, um Push-Benachrichtigungen erfolgreich in Ihrer Android-App FCM zu implementieren:

i) Android Studio – Dies ist die IDE, die für die Android-Entwicklung verwendet wird.

ii) Grundkenntnisse und Verständnis – Sie benötigen ein grundlegendes Verständnis der Android-Projektentwicklung und -struktur sowie der Manifestdateikonfiguration.

iii) Ein Firebase-Konto – Sie sollten über ein Firebase-Konto zum Erstellen und Verwalten Ihrer Projekteinstellungen verfügen.

iv) Internetverfügbarkeit – Integrationstests und Firebase-Setup erfordern eine Internetverbindung.

Schritt 1. Richten Sie Ihr Firebase-Projekt ein

Besuchen Sie die Firebase-Konsole.

Erstellen Sie Ihr Projekt, indem Sie ihm einen Namen geben und auf „Weiter“ klicken.

Zur weiteren Konfiguration können Sie den Google Analytics-Dienst aktivieren oder deaktivieren, um die Datenanalyse für Ihre App zu erhalten.

Um die Einrichtung abzuschließen, müssen Sie die Projekteinstellungen überprüfen; Dann können Sie Ihr Projekt erstellen.

Nachdem Sie Ihr Projekt erstellt haben, müssen Sie zusätzliche Projektkonfigurationen für die Push-Benachrichtigungsimplementierungen vornehmen.

Registrieren Sie Ihre App im Projekt-Dashboard

Sie müssen auf das Android-Symbol im Dashboard klicken, um eine Android-App hinzuzufügen. Geben Sie als Nächstes einen Android-Paketnamen ein. Dieser Paketname muss mit dem Paketnamen in Ihrem Projekt identisch sein (d. h. com.app.demoapp).

Sie können auch den Spitznamen Ihrer App eingeben, um Ihre App in der Konsole zu identifizieren.

Fügen Sie einen SHA-1-Schlüssel für Ihre App hinzu. Mit diesem Befehl müssen Sie Ihren SHA-1-Schlüssel in Ihrem Terminal generieren: Kopieren Sie nun den SHA-1-Schlüssel und fügen Sie ihn in die Firebase-Konsole ein.

./gradlew signingReport

Klicken Sie abschließend auf „App registrieren“, um die Konfiguration abzuschließen.

Richten Sie Google-Dienste ein

Sobald Sie die Registrierung Ihrer App abgeschlossen haben, können Sie die Datei google-services.json herunterladen und auf Ihrem Computer speichern.

Jetzt müssen Sie google-services.json zu Ihrem Android-Projekt hinzufügen und die Datei im App-Verzeichnis Ihres Android-Projekts ablegen.

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

Firebase SDK hinzufügen

Fügen Sie als Nächstes das Firebase SDK zu Ihrem Projekt hinzu und fügen Sie in build.gradle den Klassenpfad für Google-Dienste hinzu:

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

Fügen Sie in app/build.gradle die folgenden Abhängigkeiten hinzu:-

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'
}

Nachdem Sie diese Schritte abgeschlossen haben, können Sie im Android Studio auf „Jetzt synchronisieren“ klicken, um Ihr Projekt mit Firebase zu synchronisieren.

Schritt 2. Konfigurieren Sie Ihr Android-Projekt

build.gradle auf Projektebene

Öffnen Sie Ihr build.gradle auf Projektebene: Navigieren Sie zum Stammverzeichnis Ihres Android-Projekts und suchen Sie die Datei build.gradle.

Stellen Sie sicher, dass die Repositorys google() und mavenCentral() im Abschnitt „Repositorys“ enthalten sind.

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()
    }
}

Nehmen Sie Änderungen im build.gradle vor

Suchen Sie die Datei „build.gradle“ in Ihrem Projekt-App-Verzeichnis, fügen Sie dann das Google-Services-Plugin am Ende der Datei hinzu und fügen Sie im Abschnitt „Abhängigkeiten“ die Abhängigkeiten „Firebase“ und „Firebase Messaging“ hinzu.

./gradlew signingReport

Nach Abschluss dieser Schritte ist Ihr Projekt mit Firebase-Abhängigkeiten konfiguriert, einschließlich Firebase Messaging für Push-Benachrichtigungen. Lassen Sie uns nun mit der Einrichtung des Firebase Messaging-Dienstes und der Verarbeitung der Benachrichtigungen in Ihrer App fortfahren.

Schritt 3. Implementieren Sie das FCM

Fügen Sie einen Dienst zur Verarbeitung von FCM-Nachrichten hinzu

Erstellen Sie eine neue Klasse mit dem Namen MyMessagingService, die FirebaseMessagingService erweitert.

Sie müssen die Methode onMessageReceived überschreiben, um eingehende Nachrichten zu verarbeiten, wenn sich Ihre App im Vordergrund befindet. Implementieren Sie dann die Logik, um die Benachrichtigung zu verarbeiten und sie optional dem Benutzer anzuzeigen.

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

Registrieren Sie sich in der Datei AndroidManifest.xml

Öffnen Sie die Datei AndroidManifest.xml in Ihrem Projekt.

Jetzt müssen Sie den MyMessagingService im Manifest registrieren, um FCM-Nachrichten zu verarbeiten.

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

Schritt 4: Besorgen Sie sich das FCM-Registrierungstoken

Um Push-Benachrichtigungen zu erhalten, muss Ihre App das FCM-Registrierungstoken erhalten. Dieses Token identifiziert die App-Instanz auf dem Gerät eindeutig.

Codebeispiel zum Abrufen des Gerätetokens

Sie können das FCM-Registrierungstoken in Ihrem FirebaseMessagingService oder an einer anderen geeigneten Stelle in Ihrer App abrufen. Sehen wir uns an, wie es in FirebaseMessagingService geht.

MyMessagingService aktualisieren:

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'
}

Sie können das Token in einer Aktivität oder einem Fragment abrufen und es nach Bedarf speichern oder verwenden.

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()
    }
}

Mit diesen Methoden können Sie das FCM-Registrierungstoken in Ihrer Android-App abrufen. Das Token kann entweder im FirebaseMessagingService oder in einer beliebigen Aktivität oder einem beliebigen Fragment abgerufen werden. Dieses Token ist wichtig, um gezielte Push-Benachrichtigungen an bestimmte Geräte zu senden.

Schritt 5: Push-Benachrichtigungen senden

Wenn Sie Benachrichtigungen von einem Server senden möchten, müssen Sie eine POST-Anfrage an die FCM-API stellen.

Sie benötigen einen Serverschlüssel

• In der Firebase Console → Projekteinstellungen → „Projektübersicht“ → „Cloud Messaging“.
• Unter „Projektanmeldeinformationen“ finden Sie den Serverschlüssel.

cURL-Anfrage: Dieser cURL-Befehl wird zum Senden von Benachrichtigungen verwendet. Ersetzen Sie mit Ihrem tatsächlichen Serverschlüssel und mit dem FCM-Token des Zielgeräts.

./gradlew signingReport

• https://fcm.googleapis.com/fcm/send API-Endpunkt.
• H „Authorization: key=“: Dies ist ein Autorisierungsheader mit Ihrem Serverschlüssel.
• H „Content-Type: application/json“: Inhaltstyp-Header.
• d '{ ... }': Dies ist die JSON-Nutzlast, die Ihre Benachrichtigung und Daten enthält.

Fortgeschrittene Themen

Umgang mit Datennachrichten

Datennachrichten sind ein Nachrichtentyp, der benutzerdefinierte Schlüssel-Wert-Paare enthalten kann und anders als Benachrichtigungsnachrichten behandelt wird. Datennachrichten werden in der onMessageReceived-Methode von FirebaseMessagingService empfangen, unabhängig davon, ob sich die App im Vordergrund oder Hintergrund befindet.

Beispiel für den Umgang mit Datennachrichten

MyMessagingService aktualisieren

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

Benachrichtigungskanäle verwalten

Ab Android 8.0 (API-Level 26) müssen alle Benachrichtigungen einem Kanal zugewiesen werden. Dadurch können Benutzer die Benachrichtigungseinstellungen für jeden Kanal steuern.

Beispiel für die Erstellung von Benachrichtigungskanälen

Erstellen Sie eine Methode zum Einrichten von Benachrichtigungskanälen:

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

Rufen Sie diese Methode in Ihrer MainActivity- oder Anwendungsklasse auf:

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'
}

Alternativ können Sie NotificationUtils.createNotificationChannel(this); in Ihrer Anwendungsklasse, falls Sie eine haben:

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()
    }
}

Aktualisieren Sie Ihren Notification Builder, um die Kanal-ID zu verwenden:

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'

Push-Benachrichtigungen testen

Wenn Push-Benachrichtigungen implementiert werden, müssen wir Tests durchführen, um sicherzustellen, dass sie korrekt implementiert werden.

In Android Studio können Sie den Logcat öffnen, Ansicht > Tool Windows > Logcat.

Wir können die Logcat-Ausgabe auch mithilfe des Tags filtern, das wir in der FirebaseMessagingService-Klasse verwendet haben. Die Anwendung muss auf dem Gerät oder über einen Emulator ausgeführt werden.

Wenn die Benachrichtigung eingeht, können wir die Daten in Logcat wie folgt sehen:

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());
    }
}

Nachrichtendaten können wie folgt angezeigt werden:

<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>

Abschluss

In diesem Artikel haben wir etwas über Push-Benachrichtigungen und eine schrittweise Vorgehensweise zur Implementierung erfahren. Wir haben gelernt, wie Sie ein Projekt in der Firebase-Konsole einrichten und die erforderliche Konfiguration in den Firebase-Projekteinstellungen abschließen, damit Sie mit dem Senden von Android-Benachrichtigungen an Ihre Android-Benutzer beginnen können.

Sie müssen zunächst ein Firebase-Projekt einrichten und die Datei google-services.json herunterladen. Danach müssen Sie das Verzeichnis dieser Datei-App ablegen und die build.gradle-Dateien so ändern, dass sie Firebase-Abhängigkeiten enthalten.

Dann müssen Sie eine Klasse erstellen, die die eingehenden Nachrichten verarbeitet, und diese Dienstklasse in AndroidManifest.xml registrieren. Nachdem Sie den Dienst in der Manifestdatei hinzugefügt haben, müssen Sie das FCM-Token abrufen, das zur eindeutigen Identifizierung Ihrer App verwendet wird, damit eine Benachrichtigung an das Zielgerät gesendet werden kann.

Benachrichtigungen können getestet werden, indem Sie Nachrichten von der Firebase-Konsole senden und den Logcat von Android Studio verwenden, um die Zustellung zu bestätigen. Um serverseitige Benachrichtigungen zu aktivieren, verwenden Sie eine cURL-Anfrage mit Ihrem Firebase-Serverschlüssel und dem FCM-Token des Geräts.

Um die Kompatibilität mit späteren Android-Versionen aufrechtzuerhalten, müssen Sie Datennachrichten in Ihrem „FirebaseMessagingService“ verarbeiten und Benachrichtigungskanäle für anspruchsvolle Konfigurationen verwalten.

Push-Benachrichtigungen, die relevante Updates und individuelle Informationen bieten – und die Benutzerbindung und Konversionsraten erhöhen können – sind entscheidend für die Förderung des Benutzerengagements.

Weitere Informationen und ausführliche Anweisungen finden Sie in den offiziellen Firebase- und Android SDK-Dokumenten. Diese Websites bieten ausführliche Anleitungen und branchenübliche Best Practices für die Integration von Push-Benachrichtigungen in Ihre Anwendung.

Das obige ist der detaillierte Inhalt vonSchritt-für-Schritt-Anleitung für Android-Push-Benachrichtigungen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!