Activer les notifications Push

Suivre le guide de démarrage rapide

Les notifications Push web via le Kit de développement logiciel (SDK) d’appel web Azure Communication Services sont en préversion et sont disponibles dans le cadre de la version 1.12.0-beta.2+.

Pour obtenir des instructions pas à pas, consultez le guide de démarrage rapide sur GitHub.

• Un compte Firebase avec Firebase Cloud Messaging (FCM) activé et avec votre service FCM connecté à une instance Azure Notification Hubs. Pour plus d’informations, consultez notifications des services de communication.

• Android Studio version 3.6 ou ultérieure pour générer votre application.

• Ensemble d’autorisations pour permettre à l’application Android de recevoir des messages de notification de FCM. Dans votre fichier AndroidManifest.xml, ajoutez les autorisations suivantes juste après <manifest ...> ou sous la balise </application> :

  <uses-permission android:name="android.permission.INTERNET"/>
  <uses-permission android:name="android.permission.GET_ACCOUNTS"/>
  <uses-permission android:name="com.google.android.c2dm.permission.RECEIVE" />
  

Considérations relatives aux notifications Push mobiles

Les notifications Push mobiles sont les notifications contextuelles qui s’affichent sur les appareils mobiles. Pour les appels, cet article se concentre sur les notifications Push VoIP (protocole voix sur IP).

Installer le SDK

Recherchez votre fichier build.gradle au niveau du projet et ajoutez mavenCentral() à la liste des référentiels sous buildscript et allprojects :

buildscript {
    repositories {
    ...
        mavenCentral()
    ...
    }
}

allprojects {
    repositories {
    ...
        mavenCentral()
    ...
    }
}

Ensuite, dans votre fichier build.gradle au niveau du module, ajoutez les lignes suivantes à la section dependencies :

dependencies {
    ...
    implementation 'com.azure.android:azure-communication-calling:1.0.0'
    ...
}

Initialiser les objets nécessaires

Pour créer une instance CallAgent, vous devez appeler la méthode createCallAgent sur une instance CallClient. Cet appel retourne de façon asynchrone un objet d’instance CallAgent.

La méthode createCallAgent prend CommunicationUserCredential en tant qu’argument, qui encapsule un jeton d’accès.

Pour accéder à DeviceManager, vous devez d’abord créer une instance callAgent. Vous pouvez ensuite utiliser la méthode CallClient.getDeviceManager pour obtenir DeviceManager.

String userToken = '<user token>';
CallClient callClient = new CallClient();
CommunicationTokenCredential tokenCredential = new CommunicationTokenCredential(userToken);
android.content.Context appContext = this.getApplicationContext(); // From within an activity, for instance
CallAgent callAgent = callClient.createCallAgent(appContext, tokenCredential).get();
DeviceManager deviceManager = callClient.getDeviceManager(appContext).get();

Pour définir un nom d’affichage pour l’appelant, utilisez cette autre méthode :

String userToken = '<user token>';
CallClient callClient = new CallClient();
CommunicationTokenCredential tokenCredential = new CommunicationTokenCredential(userToken);
android.content.Context appContext = this.getApplicationContext(); // From within an activity, for instance
CallAgentOptions callAgentOptions = new CallAgentOptions();
callAgentOptions.setDisplayName("Alice Bob");
DeviceManager deviceManager = callClient.getDeviceManager(appContext).get();
CallAgent callAgent = callClient.createCallAgent(appContext, tokenCredential, callAgentOptions).get();

Inscription aux notifications Push

Pour s’inscrire aux notifications Push, l’application doit appeler registerPushNotification() sur une instance CallAgent en utilisant un jeton d’inscription d’appareil.

Pour obtenir le jeton d’inscription de l’appareil, ajoutez le SDK Firebase au fichier build.gradle de votre module d’application en ajoutant les lignes suivantes à la section dependencies (si elles n’y figurent pas déjà) :

// Add the SDK for Firebase Cloud Messaging
implementation 'com.google.firebase:firebase-core:16.0.8'
implementation 'com.google.firebase:firebase-messaging:20.2.4'

Dans le fichier build.gradle au niveau du projet, ajoutez la ligne suivante dans la section dependencies si elle n’y figure pas déjà :

classpath 'com.google.gms:google-services:4.3.3'

Ajoutez le plug-in suivant au début du fichier s’il n’y figure pas déjà :

apply plugin: 'com.google.gms.google-services'

Dans la barre d’outils, sélectionnez Synchroniser maintenant. Ajoutez l’extrait de code suivant pour obtenir le jeton d’inscription de l’appareil généré par le SDK Firebase Cloud Messaging pour l’instance d’application cliente. Assurez-vous d’ajouter les importations suivantes à l’en-tête de l’activité principale pour que l’instance récupère le jeton.

import com.google.android.gms.tasks.OnCompleteListener;
import com.google.android.gms.tasks.Task;
import com.google.firebase.iid.FirebaseInstanceId;
import com.google.firebase.iid.InstanceIdResult;

Ajoutez cet extrait de code pour récupérer le jeton :

FirebaseInstanceId.getInstance().getInstanceId()
    .addOnCompleteListener(new OnCompleteListener<InstanceIdResult>() {
        @Override
        public void onComplete(@NonNull Task<InstanceIdResult> task) {
            if (!task.isSuccessful()) {
                Log.w("PushNotification", "getInstanceId failed", task.getException());
                return;
            }

            // Get the new instance ID token
            String deviceToken = task.getResult().getToken();
            // Log
            Log.d("PushNotification", "Device Registration token retrieved successfully");
        }
    });

Inscrivez le jeton d’inscription d’appareil dans le SDK Calling Services pour les notifications Push des appels entrants :

String deviceRegistrationToken = "<Device Token from previous section>";
try {
    callAgent.registerPushNotification(deviceRegistrationToken).get();
}
catch(Exception e) {
    System.out.println("Something went wrong while registering for Incoming Calls Push Notifications.")
}

Gérer les notifications Push

Pour recevoir des notifications Push d’appels entrants, appelez handlePushNotification() sur une instance de CallAgent avec une charge utile.

Pour obtenir la charge utile de Firebase Cloud Messaging, commencez par créer un service (sélectionnez Fichier>Nouveau>Service>Service) qui étend la classe FirebaseMessagingService du SDK Firebase et remplace la méthode onMessageReceived. Cette méthode est le gestionnaire d’événements appelé lorsque Firebase Cloud Messaging remet la notification Push à l’application.

public class MyFirebaseMessagingService extends FirebaseMessagingService {
    private java.util.Map<String, String> pushNotificationMessageDataFromFCM;

    @Override
    public void onMessageReceived(RemoteMessage remoteMessage) {
        // Check if the message contains a notification payload.
        if (remoteMessage.getNotification() != null) {
            Log.d("PushNotification", "Message Notification Body: " + remoteMessage.getNotification().getBody());
        }
        else {
            pushNotificationMessageDataFromFCM = remoteMessage.getData();
        }
    }
}

Ajoutez la définition de service suivante au fichier AndroidManifest.xml, dans la balise <application> :

<service
    android:name=".MyFirebaseMessagingService"
    android:exported="false">
    <intent-filter>
        <action android:name="com.google.firebase.MESSAGING_EVENT" />
    </intent-filter>
</service>

Après avoir récupéré la charge utile, vous pouvez la passer au SDK Communication Services pour qu’elle soit analysée dans un objet IncomingCallInformation interne. Cet objet gère l’appel de la méthode handlePushNotification sur une instance CallAgent. Vous créez une instance CallAgent en appelant la méthode createCallAgent(...) sur la classe CallClient.

try {
    IncomingCallInformation notification = IncomingCallInformation.fromMap(pushNotificationMessageDataFromFCM);
    Future handlePushNotificationFuture = callAgent.handlePushNotification(notification).get();
}
catch(Exception e) {
    System.out.println("Something went wrong while handling the Incoming Calls Push Notifications.");
}

Lorsque la gestion du message de notification Push est réussie et que tous les gestionnaires d’événements sont correctement inscrits, l’application sonne.

Désinscription des notifications Push

Les applications peuvent annuler l’inscription aux notifications Push à tout moment. Pour annuler l’inscription, appelez la méthode unregisterPushNotification() sur callAgent :

try {
    callAgent.unregisterPushNotification().get();
}
catch(Exception e) {
    System.out.println("Something went wrong while un-registering for all Incoming Calls Push Notifications.")
}

Désactiver les notifications Push internes pour un appel entrant

Vous pouvez transmettre la charge utile Push d’un appel entrant à l’appelé de deux manières :

• En utilisant FCM et en inscrivant le jeton de l’appareil avec l’API mentionnée précédemment, registerPushNotification sur CallAgent ou TeamsCallAgent
• En inscrivant le SDK à un service interne lors de la création de CallAgent ou TeamsCallAgent pour que la charge utile Push soit transmise

En utilisant la propriété setDisableInternalPushForIncomingCall dans CallAgentOptions ou TeamsCallAgentOptions, il est possible de demander au SDK de désactiver la transmission de la charge utile Push via le service Push interne :

CallAgentOptions callAgentOptions = new CallAgentOptions();
callAgentOptions.setDisableInternalPushForIncomingCall(true);

Implémenter des notifications Push mobiles iOS

Les notifications Push mobiles sont les notifications contextuelles qui s’affichent sur les appareils mobiles. Pour les appels, cet article se concentre sur les notifications Push VoIP (protocole voix sur IP). Pour obtenir un guide sur l’intégration de CallKit dans votre application iOS, consultez Intégrer à CallKit.

Configurer votre système

Effectuez les étapes suivantes pour configurer votre système.

Créer le projet Xcode

Dans Xcode, créez un projet iOS et sélectionnez le modèle Single View App. Cet article utilise l’infrastructure SwiftUI. Vous devez donc définir Langage sur Swift et Interface sur SwiftUI.

Vous n’allez pas créer de tests dans cet article. N’hésitez pas à désactiver la case Inclure des tests.

Installer le package et les dépendances à l’aide de CocoaPods

1. Créez un Podfile pour votre application, comme cet exemple :

   platform :ios, '13.0'
   use_frameworks!
   target 'AzureCommunicationCallingSample' do
       pod 'AzureCommunicationCalling', '~> 1.0.0'
   end
   

2. Exécutez pod install.

3. Ouvrez .xcworkspace en utilisant Xcode.

Demander l’accès au microphone

Pour accéder au microphone de l’appareil, vous devez mettre à jour la liste des propriétés d’informations de votre application à l’aide de NSMicrophoneUsageDescription. Définissez la valeur associée à une chaîne qui est incluse dans la boîte de dialogue utilisée par le système pour demander l’accès à l’utilisateur.

Cliquez avec le bouton droit sur l’entrée Info.plist de l’arborescence du projet, puis sélectionnez Ouvrir en tant que>Code source. Ajoutez les lignes suivantes à la section <dict> tout en haut, puis enregistrez le fichier.

<key>NSMicrophoneUsageDescription</key>
<string>Need microphone access for VOIP calling.</string>

Configurer le framework d’application

Ouvrez le fichier ContentView.swift de votre projet. Ajoutez une déclaration import en haut du fichier pour importer la bibliothèque AzureCommunicationCalling. En outre, importez AVFoundation. Vous en avez besoin pour les demandes d’autorisations audio dans le code.

import AzureCommunicationCalling
import AVFoundation

Initialiser CallAgent

Pour créer une instance de CallAgent à partir de CallClient, vous devez utiliser une méthode callClient.createCallAgent qui retourne de manière asynchrone un objet CallAgent après qu’il a été initialisé.

Pour créer un client d’appel, transmettez un objet CommunicationTokenCredential :

import AzureCommunication

let tokenString = "token_string"
var userCredential: CommunicationTokenCredential?
do {
    let options = CommunicationTokenRefreshOptions(initialToken: token, refreshProactively: true, tokenRefresher: self.fetchTokenSync)
    userCredential = try CommunicationTokenCredential(withOptions: options)
} catch {
    updates("Couldn't created Credential object", false)
    initializationDispatchGroup!.leave()
    return
}

// tokenProvider needs to be implemented by Contoso, which fetches a new token
public func fetchTokenSync(then onCompletion: TokenRefreshOnCompletion) {
    let newToken = self.tokenProvider!.fetchNewToken()
    onCompletion(newToken, nil)
}

Transmettez l’objet CommunicationTokenCredential que vous avez créé à CallClient et définissez le nom complet :

self.callClient = CallClient()
let callAgentOptions = CallAgentOptions()
options.displayName = " iOS Azure Communication Services User"

self.callClient!.createCallAgent(userCredential: userCredential!,
    options: callAgentOptions) { (callAgent, error) in
        if error == nil {
            print("Create agent succeeded")
            self.callAgent = callAgent
        } else {
            print("Create agent failed")
        }
})

Configurer des notifications Push

Avant de commencer les tâches liées à l’inscription, à la gestion et à la désinscription des notifications Push, effectuez cette tâche de configuration :

1. Dans Xcode, accédez à Signing & Capabilities (Signature et fonctionnalités). Ajoutez une fonctionnalité en sélectionnant + Capability (Fonctionnalité), puis Push Notifications (Notifications Push).
2. Ajoutez une autre fonctionnalité en sélectionnant + Capability, puis Background Modes (Modes d’arrière-plan).
3. Sous Background Modes, cochez les cases Voice over IP (Voix sur IP) et Remote notifications (Notifications distantes).

Inscription aux notifications Push

Pour vous inscrire aux notifications push, utilisez registerPushNotification() sur une instance CallAgent en utilisant un jeton d’inscription d’appareil.

L’inscription aux notifications Push doit avoir lieu une fois l’initialisation correctement effectuée. Quand l’objet callAgent est détruit, logout est appelé, ce qui annule automatiquement l’inscription aux notifications Push.

let deviceToken: Data = pushRegistry?.pushToken(for: PKPushType.voIP)
callAgent.registerPushNotifications(deviceToken: deviceToken!) { (error) in
    if(error == nil) {
        print("Successfully registered to push notification.")
    } else {
        print("Failed to register push notification.")
    }
}

Gérer les notifications Push

Pour recevoir des notifications Push pour les appels entrants, appelez handlePushNotification() sur une instance CallAgent avec une charge utile de dictionnaire :

let callNotification = PushNotificationInfo.fromDictionary(pushPayload.dictionaryPayload)

callAgent.handlePush(notification: callNotification) { (error) in
    if (error == nil) {
        print("Handling of push notification was successful")
    } else {
        print("Handling of push notification failed")
    }
}

Désinscription des notifications Push

Les applications peuvent annuler l’inscription aux notifications Push à tout moment. Pour annuler l’inscription, appelez la méthode unregisterPushNotification sur CallAgent.

callAgent.unregisterPushNotification { (error) in
    if (error == nil) {
        print("Unregister of push notification was successful")
    } else {
       print("Unregister of push notification failed, please try again")
    }
}

Désactiver les notifications Push internes pour un appel entrant

Vous pouvez transmettre la charge utile Push d’un appel entrant à l’appelé de deux manières :

• En utilisant APNs (Apple Push Notification service) et en inscrivant le jeton de l’appareil avec l’API mentionnée précédemment, registerPushNotification sur CallAgent ou TeamsCallAgent
• En inscrivant le SDK à un service interne lors de la création de CallAgent ou TeamsCallAgent pour que la charge utile Push soit transmise

En utilisant la propriété disableInternalPushForIncomingCall dans CallAgentOptions ou TeamsCallAgentOptions, vous pouvez demander au SDK de désactiver la remise de la charge utile push via le service push interne :

let options = CallAgentOptions()
options.disableInternalPushForIncomingCall = true

Implémenter des notifications Push Windows

Les notifications Push mobiles sont les notifications contextuelles qui s’affichent sur les appareils mobiles. Pour les appels, cet article se concentre sur les notifications Push VoIP (protocole voix sur IP).

Les notifications Push sur la plateforme Windows sont transmises via les Services de notifications Push Windows (WNS).

Configurer votre système

Effectuez les étapes suivantes pour configurer votre système.

Créer le projet Visual Studio

Pour une application de plateforme Windows universelle, dans Visual Studio 2022, créez un projet Application vide (Windows universel). Après avoir entré le nom du projet, n’hésitez pas à choisir un kit de développement logiciel (SDK) Windows d’une version ultérieure à 10.0.17763.0.

Pour une application WinUI 3, créez un projet avec le modèle Application vide, Empaquetée (WinUI 3 dans Desktop) pour configurer une application WinUI 3 monopage. Le SDK d’application Windows version 1.3 ou ultérieure est nécessaire.

Installer le package et les dépendances à l’aide du Gestionnaire de package NuGet

Les API et les bibliothèques du SDK Appel sont accessibles au public via un package NuGet.

Pour rechercher, télécharger et installer le package NuGet du SDK Calling :

1. Ouvrez le Gestionnaire de package NuGet en sélectionnant Outils>Gestionnaire de package NuGet>Gérer les packages NuGet pour la solution.
2. Sélectionnez Parcourir, puis entrez Azure.Communication.Calling.WindowsClient dans la zone de recherche.
3. Vérifiez que la case Inclure la préversion est cochée.
4. Sélectionnez le package Azure.Communication.Calling.WindowsClient, puis Azure.Communication.Calling.WindowsClient1.4.0-beta.1 ou une version plus récente.
5. Cochez la case qui correspond au projet Azure Communication Services dans le volet de droite.
6. Sélectionnez Installer.

Configurer des notifications Push

Avant de commencer les tâches liées à l’inscription, à la gestion et à l’affichage d’une notification Windows pour répondre à un appel entrant ou le refuser, effectuez cette tâche de configuration :

1. Suivez le tutoriel  : Envoyez des notifications aux applications de la plateforme Windows universelle à l’aide de Microsoft Azure Notification Hubs. Après avoir suivi le tutoriel, vous disposez des éléments suivants :

   • Une application qui a les packages WindowsAzure.Messaging.Managed et Microsoft.Toolkit.Uwp.Notifications.
   • Un nom de hub Azure Notifications Hub référencé comme <AZURE_PNH_HUB_NAME> et une chaîne de connexion Azure Notifications Hub référencée comme <AZURE_PNH_HUB_CONNECTION_STRING> dans cet article.

2. Pour vous inscrire à un canal WNS à chaque initialisation d’application, veillez à ajouter le code d’initialisation dans votre fichier App.xaml.cs :

   // App.xaml.cs
   
   protected override async void OnLaunched(LaunchActivatedEventArgs e)
   {
       await InitNotificationsAsync();
   
       ...
   }
   
   private async Task InitNotificationsAsync()
   {
       if (AZURE_PNH_HUB_NAME != "<AZURE_PNH_HUB_NAME>" && AZURE_PNH_HUB_CONNECTION_STRING != "<AZURE_PNH_HUB_CONNECTION_STRING>")
       {
           var channel = await PushNotificationChannelManager.CreatePushNotificationChannelForApplicationAsync();
           channel.PushNotificationReceived += Channel_PushNotificationReceived;
   
           var hub = new NotificationHub(AZURE_PNH_HUB_NAME, AZURE_PNH_HUB_CONNECTION_STRING);
           var result = await hub.RegisterNativeAsync(channel.Uri);
   
           if (result.ChannelUri != null)
           {
               PNHChannelUri = new Uri(result.ChannelUri);
           }
           else
           {
               Debug.WriteLine("Cannot register WNS channel");
           }
       }
   }
   

3. Inscrivez le gestionnaire d’événements activé lorsqu’un nouveau message de notification Push arrive sur App.xaml.cs:

   // App.xaml.cs
   
   private void Channel_PushNotificationReceived(PushNotificationChannel sender, PushNotificationReceivedEventArgs args)
   {
       switch (args.NotificationType)
       {
         case PushNotificationType.Toast:
         case PushNotificationType.Tile:
         case PushNotificationType.TileFlyout:
         case PushNotificationType.Badge:
             break;
         case PushNotificationType.Raw:
             var frame = (Frame)Window.Current.Content;
             if (frame.Content is MainPage)
             {
                 var mainPage = frame.Content as MainPage;
                 await mainPage.HandlePushNotificationIncomingCallAsync(args.RawNotification.Content);
             }
             break;
       }
   }
   

Inscription aux notifications Push

Pour vous inscrire aux notifications Push, appelez RegisterForPushNotificationAsync() sur une instance CallAgent avec le canal d’inscription WNS obtenu lors de l’initialisation de l’application.

L’inscription aux notifications Push doit avoir lieu une fois l’initialisation correctement effectuée.

// MainPage.xaml.cs

this.callAgent = await this.callClient.CreateCallAgentAsync(tokenCredential, callAgentOptions);
                
if ((Application.Current as App).PNHChannelUri != null)
{
    await this.callAgent.RegisterForPushNotificationAsync((Application.Current as App).PNHChannelUri.ToString());
}

this.callAgent.CallsUpdated += OnCallsUpdatedAsync;
this.callAgent.IncomingCallReceived += OnIncomingCallAsync;

Gérer les notifications Push

Pour recevoir des notifications Push pour les appels entrants, appelez handlePushNotification() sur une instance CallAgent avec une charge utile de dictionnaire :

// MainPage.xaml.cs

public async Task HandlePushNotificationIncomingCallAsync(string notificationContent)
{
    if (this.callAgent != null)
    {
        PushNotificationDetails pnDetails = PushNotificationDetails.Parse(notificationContent);
        await callAgent.HandlePushNotificationAsync(pnDetails);
    }
}

Cet appel déclenche un événement d’appel entrant sur CallAgent qui affiche la notification d’appel entrant :

// MainPage.xaml.cs

private async void OnIncomingCallAsync(object sender, IncomingCallReceivedEventArgs args)
{
    incomingCall = args.IncomingCall;
    (Application.Current as App).ShowIncomingCallNotification(incomingCall);
}

// App.xaml.cs

public void ShowIncomingCallNotification(IncomingCall incomingCall)
{
    string incomingCallType = incomingCall.IsVideoEnabled ? "Video" : "Audio";
    string caller = incomingCall.CallerDetails.DisplayName != "" ? incomingCall.CallerDetails.DisplayName : incomingCall.CallerDetails.Identifier.RawId;
    new ToastContentBuilder()
    .SetToastScenario(ToastScenario.IncomingCall)
    .AddText(caller + " is calling you.")
    .AddText("New Incoming " + incomingCallType + " Call")
      .AddButton(new ToastButton()
          .SetContent("Decline")
          .AddArgument("action", "decline"))
      .AddButton(new ToastButton()
          .SetContent("Accept")
          .AddArgument("action", "accept"))
      .Show();
}

Ajoutez le code pour gérer la pression sur le bouton de la notification dans la méthode OnActivated :

// App.xaml.cs

protected override async void OnActivated(IActivatedEventArgs e)
{   
    // Handle notification activation
    if (e is ToastNotificationActivatedEventArgs toastActivationArgs)
    {
      ToastArguments args = ToastArguments.Parse(toastActivationArgs.Argument);
      string action = args?.Get("action");
    
      if (!string.IsNullOrEmpty(action))
      {
          var frame = Window.Current.Content as Frame;
          if (frame.Content is MainPage)
          {
              var mainPage = frame.Content as MainPage;
              await mainPage.AnswerIncomingCall(action);
          }
      }
    }
}

// MainPage.xaml.cs

public async Task AnswerIncomingCall(string action)
{
    if (action == "accept")
    {
      var acceptCallOptions = new AcceptCallOptions()
      {
          IncomingVideoOptions = new IncomingVideoOptions()
          {
              StreamKind = VideoStreamKind.RemoteIncoming
          }
      };
    
      call = await incomingCall?.AcceptAsync(acceptCallOptions);
      call.StateChanged += OnStateChangedAsync;
      call.RemoteParticipantsUpdated += OnRemoteParticipantsUpdatedAsync;
    }
    else if (action == "decline")
    {
      await incomingCall?.RejectAsync();
    }
}