Aktivieren von Pushbenachrichtigungen

Artikel
06/01/2023

Mit Pushbenachrichtigungen können Clients über eingehende Nachrichten und andere Vorgänge benachrichtigt werden, die in einem Chatthread in Situationen auftreten, in denen die mobile App nicht im Vordergrund ausgeführt wird. Azure Communication Services unterstützt eine Liste mit Ereignissen, die Sie abonnieren können.

Hinweis

Chat-Pushbenachrichtigungen werden für Android SDK in Versionen ab 1.1.0-beta.4 und 1.1.0 unterstützt. Es empfiehlt sich, Version 2.0.0 oder neuer zu verwenden, da bei älteren Versionen ein bekanntes Problem mit der Registrierungsverlängerung besteht. Die Schritte von 8 bis 12 sind nur für Versionen größer als oder gleich 2.0.0 erforderlich.

Richten Sie Firebase Cloud Messaging für das ChatQuickstart-Projekt ein. Führen Sie die Schritte Create a Firebase project, Register your app with Firebase, Add a Firebase configuration file, Add Firebase SDKs to your app und Edit your app manifest in der Firebase-Dokumentation aus.
Erstellen Sie einen Notification Hub innerhalb des Abonnements, in dem sich auch Ihre Communication Services-Ressource befindet, konfigurieren Sie Ihre Firebase Cloud Messaging-Einstellungen für den Hub, und verknüpfen Sie den Notification Hub mit Ihrer Communication Services-Ressource. Weitere Informationen finden Sie unter Bereitstellen von Notification Hub.

Erstellen Sie eine neue Datei mit dem Namen MyFirebaseMessagingService.java in dem Verzeichnis, in dem MainActivity.java sich befindet. Kopieren Sie den folgenden Code in MyFirebaseMessagingService.java. Sie müssen <your_package_name> durch den in MainActivity.java verwendeten Paketnamen ersetzen. Sie können einen eigenen Wert für <your_intent_name> verwenden. Dieser Wert wird in Schritt 6 weiter unten verwendet.

   package <your_package_name>;

   import android.content.Intent;
   import android.util.Log;

   import androidx.localbroadcastmanager.content.LocalBroadcastManager;

   import com.azure.android.communication.chat.models.ChatPushNotification;
   import com.google.firebase.messaging.FirebaseMessagingService;
   import com.google.firebase.messaging.RemoteMessage;

   import java.util.concurrent.Semaphore;

   public class MyFirebaseMessagingService extends FirebaseMessagingService {
       private static final String TAG = "MyFirebaseMsgService";
       public static Semaphore initCompleted = new Semaphore(1);

       @Override
       public void onMessageReceived(RemoteMessage remoteMessage) {
           try {
               Log.d(TAG, "Incoming push notification.");

               initCompleted.acquire();

               if (remoteMessage.getData().size() > 0) {
                   ChatPushNotification chatPushNotification =
                       new ChatPushNotification().setPayload(remoteMessage.getData());
                   sendPushNotificationToActivity(chatPushNotification);
               }

               initCompleted.release();
           } catch (InterruptedException e) {
               Log.e(TAG, "Error receiving push notification.");
           }
       }

       private void sendPushNotificationToActivity(ChatPushNotification chatPushNotification) {
           Log.d(TAG, "Passing push notification to Activity: " + chatPushNotification.getPayload());
           Intent intent = new Intent("<your_intent_name>");
           intent.putExtra("PushNotificationPayload", chatPushNotification);
           LocalBroadcastManager.getInstance(this).sendBroadcast(intent);
       }
   }

Fügen Sie am Anfang von MainActivity.java die folgenden Importanweisungen hinzu:

   import android.content.BroadcastReceiver;
   import android.content.Context;
   import android.content.Intent;
   import android.content.IntentFilter;

   import androidx.localbroadcastmanager.content.LocalBroadcastManager;
   import com.azure.android.communication.chat.models.ChatPushNotification;
   import com.google.android.gms.tasks.OnCompleteListener;
   import com.google.android.gms.tasks.Task;
   import com.google.firebase.messaging.FirebaseMessaging;

Fügen Sie der MainActivity-Klasse den folgenden Code hinzu:

   private BroadcastReceiver firebaseMessagingReceiver = new BroadcastReceiver() {
       @Override
       public void onReceive(Context context, Intent intent) {
           ChatPushNotification pushNotification =
               (ChatPushNotification) intent.getParcelableExtra("PushNotificationPayload");

           Log.d(TAG, "Push Notification received in MainActivity: " + pushNotification.getPayload());

           boolean isHandled = chatAsyncClient.handlePushNotification(pushNotification);
           if (!isHandled) {
               Log.d(TAG, "No listener registered for incoming push notification!");
           }
       }
   };


   private void startFcmPushNotification() {
       FirebaseMessaging.getInstance().getToken()
           .addOnCompleteListener(new OnCompleteListener<String>() {
               @Override
               public void onComplete(@NonNull Task<String> task) {
                   if (!task.isSuccessful()) {
                       Log.w(TAG, "Fetching FCM registration token failed", task.getException());
                       return;
                   }

                   // Get new FCM registration token
                   String token = task.getResult();

                   // Log and toast
                   Log.d(TAG, "Fcm push token generated:" + token);
                   Toast.makeText(MainActivity.this, token, Toast.LENGTH_SHORT).show();

                   chatAsyncClient.startPushNotifications(token, new Consumer<Throwable>() {
                       @Override
                       public void accept(Throwable throwable) {
                           Log.w(TAG, "Registration failed for push notifications!", throwable);
                       }
                   });
               }
           });
   }

Aktualisieren Sie die Funktion onCreate in MainActivity.

   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_main);

       LocalBroadcastManager
           .getInstance(this)
           .registerReceiver(
               firebaseMessagingReceiver,
               new IntentFilter("<your_intent_name>"));
   }

Geben Sie den folgenden Code unter dem Kommentar <RECEIVE CHAT MESSAGES> in MainActivity ein:

   startFcmPushNotification();

   chatAsyncClient.addPushNotificationHandler(CHAT_MESSAGE_RECEIVED, (ChatEvent payload) -> {
       Log.i(TAG, "Push Notification CHAT_MESSAGE_RECEIVED.");
       ChatMessageReceivedEvent event = (ChatMessageReceivedEvent) payload;
       // You code to handle ChatMessageReceived event
   });

Fügen Sie der Datei AndroidManifest.xml das xmlns:tools Feld hinzu:

    <manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    package="com.azure.android.communication.chat.sampleapp">

Deaktivieren Sie den Standardinitialisierer für WorkManager in AndroidManifest.xml:

    <!-- Disable the default initializer of WorkManager so that we could override it in MyAppConfiguration  -->
    <provider
        android:name="androidx.startup.InitializationProvider"
        android:authorities="${applicationId}.androidx-startup"
        android:exported="false"
        tools:node="merge">
      <!-- If you are using androidx.startup to initialize other components -->
      <meta-data
          android:name="androidx.work.WorkManagerInitializer"
          android:value="androidx.startup"
          tools:node="remove" />
    </provider>
    <!-- End of Disabling default initializer of WorkManager -->

Fügen Sie der Datei build.gradle die Abhängigkeit WorkManager hinzu:

    def work_version = "2.7.1"
    implementation "androidx.work:work-runtime:$work_version"

Fügen Sie einen benutzerdefinierten WorkManager-Initialisierer hinzu, indem Sie eine Klasse erstellen, die Configuration.Provider implementiert:

    public class MyAppConfiguration extends Application implements Configuration.Provider {
        Consumer<Throwable> exceptionHandler = new Consumer<Throwable>() {
            @Override
            public void accept(Throwable throwable) {
                Log.i("YOUR_TAG", "Registration failed for push notifications!" + throwable.getMessage());
            }
        };
    
        @Override
        public void onCreate() {
            super.onCreate();
            // Initialize application parameters here
            WorkManager.initialize(getApplicationContext(), getWorkManagerConfiguration());
        }
    
        @NonNull
        @Override
        public Configuration getWorkManagerConfiguration() {
            return new Configuration.Builder().
                setWorkerFactory(new RegistrationRenewalWorkerFactory(COMMUNICATION_TOKEN_CREDENTIAL, exceptionHandler)).build();
        }
    }

Erläuterung zum oben abgebildeten Code: Der Standardinitialisierer von WorkManager wurde in Schritt 9 deaktiviert. Dieser Schritt implementiert Configuration.Provider, um eine benutzerdefinierte „WorkFactory“ bereitzustellen, die für die Erstellung von WorkerManager während der Laufzeit zuständig ist.

Wenn die App in Azure Function integriert ist, sollte die Initialisierung von Anwendungsparametern in der Methode „onCreate()“ hinzugefügt werden. Die Methode „getWorkManagerConfiguration()“ wird aufgerufen, wenn die Anwendung gestartet wird, vor der Erstellung von Aktivitäts-, Dienst- oder Empfängerobjekten (mit Ausnahme von Inhaltsanbietern), sodass Anwendungsparameter vor der Verwendung initialisiert werden können. Weitere Informationen finden Sie in der Beispiel-Chat-App.

Fügen Sie das android:name=.MyAppConfiguration-Feld, das den Klassennamen aus Schritt 11 verwendet, zu AndroidManifest.xml hinzu:

<application
      android:allowBackup="true"
      android:icon="@mipmap/ic_launcher"
      android:label="@string/app_name"
      android:roundIcon="@mipmap/ic_launcher_round"
      android:theme="@style/Theme.AppCompat"
      android:supportsRtl="true"
      android:name=".MyAppConfiguration"
>

Aktivieren von Pushbenachrichtigungen

Zusätzliche Ressourcen