Povolení nabízených oznámení pro volání

Nabízená oznámení odesílají informace z vaší aplikace do zařízení uživatelů. Pomocí nabízených oznámení můžete zobrazit dialogové okno, přehrát zvuk nebo zobrazit příchozí volání do vrstvy uživatelského rozhraní aplikace.

V tomto článku se dozvíte, jak povolit nabízená oznámení pro volání služeb Azure Communication Services. Služba Communication Services poskytuje integrace se službou Azure Event Grid a Azure Notification Hubs , které umožňují přidávat nabízená oznámení do vašich aplikací.

Přehled tokenů TTL

Token TTL (Time to Live) je nastavení, které určuje dobu, po kterou bude token oznámení platný, než se stane neplatným. Toto nastavení je užitečné pro aplikace, u kterých zapojení uživatelů nevyžaduje každodenní interakci, ale zůstává kritické v delších obdobích.

Konfigurace hodnoty TTL umožňuje správu životního cyklu nabízených oznámení. Snižuje potřebu častého prodlužování platnosti tokenů a zároveň pomáhá zajistit, aby komunikační kanál mezi aplikací a jejími uživateli zůstal otevřený a spolehlivý po delší dobu.

Maximální hodnota hodnoty TTL je v současné době 180 dnů (15 552 000 sekund) a minimální hodnota je 5 minut (300 sekund). Tuto hodnotu můžete zadat a upravit tak, aby vyhovovala vašim potřebám. Pokud nezadáte hodnotu, výchozí hodnota je 24 hodin (86 400 sekund).

Po volání rozhraní API pro registraci nabízených oznámení se informace o tokenu zařízení uloží do registrátora. Po skončení doby trvání hodnoty TTL se odstraní informace o koncovém bodu zařízení. Žádná příchozí volání na těchto zařízeních se do zařízení nedoručí, pokud tato zařízení znovu nezavolají rozhraní API pro registraci nabízených oznámení.

Pokud chcete odvolat identitu, postupujte podle tohoto postupu. Po odvolání identity by se měla položka registrátora odstranit.

Poznámka:

Maximální hodnota TTL pro uživatele Microsoft Teams je 24 hodin (86 400 sekund). Neexistuje způsob, jak tuto hodnotu zvýšit. Aplikaci byste měli probudit každých 24 hodin na pozadí a zaregistrovat token zařízení.

Pokud chcete aplikaci probudit, načtěte nový token a proveďte registraci, postupujte podle pokynů pro platformu iOS nebo pokynů pro platformu Android.

Požadavky

• Účet Azure s aktivním předplatným. Vytvoření účtu zdarma

• Nasazený prostředek komunikační služby. Vytvořte prostředek komunikační služby.

• Přístupový token uživatele pro povolení volajícího klienta. Další informace najdete v tématu Vytváření a správa přístupových tokenů.

• Volitelné: Dokončení rychlého startu pro přidání hlasového volání do aplikace

Postupujte podle rychlého startu.

Webová nabízená oznámení prostřednictvím sady SDK pro webové volání služeb Azure jsou ve verzi Preview a jsou k dispozici jako součást verze 1.12.0-beta.2+.

Důležité

Tato funkce služeb Azure Communication Services je aktuálně ve verzi Preview.

Rozhraní API a sady SDK verze Preview jsou poskytovány bez smlouvy o úrovni služeb. Doporučujeme je nepoužívat pro produkční úlohy. Některé funkce nemusí být podporované nebo můžou mít omezené možnosti.

Další informace najdete v dodatečných podmínkách použití pro verze Preview Microsoft Azure.

Podrobné pokyny najdete v rychlém startu na GitHubu.

• Účet Firebase s povolenou službou Firebase Cloud Messaging (FCM) a vaší službou FCM připojenou k instanci Azure Notification Hubs. Další informace najdete v tématu Oznámení komunikačních služeb.

• Android Studio verze 3.6 nebo novější pro sestavení aplikace

• Sada oprávnění, která aplikaci pro Android umožní přijímat zprávy s oznámeními z FCM. AndroidManifest.xml Do souboru přidejte následující oprávnění hned za <manifest ...> značku nebo pod </application> značku:

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

Důležité

20. června 2023 společnost Google oznámila, že zastaralá odesílání zpráv pomocí starších rozhraní API FCM a začala odebírat starší verzi FCM ze služby v červnu 2024. Google doporučuje migrovat ze starších rozhraní API FCM na FCM HTTP v1.

Pokud prostředek komunikační služby stále používá starší rozhraní API FCM, postupujte podle tohoto průvodce migrací.

Důležité informace o nabízených oznámeních pro mobilní zařízení

Mobilní nabízená oznámení jsou automaticky otevíraná oznámení, která se zobrazují na mobilních zařízeních. Pro volání se tento článek zaměřuje na nabízená oznámení přes protokol VoIP (Voice over Internet Protocol).

Poznámka:

Když se aplikace zaregistruje pro nabízená oznámení a zpracuje příchozí nabízená oznámení pro uživatele Teams, rozhraní API jsou stejná. Rozhraní API, která tento článek popisuje, lze také vyvolat u CommonCallAgent třídy nebo TeamsCallAgent třídy.

Nainstalujte sadu SDK .

Vyhledejte soubor na úrovni build.gradle projektu a přidejte mavenCentral() ho do seznamu úložišť v části buildscript a allprojects:

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

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

Potom do souboru na úrovni build.gradle modulu přidejte do oddílu dependencies následující řádky:

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

Inicializace požadovaných objektů

Pokud chcete vytvořit CallAgent instanci, musíte metodu createCallAgent CallClient volat v instanci. Toto volání asynchronně vrátí CallAgent objekt instance.

Metoda createCallAgent přebírá CommunicationUserCredential jako argument, který zapouzdřuje přístupový token.

Pokud chcete získat přístup DeviceManager, musíte nejprve vytvořit callAgent instanci. Pak můžete použít metodu CallClient.getDeviceManager získat 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();

Pokud chcete nastavit zobrazovaný název volajícího, použijte tuto alternativní metodu:

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

Registrace nabízených oznámení

K registraci nabízených oznámení musí aplikace volat registerPushNotification() CallAgent instanci pomocí registračního tokenu zařízení.

Pokud chcete získat token registrace zařízení, přidejte do souboru modulu build.gradle aplikace sadu Firebase SDK přidáním následujících řádků v dependencies části (pokud tam řádky ještě nejsou):

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

Pokud soubor na úrovni build.gradle projektu ještě neexistuje, přidejte do oddílu dependencies následující řádek:

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

Pokud tam ještě není, přidejte na začátek souboru následující modul plug-in:

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

Na panelu nástrojů vyberte Synchronizovat. Přidejte následující fragment kódu pro získání tokenu registrace zařízení, který sada Firebase Cloud Messaging SDK vygenerovala pro instanci klientské aplikace. Nezapomeňte přidat následující importy do hlavičky hlavní aktivity instance pro načtení 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;

Přidejte tento fragment kódu pro načtení tokenu:

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

Zaregistrujte token registrace zařízení v sadě SDK volajících služeb pro nabízená oznámení o příchozích hovorech:

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

Zpracování nabízených oznámení

Pokud chcete přijímat nabízená oznámení příchozích hovorů, zavolejte handlePushNotification() instanci CallAgent s datovou částí.

Pokud chcete získat datovou část z Firebase Cloud Messaging, začněte vytvořením nové služby (vyberte File>New>Service Service>), která rozšiřuje FirebaseMessagingService třídu Firebase SDK a přepíše metodu.onMessageReceived Tato metoda je obslužná rutina události, která se volá, když Firebase Cloud Messaging doručí nabízené oznámení do aplikace.

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

Do souboru přidejte AndroidManifest.xml následující definici služby uvnitř značky <application> :

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

Po načtení datové části ji můžete předat sadě SDK komunikačních služeb, která se má analyzovat do interního IncomingCallInformation objektu. Tento objekt zpracovává volání handlePushNotification metody v CallAgent instanci. Instanci vytvoříte CallAgent voláním createCallAgent(...) metody ve CallClient třídě.

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

Pokud je zpracování nabízené zprávy úspěšné a všechny obslužné rutiny událostí jsou správně zaregistrovány, aplikace zazvoní.

Zrušení registrace nabízených oznámení

Aplikace můžou kdykoli zrušit registraci nabízených oznámení. Chcete-li zrušit registraci, zavolejte metodu unregisterPushNotification() callAgent:

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

Zakázání interních nabízených oznámení pro příchozí hovor

Datovou část příchozího hovoru je možné dovolat dvěma způsoby:

• Použití FCM a registrace tokenu zařízení pomocí rozhraní API uvedeného výše nebo registerPushNotification CallAgentTeamsCallAgent
• Registrace sady SDK v interní službě při vytvoření CallAgent nebo TeamsCallAgent doručení datové části push

Použitím vlastnosti setDisableInternalPushForIncomingCall v CallAgentOptions nebo TeamsCallAgentOptionsje možné sadě SDK dát pokyn, aby zakázala doručení datové části push prostřednictvím interní nabízené služby:

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

Důležité informace o nabízených oznámeních pro mobilní zařízení

Mobilní nabízená oznámení jsou automaticky otevíraná oznámení, která se zobrazují na mobilních zařízeních. Pro volání se tento článek zaměřuje na nabízená oznámení přes protokol VoIP (Voice over Internet Protocol). Průvodce integrací CallKitu v aplikaci pro iOS najdete v tématu Integrace s CallKitem.

Poznámka:

Když se aplikace zaregistruje pro nabízená oznámení a zpracuje příchozí nabízená oznámení pro uživatele Teams, rozhraní API jsou stejná. Rozhraní API, která tento článek popisuje, lze také vyvolat u CommonCallAgent třídy nebo TeamsCallAgent třídy.

Nastavení systému

Podle těchto kroků nastavte systém.

Vytvoření projektu Xcode

V Xcode vytvořte nový projekt pro iOS a vyberte šablonu aplikace s jedním zobrazením . Tento článek používá architekturu SwiftUI, takže byste měli nastavit jazyk na Swift a nastavit rozhraní na SwiftUI.

V tomto článku nebudete vytvářet testy. Zrušte zaškrtnutí políčka Zahrnout testy .

Instalace balíčku a závislostí pomocí CocoaPods

1. Vytvořte pro aplikaci soubor Podfile, například v tomto příkladu:

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

2. Spusťte pod install.

3. Otevřete .xcworkspace pomocí Xcode.

Vyžádání přístupu k mikrofonu

Pokud chcete získat přístup k mikrofonu zařízení, musíte aktualizovat seznam vlastností informací aplikace pomocí NSMicrophoneUsageDescription. Nastavte přidruženou hodnotu na řetězec, který je součástí dialogového okna, který systém používá k vyžádání přístupu od uživatele.

Klikněte pravým tlačítkem myši na položku Info.plist stromu projektu a pak vyberte Open As>Source Code. Do oddílu nejvyšší úrovně <dict> přidejte následující řádky a pak soubor uložte.

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

Nastavení architektury aplikace

Otevřete soubor projektu ContentView.swift . import Přidejte deklaraci do horní části souboru pro import AzureCommunicationCalling knihovny. Kromě toho import AVFoundation. Potřebujete ho pro žádosti o zvuková oprávnění v kódu.

import AzureCommunicationCalling
import AVFoundation

Inicializace callagentu

Chcete-li vytvořit CallAgent instanci z CallClient, musíte použít metodu callClient.createCallAgent , která asynchronně vrátí CallAgent objekt po inicializaci.

Pokud chcete vytvořit klienta volání, předejte CommunicationTokenCredential objekt:

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 Předejte objekt, který jste vytvořiliCallClient, a nastavte zobrazovaný název:

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

Nastavení nabízených oznámení

Než začnete s registrací, zpracováním a zrušením registrace nabízených oznámení, dokončete tuto úlohu nastavení:

1. V Xcode přejděte do možností podepisování a funkcí. Přidejte funkci tak , že vyberete + Schopnost a pak vyberete Nabízená oznámení.
2. Přidejte další funkci výběrem + Možnosti a pak vyberte Režimy pozadí.
3. V části Režimy pozadí zaškrtněte políčka Hlas přes IP adresu a vzdálená oznámení .

Registrace nabízených oznámení

Pokud se chcete zaregistrovat k nabízeným oznámením, zavolejte registerPushNotification() instanci CallAgent pomocí registračního tokenu zařízení.

Registrace nabízených oznámení musí proběhnout po úspěšné inicializaci. Při zničení objektu callAgent je volána, logout která automaticky zruší registraci nabízených oznámení.

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

Zpracování nabízených oznámení

Pokud chcete přijímat nabízená oznámení pro příchozí hovory, zavolejte handlePushNotification() instanci CallAgent s datovou částí slovníku:

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

Zrušení registrace nabízených oznámení

Aplikace můžou kdykoli zrušit registraci nabízených oznámení. Chcete-li zrušit registraci, zavolejte metodu unregisterPushNotification .CallAgent

Poznámka:

Aplikace se při odhlášení automaticky neodregistrují z nabízených oznámení.

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

Zakázání interních nabízených oznámení pro příchozí hovor

Datovou část příchozího hovoru je možné dovolat dvěma způsoby:

• Použití služby Apple Push Notification (APNS) a registrace tokenu zařízení pomocí rozhraní API uvedeného výše nebo registerPushNotification CallAgentTeamsCallAgent
• Registrace sady SDK v interní službě při vytvoření CallAgent nebo TeamsCallAgent doručení datové části push

Použitím vlastnosti disableInternalPushForIncomingCall v CallAgentOptions nebo TeamsCallAgentOptionsje možné sadě SDK dát pokyn, aby zakázala doručení datové části push prostřednictvím interní nabízené služby:

let options = CallAgentOptions()
options.disableInternalPushForIncomingCall = true

Důležité informace o nabízených oznámeních windows

Mobilní nabízená oznámení jsou automaticky otevíraná oznámení, která se zobrazují na mobilních zařízeních. Pro volání se tento článek zaměřuje na nabízená oznámení přes protokol VoIP (Voice over Internet Protocol).

Nabízená oznámení na platformě Windows se doručují prostřednictvím služby nabízených oznámení systému Windows (WNS).

Poznámka:

Když se aplikace zaregistruje pro nabízená oznámení a zpracuje nabízená oznámení pro vlastní koncový bod Teams (CTE), rozhraní API jsou stejná. Rozhraní API, která tento článek popisuje, se také dají vyvolat na CommonCallAgent úrovni nebo TeamsCallAgent třídy pro CTE.

Nastavení systému

Podle těchto kroků nastavte systém.

Vytvoření projektu sady Visual Studio

V případě Univerzální platforma Windows aplikace vytvořte v sadě Visual Studio 2022 nový projekt Prázdná aplikace (Universal Windows). Po zadání názvu projektu si můžete vybrat libovolnou sadu Windows SDK později než 10.0.17763.0.

V případě aplikace WinUI 3 vytvořte nový projekt pomocí šablony Prázdná aplikace zabalená (WinUI 3 v desktopové verzi) pro nastavení jednostráňové aplikace WinUI 3. Vyžaduje se sada Windows App SDK verze 1.3 nebo novější.

Instalace balíčku a závislostí pomocí Správce balíčků NuGet

Rozhraní API a knihovny volající sady SDK jsou veřejně dostupné prostřednictvím balíčku NuGet.

Vyhledání, stažení a instalace balíčku NuGet volající sady SDK:

1. Otevřete Správce balíčků NuGet výběrem nástrojů>NuGet Správce balíčků> Nabídky NuGet pro řešení.
2. Vyberte Procházet a do vyhledávacího pole zadejte Azure.Communication.Calling.WindowsClient .
3. Ujistěte se, že je zaškrtnuté políčko Zahrnout předběžné verze .
4. Vyberte balíček Azure.Communication.Calling.WindowsClient a pak vyberte Azure.Communication.Calling.WindowsClient 1.4.0-beta.1 nebo novější verzi.
5. Zaškrtněte políčko odpovídající projektu Azure Communication Services v pravém podokně.
6. Vyberte volbu Instalovat.

Nastavení nabízených oznámení

Než začnete s úlohami registrace, zpracování a zobrazování oznámení systému Windows pro přijetí nebo odmítnutí příchozího hovoru, dokončete tuto úlohu nastavení:

1. Postupujte podle kurzu: Odesílání oznámení do Univerzální platforma Windows aplikací pomocí služby Azure Notification Hubs. Po provedení tohoto kurzu máte:

   • Aplikace, která obsahuje WindowsAzure.Messaging.Managed balíčky a Microsoft.Toolkit.Uwp.Notifications balíčky.
   • Název centra oznámení Azure odkazovaný jako <AZURE_PNH_HUB_NAME> a centrum oznámení Azure připojovací řetězec odkazované jako <AZURE_PNH_HUB_CONNECTION_STRING> v tomto článku.

2. Pokud chcete zaregistrovat kanál WNS při každé inicializaci aplikace, nezapomeňte do souboru App.xaml.cs přidat inicializační kód:

   // 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. Zaregistrujte obslužnou rutinu události, která je aktivována, když přijde nová zpráva s nabízeným oznámením: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;
       }
   }
   

Registrace nabízených oznámení

Pokud se chcete zaregistrovat k nabízeným oznámením, zavolejte RegisterForPushNotificationAsync() instanci s registračním CallAgent kanálem WNS získaným při inicializaci aplikace.

Registrace nabízených oznámení musí proběhnout po úspěšné inicializaci.

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

Zpracování nabízených oznámení

Pokud chcete přijímat nabízená oznámení pro příchozí hovory, zavolejte handlePushNotification() instanci CallAgent s datovou částí slovníku:

// MainPage.xaml.cs

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

Toto volání aktivuje událost CallAgent příchozího volání, která zobrazuje oznámení o příchozím hovoru:

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

Přidejte kód pro zpracování tlačítka pro oznámení v OnActivated metodě:

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

Související obsah

• Přihlášení k odběru událostí sady SDK
• Správa hovorů
• Správa videa během hovorů
• Migrace nabízených oznámení sady Android SDK do služby Firebase Cloud Messaging HTTP v1
• Registrace nabízených oznámení sady Android SDK pomocí protokolu HTTP v1 služby Firebase Cloud Messaging