Partager via

Activer les notifications Push

  • Article

Les notifications push permettent aux clients d’être avertis des messages entrants et d’autres opérations se produisant dans un thread de conversation dans des situations où l’application mobile ne s’exécute pas au premier plan. Azure Communication Services prend en charge une liste d’événements auxquels vous pouvez vous abonner.

Notes

Les notifications Push de conversation sont prises en charge pour android SDK dans les versions à partir de la version 1.1.0-beta.4 et 1.1.0. Il est recommandé d’utiliser la version 2.0.0 ou ultérieure, car les versions antérieures rencontrent un problème connu avec le renouvellement de l’inscription. Les étapes comprises entre 8 et 12 sont nécessaires uniquement pour les versions égales ou supérieures à 2.0.0.

  1. Configurez Firebase Cloud Messaging pour le ChatQuickstart Project. Effectuez les étapes Create a Firebase project, Register your app with Firebase, Add a Firebase configuration file, Add Firebase SDKs to your app et Edit your app manifest de la documentation Firebase.

  2. Créez un hub de notification dans le même abonnement que votre ressource Communication Services, configurez vos paramètres de messagerie Firebase Cloud pour le hub et liez le hub de notification à votre ressource Communication Services. Consultez Provisionnement des hubs de notification.

  3. Créez un fichier appelé MyFirebaseMessagingService.java dans le même répertoire où MainActivity.java réside. Copiez le code ci-après 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>. Cette valeur est utilisée à l’étape 6 ci-dessous.

       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. Ajoutez les instructions d’importation suivantes au-dessus de MainActivity.java :

       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. Mettre à 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 sous 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
   });
  1. Ajoutez le champ xmlns:tools au fichier AndroidManifest.xml :
    <manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    package="com.azure.android.communication.chat.sampleapp">
  1. Désactivez l’initialiseur par défaut pour WorkManager dansAndroidManifest.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 -->
  1. Ajoutez la dépendance WorkManager à votre fichier build.gradle :
    def work_version = "2.7.1"
    implementation "androidx.work:work-runtime:$work_version"
  1. 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 ci-dessus : L’initialiseur par défaut de WorkManager a été désactivé à l’étape 9. Cette étape permet Configuration.Provider de fournir un « WorkFactory » personnalisé, qui est responsable de la création de WorkerManager pendant le runtime.

Si l’application est intégrée à Azure Function, l’initialisation des paramètres de l’application doit être ajoutée dans la méthode « onCreate() ». La méthode « getWorkManagerConfiguration() » est appelée au démarrage de l’application, avant que les objets d’activité, de service ou de récepteur (à l’exclusion des fournisseurs de contenu) aient été créés, afin que les paramètres de l’application puissent être initialisés avant d’être utilisés. Pour plus d’informations, consultez l’exemple d’application de conversation.

  1. Ajoutez le champ android:name=.MyAppConfiguration, 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"
>