Gestire la registrazione delle chiamate nel client

Installare SDK

Usare il npm install comando per installare l'SDK comune e chiamante Servizi di comunicazione di Azure per JavaScript:

npm install @azure/communication-common --save
npm install @azure/communication-calling --save

Inizializzare gli oggetti necessari

Per la maggior parte delle operazioni di chiamata è necessaria un'istanza CallClient di . Quando si crea una nuova CallClient istanza, è possibile configurarla con opzioni personalizzate come un'istanza Logger di .

Con l'istanza di è possibile creare un'istanza CallClient CallAgent chiamando .createCallAgent Questo metodo restituisce in modo asincrono un CallAgent oggetto istanza.

Il createCallAgent metodo usa CommunicationTokenCredential come argomento. Accetta un token di accesso utente.

È possibile usare il metodo nell'istanza getDeviceManager CallClient di per accedere deviceManagera .

const { CallClient } = require('@azure/communication-calling');
const { AzureCommunicationTokenCredential} = require('@azure/communication-common');
const { AzureLogger, setLogLevel } = require("@azure/logger");

// Set the logger's log level
setLogLevel('verbose');

// Redirect log output to console, file, buffer, REST API, or whatever location you want
AzureLogger.log = (...args) => {
    console.log(...args); // Redirect log output to console
};

const userToken = '<USER_TOKEN>';
callClient = new CallClient(options);
const tokenCredential = new AzureCommunicationTokenCredential(userToken);
const callAgent = await callClient.createCallAgent(tokenCredential, {displayName: 'optional Azure Communication Services user name'});
const deviceManager = await callClient.getDeviceManager()

Come gestire al meglio la connettività dell'SDK all'infrastruttura Microsoft

L'istanza Call Agent consente di gestire le chiamate (per partecipare o avviare le chiamate). Per lavorare con l'SDK per chiamate, è necessario connettersi all'infrastruttura Microsoft per ricevere notifiche delle chiamate in arrivo e coordinare altri dettagli delle chiamate. Gli Call Agent stati possibili sono due:

Connessione ed: un Call Agent valore connectionStatue indica Connected che l'SDK client è connesso e in grado di ricevere notifiche dall'infrastruttura Microsoft.

Disconnesso : valore Call Agent connectionStatue di Disconnected stati che impedisce all'SDK di connettersi correttamente. Call Agent deve essere ricreato.

• invalidToken: se un token è scaduto o l'istanza non è valida Call Agent si disconnette con questo errore.
• connectionIssue: se si verifica un problema con il client che si connette a Microsoft infrascture, dopo molti tentativi Call Agent espone l'errore connectionIssue .

È possibile verificare se l'infrastruttura locale Call Agent è connessa all'infrastruttura Microsoft controllando il valore corrente della connectionState proprietà. Durante una chiamata attiva è possibile restare in ascolto dell'evento connectionStateChanged per determinare se Call Agent cambia da Connessione stato disconnesso a Disconnesso.

const connectionState = callAgentInstance.connectionState;
console.log(connectionState); // it may return either of 'Connected' | 'Disconnected'

const connectionStateCallback = (args) => {
    console.log(args); // it will return an object with oldState and newState, each of having a value of either of 'Connected' | 'Disconnected'
    // it will also return reason, either of 'invalidToken' | 'connectionIssue'
}
callAgentInstance.on('connectionStateChanged', connectionStateCallback);

Registrazione nel cloud

La registrazione delle chiamate è una funzionalità estesa dell'API di chiamata principale. È prima necessario importare le funzionalità di chiamata da Calling SDK:

import { Features} from "@azure/communication-calling";

È quindi possibile ottenere l'oggetto API delle funzionalità di registrazione dall'istanza di chiamata:

const callRecordingApi = call.feature(Features.Recording);

Per verificare se la chiamata viene registrata, controllare la isRecordingActive proprietà di callRecordingApi. Restituisce Boolean.

const isRecordingActive = callRecordingApi.isRecordingActive;

È anche possibile sottoscrivere la registrazione delle modifiche:

const isRecordingActiveChangedHandler = () => {
    console.log(callRecordingApi.isRecordingActive);
};

callRecordingApi.on('isRecordingActiveChanged', isRecordingActiveChangedHandler);

È possibile ottenere un elenco di registrazioni usando la recordings proprietà di callRecordingApi. Restituisce RecordingInfo[], che ha lo stato corrente della registrazione cloud.

const recordings = callRecordingApi.recordings;

recordings.forEach(r => {
    console.log("State: ${r.state}");

È anche possibile sottoscrivere recordingsUpdated e ottenere una raccolta di registrazioni aggiornate. Questo evento viene attivato ogni volta che è presente un aggiornamento della registrazione.

const cloudRecordingsUpdatedHandler = (args: { added: SDK.RecordingInfo[], removed: SDK.RecordingInfo[]}) => {
                        console.log('Recording started by: ');
                        args.added?.forEach(a => {
                            console.log('State: ${a.state}');
                        });

                        console.log('Recording stopped by: ');
                        args.removed?.forEach(r => {
                            console.log('State: ${r.state}');
                        });
                    };
callRecordingApi.on('recordingsUpdated', cloudRecordingsUpdatedHandler );

Installare SDK

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

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

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

Quindi, nel file build.gradle a livello 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 di , è necessario chiamare il metodo in un'istanza createCallAgent CallClient di . Questa chiamata restituisce in modo asincrono un CallAgent oggetto istanza.

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

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

Registrare le chiamate

La registrazione delle chiamate è una funzionalità estesa dell'oggetto principale Call .

È prima necessario ottenere l'oggetto funzionalità di registrazione:

RecordingCallFeature callRecordingFeature = call.feature(Features.RECORDING);

Quindi, per verificare se la chiamata viene registrata, controllare la isRecordingActive proprietà di callRecordingFeature. Restituisce boolean.

boolean isRecordingActive = callRecordingFeature.isRecordingActive();

È anche possibile sottoscrivere la registrazione delle modifiche:

private void handleCallOnIsRecordingChanged(PropertyChangedEvent args) {
  boolean isRecordingActive = callRecordingFeature.isRecordingActive();
}

callRecordingFeature.addOnIsRecordingActiveChangedListener(handleCallOnIsRecordingChanged);

Se vuoi avviare la registrazione dall'applicazione, segui prima di tutto la panoramica della registrazione delle chiamate per la procedura per configurare la registrazione delle chiamate.

Dopo aver configurato la registrazione delle chiamate sul server, dall'applicazione Android è necessario ottenere il ServerCallId valore dalla chiamata e quindi inviarlo al server per avviare il processo di registrazione. È possibile trovare il ServerCallId valore usando getServerCallId() dalla CallInfo classe . È possibile trovare la CallInfo classe nell'oggetto classe usando getInfo().

try {
    String serverCallId = call.getInfo().getServerCallId().get();
    // Send serverCallId to your recording server to start the call recording.
} catch (ExecutionException | InterruptedException e) {

} catch (UnsupportedOperationException unsupportedOperationException) {

}

Quando si avvia la registrazione dal server, l'evento handleCallOnIsRecordingChanged viene attivato e il valore di callRecordingFeature.isRecordingActive() è true.

Proprio come l'avvio della registrazione delle chiamate, se vuoi arrestare la registrazione delle chiamate, devi ottenerla ServerCallId e inviarla al server di registrazione in modo che possa arrestare la registrazione:

try {
    String serverCallId = call.getInfo().getServerCallId().get();
    // Send serverCallId to your recording server to stop the call recording.
} catch (ExecutionException | InterruptedException e) {

} catch (UnsupportedOperationException unsupportedOperationException) {

}

Quando si arresta la registrazione dal server, l'evento handleCallOnIsRecordingChanged viene attivato e il valore di callRecordingFeature.isRecordingActive() è false.

Configurare il sistema

Creare il progetto Xcode

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

Durante questa guida introduttiva non verranno creati test. Deselezionare la casella di controllo Includi test .

Installare il pacchetto e le dipendenze usando CocoaPods

1. Creare un podfile per l'applicazione, come nell'esempio seguente:

   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à delle informazioni dell'app usando NSMicrophoneUsageDescription. Impostare il valore associato su una stringa che verrà 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 e quindi scegliere 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 ContentView.swift del progetto. Aggiungere una import dichiarazione all'inizio del file per importare la AzureCommunicationCalling libreria. Inoltre, importare AVFoundation. Sarà 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 callClient.createCallAgent metodo che restituisce in modo asincrono un CallAgent oggetto dopo l'inizializzazione.

Per creare un client di chiamata, passare un CommunicationTokenCredential oggetto :

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

Registrare le chiamate

La registrazione delle chiamate è una funzionalità estesa dell'oggetto principale Call .

È prima necessario ottenere l'oggetto funzionalità di registrazione:

let callRecordingFeature = call.feature(Features.recording)

Quindi, per verificare se la chiamata viene registrata, controllare la isRecordingActive proprietà di callRecordingFeature. Restituisce Bool.

let isRecordingActive = callRecordingFeature.isRecordingActive;

È anche possibile sottoscrivere la registrazione delle modifiche implementando il delegato nella RecordingCallFeatureDelegate classe con l'evento didChangeRecordingState:

callRecordingFeature.delegate = self

// didChangeRecordingState is a member of RecordingCallFeatureDelegate
public func recordingCallFeature(_ recordingCallFeature: RecordingCallFeature, didChangeRecordingState args: PropertyChangedEventArgs) {
    let isRecordingActive = recordingFeature.isRecordingActive
}

Se vuoi avviare la registrazione dall'applicazione, segui prima di tutto la panoramica della registrazione delle chiamate per la procedura per configurare la registrazione delle chiamate.

Dopo aver configurato la registrazione delle chiamate sul server, dall'applicazione iOS è necessario ottenere il ServerCallId valore dalla chiamata e quindi inviarlo al server per avviare il processo di registrazione. È possibile trovare il ServerCallId valore usando getServerCallId() dalla CallInfo classe . È possibile trovare la CallInfo classe nell'oggetto classe usando getInfo().

// Send serverCallId to your recording server to start the call recording.
let serverCallId = call.info.getServerCallId(){ (serverId, error) in }

Quando si avvia la registrazione dal server, l'evento didChangeRecordingState viene attivato e il valore di recordingFeature.isRecordingActive è true.

Proprio come l'avvio della registrazione delle chiamate, se vuoi arrestare la registrazione delle chiamate, devi ottenerla ServerCallId e inviarla al server di registrazione in modo che possa arrestare la registrazione:

// Send serverCallId to your recording server to stop the call recording.
let serverCallId = call.info.getServerCallId(){ (serverId, error) in }

Quando si arresta la registrazione dal server, l'evento didChangeRecordingState viene attivato e il valore di recordingFeature.isRecordingActive è false.

Configurare il sistema

Creare il progetto di Visual Studio

Per un'app UWP, 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, In pacchetto (WinUI 3 in Desktop) per configurare un'app WinUI 3 a pagina singola. SDK per app di Windows versione 1.3 o successiva è necessario.

Installare il pacchetto e le dipendenze usando NuGet Gestione pacchetti

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

I passaggi seguenti illustrano come trovare, scaricare e installare il pacchetto NuGet di Calling SDK:

1. Aprire Gestione pacchetti NuGet selezionando Strumenti>NuGet Gestione pacchetti> 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 Azure.Communication.Calling.WindowsClient pacchetto e quindi selezionare Azure.Communication.Calling.WindowsClient1.4.0-beta.1 o una versione più recente.
5. Selezionare la casella di controllo corrispondente al progetto Servizi di comunicazione nella scheda a destra.
6. Selezionare il pulsante Installa.

Registrare le chiamate

La registrazione delle chiamate è una funzionalità estesa dell'oggetto principale Call . È prima necessario ottenere l'oggetto funzionalità di registrazione:

RecordingCallFeature recordingFeature = call.Features.Recording;

Quindi, per verificare se la chiamata viene registrata, controllare la IsRecordingActive proprietà di recordingFeature. Restituisce boolean.

boolean isRecordingActive = recordingFeature.IsRecordingActive;

È anche possibile sottoscrivere la registrazione delle modifiche:

private async void Call__OnIsRecordingActiveChanged(object sender, PropertyChangedEventArgs args)
  boolean isRecordingActive = recordingFeature.IsRecordingActive;
}

recordingFeature.IsRecordingActiveChanged += Call__OnIsRecordingActiveChanged;