Aktivera push-meddelanden för samtal

  • Artikel

Här lär vi oss hur du aktiverar push-meddelanden för Azure Communication Services-anrop. När du konfigurerar push-meddelandena får användarna veta när de har ett inkommande samtal, vilket de sedan kan svara på.

Push-avisering

Med push-meddelanden kan du skicka information från ditt program till användarnas enheter. Du kan använda push-meddelanden för att visa en dialogruta, spela upp ett ljud eller visa inkommande samtal i appens användargränssnittslager. Azure Communication Services tillhandahåller integreringar med Azure Event Grid och Azure Notification Hubs som gör att du kan lägga till push-meddelanden i dina appar.

TTL-token

TTL-token (Time To Live) är en inställning som avgör hur länge en meddelandetoken förblir giltig innan den blir ogiltig. Den här inställningen är användbar för program där användarinteraktion inte kräver daglig interaktion men är fortfarande kritisk under längre perioder.

TTL-konfigurationen möjliggör hantering av push-meddelandens livscykel, vilket minskar behovet av frekventa tokenförnyelser samtidigt som kommunikationskanalen mellan programmet och dess användare förblir öppen och tillförlitlig under längre perioder.

För närvarande är det maximala värdet för TTL 180 dagar (15 552 000 sekunder) och minimivärdet är 5 minuter (300 sekunder). Du kan ange det här värdet och justera det efter dina behov. Om du inte anger något värde är standardvärdet 24 timmar (86 400 sekunder).

När api:et för push-meddelanden för registrering anropas när informationen om enhetstoken sparas i Registrar. När TTL-livslängden har upphört tas enhetens slutpunktsinformation bort. Inkommande samtal på dessa enheter kan inte levereras till enheterna om enheterna inte anropar api:et för push-meddelanden för registrering igen.

Om du vill återkalla en identitet måste du följa den här processen när identiteten har återkallats bör Registratorposten tas bort.

Kommentar

För CTE (anpassad Teams-slutpunkt) är det maximala TTL-värdet 24 timmar (86 400 sekunder) det finns inget sätt att öka det här värdet.

Förutsättningar

Azure Communication Services Web Calling SDK – snabbstart för push-meddelanden på webben

Viktigt!

Den här funktionen i Azure Communication Services är för närvarande i förhandsversion.

Förhandsversions-API:er och SDK:er tillhandahålls utan ett serviceavtal. Vi rekommenderar att du inte använder dem för produktionsarbetsbelastningar. Vissa funktioner kanske inte stöds, eller så kan de ha begränsade funktioner.

Mer information finns i Kompletterande användningsvillkor för Förhandsversioner av Microsoft Azure.

Azure Communication Services Web Calling SDK – Push-meddelanden för webben finns i offentlig förhandsversion och är tillgängliga som en del av version 1.12.0-beta.2+.

Gå till snabbstartsguiden för webb push-meddelanden: https://github.com/Azure-Samples/communication-services-javascript-quickstarts/blob/main/calling-web-push-notifications/README.md

Installera SDK:n

Leta upp filen build.gradle på projektnivå och lägg till mavenCentral() i listan med lagringsplatser under buildscript och allprojects:

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

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

I filen build.gradle på modulnivå lägger du sedan till följande rader i dependencies avsnittet:

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

Initiera nödvändiga objekt

Om du vill skapa en CallAgent instans måste du anropa createCallAgent metoden på en CallClient instans. Det här anropet returnerar asynkront ett CallAgent instansobjekt.

Metoden createCallAgent tar CommunicationUserCredential som ett argument som kapslar in en åtkomsttoken.

Om du vill komma åt DeviceManagermåste du skapa en callAgent instans först. Sedan kan du använda CallClient.getDeviceManager metoden för att hämta 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();

Om du vill ange ett visningsnamn för anroparen använder du den här alternativa metoden:

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

Ytterligare förutsättningar för push-meddelanden

Ett Firebase-konto som konfigurerats med Cloud Messaging (FCM) aktiverat och med din Firebase Cloud Messaging-tjänst ansluten till en Azure Notification Hub-instans. Mer information finns i Meddelanden om Kommunikationstjänster. Dessutom förutsätter självstudien att du använder Android Studio version 3.6 eller senare för att skapa ditt program.

En uppsättning behörigheter krävs för Android-programmet för att kunna ta emot meddelanden från Firebase Cloud Messaging. AndroidManifest.xml Lägg till följande uppsättning behörigheter direkt efter eller under taggen <manifest ...></application> i filen.

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

Översikt

Mobila push-meddelanden är popup-meddelanden som du ser på mobila enheter. För samtal fokuserar vi på VoIP-push-meddelanden (Voice over Internet Protocol). Vi registrerar oss för push-meddelanden, hanterar push-meddelanden och avregistrerar sedan push-meddelanden.

Kommentar

Om du vill registrera dig för push-meddelanden och hantera push-meddelanden för en anpassad Teams-slutpunkt (CTE) är API:ets samma. API:et som beskrivs nedan kan också anropas på CommonCallAgent klassen eller TeamsCallAgent för Custom Teams Endpoint (CTE).

Registrera dig för push-meddelanden

För att registrera sig för push-meddelanden måste programmet anropa registerPushNotification() en CallAgent instans med en enhetsregistreringstoken.

Om du vill hämta enhetsregistreringstoken lägger du till Firebase SDK i programmodulens build.gradle fil genom att lägga till följande rader i dependencies avsnittet om den inte redan finns där:

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

I filen build.gradle på projektnivån lägger du till följande i dependencies avsnittet om den inte redan finns där:

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

Lägg till följande plugin-program i början av filen om det inte redan finns där:

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

Välj Synkronisera nu i verktygsfältet. Lägg till följande kodfragment för att hämta enhetsregistreringstoken som genereras av Firebase Cloud Messaging SDK för klientprograminstansen Se till att lägga till importerna nedan i rubriken för huvudaktiviteten för instansen. De krävs för att kodfragmentet ska hämta token:

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;

Lägg till det här kodfragmentet för att hämta 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");
        }
    });

Registrera enhetsregistreringstoken med Calling Services SDK för inkommande push-meddelanden för samtal:

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

Hantering av push-meddelanden

För att ta emot inkommande push-meddelanden anropar du handlePushNotification() på en CallAgent-instans med en nyttolast.

Om du vill hämta nyttolasten från Firebase Cloud Messaging börjar du med att skapa en ny tjänst (Fil > ny tjänsttjänst>) som utökar FirebaseMessagingService Firebase SDK-klassen och åsidosätter onMessageReceived> metoden. Den här metoden är händelsehanteraren som anropas när Firebase Cloud Messaging levererar push-meddelandet till programmet.

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

Lägg till följande tjänstdefinition i AndroidManifest.xml filen i taggen <application> :

<service
    android:name=".MyFirebaseMessagingService"
    android:exported="false">
    <intent-filter>
        <action android:name="com.google.firebase.MESSAGING_EVENT" />
    </intent-filter>
</service>
  • När nyttolasten har hämtats kan den skickas till Communication Services SDK för att parsas ut till ett internt IncomingCallInformation-objekt som hanteras genom att anropa metoden handlePushNotification på en CallAgent-instans . En CallAgent instans skapas genom att anropa createCallAgent(...) -metoden för CallClient klassen.
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.");
}

När hanteringen av push-meddelandet lyckas och alla händelsehanterare har registrerats korrekt, kommer programmet att ringa.

Avregistrera push-meddelanden

Program kan när som helst avregistrera push-meddelanden. unregisterPushNotification() Anropa metoden på callAgent för att avregistrera.

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

Konfigurera systemet

Skapa Xcode-projektet

I Xcode skapar du ett nytt iOS-projekt och väljer mallen Enkel vyapp . Den här snabbstarten använder SwiftUI-ramverket, så du bör ange Language till Swift och ange Gränssnitt till SwiftUI.

Du kommer inte att skapa tester under den här snabbstarten. Avmarkera kryssrutan Inkludera tester .

Skärmbild som visar fönstret för att skapa ett projekt i Xcode.

Installera paketet och beroenden med hjälp av CocoaPods

  1. Skapa en Podfile för ditt program, som i det här exemplet:

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

  2. Kör pod install.

  3. Öppna .xcworkspace med Xcode.

Begär åtkomst till mikrofonen

För att få åtkomst till enhetens mikrofon måste du uppdatera appens egenskapslista för information med hjälp NSMicrophoneUsageDescriptionav . Du anger det associerade värdet till en sträng som ska ingå i dialogrutan som systemet använder för att begära åtkomst från användaren.

Högerklicka på posten Info.plist i projektträdet och välj sedan Öppna som>källkod. Lägg till följande rader i avsnittet på den översta nivån <dict> och spara sedan filen.

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

Konfigurera appramverket

Öppna projektets ContentView.swift-fil . Lägg till en import deklaration överst i filen för att importera AzureCommunicationCalling biblioteket. Importera dessutom AVFoundation. Du behöver den för begäranden om ljudbehörighet i koden.

import AzureCommunicationCalling
import AVFoundation

Initiera CallAgent

Om du vill skapa en CallAgent instans från CallClientmåste du använda en callClient.createCallAgent metod som asynkront returnerar ett CallAgent objekt när det har initierats.

Skicka ett CommunicationTokenCredential objekt för att skapa en anropsklient:

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

Skicka objektet CommunicationTokenCredential som du skapade till CallClientoch ange visningsnamnet:

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

Översikt

Mobila push-meddelanden är popup-meddelanden som du ser på mobila enheter. För samtal fokuserar vi på VoIP-push-meddelanden (Voice over Internet Protocol). Vi registrerar oss för push-meddelanden, hanterar push-meddelanden och avregistrerar sedan push-meddelanden. En guide om CallKit-integrering i ditt iOS-program finns här, CallKit-integrering med iOS ACS SDK.

Kommentar

Om du vill registrera dig för push-meddelanden och hantering av push-meddelanden för en anpassad Teams-slutpunkt (CTE) är API:erna desamma. De API:er som beskrivs kan också anropas på CommonCallAgent klassen eller TeamsCallAgent för Custom Teams Endpoint (CTE).

Konfigurera push-meddelanden

Ett mobilt push-meddelande är popup-meddelandet som du får i den mobila enheten. För samtal fokuserar vi på VoIP-push-meddelanden (voice over Internet Protocol).

I följande avsnitt beskrivs hur du registrerar dig för, hanterar och avregistrerar push-meddelanden. Innan du påbörjar dessa uppgifter måste du slutföra följande krav:

  1. I Xcode går du till Signering och funktioner. Lägg till en funktion genom att välja + Kapacitet och välj sedan Push-meddelanden.
  2. Lägg till ytterligare en funktion genom att välja + Kapacitet och välj sedan Bakgrundslägen.
  3. Under Bakgrundslägen markerar du kryssrutorna Röst över IP och Fjärrmeddelanden .

Skärmbild som visar hur du lägger till funktioner i Xcode.

Registrera dig för push-meddelanden

Om du vill registrera dig för push-meddelanden anropar du registerPushNotification() en CallAgent instans med en enhetsregistreringstoken.

Registrering för push-meddelanden måste ske efter en lyckad initiering. När objektet callAgent förstörs logout anropas, vilket automatiskt avregistrerar push-meddelanden.

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

Hantera push-meddelanden

Om du vill ta emot push-meddelanden för inkommande samtal anropar handlePushNotification() du en CallAgent instans med en ordlistenyttolast.

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

Avregistrera push-meddelanden

Program kan när som helst avregistrera push-meddelanden. Anropa helt enkelt metoden på unregisterPushNotificationCallAgent.

Kommentar

Program avregistreras inte automatiskt från push-meddelanden vid utloggning.

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

Konfigurera systemet

Skapa Visual Studio-projektet

För en UWP-app i Visual Studio 2022 skapar du ett nytt projekt för Tom app (Universell Windows). När du har angett projektnamnet kan du välja valfri Windows SDK senare än 10.0.17763.0.

För en WinUI 3-app skapar du ett nytt projekt med mallen Tom app, Paketerad (WinUI 3 i Desktop) för att konfigurera en WinUI 3-app med en enda sida. SDK för Windows-appar version 1.3 eller senare krävs.

Installera paketet och beroendena med hjälp av NuGet Package Manager

Anropande SDK-API:er och bibliotek är offentligt tillgängliga via ett NuGet-paket.

Följande steg illustrerar hur du hittar, laddar ned och installerar NuGet-paketet Calling SDK:

  1. Öppna NuGet Package Manager genom att välja Verktyg>NuGet Package Manager>Hantera NuGet-paket för lösning.
  2. Välj Bläddra och ange Azure.Communication.Calling.WindowsClient sedan i sökrutan.
  3. Kontrollera att kryssrutan Inkludera förhandsversion är markerad.
  4. Välj paketet Azure.Communication.Calling.WindowsClient och välj Azure.Communication.Calling.WindowsClientsedan 1.4.0-beta.1 eller en nyare version.
  5. Markera kryssrutan som motsvarar Communication Services-projektet på den högra fliken.
  6. Välj knappen Installera.

Översikt

Push-meddelanden på Windows-plattformen levereras med .Windows Push Notification Service (WNS),

Kommentar

Om du vill registrera dig för push-meddelanden och hantera push-meddelanden för en anpassad Teams-slutpunkt (CTE) är API:ets samma. API:et som beskrivs nedan kan också anropas på CommonCallAgent klassen eller TeamsCallAgent för Custom Teams Endpoint (CTE).

Konfigurera push-meddelanden

Ett push-meddelande är popup-meddelandet som du får i enheten. För samtal fokuserar vi på VoIP-push-meddelanden (voice over Internet Protocol).

I följande avsnitt beskrivs hur du registrerar dig för, hanterar och visar ett Windows-meddelande för att besvara/avvisa ett inkommande samtal. Innan du påbörjar dessa uppgifter måste du slutföra följande krav:

  1. Följ självstudie: Skicka meddelanden till Universell Windows-plattform appar med Hjälp av Azure Notification Hubs. När du har följt den här självstudien har du:

    • Ett program som har paketen WindowsAzure.Messaging.Managed och Microsoft.Toolkit.Uwp.Notifications .
    • Ett Azure PNH-hubbnamn (Push Notifications Hub) som refereras till och <AZURE_PNH_HUB_NAME> Azure PNH-Anslut ionssträngen refereras som <AZURE_PNH_HUB_CONNECTION_STRING> i den här snabbstarten.

  2. Om du vill registrera dig för en WNS-kanal (Windows Notification Service) i varje programinitiering måste du lägga till initieringskoden i din App.xaml.cs-fil:

// 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");
        }
    }
}
  1. Registrera händelsehanteraren som aktiverades när ett nytt push-meddelande tas emot på 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;
    }
}

Registrera dig för push-meddelanden

Om du vill registrera dig för push-meddelanden anropar du RegisterForPushNotificationAsync() en CallAgent instans med WNS-registreringskanalen som hämtas i programinit.

Registrering för push-meddelanden måste ske efter en lyckad initiering.

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

Hantera push-meddelanden

Om du vill ta emot push-meddelanden för inkommande samtal anropar handlePushNotification() du en CallAgent instans med en ordlistenyttolast.

// MainPage.xaml.cs

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

Detta utlöser en inkommande samtalshändelse på CallAgent som visar meddelandet om inkommande samtal.

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

Lägg till koden för att hantera knapptryckningen för meddelandet i metoden 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();
    }
}

Nästa steg