Aktivieren von Pushbenachrichtigungen für Anrufe

Artikel
04/19/2024

Hier erfahren Sie, wie Sie Pushbenachrichtigungen für Azure Communication Services-Anrufe aktivieren. Wenn Sie die Pushbenachrichtigungen einrichten, werden Ihre Benutzer informiert, wenn ein Anruf für sie eingegangen ist, den sie dann beantworten können.

Pushbenachrichtigung

Mithilfe von Pushbenachrichtigungen können Sie Informationen von der Anwendung an die Geräte der Benutzer senden. Sie können Pushbenachrichtigungen verwenden, um ein Dialogfeld anzuzeigen, einen Ton wiederzugeben oder eingehende Anrufe auf der Benutzeroberflächenebene der App anzuzeigen. Azure Communication Services bietet Integrationen in Azure Event Grid und Azure Notification Hubs, mit denen Sie zu Ihren Apps Pushbenachrichtigungen hinzufügen können.

TTL-Token

Das TTL-Token (Time To Live) ist eine Einstellung, die bestimmt, wie lange ein Benachrichtigungstoken gültig bleibt, bevor es ungültig wird. Diese Einstellung ist nützlich für Anwendungen, bei denen die Kundenbindung keine tägliche Interaktion erfordert, aber über längere Zeiträume kritisch bleibt.

Die TTL-Konfiguration ermöglicht die Verwaltung des Lebenszyklus von Pushbenachrichtigungen, wodurch die Notwendigkeit häufiger Tokenverlängerungen reduziert wird und gleichzeitig sichergestellt wird, dass der Kommunikationskanal zwischen der Anwendung und den Benutzern über längere Zeiträume offen und zuverlässig bleibt.

Der maximale TTL-Wert beträgt derzeit 180 Tage (15.552.000 Sekunden) und der Mindestwert ist 5 Minuten (300 Sekunden). Sie können diesen Wert eingeben und entsprechend ihren Anforderungen anpassen. Wenn Sie keinen Wert angeben, wird der Standardwert 24 Stunden (86.400 Sekunden) verwendet.

Nach dem Aufrufen der API zum Registrieren von Pushbenachrichtigungen werden die Gerätetokeninformationen 24 Stunden lang im Registrar gespeichert. Nach Ende der TTL-Lebensdauer werden die Geräteendpunktinformationen gelöscht. Alle eingehenden Anrufe auf diesen Geräten können nicht an die Geräte übermittelt werden, wenn diese Geräte nicht erneut die API zum Registrieren von Pushbenachrichtigungen aufrufen.

Wenn Sie eine Identität widerrufen möchten, müssen Sie diesem Prozess folgen. Der Registrareintrag sollte gelöscht werden, sobald die Identität widerrufen wurde.

Hinweis

Für CTE (Custom Teams Endpoint) beträgt der maximale TTL-Wert 24 Stunden (86.400 Sekunden). Es gibt keine Möglichkeit, diesen Wert zu erhöhen.

Voraussetzungen

Ein Azure-Konto mit einem aktiven Abonnement. Sie können kostenlos ein Konto erstellen.
Eine bereitgestellte Communication Services-Ressource. Erstellen Sie eine Communication Services-Ressource.
Ein Benutzerzugriffstoken zum Aktivieren des Anrufclients. Weitere Informationen finden Sie unter Erstellen und Verwalten von Zugriffstoken.
Optional: Arbeiten Sie den Schnellstart zum Hinzufügen von Sprachanrufen zu Ihrer Anwendung durch.

Azure Communication Services Web-Anruf-SDK – Schnellstart für Web-Pushbenachrichtigungen

Wichtig

Dieses Feature von Azure Communication Services befindet sich derzeit in der Vorschau.

Vorschau-APIs und -SDKs werden ohne Vereinbarung zum Servicelevel bereitgestellt. Es wird empfohlen, diese nicht für Produktionsworkloads zu verwenden. Einige Features werden möglicherweise nicht unterstützt oder bieten nur eingeschränkte Funktionalität.

Weitere Informationen finden Sie in den ergänzenden Nutzungsbestimmungen für Microsoft Azure-Vorschauversionen.

Azure Communication Services Web-Calling SDK – Web-Pushbenachrichtigungen ist in der öffentlichen Vorschau und als Teil der Version 1.12.0-beta.2+ verfügbar.

Besuchen Sie unser Schnellstart-Tutorial für Web-Push-Benachrichtigungen:https://github.com/Azure-Samples/communication-services-javascript-quickstarts/blob/main/calling-web-push-notifications/README.md

Das SDK installieren

Wählen Sie Ihre Datei build.gradle auf Projektebene aus, und fügen Sie mavenCentral() zur Liste der Repositorys unter buildscript und allprojects hinzu:

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

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

Fügen Sie dann in der Datei build.gradle auf Modulebene die folgenden Zeilen zum Abschnitt dependencies hinzu:

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

Initialisieren der erforderlichen Objekte

Zum Erstellen einer CallAgent-Instanz müssen Sie die createCallAgent-Methode für eine CallClient-Instanz aufrufen. Dieser Aufruf gibt asynchron ein CallAgent-Instanzobjekt zurück.

Die createCallAgent-Methode verwendet CommunicationUserCredential als Argument, womit ein Zugriffstoken gekapselt wird.

Um auf DeviceManager zuzugreifen, müssen Sie zuerst eine callAgent-Instanz erstellen. Anschließend können Sie die CallClient.getDeviceManager-Methode zum Abrufen von DeviceManager verwenden.

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

Zum Festlegen eines Anzeigenamens für den Anrufer verwenden Sie diese alternative Methode:

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

Zusätzliche Voraussetzungen für Pushbenachrichtigungen

Ein Firebase-Konto, das mit aktiviertem Cloud Messaging (FCM) eingerichtet wurde und bei dem Ihr Firebase Cloud Messaging-Dienst mit einer Azure Notification Hub-Instanz verbunden ist. Weitere Informationen finden Sie unter Communication Services-Benachrichtigungen. Außerdem geht das Tutorial davon aus, dass Sie zur Entwicklung Ihrer Anwendung mindestens die Android Studio-Version 3.6 einsetzen.

Für die Android-Anwendung sind eine Reihe von Berechtigungen erforderlich, um Benachrichtigungen von Firebase Cloud Messaging empfangen zu können. Fügen Sie in Ihrer Datei AndroidManifest.xml direkt nach <manifest ...> oder unter dem Tag </application> den folgenden Berechtigungssatz hinzu.

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

Überblick

Mobile Pushbenachrichtigungen sind die Popupbenachrichtigungen, die auf mobilen Geräten angezeigt werden. Bei Anruffunktionen konzentrieren wir uns auf VoIP-Pushbenachrichtigungen (Voice over Internet Protocol). Wir werden uns für Pushbenachrichtigungen registrieren, Pushbenachrichtigungen bearbeiten und dann die Registrierung von Pushbenachrichtigungen aufheben.

Hinweis

Zum Registrieren für Pushbenachrichtigungen und die Behandlung der Pushbenachrichtigungen für einen benutzerdefinierten Teams-Endpunkt (Custom Teams Endpoint, CTE) sind die APIs identisch. Die unten beschriebene APIs können auch für die -CommonCallAgent oder TeamsCallAgent- Klasse für benutzerdefinierte Teams-Endpunkte (CTE) aufgerufen werden.

Registrieren für Pushbenachrichtigungen

Um sich für Pushbenachrichtigungen zu registrieren, muss die Anwendung registerPushNotification() für eine CallAgent-Instanz mit einem Geräteregistrierungstoken aufrufen.

Um das Geräteregistrierungstoken zu erhalten, fügen Sie das Firebase SDK zur Datei build.gradle Ihres Anwendungsmoduls hinzu, indem Sie die folgenden Zeilen im Abschnitt dependencies hinzufügen (sofern noch nicht vorhanden):

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

Fügen Sie in der Datei build.gradle auf Projektebene im Abschnitt dependencies Folgendes hinzu, sofern noch nicht vorhanden:

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

Fügen Sie das folgende Plug-In am Anfang der Datei hinzu, sofern noch nicht vorhanden:

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

Wählen Sie auf der Symbolleiste Jetzt synchronisieren aus. Fügen Sie den folgenden Codeausschnitt hinzu, um das Geräteregistrierungstoken abzurufen, das vom Firebase Cloud Messaging SDK für die Clientanwendungsinstanz generiert wird. Achten Sie darauf, dass Sie die unten aufgeführten Importe zum Header der Hauptaktivität für die Instanz hinzufügen. Sie sind erforderlich, damit der Ausschnitt das Token abruft.

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;

Fügen Sie diesen Ausschnitt hinzu, um das Token abzurufen:

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

Registrieren Sie das Geräteregistrierungstoken beim Calling Services SDK für Pushbenachrichtigungen zu eingehenden Anrufen:

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

Behandlung von Pushbenachrichtigungen

Um Pushbenachrichtigungen für eingehende Anrufe zu empfangen, rufen Sie handlePushNotification() für eine CallAgent-Instanz mit Nutzdaten auf.

Um die Nutzdaten von Firebase Cloud Messaging abzurufen, erstellen Sie zunächst einen neuen Dienst („Datei“ > > „Neu“ > > „Dienst“ > > „Dienst“), der das Firebase SDK FirebaseMessagingService erweitert, und überschreiben Sie dann die onMessageReceived Methode. Diese Methode ist der Ereignishandler, der aufgerufen wird, wenn Firebase Cloud Messaging die Pushbenachrichtigung an die Anwendung übermittelt.

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

Fügen Sie der Datei AndroidManifest.xml im Tag <application> die unten angegebene Dienstdefinition hinzu:

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

Sobald die Nutzdaten abgerufen wurden, können sie an das Communication Services SDK übergeben werden, um sie in ein internes Objekt vom Typ IncomingCallInformation zu analysieren, das durch Aufrufen der Methode handlePushNotification für eine Instanz von CallAgent behandelt wird. Eine CallAgent-Instanz wird durch den Aufruf der Methode createCallAgent(...) für die Klasse CallClient erstellt.

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

Wenn die Verarbeitung der Pushbenachrichtigung erfolgreich ist und alle Ereignishandler ordnungsgemäß registriert sind, löst die Anwendung ein Klingeln aus.

Aufheben der Registrierung der Pushbenachrichtigungen

Anwendungen können die Registrierung der Pushbenachrichtigung jederzeit aufheben. Rufen Sie die Methode unregisterPushNotification() für callAgent auf, um die Registrierung aufzuheben.

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

Einrichten des Systems

Erstellen des Xcode-Projekts

Erstellen Sie in Xcode ein neues iOS-Projekt, und wählen Sie die Vorlage Single View App (Einzelansicht-App) aus. In diesem Schnellstart wird das SwiftUI-Framework verwendet. Legen Sie daher Sprache auf Swift und Schnittstelle auf SwiftUI fest.

Im Rahmen dieser Schnellstartanleitung werden keine Tests erstellt. Sie können das Kontrollkästchen Tests einschließen deaktivieren.

Screenshot: Fenster zum Erstellen eines Projekts in Xcode

Installieren des Pakets und der Abhängigkeiten mithilfe von CocoaPods

Erstellen Sie eine Podfile-Datei für die Anwendung, wie in diesem Beispiel:

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

Führen Sie pod install aus.
Öffnen Sie .xcworkspace mithilfe von Xcode.

Anfordern des Zugriffs auf das Mikrofon

Um auf das Mikrofon des Geräts zuzugreifen, müssen Sie die Liste der Informationseigenschaften Ihrer App mithilfe von NSMicrophoneUsageDescription aktualisieren. Legen Sie den zugehörigen Wert auf eine Zeichenfolge fest. Diese wird in das Dialogfeld eingeschlossen, mit dem das System Zugriff vom Benutzer anfordert.

Klicken Sie mit der rechten Maustaste auf den Eintrag info.plist in der Projektstruktur, und wählen Sie dann Öffnen als>Quellcode aus. Fügen Sie im Abschnitt <dict> der obersten Ebene die folgenden Zeilen hinzu, und speichern Sie dann die Datei.

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

Einrichten des App-Frameworks

Öffnen Sie die Datei ContentView.swift Ihres Projekts. Fügen Sie am Anfang der Datei eine import-Deklaration hinzu, um die AzureCommunicationCalling-Bibliothek zu importieren. Importieren Sie außerdem AVFoundation. Dies ist für Audioberechtigungsanforderungen im Code erforderlich.

import AzureCommunicationCalling
import AVFoundation

Initialisieren von „CallAgent“

Um eine CallAgent-Instanz auf der Grundlage von CallClient zu erstellen, müssen Sie eine Methode vom Typ callClient.createCallAgent verwenden, die asynchron ein Objekt vom Typ CallAgent zurückgibt, nachdem es initialisiert wurde.

Übergeben Sie für die Erstellung eines Anrufclients ein Objekt vom Typ 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)
}

Übergeben Sie das von Ihnen erstellte CommunicationTokenCredential-Objekt an CallClient, und legen Sie den Anzeigenamen fest:

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

Übersicht

Hinweis

Zum Registrieren für Pushbenachrichtigungen und die Behandlung der Pushbenachrichtigungen für einen benutzerdefinierten Teams-Endpunkt (Custom Teams Endpoint, CTE) sind die APIs identisch. Die beschriebene APIs können auch für die -CommonCallAgent oder TeamsCallAgent- Klasse für benutzerdefinierte Teams-Endpunkte (CTE) aufgerufen werden.

Pushbenachrichtigungen einrichten

Eine mobile Pushbenachrichtigung ist die Popupbenachrichtigung, die Sie auf dem mobilen Gerät erhalten. Bei Anrufen konzentrieren wir uns auf VoIP-Pushbenachrichtigungen (Voice over Internet Protocol).

In den folgenden Abschnitten erfahren Sie, wie Sie sich für Pushbenachrichtigungen registrieren, sie behandeln und die Registrierung für sie aufheben. Bevor Sie mit diesen Aufgaben beginnen, sind jedoch folgende Schritte erforderlich:

Navigieren Sie in Xcode zur Registerkarte Signing & Capabilities (Signieren und Funktionen). Fügen Sie eine Funktion hinzu, indem Sie + Capability (+ Funktion) und anschließend Push Notifications (Pushbenachrichtigungen) auswählen.
Fügen Sie eine weitere Funktion hinzu, indem Sie + Capability (+ Funktion) und anschließend Background Modes (Hintergrundmodi) auswählen.
Aktivieren Sie unter Background Modes (Hintergrundmodi) die Kontrollkästchen Voice over IP und Remote notifications (Remotebenachrichtigungen) aus.

Registrieren für Pushbenachrichtigungen

Rufen Sie zum Registrieren für Pushbenachrichtigungen registerPushNotification() für eine CallAgent-Instanz mit einem Geräteregistrierungstoken auf.

Die Registrierung für Pushbenachrichtigungen muss nach erfolgreicher Initialisierung erfolgen. Wenn das Objekt callAgent zerstört wurde, wird logout aufgerufen, wodurch die Registrierung von Pushbenachrichtigungen automatisch aufgehoben wird.

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

Behandeln von Pushbenachrichtigungen

Rufen Sie handlePushNotification() für eine CallAgent-Instanz mit Wörterbuchnutzdaten auf, um Pushbenachrichtigungen für eingehende Anrufe zu erhalten.

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

Aufheben der Registrierung der Pushbenachrichtigungen

Anwendungen können die Registrierung der Pushbenachrichtigung jederzeit aufheben. Rufen Sie einfach die unregisterPushNotification-Methode auf CallAgent.

Hinweis

Die Registrierung von Anwendungen für Pushbenachrichtigungen wird bei der Abmeldung nicht automatisch aufgehoben.

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

Einrichten des Systems

Erstellen des Visual Studio-Projekts

Erstellen Sie für eine UWP-App in Visual Studio 2022 ein neues Projekt vom Typ Leere App (universelles Windows). Nachdem Sie den Projektnamen eingegeben haben, können Sie ein beliebiges Windows SDK höher als Version 10.0.17763.0 auswählen.

Für eine WinUI 3-App erstellen Sie ein neues Projekt mit der Vorlage Leere App, Gepackt (WinUI 3 in Desktop), um eine WinUI 3-Single-Page-Webanwendung einzurichten. Windows-App SDK-Version 1.3 oder höher ist erforderlich.

Installieren Sie das Paket und die Abhängigkeiten mit dem NuGet-Paket-Manager

Die Calling SDK-APIs und -Bibliotheken sind über ein NuGet-Paket öffentlich verfügbar.

In den folgenden Schritten wird veranschaulicht, wie Sie das NuGet-Paket für das Calling SDK suchen, herunterladen und installieren:

Öffnen Sie den NuGet-Paket-Manager, indem Sie Tools>NuGet-Paket-Manager>NuGet-Pakete für Lösung verwalten auswählen.
Wählen Sie Durchsuchen aus, und geben Sie dann Azure.Communication.Calling.WindowsClient in das Suchfeld ein.
Stellen Sie sicher, dass das Kontrollkästchen Vorabversion einbeziehen aktiviert ist.
Wählen Sie das Azure.Communication.Calling.WindowsClient-Paket und dann Azure.Communication.Calling.WindowsClient1.4.0-beta.1 oder eine neuere Version aus.
Aktivieren Sie das Kontrollkästchen, das dem Communication Services-Projekt auf der rechten Registerkarte entspricht.
Wählen Sie die Schaltfläche Installieren aus.

Übersicht

Pushbenachrichtigungen auf der Windows-Plattform werden mithilfe von Windows Push Notification Service (WNS), übermittelt.

Hinweis

Pushbenachrichtigungen einrichten

Eine Pushbenachrichtigung ist die Popupbenachrichtigung, die Sie auf Ihrem Gerät erhalten. Bei Anrufen konzentrieren wir uns auf VoIP-Pushbenachrichtigungen (Voice over Internet Protocol).

In den folgenden Abschnitten wird beschrieben, wie Sie eine Windows-Benachrichtigung registrieren, behandeln und anzeigen, um einen eingehenden Anruf anzunehmen/abzulehnen. Bevor Sie mit diesen Aufgaben beginnen, sind jedoch folgende Schritte erforderlich:

Führen Sie Tutorial: Senden von Benachrichtigungen an Apps für die universelle Windows-Plattform mit Azure Notification Hubs aus. Nach Abschluss dieses Tutorials verfügen Sie über:
- Eine Anwendung mit den Paketen WindowsAzure.Messaging.Managed und Microsoft.Toolkit.Uwp.Notifications.
- Einen Azure PNH-Namen (Push Notifications Hub), der als <AZURE_PNH_HUB_NAME> referenziert wird, und die Azure PNH-Verbindungszeichenfolge, die in diesem Schnellstart als <AZURE_PNH_HUB_CONNECTION_STRING> referenziert wird.
Um sich bei jedem Anwendungsstart für einen WNS-Kanal (Windows Notification Service) zu registrieren, müssen Sie den Initialisierungscode in die Datei „App.xaml.cs“ einfügen:

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

Registrieren Sie den Ereignishandler, der aktiviert wird, wenn eine neue Pushbenachrichtigung in „App.xaml.cs“ eintrifft:

// 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;
    }
}

Registrieren für Pushbenachrichtigungen

Um sich für Pushbenachrichtigungen zu registrieren, rufen Sie RegisterForPushNotificationAsync() in einer CallAgent-Instanz mit dem bei der Anwendungsinitialisierung bezogenen WNS-Registrierungskanal auf.

Die Registrierung für Pushbenachrichtigungen muss nach erfolgreicher Initialisierung erfolgen.

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

Behandeln von Pushbenachrichtigungen

Rufen Sie handlePushNotification() für eine CallAgent-Instanz mit Wörterbuchnutzdaten auf, um Pushbenachrichtigungen für eingehende Anrufe zu erhalten.

// MainPage.xaml.cs

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

Dadurch wird ein Ereignis für eingehende Anrufe in CallAgent ausgelöst, das die Benachrichtigung über eingehende Anrufe anzeigt.

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

Fügen Sie den Code hinzu, um den Tastendruck für die Benachrichtigung in der OnActivated-Methode zu verarbeiten:

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

Share via

Aktivieren von Pushbenachrichtigungen für Anrufe

Pushbenachrichtigung

TTL-Token

Voraussetzungen

Das SDK installieren

Initialisieren der erforderlichen Objekte

Zusätzliche Voraussetzungen für Pushbenachrichtigungen

Überblick

Registrieren für Pushbenachrichtigungen

Behandlung von Pushbenachrichtigungen

Aufheben der Registrierung der Pushbenachrichtigungen

Einrichten des Systems

Erstellen des Xcode-Projekts

Installieren des Pakets und der Abhängigkeiten mithilfe von CocoaPods

Anfordern des Zugriffs auf das Mikrofon

Einrichten des App-Frameworks

Initialisieren von „CallAgent“

Übersicht

Pushbenachrichtigungen einrichten

Registrieren für Pushbenachrichtigungen

Behandeln von Pushbenachrichtigungen

Aufheben der Registrierung der Pushbenachrichtigungen

Einrichten des Systems

Erstellen des Visual Studio-Projekts

Installieren Sie das Paket und die Abhängigkeiten mit dem NuGet-Paket-Manager

Übersicht

Pushbenachrichtigungen einrichten

Registrieren für Pushbenachrichtigungen

Behandeln von Pushbenachrichtigungen

Nächste Schritte

Zusätzliche Ressourcen