Włączanie powiadomień wypychanych dla wywołań

Tutaj dowiesz się, jak włączyć powiadomienia wypychane dla wywołań usług Azure Communication Services. Skonfiguruj powiadomienia wypychane, aby poinformować użytkowników o tym, kiedy mają połączenie przychodzące, na które mogą odpowiedzieć.

Powiadomienie push

Powiadomienia wypychane umożliwiają wysyłanie informacji z aplikacji do urządzeń użytkowników. Powiadomienia wypychane umożliwiają wyświetlanie okna dialogowego, odtwarzanie dźwięku lub wyświetlanie przychodzącego wywołania do warstwy interfejsu użytkownika aplikacji. Usługi Azure Communication Services zapewniają integrację z usługami Azure Event Grid i Azure Notification Hubs , które umożliwiają dodawanie powiadomień wypychanych do aplikacji.

Token czasu wygaśnięcia

Token Time To Live (TTL) to ustawienie, które określa czas, przez jaki token powiadomienia pozostaje prawidłowy, zanim stanie się nieprawidłowy. To ustawienie jest przydatne w przypadku aplikacji, w których zaangażowanie użytkowników nie wymaga codziennej interakcji, ale pozostaje krytyczne w dłuższych okresach.

Konfiguracja czasu wygaśnięcia umożliwia zarządzanie cyklem życia powiadomień wypychanych, co zmniejsza potrzebę częstego odnawiania tokenu przy jednoczesnym zapewnieniu, że kanał komunikacyjny między aplikacją a jej użytkownikami pozostaje otwarty i niezawodny przez dłuższy czas.

Obecnie maksymalna wartość czasu wygaśnięcia wynosi 180 dni (15 552 000 sekund), a wartość minimalna to 5 minut (300 sekund). Możesz wprowadzić tę wartość i dostosować ją odpowiednio do Twoich potrzeb. Jeśli nie podasz wartości, wartość domyślna to 24 godziny (86 400 sekund).

Po wywołaniu interfejsu API powiadomień wypychanych rejestru podczas zapisywania informacji o tokenie urządzenia w rejestratorze. Po zakończeniu cyklu życia czasu wygaśnięcia informacje o punkcie końcowym urządzenia zostaną usunięte. Nie można dostarczyć żadnych wywołań przychodzących na tych urządzeniach, jeśli te urządzenia nie wywołają ponownie interfejsu API powiadomień wypychanych rejestru.

Jeśli chcesz odwołać tożsamość, musisz wykonać ten proces, po odwołaniu tożsamości wpis Rejestrator powinien zostać usunięty.

Uwaga

W przypadku CTE (punkt końcowy usługi Custom Teams) maksymalna wartość czasu wygaśnięcia wynosi 24 godziny (86 400 sekund) nie ma możliwości zwiększenia tej wartości.

Wymagania wstępne

• Konto platformy Azure z aktywną subskrypcją. Utwórz konto bezpłatnie.
• Wdrożony zasób usług komunikacyjnych. Utwórz zasób usług komunikacyjnych.
• Token dostępu użytkownika umożliwiający włączenie klienta wywołującego. Aby uzyskać więcej informacji, zobacz Tworzenie tokenów dostępu i zarządzanie nimi.
• Opcjonalnie: ukończ przewodnik Szybki start, aby dodać połączenie głosowe do aplikacji

Zestaw SDK połączeń internetowych usług Azure Communication Services — przewodnik Szybki start dotyczący powiadomień wypychanych w Sieci Web

Ważne

Ta funkcja usług Azure Communication Services jest obecnie dostępna w wersji zapoznawczej.

Interfejsy API i zestawy SDK w wersji zapoznawczej są udostępniane bez umowy dotyczącej poziomu usług. Zalecamy, aby nie używać ich w przypadku obciążeń produkcyjnych. Niektóre funkcje mogą nie być obsługiwane lub mogą mieć ograniczone możliwości.

Aby uzyskać więcej informacji, zapoznaj się z dodatkowymi warunkami użytkowania dla wersji zapoznawczych platformy Microsoft Azure.

Zestaw SDK połączeń internetowych usług Azure Communication Services — powiadomienia wypychane w sieci Web są dostępne w publicznej wersji zapoznawczej i są dostępne w wersji 1.12.0-beta.2 lub nowszej.

Odwiedź nasz internetowy samouczek Szybki start dotyczący powiadomień wypychanych: https://github.com/Azure-Samples/communication-services-javascript-quickstarts/blob/main/calling-web-push-notifications/README.md

Ważne

20 czerwca 2023 r. google ogłosiło, że przestarzałe wysyłanie komunikatów przy użyciu starszych interfejsów API usługi FCM. Google usuwa starsze fcM z usługi w czerwcu 2024 roku. Firma Google zaleca migrację ze starszych interfejsów API usługi FCM do protokołu HTTP fcM w wersji 1. Postępuj zgodnie z tym przewodnikiem migracji , jeśli twoje zapewnienie komunikacji nadal korzysta ze starych starszych interfejsów API usługi FCM.

Instalacja zestawu SDK

Znajdź plik build.gradle na poziomie projektu i dodaj mavenCentral() go do listy repozytoriów w obszarze buildscript i allprojects:

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

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

Następnie w pliku build.gradle na poziomie modułu dependencies dodaj następujące wiersze do sekcji:

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

Inicjowanie wymaganych obiektów

Aby utworzyć CallAgent wystąpienie, należy wywołać createCallAgent metodę w wystąpieniu CallClient . To wywołanie asynchroniczne zwraca CallAgent obiekt wystąpienia.

Metoda createCallAgent przyjmuje CommunicationUserCredential jako argument, który hermetyzuje token dostępu.

Aby uzyskać dostęp, DeviceManagernależy najpierw utworzyć callAgent wystąpienie. Następnie możesz użyć metody , aby pobrać metodę CallClient.getDeviceManager 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();

Aby ustawić nazwę wyświetlaną elementu wywołującego, użyj tej alternatywnej metody:

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

Dodatkowe wymagania wstępne dotyczące powiadomień wypychanych

Konto firebase skonfigurowane z włączoną usługą Cloud Messaging (FCM) i usługą Firebase Cloud Messaging połączoną z wystąpieniem usługi Azure Notification Hub. Aby uzyskać więcej informacji, zobacz Powiadomienia usług Komunikacyjnych . Ponadto w samouczku założono, że do kompilowania aplikacji używasz programu Android Studio w wersji 3.6 lub nowszej.

Dla aplikacji systemu Android wymagany jest zestaw uprawnień, aby móc odbierać komunikaty z usługi Firebase Cloud Messaging. AndroidManifest.xml W pliku dodaj następujący zestaw uprawnień bezpośrednio po tagu <manifest ...> </application> lub poniżej.

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

Omówienie

Powiadomienia wypychane na urządzeniach przenośnych to wyskakujące powiadomienia widoczne na urządzeniach przenośnych. W przypadku połączeń skupimy się na powiadomieniach wypychanych VoIP (Voice over Internet Protocol). Zarejestrujemy się w celu otrzymywania powiadomień wypychanych, obsłużymy powiadomienia wypychane, a następnie anulujemy rejestrowanie powiadomień wypychanych.

Uwaga

Aby zarejestrować się w celu otrzymywania powiadomień wypychanych i obsługi powiadomień wypychanych dla niestandardowego punktu końcowego usługi Teams (CTE), interfejs API jest taki sam. Opisane poniżej interfejsy API można również wywołać w CommonCallAgent klasie lub TeamsCallAgent dla niestandardowego punktu końcowego usługi Teams (CTE).

Rejestrowanie w celu otrzymywania powiadomień wypychanych

Aby zarejestrować się w celu otrzymywania powiadomień wypychanych, aplikacja musi wywołać registerPushNotification() CallAgent wystąpienie przy użyciu tokenu rejestracji urządzenia.

Aby uzyskać token rejestracji urządzenia, dodaj zestaw SDK programu Firebase do pliku modułu build.gradle aplikacji, dodając następujące wiersze w dependencies sekcji , jeśli jeszcze nie istnieje:

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

W pliku build.gradle na poziomie projektu dodaj następujący kod w dependencies sekcji , jeśli jeszcze nie istnieje:

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

Dodaj następującą wtyczkę na początku pliku, jeśli jeszcze go nie ma:

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

Wybierz pozycję Synchronizuj teraz na pasku narzędzi. Dodaj następujący fragment kodu, aby pobrać token rejestracji urządzenia wygenerowany przez zestaw SDK usługi Firebase Cloud Messaging dla wystąpienia aplikacji klienckiej, pamiętaj, aby dodać poniższe importy do nagłówka głównego działania dla wystąpienia. Są one wymagane do pobrania tokenu przez fragment kodu:

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;

Dodaj ten fragment kodu, aby pobrać token:

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

Zarejestruj token rejestracji urządzenia za pomocą zestawu SDK usług wywołujących na potrzeby powiadomień wypychanych połączeń przychodzących:

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

Obsługa powiadomień wypychanych

Aby odbierać powiadomienia wypychane połączeń przychodzących, wywołaj metodę handlePushNotification() w wystąpieniu callAgent z ładunkiem.

Aby uzyskać ładunek z usługi Firebase Cloud Messaging, rozpocznij od utworzenia nowej usługi (usługi File > New > Service > ), która rozszerza klasę zestawu FirebaseMessagingService Firebase SDK i przesłania metodę onMessageReceived . Ta metoda jest procedurą obsługi zdarzeń wywoływaną, gdy usługa Firebase Cloud Messaging dostarcza powiadomienie wypychane do aplikacji.

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

Dodaj następującą definicję usługi do AndroidManifest.xml pliku wewnątrz tagu <application> :

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

• Po pobraniu ładunku można przekazać go do zestawu SDK usług komunikacyjnych, który ma zostać przeanalizowany do wewnętrznego obiektu IncomingCallInformation , który będzie obsługiwany przez wywołanie metody handlePushNotification w wystąpieniu callAgent . Wystąpienie CallAgent jest tworzone przez wywołanie createCallAgent(...) metody w CallClient klasie .

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

Gdy obsługa komunikatu powiadomienia wypychanego zakończy się pomyślnie, a wszystkie programy obsługi zdarzeń są prawidłowo zarejestrowane, aplikacja będzie dzwonić.

Wyrejestrowywanie powiadomień wypychanych

Aplikacje mogą wyrejestrować powiadomienia wypychane w dowolnym momencie. Wywołaj metodę wywołania unregisterPushNotification() elementu callAgent, aby wyrejestrować.

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

Konfigurowanie systemu

Tworzenie projektu Xcode

W programie Xcode utwórz nowy projekt systemu iOS i wybierz szablon Aplikacja z jednym widokiem. W tym przewodniku Szybki start jest używana struktura SwiftUI, dlatego należy ustawić wartość Language na Swift i ustawić wartość Interface (Interfejs ) na SwiftUI.

Podczas pracy z tym przewodnikiem Szybki start nie utworzysz testów. Możesz wyczyścić pole wyboru Uwzględnij testy .

Instalowanie pakietu i zależności przy użyciu narzędzia CocoaPods

1. Utwórz plik Podfile dla aplikacji, podobnie jak w tym przykładzie:

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

2. Uruchom program pod install.

3. Otwórz .xcworkspace za pomocą programu Xcode.

Żądanie dostępu do mikrofonu

Aby uzyskać dostęp do mikrofonu urządzenia, należy zaktualizować listę właściwości informacji aplikacji przy użyciu polecenia NSMicrophoneUsageDescription. Skojarzona wartość zostanie ustawiona na ciąg, który zostanie uwzględniony w oknie dialogowym używanym przez system do żądania dostępu od użytkownika.

Kliknij prawym przyciskiem myszy wpis Info.plist drzewa projektu, a następnie wybierz pozycję Otwórz jako>kod źródłowy. Dodaj następujące wiersze w sekcji najwyższego poziomu <dict> , a następnie zapisz plik.

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

Konfigurowanie struktury aplikacji

Otwórz plik ContentView.swift projektu. Dodaj deklarację import na początku pliku, aby zaimportować bibliotekę AzureCommunicationCalling . Ponadto zaimportuj plik AVFoundation. Będą potrzebne żądania uprawnień dźwięku w kodzie.

import AzureCommunicationCalling
import AVFoundation

Inicjowanie klasy CallAgent

Aby utworzyć CallAgent wystąpienie z CallClientklasy , należy użyć callClient.createCallAgent metody, która asynchronicznie zwraca CallAgent obiekt po zainicjowaniu.

Aby utworzyć klienta wywołania, przekaż CommunicationTokenCredential obiekt:

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

CommunicationTokenCredential Przekaż utworzony obiekt do CallClient, a następnie ustaw nazwę wyświetlaną:

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

Omówienie

Powiadomienia wypychane na urządzeniach przenośnych to wyskakujące powiadomienia widoczne na urządzeniach przenośnych. W przypadku połączeń skupimy się na powiadomieniach wypychanych VoIP (Voice over Internet Protocol). Zarejestrujemy się w celu otrzymywania powiadomień wypychanych, obsłużymy powiadomienia wypychane, a następnie anulujemy rejestrowanie powiadomień wypychanych. Aby zapoznać się z przewodnikiem dotyczącym integracji biblioteki CallKit w aplikacji systemu iOS, zapoznaj się z tematem CallKit integration with iOS ACS SDK (Integracja biblioteki CallKit z zestawem SDK acS systemu iOS).

Uwaga

Aby zarejestrować się w celu otrzymywania powiadomień wypychanych i obsługi powiadomień wypychanych dla niestandardowego punktu końcowego usługi Teams (CTE), interfejsy API są takie same. Opisane interfejsy API można również wywołać w klasie lub TeamsCallAgent dla niestandardowego CommonCallAgent punktu końcowego usługi Teams (CTE).

Konfigurowanie powiadomień wypychanych

Powiadomienie push dla urządzeń przenośnych to wyskakujące powiadomienie, które otrzymasz na urządzeniu przenośnym. W celu wywołania skoncentrujemy się na powiadomieniach wypychanych VoIP (głos za pośrednictwem protokołu internetowego).

W poniższych sekcjach opisano sposób rejestrowania, obsługi i wyrejestrowania powiadomień wypychanych. Przed rozpoczęciem tych zadań wykonaj następujące wymagania wstępne:

1. W programie Xcode przejdź do pozycji Podpisywanie i możliwości. Dodaj możliwość, wybierając pozycję + Możliwości, a następnie wybierz pozycję Powiadomienia wypychane.
2. Dodaj kolejną możliwość, wybierając pozycję + Możliwości, a następnie wybierz pozycję Tryby w tle.
3. W obszarze Tryby tła zaznacz pola wyboru Voice over IP i Remote notifications (Głos za pośrednictwem adresu IP i powiadomień zdalnych ).

Rejestrowanie w celu otrzymywania powiadomień wypychanych

Aby zarejestrować się w CallAgent celu otrzymywania powiadomień wypychanych, wywołaj registerPushNotification() wystąpienie przy użyciu tokenu rejestracji urządzenia.

Rejestracja powiadomień wypychanych musi nastąpić po pomyślnym zainicjowaniu. Gdy callAgent obiekt zostanie zniszczony, logout zostanie wywołany, co spowoduje automatyczne wyrejestrowanie powiadomień wypychanych.

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

Obsługa powiadomień wypychanych

Aby odbierać powiadomienia wypychane dla wywołań przychodzących, wywołaj handlePushNotification() CallAgent wystąpienie z ładunkiem słownika.

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

Wyrejestrowywanie powiadomień wypychanych

Aplikacje mogą wyrejestrować powiadomienia wypychane w dowolnym momencie. Wystarczy wywołać metodę unregisterPushNotification w pliku CallAgent.

Uwaga

Aplikacje nie są automatycznie wyrejestrowane z powiadomień wypychanych po wylogowaniu.

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

Konfigurowanie systemu

Tworzenie projektu programu Visual Studio

W przypadku aplikacji platformy UWP w programie Visual Studio 2022 utwórz nowy projekt Pusta aplikacja (uniwersalny system Windows). Po wprowadzeniu nazwy projektu możesz wybrać dowolny zestaw Windows SDK nowszy niż 10.0.17763.0.

W przypadku aplikacji WinUI 3 utwórz nowy projekt z pustą aplikacją, spakowanym szablonem (WinUI 3 w programie Desktop), aby skonfigurować jednostronicową aplikację WinUI 3. Wymagany jest zestaw Windows App SDK w wersji 1.3 lub nowszej.

Instalowanie pakietu i zależności przy użyciu Menedżer pakietów NuGet

Interfejsy API i biblioteki zestawu SDK wywołujących są publicznie dostępne za pośrednictwem pakietu NuGet.

W poniższych krokach przedstawiono sposób znajdowania, pobierania i instalowania pakietu NuGet zestawu SDK wywołującego:

1. Otwórz Menedżer pakietów NuGet, wybierając pozycję Narzędzia>NuGet Menedżer pakietów> Zarządzanie pakietami NuGet dla rozwiązania.
2. Wybierz pozycję Przeglądaj, a następnie wprowadź Azure.Communication.Calling.WindowsClient ciąg w polu wyszukiwania.
3. Upewnij się, że pole wyboru Uwzględnij wersję wstępną jest zaznaczone.
4. Azure.Communication.Calling.WindowsClient Wybierz pakiet, a następnie wybierz Azure.Communication.Calling.WindowsClient wersję 1.4.0-beta.1 lub nowszą.
5. Zaznacz pole wyboru odpowiadające projektowi Usług komunikacyjnych na karcie po prawej stronie.
6. Wybierz przycisk Zainstaluj.

Omówienie

Powiadomienia wypychane na platformie Windows są dostarczane przy użyciu polecenia Windows Push Notification Service (WNS),.

Uwaga

Aby zarejestrować się w celu otrzymywania powiadomień wypychanych i obsługi powiadomień wypychanych dla niestandardowego punktu końcowego usługi Teams (CTE), interfejs API jest taki sam. Opisane poniżej interfejsy API można również wywołać w CommonCallAgent klasie lub TeamsCallAgent dla niestandardowego punktu końcowego usługi Teams (CTE).

Konfigurowanie powiadomień wypychanych

Powiadomienie wypychane to wyskakujące powiadomienie, które otrzymasz na urządzeniu. W celu wywołania skoncentrujemy się na powiadomieniach wypychanych VoIP (głos za pośrednictwem protokołu internetowego).

W poniższych sekcjach opisano sposób rejestrowania, obsługi i wyświetlania powiadomienia systemu Windows w celu odpowiedzi/odrzucenia połączenia przychodzącego. Przed rozpoczęciem tych zadań wykonaj następujące wymagania wstępne:

1. Postępuj zgodnie z samouczkiem: wysyłanie powiadomień do aplikacji platforma uniwersalna systemu Windows przy użyciu usługi Azure Notification Hubs. Po wykonaniu tego samouczka masz następujące elementy:

   • Aplikacja zawierająca WindowsAzure.Messaging.Managed pakiety i Microsoft.Toolkit.Uwp.Notifications .
   • Nazwa centrum powiadomień wypychanych (Push Notifications Hub) o nazwie <AZURE_PNH_HUB_NAME> i parametrach połączenia usługi Azure PNH, do <AZURE_PNH_HUB_CONNECTION_STRING> których odwołuje się w tym przewodniku Szybki start.

2. Aby zarejestrować się w kanale usługi WNS (usługa powiadomień systemu Windows) na każdym init aplikacji, upewnij się, że kod inicjowania został dodany do pliku App.xaml.cs:

// App.xaml.cs

protected override async void OnLaunched(LaunchActivatedEventArgs e)
{
    await InitNotificationsAsync();
    
    ...
}

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

3. Zarejestruj program obsługi zdarzeń aktywowany po nadejściu nowego komunikatu powiadomienia wypychanego na 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;
    }
}

Rejestrowanie w celu otrzymywania powiadomień wypychanych

Aby zarejestrować się w CallAgent celu otrzymywania powiadomień wypychanych, wywołaj RegisterForPushNotificationAsync() wystąpienie za pomocą kanału rejestracji usługi WNS uzyskanego w init aplikacji.

Rejestracja powiadomień wypychanych musi nastąpić po pomyślnym zainicjowaniu.

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

Obsługa powiadomień wypychanych

Aby odbierać powiadomienia wypychane dla wywołań przychodzących, wywołaj handlePushNotification() CallAgent wystąpienie z ładunkiem słownika.

// MainPage.xaml.cs

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

Spowoduje to wyzwolenie zdarzenia połączenia przychodzącego w usłudze CallAgent, które wyświetla przychodzące powiadomienie o wywołaniu.

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

Dodaj kod, aby obsłużyć naciśnięcie przycisku dla powiadomienia w metodzie 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();
    }
}

Następne kroki

• Dowiedz się, jak subskrybować zdarzenia
• Dowiedz się, jak zarządzać wywołaniami
• Dowiedz się, jak zarządzać filmem wideo

Powiązane tematy

• Migrowanie powiadomień wypychanych zestawu ANDROID SDK do usługi FCM w wersji 1
• Rejestrowanie w przypadku powiadomień wypychanych zestawu ANDROID SDK przy użyciu usługi FCM w wersji 1