Activer les notifications Push pour des appels

Article
04/19/2024

Ici, nous allons découvrir comment activer les notifications Push pour les appels Azure Communication Services. La configuration des notifications Push permet aux utilisateurs de savoir quand ils ont un appel entrant, auquel ils peuvent alors répondre.

Notification Push

Les notifications Push vous permettent d’envoyer des informations à partir de votre application vers les appareils des utilisateurs. Vous pouvez utiliser des notifications Push pour afficher une boîte de dialogue, émettre un signal sonore ou afficher des appels entrants dans la couche interface utilisateur de l’application. Azure Communication Services fournit des intégrations avec Azure Event Grid et Azure Notification Hubs qui vous permettent d’ajouter des notifications Push à vos applications.

Jeton TTL

Le jeton de durée de vie (TTL) est un paramètre pour déterminer 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 la gestion du cycle de vie des notifications Push. Ceci réduit la nécessité de renouvellements fréquents de jetons, tout en garantissant que le canal de communication entre l’application et ses utilisateurs reste ouvert et fiable pendant des durées prolongées.

La valeur maximale de TTL est actuellement de 180 jours (15 552 000 secondes) et sa valeur minimale est 5 minutes (300 secondes). Vous pouvez entrer cette valeur et l’ajuster selon 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’enregistrement de notifications Push, lorsque les informations du jeton de l’appareil sont sauvegardées dans le bureau d’enregistrement. À la fin de la durée de vie TTL, 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'enregistrement des notifications push.

Pour révoquer une identité, vous devez suivre ce processus. Une fois l’identité révoquée, l’entrée du bureau d’enregistrement doit être supprimée.

Remarque

Pour un point de terminaison Teams personnalisé (CTE), la valeur maximale de TTL est 24 heures (86 400 secondes).

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 : suivez le guide de démarrage rapide permettant d’ajouter l’appel vocal à votre application.

Kit de développement logiciel (SDK) d’appel web Azure Communication Services : Démarrage rapide des notifications push web

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.

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

Veuillez consulter notre tutoriel de démarrage rapide sur les notifications Push Web : https://github.com/Azure-Samples/communication-services-javascript-quickstarts/blob/main/calling-web-push-notifications/README.md

Important

Le 20 juin 2023, Google a annoncé qu’il dépréciait l’envoi de messages avec les API héritées FCM. Google supprime les API FCM héritées du service en juin 2024. Google recommande la migration des API FCM héritées vers FCM HTTP v1. Suivez ce guide de migration si votre ressource de communication utilise toujours les anciennes API héritées FCM.

Installer le SDK

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

Conditions préalables supplémentaires pour les notifications push

Un compte Firebase sur lequel Cloud Messaging (FCM) est activé et avec votre service Firebase Cloud Messaging connecté à une instance Azure Notification Hub. Pour plus d’informations, consultez Notifications Communication Services. De plus, ce tutoriel suppose que vous utilisez Android Studio version 3.6 ou supérieure pour générer votre application.

Un jeu d’autorisations pour l’application Android est requis pour pouvoir recevoir des messages de notification de la part de Firebase Cloud Messaging. Dans votre fichier AndroidManifest.xml, ajoutez le jeu d’autorisations suivant 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" />

Vue d’ensemble

Remarque

Pour une inscription aux notifications Push et à la gestion des notifications Push pour un point de terminaison Teams personnalisé (CTE), les API sont identiques. L’API décrite ci-dessous peut également être appelée sur la classe CommonCallAgent ou TeamsCallAgent pour le point de terminaison Teams personnalisé (CTE).

Inscription aux notifications Push

Pour vous inscrire aux notifications Push, l’application doit appeler registerPushNotification() sur une instance de CallAgent avec 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 encore :

// 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 de votre niveau de projet, ajoutez l’élément suivant dans la section dependencies s’il n’y figure pas encore.

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 encore :

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

Sélectionnez Synchroniser maintenant dans la barre d’outils. 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 de l’application cliente. Veillez à ajouter les importations ci-dessous à l’en-tête de l’activité principale de l’instance. Celles-ci sont nécessaires pour que l’extrait de code 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 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.")
}

Gestion des notifications Push

Pour recevoir les notifications Push d’appel entrant, appelez handlePushNotification() sur une instance CallAgent avec une charge utile.

Pour obtenir la charge utile depuis Firebase Cloud Messaging, commencez par créer un nouveau Service (Fichier > Nouveau > Service > Service) qui étend la classe du SDK Firebase FirebaseMessagingService et remplacez 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 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>

Une fois la charge utile récupérée, elle peut être transmise au SDK Communication Services afin d’être analysée en un objet IncomingCallInformation qui sera géré en appelant la méthode handlePushNotification sur une instance de CallAgent. Une instance CallAgent est créée 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. Appelez la méthode unregisterPushNotification() sur callAgent pour procéder à la désinscription.

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

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. Ce guide de démarrage rapide utilise l’infrastructure SwiftUI. Vous devez donc définir le langage sur Swift et l’interface sur SwiftUI.

Vous n’allez pas créer de tests au cours de ce guide démarrage rapide. 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. Vous définissez la valeur associée sur une chaîne qui sera incluse dans la boîte de dialogue utilisée par le système pour demander l’accès de 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 aurez 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")
        }
})

Vue d’ensemble

Les notifications Push mobiles sont les notifications contextuelles que vous recevez sur des appareils mobiles. Pour l’appel, nous utilisons des notifications Push VoIP (Voice over Internet Protocol). Nous effectuons l’inscription aux notifications push, nous traitons les notifications push, puis annulons l’inscription aux notifications push. Pour obtenir un guide sur l’intégration de CallKit dans votre application iOS, consultez Intégration de CallKit avec le kit de développement logiciel (SDK) ACS iOS.

Remarque

Pour une inscription aux notifications Push et à la gestion des notifications Push pour un point de terminaison Teams personnalisé (CTE), les API sont identiques. L’API décrite peut également être appelée sur la classe CommonCallAgent ou TeamsCallAgent pour le point de terminaison Teams personnalisé (CTE).

Configurer des notifications Push

Une notification Push mobile est la notification contextuelle que vous recevez sur un appareil mobile. Pour l’appel, nous utilisons des notifications Push VoIP (protocole voix sur IP).

Les sections suivantes expliquent comment s’inscrire à des notifications Push, les gérer et annuler cette inscription. Avant de démarrer ces tâches, effectuez les prérequis suivants :

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 avec 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 les notifications Push relatives aux 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. Appelez simplement 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")
    }
}

Configurer votre système

Créer le projet Visual Studio

Pour une application UWP, 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.

Les étapes suivantes illustrent comment rechercher, télécharger et installer le package NuGet du kit de développement logiciel (SDK) Calling :

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 activée.
Sélectionnez le package Azure.Communication.Calling.WindowsClient, puis Azure.Communication.Calling.WindowsClient1.4.0-beta.1 ou une version plus récente.
Activez la case correspondant au projet Communication Services dans l’onglet de droite.
Sélectionnez le bouton Installer.

Vue d’ensemble

Les notifications Push sur la plateforme Windows sont fournies à l’aide de Windows Push Notification Service (WNS),.

Remarque

Configurer des notifications Push

Une notification Push est une notification contextuelle que vous recevez sur votre appareil. Pour l’appel, nous utilisons des notifications Push VoIP (protocole voix sur IP).

Les sections suivantes décrivent comment s’inscrire, gérer et afficher une notification Windows pour répondre ou refuser un appel entrant. Avant de démarrer ces tâches, effectuez les prérequis suivants :

Suivez le tutoriel : Envoyez des notifications aux applications de la plateforme Windows universelle à l’aide de Microsoft Azure Notification Hubs. Après avoir suivi ce 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 PNH (Hub de notifications Push) référencé en tant que <AZURE_PNH_HUB_NAME> et la chaîne de connexion Azure PNH référencée comme <AZURE_PNH_HUB_CONNECTION_STRING> dans ce guide de démarrage rapide.
Pour vous inscrire à un canal WNS (Service de notification Windows) sur chaque init 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 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, il faut faire appel RegisterForPushNotificationAsync()à unCallAgente instance avec le canal d’enregistrement 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 les notifications Push relatives aux 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);
    }
}

Cela déclenche un événement d’appel entrant sur CallAgent qui affiche la notification d’appel entrante.

// 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 pour 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

Notification Push

Jeton TTL

Prérequis

Installer le SDK

Initialiser les objets nécessaires

Conditions préalables supplémentaires pour les notifications push

Vue d’ensemble

Inscription aux notifications Push

Gestion des notifications Push

Désinscription des notifications Push

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

Vue d’ensemble

Configurer des notifications Push

Inscription aux notifications Push

Gérer les notifications Push

Désinscription des notifications Push

Configurer votre système

Créer le projet Visual Studio

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

Vue d’ensemble

Configurer des notifications Push

Inscription aux notifications Push

Gérer les notifications Push

Étapes suivantes

Commentaires

Commentaires

Ressources supplémentaires

Partager via

Activer les notifications Push pour des appels

Notification Push

Jeton TTL

Prérequis

Installer le SDK

Initialiser les objets nécessaires

Conditions préalables supplémentaires pour les notifications push

Vue d’ensemble

Inscription aux notifications Push

Gestion des notifications Push

Désinscription des notifications Push

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

Vue d’ensemble

Configurer des notifications Push

Inscription aux notifications Push

Gérer les notifications Push

Désinscription des notifications Push

Configurer votre système

Créer le projet Visual Studio

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

Vue d’ensemble

Configurer des notifications Push

Inscription aux notifications Push

Gérer les notifications Push

Étapes suivantes

Rubriques connexes

Commentaires

Commentaires

Ressources supplémentaires