Registrare una chiamata all'avvio

La registrazione chiamata 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 quello bancario o sanitario, la registrazione delle chiamate è necessaria fin dall'introduzione. 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 questa guida introduttiva viene illustrata l'elaborazione degli eventi avviati tramite Funzioni di Azure usando i trigger di Griglia di eventi. Per avviare la registrazione, viene usato SDK per automazione delle chiamate per Servizi di comunicazione di Azure.

L'evento Call Started quando un viene avviata 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"
  }
]

Annotazioni

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

Prerequisiti

Un account Azure con una sottoscrizione attiva. Creare un account gratuito.
Una risorsa attiva di Servizi di Comunicazione e una stringa di connessione. 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 l'evento CallStarted viene attivato.


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

Avvia registrazione

Creare un metodo per gestire gli eventi CallStarted. Questo metodo attiva la registrazione per l'avvio all'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.

Quando la funzione è in esecuzione, si configura ngrok. È necessario scaricare ngrok per l'ambiente in uso.
```
 ngrok http 7071
```
Copiare il collegamento ngrok fornito 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 di Servizi di comunicazione di Azure, disponibile nel portale di Azure. (L'ID risorsa ha un aspetto 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 per le chiamate e verificare se il valore booleano diventa TRUE.

Distribuzione su Azure

Per distribuire la funzione di Azure in Azure, è necessario seguire queste istruzioni. Dopo la distribuzione, viene configurata Griglia di eventi per la risorsa di Servizi di comunicazione di Azure. Con l'URL per la funzione di Azure distribuita (URL trovato nella portale di Azure nella 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é è in corso l'aggiornamento della sottoscrizione di eventi creata, assicurarsi di usare lo stesso nome di sottoscrizione di eventi usato nel passaggio precedente.

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

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2025-10-11