Pushmeldingen inschakelen in Android

Met pushmeldingen kunnen clients op de hoogte worden gesteld van binnenkomende berichten en andere bewerkingen die plaatsvinden in een chatgesprek wanneer de mobiele app niet op de voorgrond wordt uitgevoerd. Azure Communication Services ondersteunt een lijst met gebeurtenissen waarop u zich kunt abonneren.

1. Stel Firebase Cloud Messaging in voor het ChatQuickstart-project. Voer de stappenCreate a Firebase project, Register your app with Firebase, , Add a Firebase configuration fileen Edit your app manifestAdd Firebase SDKs to your appin de Firebase-documentatie uit.

2. Maak een Notification Hub binnen hetzelfde abonnement als uw Communication Services-resource, configureer uw Firebase Cloud Messaging-instellingen voor de hub en koppel de Notification Hub aan uw Communication Services-resource. Zie Het inrichten van Notification Hub.

3. Maak een nieuw bestand met de naam MyFirebaseMessagingService.java in dezelfde map waarin MainActivity.java zich bevindt. Kopieer de volgende code naar MyFirebaseMessagingService.java. U moet <your_package_name> vervangen door de pakketnaam die wordt gebruikt in MainActivity.java. U kunt uw eigen waarde gebruiken voor <your_intent_name>. Gebruik deze waarde in stap 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. Voeg boven aan het bestand MainActivity.javade volgende importinstructies toe:

      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. Voeg de volgende code toe aan de klasse MainActivity:

      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. Werk de functie onCreate bij 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. Plaats de volgende code na de opmerking <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. Voeg het xmlns:tools veld toe aan het AndroidManifest.xml bestand:

    <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. Uitschakelen de standaard initialisator voor 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. Voeg de WorkManager afhankelijkheid toe aan uw build.gradle bestand:

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

11. Voeg een aangepaste WorkManager initializer toe door een klasse te maken die Configuration.Provider implementeert.

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

Uitleg van de voorgaande code: De standaard initialisatiefunctie van WorkManager is uitgeschakeld in stap 9. Deze stap implementeert Configuration.Provider om een geconfigureerde WorkFactory te bieden die verantwoordelijk is voor het creëren van WorkerManager tijdens de uitvoering.

Als de app is geïntegreerd met Azure Function, initialiseert u de toepassingsparameters in de methode onCreate(). De methode getWorkManagerConfiguration() wordt aangeroepen wanneer de toepassing wordt gestart, voordat er activiteits-, service- of ontvangerobjecten (met uitzondering van inhoudsproviders) worden gemaakt, zodat toepassingsparameters kunnen worden geïnitialiseerd voordat ze worden gebruikt. Zie de voorbeeld-chat-app voor meer informatie.

12. Voeg het android:name=.MyAppConfiguration veld toe, dat gebruikmaakt van de klassenaam uit stap 11, 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"
>

Verwante artikelen

• Android SDK-pushmeldingen migreren naar FCM v1
• Registreren voor Android SDK-pushmeldingen met FCM v1