Aktivieren von Pushbenachrichtigungen in Android

Mithilfe von Pushbenachrichtigungen können Clients über eingehende Nachrichten und andere Vorgänge benachrichtigt werden, die in einem Chatthread auftreten, wenn 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 wird empfohlen, version 2.0.0 oder höher zu verwenden, da ältere Versionen ein bekanntes Problem mit der Registrierungsverlängerung haben. Schritte von 8 bis 12 sind nur für Versionen erforderlich, die gleich oder größer als 2.0.0 sind.

1. 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 appund Edit your app manifest in der Firebase-Dokumentation aus.

2. Erstellen Sie einen Benachrichtigungshub innerhalb desselben Abonnements wie Ihre Communication Services-Ressource, konfigurieren Sie Ihre Firebase Cloud Messaging-Einstellungen für den Hub, und verknüpfen Sie den Benachrichtigungshub mit Ihrer Kommunikationsdienste-Ressource. Siehe Benachrichtigungshubbereitstellung.

3. Erstellen Sie eine neue Datei mit dem Namen MyFirebaseMessagingService.java in demselben Verzeichnis, in dem sich MainActivity.java 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 Ihren eigenen Wert für <your_intent_name> verwenden. Verwenden Sie diesen Wert in Schritt 6.

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

4. Fügen Sie oben in der Datei MainActivity.javadie 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;
   

5. Fügen Sie der MainActivity-Klasse 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);
                          }
                      });
                  }
              });
      }
   
   

6. 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>"));
      }
   

7. Setzen Sie den folgenden Code nach dem Kommentar <RECEIVE CHAT MESSAGES> in MainActivity:

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

8. Fügen Sie das xmlns:tools Feld zur AndroidManifest.xml Datei 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">

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

10. Fügen Sie die WorkManager Abhängigkeit zu Ihrer build.gradle Datei hinzu.

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

11. Fügen Sie einen benutzerdefinierten WorkManager Initialisierer hinzu, indem Sie eine Klasse implementieren, 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 des vorherigen Codes: Der Standardinitialisierer von WorkManager ist in Schritt 9 deaktiviert. Dieser Schritt implementiert Configuration.Provider, um eine angepasste WorkFactory bereitzustellen, die für die Erstellung von WorkerManager während der Laufzeit verantwortlich ist.

Wenn die App in Azure Function integriert ist, initialisieren Sie die Anwendungsparameter in der Methode onCreate(). Die Methode getWorkManagerConfiguration() wird aufgerufen, wenn die Anwendung gestartet wird, bevor Aktivitäts-, Dienst- oder Empfängerobjekte (mit Ausnahme von Inhaltsanbietern) erstellt werden, sodass Anwendungsparameter vor der Verwendung initialisiert werden können. Weitere Informationen finden Sie in der Beispielchat-App.

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

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

Verwandte Artikel

• Migrieren von Android SDK-Pushbenachrichtigungen zu FCM v1
• Registrieren für Android SDK-Pushbenachrichtigungen mit FCM v1