Włącz powiadomienia push

Postępuj zgodnie z przewodnikiem Szybki start

Powiadomienia typu web push za pośrednictwem zestawu SDK połączeń internetowych Azure Communication Services są w wersji zapoznawczej jako część wersji 1.12.0-beta.2 lub nowszej.

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

Rozważania dotyczące powiadomień push na urządzeniach mobilnych

Powiadomienia push to wyskakujące powiadomienia wyświetlane na urządzeniach mobilnych. Artykuł koncentruje się na powiadomieniach push Voice over Internet Protocol (VoIP).

Instalacja zestawu SDK

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

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

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

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

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

Inicjowanie wymaganych obiektów

Aby utworzyć instancję CallAgent, należy wywołać metodę createCallAgent dla wystąpienia CallClient. To wywołanie asynchroniczne zwraca instancję obiektu CallAgent.

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

Aby uzyskać dostęp do DeviceManager, należy najpierw utworzyć instancję callAgent. Następnie możesz użyć metody CallClient.getDeviceManager, aby pobrać 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();

Zarejestruj się na powiadomienia push

Aby zarejestrować się do powiadomień push, aplikacja musi wywołać registerPushNotification() na instancji CallAgent 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 poziomu projektu build.gradle dodaj następujący wiersz w sekcji dependencies 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łównej aktywności, aby pobrać token dla danego wystąpienia.

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 rejestracyjny urządzenia w SDK usług telefonicznych, aby otrzymywać powiadomienia push o przychodzących połączeniach.

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ń push

Aby otrzymywać powiadomienia push dotyczące połączeń przychodzących, wywołaj handlePushNotification() na CallAgent wystąpieniu z ładunkiem.

Aby uzyskać ładunek z Firebase Cloud Messaging, zacznij od utworzenia nowej usługi (wybierz File>New>Service), która rozszerza klasę zestawu Firebase SDK i zastępuje metodę >. Ta metoda jest procedurą obsługi zdarzeń wywoływaną, gdy usługa Firebase Cloud Messaging dostarcza powiadomienie push 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 SDK Usług Komunikacyjnych, aby został przetworzony na wewnętrzny obiekt IncomingCallInformation. Ten obiekt obsługuje wywoływanie metody handlePushNotification na wystąpieniu CallAgent. Instancję można utworzyć CallAgent, wywołując metodę createCallAgent(...) w klasie CallClient.

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 push zakończy się pomyślnie i wszystkie programy obsługi zdarzeń zostaną prawidłowo zarejestrowane, aplikacja zaczyna dzwonić.

Wyrejestrować powiadomienia push

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

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

Wyłącz wewnętrzne powiadomienia push dla połączenia przychodzącego

Ładunek powiadomienia o przychodzącym połączeniu można dostarczyć do osoby odbierającej na dwa sposoby:

• Używanie usługi FCM i rejestrowanie tokenu urządzenia za pomocą wspomnianego wcześniej interfejsu API na registerPushNotification lub CallAgent albo TeamsCallAgent
• Rejestrowanie zestawu SDK z usługą wewnętrzną w momencie tworzenia CallAgent lub TeamsCallAgent, aby otrzymać przesyłany ładunek.

Za pomocą właściwości setDisableInternalPushForIncomingCall w CallAgentOptions lub TeamsCallAgentOptions można poinstruować zestaw SDK, aby wyłączyć dostarczanie payloadu powiadomienia push za pośrednictwem wewnętrznej usługi push.

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

Implementowanie powiadomień push dla urządzeń przenośnych z systemem iOS

Powiadomienia push to wyskakujące powiadomienia wyświetlane na urządzeniach mobilnych. Artykuł koncentruje się na powiadomieniach push Voice over Internet Protocol (VoIP). Aby zapoznać się z przewodnikiem dotyczącym integracji biblioteki CallKit w aplikacji systemu iOS, zobacz Integracja z zestawem CallKit.

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 odznaczyć 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. Ustaw skojarzoną wartość na ciąg zawarty w dialogu używanym przez system do żądania dostępu użytkownika.

Kliknij prawym przyciskiem myszy wpis Info.plist w drzewie projektu, a następnie wybierz 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. Potrzebujesz tego do obsługi żądań uprawnień dotyczących dźwięku w kodzie.

import AzureCommunicationCalling
import AVFoundation

Inicjowanie CallAgent

Aby utworzyć CallAgent instancję z CallClient klasy, należy użyć callClient.createCallAgent metody, która asynchronicznie zwraca CallAgent obiekt po zainicjowaniu.

Aby utworzyć klienta połączeń, przekaż obiekt CommunicationTokenCredential.

import AzureCommunication

let tokenString = "token_string"
var userCredential: CommunicationTokenCredential?
do {
    let options = CommunicationTokenRefreshOptions(initialToken: token, refreshProactively: true, tokenRefresher: self.fetchTokenSync)
    userCredential = try CommunicationTokenCredential(withOptions: options)
} catch {
    updates("Couldn't created Credential object", false)
    initializationDispatchGroup!.leave()
    return
}

// tokenProvider needs to be implemented by Contoso, which fetches a new token
public func fetchTokenSync(then onCompletion: TokenRefreshOnCompletion) {
    let newToken = self.tokenProvider!.fetchNewToken()
    onCompletion(newToken, nil)
}

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

Ustawianie powiadomień push

Zanim rozpoczniesz czynności związane z rejestrowaniem, obsługą i wyrejestrowywaniem powiadomień push, wykonaj następującą czynność konfiguracyjną:

1. W programie Xcode przejdź do pozycji Podpisywanie i możliwości. Dodaj funkcjonalność, wybierając + Funkcjonalność, a następnie wybierz Powiadomienia push.
2. Dodaj kolejną możliwość, wybierając + Możliwość, a następnie wybierz pozycję Tryby działania w tle.
3. W sekcji Tryby Tła zaznacz pola wyboru Głos przez IP i Powiadomienia zdalne.

Zarejestruj się na powiadomienia push

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

Rejestracja powiadomień push musi nastąpić po pomyślnej inicjalizacji. Gdy callAgent obiekt jest niszczony, wywoływany jest logout, co automatycznie wyrejestrowuje powiadomienia push.

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ń push

Aby otrzymywać powiadomienia push dla połączeń przychodzących, wywołaj funkcję handlePushNotification() na instancji CallAgent 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")
    }
}

Wyrejestrować powiadomienia push

Aplikacje mogą wyrejestrować powiadomienia push w dowolnym momencie. Aby wyrejestrować, wywołaj metodę unregisterPushNotification w pliku CallAgent.

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łącz wewnętrzne powiadomienia push dla połączenia przychodzącego

Ładunek powiadomienia o przychodzącym połączeniu można dostarczyć do osoby odbierającej 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, na registerPushNotification lub CallAgent czy TeamsCallAgent
• Rejestrowanie zestawu SDK z usługą wewnętrzną w momencie tworzenia CallAgent lub TeamsCallAgent, aby otrzymać przesyłany ładunek.

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

let options = CallAgentOptions()
options.disableInternalPushForIncomingCall = true

Implementować powiadomienia typu push systemu Windows

Powiadomienia push to wyskakujące powiadomienia wyświetlane na urządzeniach mobilnych. Artykuł koncentruje się na powiadomieniach push Voice over Internet Protocol (VoIP).

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

Konfigurowanie systemu

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

Tworzenie projektu programu Visual Studio

Dla aplikacji uniwersalnej platformy Windows, w programie Visual Studio 2022, utwórz nowy projekt Aplikacja Pusta (uniwersalna Windows). Po wprowadzeniu nazwy projektu możesz wybrać dowolny zestaw Windows SDK nowszy niż 10.0.17763.0.

Dla aplikacji WinUI 3 utwórz nowy projekt z Pustą aplikacją, spakowaną (WinUI 3 w aplikacji 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 Calling SDK są publicznie dostępne za pośrednictwem pakietu NuGet.

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

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

Ustawianie powiadomień push

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:

1. Postępuj zgodnie z Samouczkiem: wysyłanie powiadomień do aplikacji Uniwersalna platforma Windows przy użyciu usługi Azure Notification Hubs. Po wykonaniu instrukcji masz co następuje:

   • Aplikacja, która zawiera pakiety WindowsAzure.Messaging.Managed i Microsoft.Toolkit.Uwp.Notifications.
   • Nazwa centrum Azure Notifications Hub oznaczona jako <AZURE_PNH_HUB_NAME> oraz ciąg połączenia Azure Notifications Hub oznaczony jako <AZURE_PNH_HUB_CONNECTION_STRING> w tym artykule.

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

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

Zarejestruj się na powiadomienia push

Aby zarejestrować się do otrzymywania powiadomień push, użyj wystąpienia RegisterForPushNotificationAsync() z kanałem rejestracji WNS uzyskanym podczas inicjowania aplikacji.

Rejestracja powiadomień push musi nastąpić po pomyślnej inicjalizacji.

// 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ń push

Aby otrzymywać powiadomienia push dla połączeń przychodzących, wywołaj funkcję handlePushNotification() na instancji CallAgent 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 uruchamia zdarzenie połączenia przychodzącego na CallAgent, które pokazuje powiadomienie o tym połączeniu.

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