Registrare una chiamata all'avvio

Articolo
2023-10-26

La registrazione delle chiamate viene spesso usata direttamente tramite l'interfaccia utente di un'applicazione chiamante, in cui l'utente attiva la registrazione. Per le applicazioni all'interno di settori come il settore bancario o sanitario, la registrazione delle chiamate è necessaria dal get-go. Il servizio deve registrare automaticamente a scopo di conformità. Questo esempio illustra come registrare una chiamata all'avvio. Usa Servizi di comunicazione di Azure e Griglia di eventi di Azure per attivare una funzione di Azure all'avvio di una chiamata. Registra automaticamente ogni chiamata all'interno della risorsa Servizi di comunicazione di Azure.

In questo argomento di avvio rapido viene illustrato l'elaborazione degli eventi avviati dalle chiamate tramite Funzioni di Azure usando i trigger di Griglia di eventi. Per avviare la registrazione si usa Call Automation SDK per Servizi di comunicazione di Azure.

Evento Call Started quando un avvio di una chiamata viene formattato nel modo seguente:


[
  {
    "id": "a8bcd8a3-12d7-46ba-8cde-f6d0bda8feeb",
    "topic": "/subscriptions/{subscription-id}/resourcegroups/{group-name}/providers/microsoft.communication/communicationservices/{communication-services-resource-name}",
    "subject": "call/{serverCallId}/startedBy/8:acs:bc360ba8-d29b-4ef2-b698-769ebef85521_0000000c-1fb9-4878-07fd-0848220077e1",
    "data": {
      "startedBy": {
        "communicationIdentifier": {
          "rawId": "8:acs:bc360ba8-d29b-4ef2-b698-769ebef85521_0000000c-1fb9-4878-07fd-0848220077e1",
          "communicationUser": {
            "id": "8:acs:bc360ba8-d29b-4ef2-b698-769ebef85521_0000000c-1fb9-4878-07fd-0848220077e1"
          }
        },
        "role": "{role}"
      },
      "serverCallId": "{serverCallId}",
      "group": {
        "id": "00000000-0000-0000-0000-000000000000"
      },
      "room": {
        "id": "{roomId}"
      },
      "isTwoParty": false,
      "correlationId": "{correlationId}",
      "isRoomsCall": true
    },
    "eventType": "Microsoft.Communication.CallStarted",
    "dataVersion": "1.0",
    "metadataVersion": "1",
    "eventTime": "2021-09-22T17:02:38.6905856Z"
  }
]

Nota

L'uso di Griglia di eventi di Azure comporta costi aggiuntivi. Per altre informazioni, vedere prezzi Griglia di eventi di Azure.

Prerequisiti

Un account Azure con una sottoscrizione attiva. Creare un account gratuitamente.
Una stringa di connessione e una risorsa attiva di Servizi di comunicazione. Creare una risorsa di Servizi di comunicazione.
Installare l'interfaccia della riga di comando di Azure.

Configurazione dell'ambiente locale

Usando Visual Studio Code, installare l'estensione Funzioni di Azure.

Con l'estensione creare una funzione di Azure seguendo queste istruzioni.

Configurare la funzione con le istruzioni seguenti:

Linguaggio: C#
Modello: trigger Griglia di eventi di Azure
Nome funzione: definito dall'utente

Dopo la creazione, viene visualizzata una funzione creata nella directory come segue:


using System;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.EventGrid;
using Microsoft.Extensions.Logging;
using Azure.Messaging.EventGrid;
using System.Threading.Tasks;

namespace Company.Function
{
    public static class acs_recording_test
    {
        [FunctionName("acs_recording_test")]
        public static async Task RunAsync([EventGridTrigger]EventGridEvent eventGridEvent, ILogger log)
        {
            log.LogInformation(eventGridEvent.EventType);
        }

    }
}

Configurare la funzione di Azure per ricevere l'evento `CallStarted`

Configurare la funzione di Azure per eseguire azioni quando viene attivato l'evento CallStarted .


    public static async Task RunAsync([EventGridTrigger]EventGridEvent eventGridEvent, ILogger log)
    {
        if(eventGridEvent.EventType == "Microsoft.Communication.CallStarted")
        {
            log.LogInformation("Call started");
            var callEvent = eventGridEvent.Data.ToObjectFromJson<CallStartedEvent>();
            
            // CallStartedEvent class is defined in documentation, but the objects looks like this:
            // public class CallStartedEvent
            // {
            //     public StartedBy startedBy { get; set; }
            //     public string serverCallId { get; set; }
            //     public Group group { get; set; }
            //     public bool isTwoParty { get; set; }
            //     public string correlationId { get; set; }
            //     public bool isRoomsCall { get; set; }
            // }
            // public class Group
            // {
            //     public string id { get; set; }
            // }
            // public class StartedBy
            // {
            //     public CommunicationIdentifier communicationIdentifier { get; set; }
            //     public string role { get; set; }
            // }
            // public class CommunicationIdentifier
            // {
            //     public string rawId { get; set; }
            //     public CommunicationUser communicationUser { get; set; }
            // }
            // public class CommunicationUser
            // {
            //     public string id { get; set; }
            // }
        }
    }

Avviare la registrazione

Creare un metodo per gestire gli CallStarted eventi. Questo metodo attiva la registrazione per l'avvio della chiamata.


    public static async Task RunAsync([EventGridTrigger]EventGridEvent eventGridEvent, ILogger log)
    {
        if(eventGridEvent.EventType == "Microsoft.Communication.CallStarted")
        {
            log.LogInformation("Call started");
            var callEvent = eventGridEvent.Data.ToObjectFromJson<CallStartedEvent>();
            await startRecordingAsync(callEvent.serverCallId);
        }
    }

    public static async Task startRecordingAsync (String serverCallId)
    {
        CallAutomationClient callAutomationClient = new CallAutomationClient(Environment.GetEnvironmentVariable("ACS_CONNECTION_STRING"));
        StartRecordingOptions recordingOptions = new StartRecordingOptions(new ServerCallLocator(serverCallId));
        recordingOptions.RecordingChannel = RecordingChannel.Mixed;
        recordingOptions.RecordingContent = RecordingContent.AudioVideo;
        recordingOptions.RecordingFormat = RecordingFormat.Mp4;        
        var startRecordingResponse = await callAutomationClient.GetCallRecording()
            .StartRecordingAsync(recordingOptions).ConfigureAwait(false);
    }

Esecuzione in locale

Per eseguire la funzione in locale, è possibile premere F5 in Visual Studio Code. Si usa ngrok per associare la funzione di Azure in esecuzione in locale con Griglia di eventi di Azure.

Dopo l'esecuzione della funzione, viene configurato ngrok. È necessario scaricare ngrok per l'ambiente in uso.
```
 ngrok http 7071
```
Copiare il collegamento ngrok specificato in cui è in esecuzione la funzione.
Configurare gli eventi CallStarted tramite Griglia di eventi all'interno della risorsa Servizi di comunicazione di Azure. A questo scopo viene usata l'interfaccia della riga di comando di Azure. È necessario l'ID risorsa per la risorsa Servizi di comunicazione di Azure disponibile nel portale di Azure. L'ID risorsa è simile al seguente: /subscriptions/<<AZURE SUBSCRIPTION ID>>/resourceGroups/<<RESOURCE GROUP NAME>>/providers/Microsoft.Communication/CommunicationServices/<<RESOURCE NAME>>)
```
az eventgrid event-subscription create --name "<<EVENT_SUBSCRIPTION_NAME>>" --endpoint-type webhook --endpoint "<<NGROK URL>>/runtime/webhooks/EventGrid?functionName=<<FUNCTION NAME>> " --source-resource-id "<<RESOURCE_ID>>"  --included-event-types Microsoft.Communication.CallStarted
```
Ora che tutto è collegato, testare il flusso avviando una chiamata alla risorsa. Verranno visualizzati i log della console nel terminale in cui è in esecuzione la funzione. È possibile verificare che la registrazione venga avviata usando la funzionalità di registrazione delle chiamate nell'SDK chiamante e verificare che il valore booleano sia impostato su TRUE.

Distribuisci in Azure

Per distribuire la funzione di Azure in Azure, è necessario seguire queste istruzioni. Dopo la distribuzione, si configura Griglia di eventi per la risorsa Servizi di comunicazione di Azure. Con l'URL per la funzione di Azure distribuita (URL trovato nella portale di Azure sotto la funzione), viene eseguito un comando simile:


az eventgrid event-subscription update --name "<<EVENT_SUBSCRIPTION_NAME>>" --endpoint-type azurefunction --endpoint "<<AZ FUNCTION URL>> " --source-resource-id "<<RESOURCE_ID>>"

Poiché si sta aggiornando la sottoscrizione di eventi creata, assicurarsi di usare lo stesso nome della sottoscrizione di eventi usato nel passaggio precedente.

È possibile eseguire il test avviando una chiamata nella risorsa, simile al passaggio precedente.

Condividi tramite