Aktivera push-meddelanden

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 ) som utökar > Firebase SDK-klassen och åsidosätter 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 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 vid skapandet av CallAgent eller TeamsCallAgent för att få pushmeddelandet levererat

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

Implementera push-meddelanden för iOS-mobila enheter

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 informationsegenskapslistan i din app med hjälp av NSMicrophoneUsageDescription. 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() på 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å unregisterPushNotificationCallAgent.

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:

• Att 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 vid skapandet av CallAgent eller TeamsCallAgent för att få pushmeddelandet levererat

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

Implementera 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 Universal Windows Platform-app, skapa ett nytt projekt för Tomt App (Universal Windows) i Visual Studio 2022. 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ör att hitta, ladda ned och installera Calling 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.WindowsClient1.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-plattformsappar med hjälp av Azure Notification Hubs. Efter att du har följt handledningen så har du:

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

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

För att registrera dig för push-meddelanden anropar du RegisterForPushNotificationAsync() på en CallAgent-instans med WNS-registreringskanalen som erhålls vid applikationsinitiering.

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 händelse för inkommande samtal på CallAgent som visar aviseringen för 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 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();
    }
}