Abilitare le notifiche push per le chiamate

Seguire la guida introduttiva

Le notifiche push Web tramite Servizi di comunicazione di Azure Web Calling SDK sono in anteprima e sono disponibili come parte della versione 1.12.0-beta.2+.

Per istruzioni dettagliate, vedere la guida introduttiva in GitHub.

• Un account Firebase con Firebase Cloud Messaging (FCM) abilitato e con il servizio FCM connesso a un'istanza di Hub di notifica di Azure. Per altre informazioni, vedere Notifiche di Servizi di comunicazione.

• Android Studio versione 3.6 o successiva per compilare l'applicazione.

• Set di autorizzazioni per consentire all'applicazione Android di ricevere messaggi di notifica da FCM. AndroidManifest.xml Nel file aggiungere le autorizzazioni seguenti subito dopo <manifest ...> o sotto il </application> tag:

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

Considerazioni sulle notifiche push per dispositivi mobili

Le notifiche push per dispositivi mobili sono le notifiche popup visualizzate nei dispositivi mobili. Per le chiamate, questo articolo è incentrato sulle notifiche push voice over Internet Protocol (VoIP).

Installazione dell'SDK

Individuare il file a livello build.gradle di progetto e aggiungere mavenCentral() all'elenco dei repository in buildscript e allprojects:

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

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

Quindi, nel file a livello build.gradle di modulo aggiungere le righe seguenti alla dependencies sezione :

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

Inizializzare gli oggetti necessari

Per creare un'istanza CallAgent, è necessario chiamare il metodo createCallAgent in un'istanza CallClient. Questa chiamata restituisce in modo asincrono un oggetto istanza CallAgent.

Il metodo createCallAgent accetta CommunicationUserCredential come argomento, che incapsula un token di accesso.

Per accedere a DeviceManager, è prima necessario creare un'istanza callAgent. Quindi è possibile usare il metodo CallClient.getDeviceManager per ottenere 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();

Per impostare nome visualizzato per il chiamante, usare questo metodo alternativo:

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

Registrarsi per le notifiche push

Per eseguire la registrazione per le notifiche push, l'applicazione deve chiamare registerPushNotification() su un'istanza CallAgent usando un token di registrazione del dispositivo.

Per ottenere il token di registrazione del dispositivo, aggiungere Firebase SDK al file del modulo dell'applicazione build.gradle aggiungendo le righe seguenti nella dependencies sezione (se le righe non sono già presenti):

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

Nel file del livello di build.gradle progetto aggiungere la riga seguente nella dependencies sezione se non è già presente:

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

Aggiungere il plug-in seguente all'inizio del file, se non è già presente:

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

Sulla barra degli strumenti selezionare Sincronizza ora. Aggiungere il frammento di codice seguente per ottenere il token di registrazione del dispositivo generato da Firebase Cloud Messaging SDK per l'istanza dell'applicazione client. Assicurarsi di aggiungere le importazioni seguenti all'intestazione dell'attività principale per l'istanza di per recuperare il 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;

Aggiungere questo frammento di codice per recuperare il 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");
        }
    });

Registrare il token di registrazione del dispositivo con Calling Services SDK per le notifiche push delle chiamate in ingresso:

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

Gestire le notifiche push

Per ricevere notifiche push di chiamata in ingresso, chiamare handlePushNotification() su un'istanza CallAgent con un payload.

Per ottenere il payload da Firebase Cloud Messaging, iniziare creando un nuovo servizio (selezionare File>Nuovo>servizio>) che estende la FirebaseMessagingService classe Firebase SDK ed esegue l'override del onMessageReceived metodo . Questo metodo è il gestore eventi chiamato quando Firebase Cloud Messaging recapita la notifica push all'applicazione.

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

Aggiungere la definizione di servizio seguente al file AndroidManifest.xml all'interno del tag <application>:

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

Dopo aver recuperato il payload, è possibile passarlo all'SDK di Servizi di comunicazione da analizzare in un oggetto interno IncomingCallInformation . Questo oggetto gestisce la chiamata al metodo in un'istanza handlePushNotification CallAgent di . Per creare un'istanza CallAgent , chiamare il createCallAgent(...) metodo sulla CallClient classe .

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

Quando la gestione del messaggio di notifica push ha esito positivo e tutti i gestori eventi vengono registrati correttamente, gli anelli dell'applicazione.

Annullare la registrazione delle notifiche push

Le applicazioni possono annullare la registrazione delle notifiche push in qualsiasi momento. Per annullare la registrazione, chiamare il unregisterPushNotification() metodo su callAgent:

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

Disabilitare le notifiche push interne per una chiamata in ingresso

Il payload push di una chiamata in ingresso può essere recapitato al chiamato in due modi:

• Uso di FCM e registrazione del token del dispositivo con l'API menzionata in precedenza, registerPushNotification in CallAgent o TeamsCallAgent
• Registrazione dell'SDK con un servizio interno al momento della creazione di CallAgent o TeamsCallAgent per ottenere il payload push recapitato

Usando la proprietà setDisableInternalPushForIncomingCall in CallAgentOptions o TeamsCallAgentOptions, è possibile indicare all'SDK di disabilitare il recapito del payload push tramite il servizio push interno:

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

Considerazioni sulle notifiche push per dispositivi mobili

Le notifiche push per dispositivi mobili sono le notifiche popup visualizzate nei dispositivi mobili. Per le chiamate, questo articolo è incentrato sulle notifiche push voice over Internet Protocol (VoIP). Per una guida sull'integrazione di CallKit nell'applicazione iOS, vedere Integrare con CallKit.

Configurare il sistema

Seguire questa procedura per configurare il sistema.

Creare il progetto Xcode

In Xcode creare un nuovo progetto iOS e selezionare il modello Single View Application. Questo articolo usa il framework SwiftUI, quindi è consigliabile impostare Language su Swift e impostare Interface su SwiftUI.

In questo articolo non verranno creati test. È possibile deselezionare la casella di controllo Includi i test.

Installare il pacchetto e le dipendenze usando CocoaPods

1. Creare un file Podfile per l'applicazione, come questo esempio:

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

2. Eseguire pod install.

3. Aprire .xcworkspace con Xcode.

Richiedere l'accesso al microfono

Per accedere al microfono del dispositivo, è necessario aggiornare l'elenco delle proprietà informazioni dell'app usando NSMicrophoneUsageDescription. Impostare il valore associato su una stringa inclusa nella finestra di dialogo usata dal sistema per richiedere l'accesso dall'utente.

Fare clic con il pulsante destro del mouse sulla voce info.plist dell'albero del progetto, quindi selezionare Apri come>codice sorgente. Aggiungere le righe seguenti nella sezione di primo livello <dict> e quindi salvare il file.

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

Configurare il framework dell'app

Aprire il file del ContentView.swift progetto. Aggiungere una dichiarazione import all'inizio del file per importare la libreria AzureCommunicationCalling. Inoltre, importare AVFoundation: È necessario per le richieste di autorizzazione audio nel codice.

import AzureCommunicationCalling
import AVFoundation

Inizializzare CallAgent

Per creare un'istanza CallAgent da CallClient, è necessario usare un metodo callClient.createCallAgent che restituisce in modo asincrono un oggetto CallAgent dopo l'inizializzazione.

Per creare un client di chiamata, passare un oggetto 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)
}

Passare l'oggetto CommunicationTokenCredential creato in CallClient e impostare il nome visualizzato:

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

Impostazione delle notifiche push

Prima di avviare le attività di registrazione per, gestione e annullamento della registrazione delle notifiche push, completare questa attività di configurazione:

1. In Xcode passare a Firma e funzionalità. Aggiungere una funzionalità selezionando + Funzionalità e quindi selezionare Notifiche push.
2. Aggiungere un'altra funzionalità selezionando + Funzionalità e quindi selezionare Modalità in background.
3. In Modalità in background, selezionare le caselle di controllo Voice over IP e Notifiche remote.

Registrarsi per le notifiche push

Per eseguire la registrazione per le notifiche push, chiamare registerPushNotification() su un'istanza CallAgent usando un token di registrazione del dispositivo.

La registrazione per le notifiche push deve essere eseguita dopo l'inizializzazione riuscita. Quando l'oggetto callAgent viene eliminato definitivamente, logout viene chiamato , che annulla automaticamente la registrazione delle notifiche 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.")
    }
}

Gestire le notifiche push

Per ricevere notifiche push per le chiamate in ingresso, chiamare handlePushNotification() su un'istanza CallAgent con un payload del dizionario:

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

Annullare la registrazione delle notifiche push

Le applicazioni possono annullare la registrazione delle notifiche push in qualsiasi momento. Per annullare la registrazione, chiamare il unregisterPushNotification metodo su 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")
    }
}

Disabilitare le notifiche push interne per una chiamata in ingresso

Il payload push di una chiamata in ingresso può essere recapitato al chiamato in due modi:

• Uso del servizio Apple Push Notification (APNS) e registrazione del token del dispositivo con l'API menzionata in precedenza, registerPushNotification in CallAgent o TeamsCallAgent
• Registrazione dell'SDK con un servizio interno al momento della creazione di CallAgent o TeamsCallAgent per ottenere il payload push recapitato

Usando la proprietà disableInternalPushForIncomingCall in CallAgentOptions o TeamsCallAgentOptions, è possibile indicare all'SDK di disabilitare il recapito del payload push tramite il servizio push interno:

let options = CallAgentOptions()
options.disableInternalPushForIncomingCall = true

Considerazioni sulle notifiche push di Windows

Le notifiche push per dispositivi mobili sono le notifiche popup visualizzate nei dispositivi mobili. Per le chiamate, questo articolo è incentrato sulle notifiche push voice over Internet Protocol (VoIP).

Le notifiche push nella piattaforma Windows vengono recapitate tramite Il servizio notifica push windows (WNS).

Configurare il sistema

Seguire questa procedura per configurare il sistema.

Creare il progetto di Visual Studio

Per un'app piattaforma UWP (Universal Windows Platform), in Visual Studio 2022 creare un nuovo progetto App vuota (Windows universale). Dopo aver immesso il nome del progetto, è possibile scegliere qualsiasi Windows SDK successivo alla versione 10.0.17763.0.

Per un'app WinUI 3, creare un nuovo progetto con il modello App vuota, Incluso nel pacchetto (WinUI 3 in Desktop) per configurare un'app WinUI 3 a pagina singola. È necessario SDK per app di Windows in versione 1.3 o successiva.

Installare il pacchetto e le dipendenze usando Gestione pacchetti NuGet

Le API e le librerie di SDK Chiamata sono disponibili pubblicamente tramite un pacchetto NuGet.

Per trovare, scaricare e installare il pacchetto NuGet Calling SDK:

1. Aprire Gestione pacchetti NuGet selezionando Strumenti>Gestione pacchetti NuGet> Gestisci pacchetti NuGet per la soluzione.
2. Selezionare Sfoglia e quindi immettere Azure.Communication.Calling.WindowsClient nella casella di ricerca.
3. Assicurarsi che la casella di controllo Includi versione preliminare sia selezionata.
4. Selezionare il pacchetto Azure.Communication.Calling.WindowsClient e quindi selezionare Azure.Communication.Calling.WindowsClient 1.4.0-beta.1 o una versione più recente.
5. Selezionare la casella di controllo corrispondente al progetto Servizi di comunicazione di Azure nel riquadro destro.
6. Selezionare Installa.

Impostazione delle notifiche push

Prima di avviare le attività di registrazione per, gestione e visualizzazione di una notifica di Windows per rispondere o rifiutare una chiamata in arrivo, completare questa attività di configurazione:

1. Seguire Esercitazione: Inviare notifiche alle app della piattaforma UWP (Universal Windows Platform) usando Hub di notifica di Azure. Dopo aver seguito l'esercitazione, si dispone di:

   • Applicazione con i pacchetti WindowsAzure.Messaging.Managed e Microsoft.Toolkit.Uwp.Notifications.
   • Un nome dell'hub di notifiche di Azure a cui si fa riferimento come <AZURE_PNH_HUB_NAME> e un hub di notifiche di Azure stringa di connessione a cui si fa riferimento come <AZURE_PNH_HUB_CONNECTION_STRING> in questo articolo.

2. Per registrarsi per un canale WNS in ogni inizializzazione dell'applicazione, assicurarsi di aggiungere il codice di inizializzazione nel App.xaml.cs file:

   // 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. Registrare il gestore eventi attivato quando arriva un nuovo messaggio di notifica push in 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;
       }
   }
   

Registrarsi per le notifiche push

Per eseguire la registrazione per le notifiche push, chiamare RegisterForPushNotificationAsync() su un'istanza CallAgent con il canale di registrazione WNS ottenuto durante l'inizializzazione dell'applicazione.

La registrazione per le notifiche push deve essere eseguita dopo l'inizializzazione riuscita.

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

Gestire le notifiche push

Per ricevere notifiche push per le chiamate in ingresso, chiamare handlePushNotification() su un'istanza CallAgent con un payload del dizionario:

// MainPage.xaml.cs

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

Questa chiamata attiva un evento di chiamata in ingresso in CallAgent che mostra la notifica di chiamata in ingresso:

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

Aggiungere il codice per gestire la pressione del pulsante per la notifica nel OnActivated metodo :

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