Aktivieren von Pushbenachrichtigungen für Anrufe

Artikel
10/27/2024

Pushbenachrichtigungen übermitteln Informationen von der Anwendung an die Geräte der Benutzer. Sie können Pushbenachrichtigungen verwenden, um ein Dialogfeld anzuzeigen, einen Ton wiederzugeben oder eingehende Anrufe auf der Benutzeroberflächenebene der App anzuzeigen.

In diesem Artikel erfahren Sie, wie Sie Pushbenachrichtigungen für Azure Communication Services-Anrufe aktivieren. Communication Services bietet Integrationen mit Azure Event Grid und Azure Notification Hubs, mit denen Sie Ihren Apps Pushbenachrichtigungen hinzufügen können.

Übersicht über 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. Dadurch wird die Notwendigkeit häufiger Tokenverlängerungen reduziert und gleichzeitig sichergestellt, dass der Kommunikationskanal zwischen der Anwendung und den Benutzern für längere Zeit 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 an Ihre 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 im Registrar gespeichert. Nach dem Ende der TTL-Dauer 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, führen Sie diesen Vorgang aus. Nachdem die Identität widerrufen wurde, sollte der Eintrag beim Registrar gelöscht werden.

Hinweis

Für einen Microsoft Teams-Benutzer beträgt der maximale TTL-Wert 24 Stunden (86.400 Sekunden). Dieser Wert kann nicht erhöht werden. Sie sollten die Anwendung alle 24 Stunden im Hintergrund aktivieren und das Gerätetoken registrieren.

Um die Anwendung zu aktivieren, rufen Sie das neue Token ab und führen die Registrierung durch. Befolgen Sie dazu die Anweisungen für die iOS-Plattform oder die Anweisungen für die Android-Plattform.

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: Schnellstart zum Hinzufügen von Sprachanrufen zu Ihrer Anwendung

Führen Sie den Schnellstart durch.

Webpushbenachrichtigungen über das Web-Calling SDK von Azure Communication Services befinden sich in der öffentlichen Vorschau und sind als Teil der Version 1.12.0-beta.2+ verfügbar.

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.

Ausführliche Anweisungen finden Sie im Schnellstart auf GitHub.

Ein Firebase-Konto mit aktiviertem Firebase Cloud Messaging (FCM) und Ihrem FCM-Dienst, der mit einer Azure Notification Hubs-Instanz verbunden ist Weitere Informationen finden Sie unter Communication Services-Benachrichtigungen.
Android Studio Version 3.6 oder höher, um Ihre Anwendung zu erstellen
Berechtigungen zum Aktivieren des Empfangs von Benachrichtigungen vom FCM durch die Android-Anwendung Fügen Sie in Ihrer Datei AndroidManifest.xml direkt nach <manifest ...> oder unter dem Tag </application> die folgenden Berechtigungen 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" />
```

Wichtig

Am 20. Juni 2023 gab Google bekannt, dass das Senden von Nachrichten mit den FCM-Legacy-APIs veraltet ist und im Juni 2024 mit dem Entfernen des älteren FCM aus dem Dienst beginnt. Google empfiehlt die Migration von Legacy-FCM-APIs zu FCM HTTP v1.

Wenn Ihre Communication Services-Ressource weiterhin die älteren FCM-APIs verwendet, befolgen Sie diesen Migrationsleitfaden.

Überlegungen zu mobilen Pushbenachrichtigungen

Hinweis

Wenn sich die Anwendung für Pushbenachrichtigungen und das Verarbeiten eingehender Pushbenachrichtigungen für Teams-Benutzer registrieren, sind die APIs identisch. Die in diesem Artikel beschriebenen APIs können auch für die Klasse CommonCallAgent oder TeamsCallAgent aufgerufen werden.

Das SDK installieren

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

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

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

Fügen Sie anschließend in der Datei build.gradle auf Modulebene die folgenden Zeilen im 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();

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 ein Geräteregistrierungstoken abzurufen, fügen Sie das Firebase SDK der Datei build.gradle Ihres Anwendungsmoduls hinzu, indem Sie die folgenden Zeilen im Abschnitt dependencies hinzufügen (sofern sie noch nicht vorhanden sind):

// 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 folgende Zeile hinzu, sofern sie noch nicht vorhanden ist:

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

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

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

Wählen Sie auf der Symbolleiste Jetzt synchronisieren aus. Fügen Sie den folgenden Codeschnipsel hinzu, um das Geräteregistrierungstoken abzurufen, das vom Firebase Cloud Messaging SDK für die Clientanwendungsinstanz generiert wird. Achten Sie darauf, dem Header der Hauptaktivität für die Instanz die folgenden Importe hinzuzufügen, um das Token abzurufen.

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

Behandeln 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 (wählen Sie Datei>Neu>Dienst>Dienst aus), der die FirebaseMessagingService-Klasse des Firebase SDK erweitert und die onMessageReceived-Methode überschreibt. 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 the 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>

Nachdem Sie die Nutzdaten abgerufen haben, können Sie sie an das Communication Services SDK übergeben, damit sie in ein internes IncomingCallInformation-Objekt geparst werden. Dieses Objekt behandelt das Aufrufen der handlePushNotification-Methode für eine CallAgent-Instanz. Sie erstellen eine CallAgent-Instanz, indem Sie die createCallAgent(...)-Methode der CallClient-Klasse aufrufen.

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 wurden, löst die Anwendung ein Klingeln aus.

Aufheben der Registrierung der Pushbenachrichtigungen

Anwendungen können die Registrierung der Pushbenachrichtigung jederzeit aufheben. Zum Aufheben der Registrierung, rufen Sie die unregisterPushNotification()-Methode in callAgent auf:

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

Deaktivieren interner Pushbenachrichtigungen für eingehende Anrufe

Es gibt zwei Möglichkeiten, Pushnutzdaten eines eingehenden Anrufs an die angerufene Person zu übermitteln:

Verwenden von FCM und Registrieren des Gerätetokens mit der oben erwähnten API registerPushNotification in CallAgent oder TeamsCallAgent
Registrieren des SDK bei einem internen Dienst beim Erstellen von CallAgent oder TeamsCallAgent, um die bereitgestellten Pushnutzdaten abzurufen

Die Verwendung der setDisableInternalPushForIncomingCall-Eigenschaft in CallAgentOptions oder TeamsCallAgentOptions ermöglicht, das SDK anzuweisen, die Übermittlung der Pushnutzdaten mithilfe des internen Pushdiensts zu deaktivieren:

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

Überlegungen zu mobilen Pushbenachrichtigungen

Mobile Pushbenachrichtigungen sind Popupbenachrichtigungen, die auf mobilen Geräten angezeigt werden. In Bezug auf Anrufe liegt der Schwerpunkt dieses Artikels auf VoIP-Pushbenachrichtigungen (Voice over IP). Einen Leitfaden zur CallKit-Integration in Ihre iOS-Anwendung finden Sie unter Integration von CallKit.

Hinweis

Einrichten des Systems

Führen Sie die unten angegebenen Schritte aus, um Ihr System einzurichten.

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 Artikel wird das SwiftUI-Framework verwendet. Legen Sie daher Sprache auf Swift und Schnittstelle auf SwiftUI fest.

Sie werden in diesem Artikel keine Tests erstellen. 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 den Dialog aufgenommen, mit dem das System den Zugriff beim 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. Sie 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 Objekt vom Typ CommunicationTokenCredential 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")
        }
})

Pushbenachrichtigungen einrichten

Bevor Sie die Aufgaben zum Registrieren, Behandeln und Aufheben der Registrierung von Pushbenachrichtigungen starten, führen Sie die folgende Setupaufgabe aus:

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. Nachdem das callAgent-Objekt 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. Zum Aufheben der Registrierung, rufen Sie die unregisterPushNotification-Methode in CallAgent auf.

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

Deaktivieren interner Pushbenachrichtigungen für eingehende Anrufe

Es gibt zwei Möglichkeiten, Pushnutzdaten eines eingehenden Anrufs an die angerufene Person zu übermitteln:

Verwenden von Apple Push Notification Service (APNS) und Registrieren des Gerätetokens mit der oben erwähnten API registerPushNotification in CallAgent oder TeamsCallAgent
Registrieren des SDK bei einem internen Dienst beim Erstellen von CallAgent oder TeamsCallAgent, um die bereitgestellten Pushnutzdaten abzurufen

Die Verwendung der disableInternalPushForIncomingCall-Eigenschaft in CallAgentOptions oder TeamsCallAgentOptions ermöglicht, das SDK anzuweisen, die Übermittlung der Pushnutzdaten mithilfe des internen Pushdiensts zu deaktivieren:

let options = CallAgentOptions()
options.disableInternalPushForIncomingCall = true

Überlegungen zu Windows-Pushbenachrichtigungen

Pushbenachrichtigungen auf der Windows-Plattform werden über den Windows-Pushbenachrichtigungsdienst (Windows Push Notification Service, WNS) übermittelt.

Hinweis

Zum Registrieren für Pushbenachrichtigungen und Behandeln der Pushbenachrichtigungen für einen benutzerdefinierten Teams-Endpunkt (Custom Teams Endpoint, CTE) sind die APIs identisch. Die in diesem Artikel beschriebenen APIs können auch für die Klasse CommonCallAgent oder TeamsCallAgent für einen benutzerdefinierten Teams-Endpunkt aufgerufen werden.

Einrichten des Systems

Führen Sie die unten angegebenen Schritte aus, um Ihr System einzurichten.

Erstellen des Visual Studio-Projekts

Erstellen Sie für eine UWP-App (Universelle Windows-Plattform) 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.

So können 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 Paket Azure.Communication.Calling.WindowsClient und dann Azure.Communication.Calling.WindowsClient 1.4.0-beta.1 oder eine neuere Version aus.
Aktivieren Sie das Kontrollkästchen für das Azure Communication Services-Projekt im rechten Bereich.
Wählen Sie Installieren aus.

Pushbenachrichtigungen einrichten

Bevor Sie die Aufgaben zum Registrieren, Behandeln und Anzeigen einer Windows-Benachrichtigung starten, um einen eingehenden Anruf anzunehmen oder abzulehnen, führen Sie die folgende Setupaufgabe aus:

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 Folgendes:
- Eine Anwendung mit den Paketen WindowsAzure.Messaging.Managed und Microsoft.Toolkit.Uwp.Notifications.
- Einen Azure Notifications Hub-Hubnamen, auf den mit <AZURE_PNH_HUB_NAME> verwiesen wird, und eine Azure Notifications Hub-Verbindungszeichenfolge, auf die in diesem Artikel mit <AZURE_PNH_HUB_CONNECTION_STRING> verwiesen wird.

Um sich bei jeder Anwendungsinitialisierung für einen WNS-Kanal zu registrieren, müssen Sie in Ihrer Datei App.xaml.cs Initialisierungscode hinzufü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 eingeht:

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

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

Freigeben über

Aktivieren von Pushbenachrichtigungen für Anrufe

Übersicht über TTL-Token

Voraussetzungen

Führen Sie den Schnellstart durch.

Überlegungen zu mobilen Pushbenachrichtigungen

Das SDK installieren

Initialisieren der erforderlichen Objekte

Registrieren für Pushbenachrichtigungen

Behandeln von Pushbenachrichtigungen

Aufheben der Registrierung der Pushbenachrichtigungen

Deaktivieren interner Pushbenachrichtigungen für eingehende Anrufe

Überlegungen zu mobilen 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“

Pushbenachrichtigungen einrichten

Registrieren für Pushbenachrichtigungen

Behandeln von Pushbenachrichtigungen

Aufheben der Registrierung der Pushbenachrichtigungen

Deaktivieren interner Pushbenachrichtigungen für eingehende Anrufe

Überlegungen zu Windows-Pushbenachrichtigungen

Einrichten des Systems

Erstellen des Visual Studio-Projekts

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

Pushbenachrichtigungen einrichten

Registrieren für Pushbenachrichtigungen

Behandeln von Pushbenachrichtigungen

Feedback

Zusätzliche Ressourcen

Freigeben über

Aktivieren von Pushbenachrichtigungen für Anrufe

Übersicht über TTL-Token

Voraussetzungen

Führen Sie den Schnellstart durch.

Überlegungen zu mobilen Pushbenachrichtigungen

Das SDK installieren

Initialisieren der erforderlichen Objekte

Registrieren für Pushbenachrichtigungen

Behandeln von Pushbenachrichtigungen

Aufheben der Registrierung der Pushbenachrichtigungen

Deaktivieren interner Pushbenachrichtigungen für eingehende Anrufe

Überlegungen zu mobilen 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“

Pushbenachrichtigungen einrichten

Registrieren für Pushbenachrichtigungen

Behandeln von Pushbenachrichtigungen

Aufheben der Registrierung der Pushbenachrichtigungen

Deaktivieren interner Pushbenachrichtigungen für eingehende Anrufe

Überlegungen zu Windows-Pushbenachrichtigungen

Einrichten des Systems

Erstellen des Visual Studio-Projekts

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

Pushbenachrichtigungen einrichten

Registrieren für Pushbenachrichtigungen

Behandeln von Pushbenachrichtigungen

Zugehöriger Inhalt

Feedback

Zusätzliche Ressourcen