Activer les notifications Push pour des appels

Article
10/28/2024

Les notifications Push envoient des informations de votre application aux appareils des utilisateurs. Vous pouvez utiliser des notifications Push pour afficher une boîte de dialogue, émettre un son ou afficher des appels entrants dans la couche d’interface utilisateur de l’application.

Dans cet article, vous allez apprendre à activer les notifications Push pour les appels Azure Communication Services. Communication Services fournit des intégrations à Azure Event Grid et Azure Notification Hubs qui vous permettent d’ajouter des notifications Push à vos applications.

Vue d’ensemble des jetons TTL

Le jeton de durée de vie (TTL) est un paramètre qui détermine la durée pendant laquelle un jeton de notification reste valide avant de devenir non valide. Ce paramètre est utile pour les applications dans lesquelles l’engagement utilisateur ne nécessite aucune interaction quotidienne, mais reste critique sur de longues périodes.

La configuration TTL permet de gérer le cycle de vie des notifications Push. Elle réduit la nécessité de renouveler fréquemment les jetons tout en contribuant à garantir que le canal de communication entre l’application et ses utilisateurs reste ouvert et fiable pendant de longues périodes.

La valeur maximale de TTL est actuellement de 180 jours (15 552 000 secondes) et sa valeur minimale est de 5 minutes (300 secondes). Vous pouvez entrer cette valeur et l’ajuster en fonction de vos besoins. Si vous ne fournissez aucune valeur, la valeur par défaut est 24 heures (86 400 secondes).

Après l’appel de l’API d’inscription des notifications Push, les informations du jeton de l’appareil sont enregistrées dans le registrar. À la fin de la durée de vie, les informations du point de terminaison de l’appareil sont supprimées. Tout appel entrant sur ces appareils ne peut pas être transmis aux appareils si ces derniers n’appellent pas à nouveau l’API d’inscription des notifications Push.

Si vous souhaitez révoquer une identité, suivez ce processus. Une fois l’identité révoquée, l’entrée du registrar doit être supprimée.

Remarque

Pour un utilisateur Microsoft Teams, la valeur TTL maximale est de 24 heures (86 400 secondes). Il n'y a aucun moyen d'augmenter cette valeur. Vous devez sortir l’application de veille toutes les 24 heures en arrière-plan et inscrire le jeton de l’appareil.

Pour sortir l’application de veille, récupérer le nouveau jeton et effectuer l’inscription, suivez les instructions pour la plateforme iOS ou celles pour la plateforme Android.

Prérequis

Compte Azure avec un abonnement actif. Créez un compte gratuitement.
Une ressource Communication Services déployée. Créez une ressource Communication Services.
Un jeton d’accès utilisateur pour activer le client appelant. Pour plus d’informations, consultez Créer et gérer des jetons d’accès.
Facultatif : avoir suivi le guide de démarrage rapide permettant d’ajouter l’appel vocal à votre application.

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

Important

Cette fonctionnalité d’Azure Communication Services est actuellement en préversion.

Ces interfaces de programmation d’applications et kits de développement logiciel (SDK) en préversion sont fournis sans contrat au niveau du service. Nous vous recommandons de ne pas les utiliser pour les charges de travail de production. Certaines fonctionnalités peuvent être limitées ou non prises en charge.

Pour plus d’informations, consultez Conditions d’utilisation supplémentaires relatives aux préversions de Microsoft Azure.

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 Communication Services.
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" />
```

Important

Le 20 juin 2023, Google a annoncé que l’envoi de messages à l’aide des API FCM héritées était déconseillé et que la suppression des API héritées FCM du service débuterait en juin 2024. Google recommande la migration des API FCM héritées vers FCM HTTP v1.

Si votre ressource Communication Services utilise toujours les API FCM héritées, suivez ce guide de migration.

Considérations relatives aux notifications Push mobiles

Remarque

Quand l’application s’inscrit aux notifications Push et gère les notifications Push entrantes pour un utilisateur Teams, les API sont les mêmes. Les API décrites dans cet article peuvent également être appelées sur la classe CommonCallAgent ou TeamsCallAgent.

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 auprès du 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 avec 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);

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). Pour obtenir un guide sur l’intégration de CallKit dans votre application iOS, consultez Intégrer à CallKit.

Remarque

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.

Capture d’écran montrant la fenêtre de création d’un projet dans Xcode.

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

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

Exécutez pod install.
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 :

Dans Xcode, accédez à Signing & Capabilities (Signature et fonctionnalités). Ajoutez une fonctionnalité en sélectionnant + Capability (Fonctionnalité), puis Push Notifications (Notifications Push).
Ajoutez une autre fonctionnalité en sélectionnant + Capability, puis Background Modes (Modes d’arrière-plan).
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, appelez 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.

Remarque

Les applications ne sont pas automatiquement désinscrites des notifications Push lors de la déconnexion.

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 avec 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, il est possible de demander au SDK de désactiver la transmission de la charge utile Push via le service Push interne :

let options = CallAgentOptions()
options.disableInternalPushForIncomingCall = true

Considérations relatives aux notifications Push Windows

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

Remarque

Quand l’application s’inscrit aux notifications Push et gère les notifications Push pour un point de terminaison Teams personnalisé (CTE), les API sont les mêmes. Les API décrites dans cet article peuvent également être appelées sur la classe CommonCallAgent ou TeamsCallAgent d’un CTE.

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 Kit de développement logiciel (SDK) Appel sont accessibles au public via un package NuGet.

Pour rechercher, télécharger et installer le package NuGet du SDK d’appel :

Ouvrez le Gestionnaire de package NuGet en sélectionnant Outils>Gestionnaire de package NuGet>Gérer les packages NuGet pour la solution.
Sélectionnez Parcourir, puis entrez Azure.Communication.Calling.WindowsClient dans la zone de recherche.
Vérifiez que la case Inclure la préversion est cochée.
Sélectionnez le package Azure.Communication.Calling.WindowsClient, puis Azure.Communication.Calling.WindowsClient 1.4.0-beta.1 ou une version plus récente.
Cochez la case qui correspond au projet Azure Communication Services dans le volet de droite.
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 :

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.

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

Inscrivez le gestionnaire d’événements qui est 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();
    }
}

Partager via

Activer les notifications Push pour des appels

Vue d’ensemble des jetons TTL

Prérequis

Suivre le guide de démarrage rapide

Considérations relatives aux notifications Push mobiles

Installer le SDK

Initialiser les objets nécessaires

Inscription aux notifications Push

Gérer les notifications Push

Désinscription des notifications Push

Désactiver les notifications Push internes pour un appel entrant

Considérations relatives aux notifications Push mobiles

Configurer votre système

Créer le projet Xcode

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

Demander l’accès au microphone

Configurer le framework d’application

Initialiser CallAgent

Configurer des notifications Push

Inscription aux notifications Push

Gérer les notifications Push

Désinscription des notifications Push

Désactiver les notifications Push internes pour un appel entrant

Considérations relatives aux notifications Push Windows

Configurer votre système

Créer le projet Visual Studio

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

Configurer des notifications Push

Inscription aux notifications Push

Gérer les notifications Push

Commentaires

Ressources supplémentaires

Partager via

Activer les notifications Push pour des appels

Vue d’ensemble des jetons TTL

Prérequis

Suivre le guide de démarrage rapide

Considérations relatives aux notifications Push mobiles

Installer le SDK

Initialiser les objets nécessaires

Inscription aux notifications Push

Gérer les notifications Push

Désinscription des notifications Push

Désactiver les notifications Push internes pour un appel entrant

Considérations relatives aux notifications Push mobiles

Configurer votre système

Créer le projet Xcode

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

Demander l’accès au microphone

Configurer le framework d’application

Initialiser CallAgent

Configurer des notifications Push

Inscription aux notifications Push

Gérer les notifications Push

Désinscription des notifications Push

Désactiver les notifications Push internes pour un appel entrant

Considérations relatives aux notifications Push Windows

Configurer votre système

Créer le projet Visual Studio

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

Configurer des notifications Push

Inscription aux notifications Push

Gérer les notifications Push

Contenu connexe

Commentaires

Ressources supplémentaires