Activer les notifications Push dans Android

Les notifications Push permettent aux clients d’être avertis des messages entrants et d’autres opérations se produisant dans un thread de conversation lorsque l’application mobile n’est pas en cours d’exécution au premier plan. Azure Communication Services prend en charge une liste d’événements auxquels vous pouvez vous abonner.

1. Configurez Firebase Cloud Messaging pour le projet ChatQuickstart. Effectuez les étapesCreate a Firebase project, , Register your app with Firebase, Add a Firebase configuration fileAdd Firebase SDKs to your appet Edit your app manifest dans la documentation Firebase.

2. Créez un hub de notification dans le même abonnement que votre ressource Communication Services, configurez vos paramètres Firebase Cloud Messaging pour le hub et liez le hub de notification à votre ressource Communication Services. Consultez la configuration de Notification Hub.

3. Créez un fichier appelé MyFirebaseMessagingService.java dans le même répertoire où MainActivity.java réside. Copiez le code suivant dans MyFirebaseMessagingService.java. Vous devez remplacer <your_package_name> par le nom du package utilisé dans MainActivity.java. Vous pouvez utiliser votre propre valeur pour <your_intent_name>. Utilisez cette valeur à l’étape 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. En haut du fichier MainActivity.java, ajoutez les instructions import suivantes :

      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. Ajoutez le code suivant à la classe 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. Mettez à jour la fonction onCreate dans 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. Placez le code suivant après le commentaire <RECEIVE CHAT MESSAGES> dans 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. Ajoutez le xmlns:tools champ au AndroidManifest.xml fichier :

    <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. Désactivez l’initialiseur par défaut pour WorkManager dans 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. Ajoutez la WorkManager dépendance à votre build.gradle fichier :

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

11. Ajoutez un initialiseur personnalisé WorkManager en créant une classe implémentant Configuration.Provider:

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

Explication du code précédent : L’initialiseur par défaut est WorkManager désactivé à l’étape 9. Cette étape implémente Configuration.Provider pour fournir un élément personnalisé WorkFactory, qui est responsable de la création WorkerManager pendant l’exécution.

Si l’application est intégrée à Azure Function, initialisez les paramètres de l’application dans la méthode onCreate(). La méthode getWorkManagerConfiguration() est appelée lorsque l’application démarre, avant toute activité, service ou objets récepteur (à l’exclusion des fournisseurs de contenu) sont créés, afin que les paramètres de l’application puissent être initialisés avant l’utilisation. Pour plus d’informations, consultez l’exemple d’application de conversation.

12. Ajoutez le android:name=.MyAppConfiguration champ, qui utilise le nom de classe de l’étape 11, dans 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"
>

Articles connexes

• Migrer des notifications Push du Kit de développement logiciel (SDK) Android vers FCM v1
• S’inscrire aux notifications Push android SDK à l’aide de FCM v1