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

Artykuł
10/23/2024

Powiadomienia wypychane wysyłają informacje 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.

Z tego artykułu dowiesz się, jak włączyć powiadomienia wypychane dla wywołań usług Azure Communication Services. Usługi Communication Services zapewniają integrację z usługami Azure Event Grid i Azure Notification Hubs , które umożliwiają dodawanie powiadomień wypychanych do aplikacji.

Omówienie tokenów czasu wygaśnięcia

Token czasu wygaśnięcia (TTL) to ustawienie, które określa czas, przez jaki token powiadomień 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. Zmniejsza to potrzebę częstego odnawiania tokenów, a jednocześnie pomaga zapewnić, że kanał komunikacyjny między aplikacją a jej użytkownikami pozostaje otwarty i niezawodny przez dłuższy czas.

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

Po wywołaniu interfejsu API rejestrowania powiadomień wypychanych informacje o tokenie urządzenia są zapisywane w rejestratorze. Po zakończeniu 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 rejestrowania powiadomień wypychanych.

Jeśli chcesz odwołać tożsamość, wykonaj ten proces. Po odwołaniu tożsamości wpis rejestratora powinien zostać usunięty.

Uwaga

W przypadku użytkownika usługi Microsoft Teams maksymalna wartość czasu wygaśnięcia to 24 godz. (86 400 sekund). Nie ma możliwości zwiększenia tej wartości. Aplikacja powinna zostać wznawiana co 24 godziny w tle i zarejestrować token urządzenia.

Aby obudzić aplikację, pobierz nowy token i wykonaj rejestrację, postępuj zgodnie z instrukcjami dotyczącymi platformy iOS lub instrukcjami dotyczącymi platformy Android.

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ńczenie przewodnika Szybki start w celu dodania połączeń głosowych do aplikacji.

Postępuj zgodnie z przewodnikiem Szybki start

Powiadomienia wypychane w Internecie za pośrednictwem zestawu SDK połączeń internetowych usług Azure Communication Services są dostępne w wersji zapoznawczej i są dostępne w wersji 1.12.0-beta.2 lub nowszej.

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.

Aby uzyskać instrukcje krok po kroku, zobacz przewodnik Szybki start w witrynie GitHub.

Konto firebase z włączoną usługą Firebase Cloud Messaging (FCM) i usługą FCM połączoną z wystąpieniem usługi Azure Notification Hubs. Aby uzyskać więcej informacji, zobacz Powiadomienia usług komunikacyjnych.
Program Android Studio w wersji 3.6 lub nowszej w celu skompilowania aplikacji.
Zestaw uprawnień umożliwiających aplikacji systemu Android odbieranie komunikatów powiadomień z usługi FCM. AndroidManifest.xml W pliku dodaj następujące uprawnienia bezpośrednio po <manifest ...> lub poniżej tagu</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" />
```

Ważne

20 czerwca 2023 r. firma Google ogłosiła, że w czerwcu 2024 r. wycofała wysyłanie komunikatów przy użyciu starszych interfejsów API usługi FCM i rozpocznie usuwanie starszej wersji usługi FCM. Firma Google zaleca migrację ze starszych interfejsów API usługi FCM do protokołu HTTP fcM w wersji 1.

Jeśli zasób usługi Communication Services nadal korzysta ze starszych interfejsów API usługi FCM, postępuj zgodnie z tym przewodnikiem migracji.

Zagadnienia dotyczące powiadomień wypychanych na urządzeniach przenośnych

Uwaga

Gdy aplikacja rejestruje się w celu otrzymywania powiadomień wypychanych i obsługuje przychodzące powiadomienia wypychane dla użytkownika usługi Teams, interfejsy API są takie same. Interfejsy API opisane w tym artykule mogą być również wywoływane w CommonCallAgent klasie lub TeamsCallAgent .

Instalacja zestawu SDK

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

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

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

Następnie w pliku na poziomie build.gradle 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();

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 wiersze jeszcze nie istnieją):

// 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 na poziomie build.gradle projektu dodaj następujący wiersz w dependencies sekcji , jeśli jeszcze go nie ma:

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'

Na pasku narzędzi wybierz pozycję Synchronizuj teraz. Dodaj następujący fragment kodu, aby uzyskać token rejestracji urządzenia wygenerowany przez zestaw SDK usługi Firebase Cloud Messaging dla wystąpienia aplikacji klienckiej. Pamiętaj, aby dodać następujące importy do nagłówka głównego działania dla wystąpienia w celu pobrania tokenu.

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 the 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 handlePushNotification() CallAgent wystąpienie z ładunkiem.

Aby uzyskać ładunek z usługi Firebase Cloud Messaging, zacznij od utworzenia nowej usługi (wybierz pozycję File>New>Service Service>), która rozszerza FirebaseMessagingService klasę zestawu FIREbase SDK i zastępuje metodę .onMessageReceived Ta metoda to procedura obsługi zdarzeń wywoływana, 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 the 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 obiektu wewnętrznego IncomingCallInformation . Ten obiekt obsługuje wywoływanie handlePushNotification metody w wystąpieniu CallAgent . Wystąpienie można utworzyć CallAgent , wywołując metodę createCallAgent(...) 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, pierścienie aplikacji.

Wyrejestrowywanie powiadomień wypychanych

Aplikacje mogą wyrejestrować powiadomienia wypychane w dowolnym momencie. Aby wyrejestrować metodę , wywołaj metodę unregisterPushNotification() w pliku callAgent:

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

Wyłączanie wewnętrznych powiadomień wypychanych dla połączenia przychodzącego

Ładunek wypychania wywołania przychodzącego można dostarczyć do wywołania na dwa sposoby:

Używanie usługi FCM i rejestrowanie tokenu urządzenia przy użyciu wymienionego wcześniej interfejsu API lub registerPushNotification CallAgentTeamsCallAgent
Rejestrowanie zestawu SDK za pomocą usługi wewnętrznej podczas tworzenia lub TeamsCallAgent pobierania ładunku CallAgent wypychanego

Za pomocą właściwości setDisableInternalPushForIncomingCall w CallAgentOptions systemie lub TeamsCallAgentOptionsmożna poinstruować zestaw SDK, aby wyłączyć dostarczanie ładunku wypychania za pośrednictwem wewnętrznej usługi wypychania:

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

Zagadnienia dotyczące powiadomień wypychanych na urządzeniach przenośnych

Powiadomienia wypychane na urządzeniach przenośnych to wyskakujące powiadomienia wyświetlane na urządzeniach przenośnych. W celu wywołania ten artykuł koncentruje się na powiadomieniach wypychanych za pośrednictwem protokołu Internet Protocol (VoIP). Aby zapoznać się z przewodnikiem dotyczącym integracji biblioteki CallKit w aplikacji systemu iOS, zobacz Integracja z zestawem CallKit.

Uwaga

Konfigurowanie systemu

Wykonaj następujące kroki, aby skonfigurować system.

Tworzenie projektu Xcode

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

Nie zamierzasz tworzyć testów w tym artykule. Możesz wyczyścić pole wyboru Uwzględnij testy .

Zrzut ekranu przedstawiający okno tworzenia projektu w programie Xcode.

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

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

Uruchom program pod install.
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. Ustaw skojarzona wartość na ciąg zawarty 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 projektu ContentView.swift . Dodaj deklarację import na początku pliku, aby zaimportować bibliotekę AzureCommunicationCalling . Ponadto zaimportuj plik AVFoundation. Potrzebne są żą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")
        }
})

Konfigurowanie powiadomień wypychanych

Przed rozpoczęciem zadań rejestrowania, obsługi i wyrejestrowania powiadomień wypychanych wykonaj następujące zadanie konfiguracji:

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.
Dodaj kolejną możliwość, wybierając pozycję + Możliwości, a następnie wybierz pozycję Tryby w tle.
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 jest wywoływany, co powoduje automatyczne wyrejestrowywanie 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 połączeń 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. Aby wyrejestrować, wywołaj 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")
    }
}

Wyłączanie wewnętrznych powiadomień wypychanych dla połączenia przychodzącego

Ładunek wypychania wywołania przychodzącego można dostarczyć do wywołania na dwa sposoby:

Korzystanie z usługi Apple Push Notification Service (APNS) i rejestrowanie tokenu urządzenia przy użyciu interfejsu API wymienionego wcześniej lub registerPushNotification CallAgentTeamsCallAgent
Rejestrowanie zestawu SDK za pomocą usługi wewnętrznej podczas tworzenia lub TeamsCallAgent pobierania ładunku CallAgent wypychanego

Za pomocą właściwości disableInternalPushForIncomingCall w CallAgentOptions systemie lub TeamsCallAgentOptionsmożna poinstruować zestaw SDK, aby wyłączyć dostarczanie ładunku wypychania za pośrednictwem wewnętrznej usługi wypychania:

let options = CallAgentOptions()
options.disableInternalPushForIncomingCall = true

Zagadnienia dotyczące powiadomień wypychanych systemu Windows

Powiadomienia wypychane na platformie Windows są dostarczane za pośrednictwem usługi powiadomień wypychanych systemu Windows (WNS).

Uwaga

Gdy aplikacja rejestruje się na potrzeby powiadomień wypychanych i obsługuje powiadomienia wypychane dla niestandardowego punktu końcowego usługi Teams (CTE), interfejsy API są takie same. Interfejsy API opisane w tym artykule mogą być również wywoływane w CommonCallAgent klasie lub TeamsCallAgent dla CTE.

Konfigurowanie systemu

Wykonaj następujące kroki, aby skonfigurować system.

Tworzenie projektu programu Visual Studio

W przypadku aplikacji platforma uniwersalna systemu Windows 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.

Aby znaleźć, pobrać i zainstalować pakiet NuGet zestawu SDK wywołującego:

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

Konfigurowanie powiadomień wypychanych

Przed rozpoczęciem zadań rejestrowania, obsługi i wyświetlania powiadomienia systemu Windows w celu udzielenia odpowiedzi lub odrzucenia połączenia przychodzącego wykonaj następujące zadanie konfiguracji:

Postępuj zgodnie z samouczkiem: wysyłanie powiadomień do aplikacji platforma uniwersalna systemu Windows przy użyciu usługi Azure Notification Hubs. Po wykonaniu czynności z samouczka masz następujące elementy:
- Aplikacja zawierająca WindowsAzure.Messaging.Managed pakiety i Microsoft.Toolkit.Uwp.Notifications .
- Nazwa centrum Usługi Azure Notifications Hub, do których odwołuje się <AZURE_PNH_HUB_NAME> usługa Azure Notifications Hub, oraz parametry połączenia, do <AZURE_PNH_HUB_CONNECTION_STRING> których odwołuje się ten artykuł.

Aby zarejestrować się w kanale usługi WNS w każdej inicjalizacji aplikacji, pamiętaj, aby dodać kod inicjowania w App.xaml.cs pliku:

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

Zarejestruj procedurę obsługi zdarzeń, która jest aktywowana po nadejściu nowego komunikatu powiadomienia wypychanego w dniu 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 podczas inicjowania 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 połączeń 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);
    }
}

To wywołanie wyzwala zdarzenie połączenia przychodzącego, w CallAgent ramach którego jest wyświetlane powiadomienie o wywołaniu przychodzącym:

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

Udostępnij za pośrednictwem

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

Omówienie tokenów czasu wygaśnięcia

Wymagania wstępne

Postępuj zgodnie z przewodnikiem Szybki start

Zagadnienia dotyczące powiadomień wypychanych na urządzeniach przenośnych

Instalacja zestawu SDK

Inicjowanie wymaganych obiektów

Rejestrowanie w celu otrzymywania powiadomień wypychanych

Obsługa powiadomień wypychanych

Wyrejestrowywanie powiadomień wypychanych

Wyłączanie wewnętrznych powiadomień wypychanych dla połączenia przychodzącego

Zagadnienia dotyczące powiadomień wypychanych na urządzeniach przenośnych

Konfigurowanie systemu

Tworzenie projektu Xcode

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

Żądanie dostępu do mikrofonu

Konfigurowanie struktury aplikacji

Inicjowanie klasy CallAgent

Konfigurowanie powiadomień wypychanych

Rejestrowanie w celu otrzymywania powiadomień wypychanych

Obsługa powiadomień wypychanych

Wyrejestrowywanie powiadomień wypychanych

Wyłączanie wewnętrznych powiadomień wypychanych dla połączenia przychodzącego

Zagadnienia dotyczące powiadomień wypychanych systemu Windows

Konfigurowanie systemu

Tworzenie projektu programu Visual Studio

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

Konfigurowanie powiadomień wypychanych

Rejestrowanie w celu otrzymywania powiadomień wypychanych

Obsługa powiadomień wypychanych

Opinia

Dodatkowe zasoby

Udostępnij za pośrednictwem

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

Omówienie tokenów czasu wygaśnięcia

Wymagania wstępne

Postępuj zgodnie z przewodnikiem Szybki start

Zagadnienia dotyczące powiadomień wypychanych na urządzeniach przenośnych

Instalacja zestawu SDK

Inicjowanie wymaganych obiektów

Rejestrowanie w celu otrzymywania powiadomień wypychanych

Obsługa powiadomień wypychanych

Wyrejestrowywanie powiadomień wypychanych

Wyłączanie wewnętrznych powiadomień wypychanych dla połączenia przychodzącego

Zagadnienia dotyczące powiadomień wypychanych na urządzeniach przenośnych

Konfigurowanie systemu

Tworzenie projektu Xcode

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

Żądanie dostępu do mikrofonu

Konfigurowanie struktury aplikacji

Inicjowanie klasy CallAgent

Konfigurowanie powiadomień wypychanych

Rejestrowanie w celu otrzymywania powiadomień wypychanych

Obsługa powiadomień wypychanych

Wyrejestrowywanie powiadomień wypychanych

Wyłączanie wewnętrznych powiadomień wypychanych dla połączenia przychodzącego

Zagadnienia dotyczące powiadomień wypychanych systemu Windows

Konfigurowanie systemu

Tworzenie projektu programu Visual Studio

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

Konfigurowanie powiadomień wypychanych

Rejestrowanie w celu otrzymywania powiadomień wypychanych

Obsługa powiadomień wypychanych

Powiązana zawartość

Opinia

Dodatkowe zasoby