Aktivera push-meddelanden för samtal

Följ snabbstarten

Webb push-meddelanden via Azure Communication Services Web Calling SDK är i förhandsversion och är tillgängliga som en del av version 1.12.0-beta.2+.

Stegvisa instruktioner finns i snabbstarten på GitHub.

• Ett Firebase-konto med Firebase Cloud Messaging (FCM) aktiverat och med din FCM-tjänst ansluten till en Azure Notification Hubs-instans. Mer information finns i Meddelanden om Kommunikationstjänster.

• Android Studio version 3.6 eller senare för att skapa ditt program.

• En uppsättning behörigheter för att göra det möjligt för Android-programmet att ta emot meddelanden från FCM. AndroidManifest.xml Lägg till följande behörigheter direkt efter <manifest ...> eller under taggen </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" />
  

Överväganden för mobila push-meddelanden

Mobila push-meddelanden är popup-meddelanden som visas på mobila enheter. För samtal fokuserar den här artikeln på voIP-push-meddelanden (Voice over Internet Protocol).

Installera SDK:n

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

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

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

Lägg sedan till följande rader i modulnivåfilen build.gradle 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();

Registrera dig för push-meddelanden

För att registrera sig för push-meddelanden måste programmet anropa registerPushNotification() en CallAgent instans med hjälp av 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 raderna 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 projektnivåns build.gradle fil lägger du till följande rad 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 Firebase Cloud Messaging SDK genererade för klientprograminstansen. Se till att lägga till följande importer i rubriken för huvudaktiviteten för instansen för att 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 the 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.")
}

Hantera push-meddelanden

Om du vill ta emot push-meddelanden för inkommande samtal anropar du handlePushNotification() 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 (välj Arkiv>ny>tjänsttjänst>) som utökar FirebaseMessagingService Firebase SDK-klassen och åsidosätter onMessageReceived metoden. Den här metoden är den händelsehanterare 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 the 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 du har hämtat nyttolasten kan du skicka den till Communication Services SDK för att parsas till ett internt IncomingCallInformation objekt. Det här objektet hanterar anrop av handlePushNotification metoden på en CallAgent instans. Du skapar en CallAgent instans 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, ringer programmet.

Avregistrera push-meddelanden

Program kan när som helst avregistrera push-meddelanden. Om du vill avregistrera dig anropar du metoden på unregisterPushNotification() callAgent:

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

Inaktivera interna push-meddelanden för ett inkommande samtal

Push-nyttolasten för ett inkommande samtal kan levereras till anropare på två sätt:

• Använda FCM och registrera enhetstoken med det API som nämndes tidigare, registerPushNotification på CallAgent eller TeamsCallAgent
• Registrera SDK:t med en intern tjänst när du skapar CallAgent eller TeamsCallAgent för att få push-nyttolasten levererad

Genom att använda egenskapen setDisableInternalPushForIncomingCall i CallAgentOptions eller TeamsCallAgentOptionskan du instruera SDK:t att inaktivera leveransen av push-nyttolasten via den interna push-tjänsten:

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

Överväganden för mobila push-meddelanden

Mobila push-meddelanden är popup-meddelanden som visas på mobila enheter. För samtal fokuserar den här artikeln på voIP-push-meddelanden (Voice over Internet Protocol). En guide om CallKit-integrering i ditt iOS-program finns i Integrera med CallKit.

Konfigurera systemet

Följ de här stegen för att konfigurera systemet.

Skapa Xcode-projektet

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

Du kommer inte att skapa tester i den här artikeln. Avmarkera kryssrutan Inkludera tester .

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 . Ange det associerade värdet till en sträng som ingår 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")
        }
})

Konfigurera push-meddelanden

Slutför den här installationsuppgiften innan du börjar registrera dig för, hantera och avregistrera push-meddelanden:

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 .

Registrera dig för push-meddelanden

Om du vill registrera dig för push-meddelanden anropar du registerPushNotification() en CallAgent instans med hjälp av 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. Om du vill avregistrera dig anropar du metoden på unregisterPushNotification 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")
    }
}

Inaktivera interna push-meddelanden för ett inkommande samtal

Push-nyttolasten för ett inkommande samtal kan levereras till anropare på två sätt:

• Använda Apple Push Notification Service (APNS) och registrera enhetstoken med API:et som nämndes tidigare, registerPushNotification på CallAgent eller TeamsCallAgent
• Registrera SDK:t med en intern tjänst när du skapar CallAgent eller TeamsCallAgent för att få push-nyttolasten levererad

Genom att använda egenskapen disableInternalPushForIncomingCall i CallAgentOptions eller TeamsCallAgentOptionskan du instruera SDK:t att inaktivera leveransen av push-nyttolasten via den interna push-tjänsten:

let options = CallAgentOptions()
options.disableInternalPushForIncomingCall = true

Överväganden för Push-meddelanden i Windows

Mobila push-meddelanden är popup-meddelanden som visas på mobila enheter. För samtal fokuserar den här artikeln på voIP-push-meddelanden (Voice over Internet Protocol).

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

Konfigurera systemet

Följ de här stegen för att konfigurera systemet.

Skapa Visual Studio-projektet

För en Universell Windows-plattform app skapar du i Visual Studio 2022 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.

Så här hittar du, laddar ned och installerar det anropande SDK NuGet-paketet:

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 sedan Azure.Communication.Calling.WindowsClient i sökrutan.
3. Kontrollera att kryssrutan Inkludera förhandsversion är markerad.
4. Välj paketet Azure.Communication.Calling.WindowsClient och välj sedan Azure.Communication.Calling.WindowsClient 1.4.0-beta.1 eller en nyare version.
5. Markera kryssrutan som motsvarar Azure Communication Services-projektet i den högra rutan.
6. Välj Installera.

Konfigurera push-meddelanden

Slutför den här installationsuppgiften innan du börjar registrera dig för, hantera och visa ett Windows-meddelande för att besvara eller avvisa ett inkommande samtal:

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 självstudien har du:

   • Ett program som har paketen WindowsAzure.Messaging.Managed och Microsoft.Toolkit.Uwp.Notifications .
   • Ett Azure Notifications Hub-namn som refereras till och <AZURE_PNH_HUB_NAME> en Azure Notifications Hub-anslutningssträng refereras som <AZURE_PNH_HUB_CONNECTION_STRING> i den här artikeln.

2. Om du vill registrera dig för en WNS-kanal för varje programinitiering måste du lägga till initieringskoden i App.xaml.cs filen:

   // 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. Registrera händelsehanteraren som aktiveras 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 vid programinitiering.

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

Det här samtalet utlöser en inkommande samtalshändelse CallAgent som visar det inkommande samtalsmeddelandet:

// 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 OnActivated metoden:

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