Gerenciar a gravação de chamadas no cliente

Instale o SDK

Use o comando npm install para instalar o SDK Comum e de Chamada dos Serviços de Comunicação do Azure para JavaScript.

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

Inicializar objetos necessários

Uma CallClient instância é necessária para a maioria das operações de chamada. Ao criar uma nova CallClient instância, você pode configurá-la com opções personalizadas, como uma Logger instância.

Com a instância CallClient, podes criar uma instância CallAgent chamando o createCallAgent. Esse método retorna de forma assíncrona um objeto de CallAgent instância.

O createCallAgent método usa CommunicationTokenCredential como argumento. Ele aceita um token de acesso de usuário.

Você pode usar o getDeviceManager na instância CallClient para acessar deviceManager.

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

Gerenciar a conectividade do SDK com a infraestrutura da Microsoft

A Call Agent instância ajuda você a gerenciar chamadas (para ingressar ou iniciar chamadas). Para funcionar, seu SDK de chamada precisa se conectar à infraestrutura da Microsoft para receber notificações de chamadas recebidas e coordenar outros detalhes da chamada. O seu Call Agent tem dois estados possíveis:

Conectado - Um Call Agent valor connectionStatue significa que o SDK do Connected cliente está conectado e é capaz de receber notificações da infraestrutura da Microsoft.

Desconectado - Um valor Call Agent connectionStatue de Disconnected indica que há um problema que está impedindo o SDK de se conectar corretamente. Call Agent deve ser recriado.

• invalidToken: Se um token expirou ou é inválido Call Agent , a instância se desconecta com esse erro.
• connectionIssue: Se houver um problema com o cliente se conectando à infraestrutura da Microsoft, depois de muitas novas tentativas Call Agent expõe o erro connectionIssue.

Você pode verificar se seu local Call Agent está conectado à infraestrutura da Microsoft inspecionando o valor atual da connectionState propriedade. Durante uma chamada ativa, você pode ouvir o connectionStateChanged evento para determinar se Call Agent muda do estado Conectado para Desconectado.

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

Registo de nuvem e conformidade

A gravação de chamadas é um recurso estendido da API de chamada principal. Primeiro, você precisa importar recursos de chamada do SDK de chamada:

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

Em seguida, você pode obter o objeto API dos recursos de gravação da instância de chamada:

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

Para verificar se a chamada está sendo gravada, inspecione a isRecordingActive propriedade de callRecordingApi. Ele retorna Boolean.

const isRecordingActive = callRecordingApi.isRecordingActive;

Também pode inscrever-se para registar alterações:

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

callRecordingApi.on('isRecordingActiveChanged', isRecordingActiveChangedHandler);

Você pode obter uma lista de gravações usando a recordings propriedade de callRecordingApi. Ele retorna RecordingInfo[], que tem o estado atual da gravação na nuvem.

const recordings = callRecordingApi.recordings;

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

Você também pode se inscrever recordingsUpdated e obter uma coleção de gravações atualizadas. Este evento é ativado sempre que há uma atualização de gravação.

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

Consentimento explícito

Quando sua reunião ou chamada do Teams é configurada para exigir consentimento explícito para gravação e transcrição, é necessário coletar o consentimento de todos os participantes da chamada antes de gravá-los. Você pode fornecer consentimento de forma proativa ao ingressar na reunião ou reativamente quando a gravação for iniciada. Até que o consentimento explícito seja dado, o áudio, o vídeo e o compartilhamento de tela dos participantes serão desativados durante a gravação.

Você pode verificar se a gravação da reunião requer consentimento explícito através da propriedade isTeamsConsentRequired. Se o valor for definido como true, é necessário o consentimento explícito para o call.

const isConsentRequired = callRecordingApi.isTeamsConsentRequired;

Se você já obteve o consentimento do usuário para gravação, você pode chamar grantTeamsConsent() o método para indicar consentimento explícito para o serviço. Esse consentimento é válido apenas para uma call sessão e os usuários precisam fornecer consentimento novamente se voltarem a participar da reunião.

callRecordingApi.grantTeamsConsent();

As tentativas de ativar o compartilhamento de áudio, vídeo ou tela falham quando a gravação está ativa, o consentimento explícito é necessário, mas ainda não foi dado. Você pode reconhecer essa situação verificando a propriedade reason da classe ParticipantCapabilities para as capacidadesturnVideoOn, unmuteMic e shareScreen. Você pode encontrar esses recursos no recurso call.feature(Features.Capabilities). Esses recursos retornariam a razão ExplicitConsentRequired , pois os usuários precisam fornecer consentimento explícito.

Instale o SDK

Localize seu arquivo no nível build.gradle do projeto e adicione mavenCentral() à lista de repositórios em buildscript e allprojects:

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

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

Em seguida, no arquivo de nível de módulo build.gradle, adicione as seguintes linhas à seção dependencies:

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

Inicializar os objetos necessários

Para criar uma CallAgent instância, você precisa chamar o createCallAgent método em uma CallClient instância. Esta chamada retorna de forma assíncrona um objeto de instância CallAgent.

O createCallAgent método toma CommunicationUserCredential como um argumento, que encapsula um token de acesso.

Para aceder DeviceManager, deve primeiro criar uma instância de callAgent. Então você pode usar o CallClient.getDeviceManager método para obter 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();

Para definir um nome de exibição para o chamador, use este método 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();

Gravar chamadas

A gravação de chamadas é um recurso estendido do objeto principal Call .

Primeiro, você precisa obter o objeto de recurso de gravação:

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

Em seguida, para verificar se a chamada está sendo gravada, inspecione a isRecordingActive propriedade de callRecordingFeature. Ele retorna boolean.

boolean isRecordingActive = callRecordingFeature.isRecordingActive();

Também pode inscrever-se para registar alterações:

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

callRecordingFeature.addOnIsRecordingActiveChangedListener(handleCallOnIsRecordingChanged);

Se você quiser começar a gravar a partir do seu aplicativo, primeiro siga a visão geral da gravação de chamadas para as etapas para configurar a gravação de chamadas.

Depois de configurar a gravação de chamadas no seu servidor, a partir do seu aplicativo Android, você precisa obter o ServerCallId valor da chamada e, em seguida, enviá-lo para o seu servidor para iniciar o processo de gravação. Você pode encontrar o valor ServerCallId usando getServerCallId() da classe CallInfo. Você pode encontrar a CallInfo classe no objeto de 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 você inicia a gravação a partir do servidor, o evento handleCallOnIsRecordingChanged é acionado e o valor de callRecordingFeature.isRecordingActive() é true.

Assim como iniciar a gravação da chamada, se você quiser parar a gravação da chamada, você precisa obter ServerCallId e enviá-lo para o seu servidor de gravação para que ele possa parar a gravação:

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 você para de gravar a partir do servidor, o evento handleCallOnIsRecordingChanged é acionado e o valor de callRecordingFeature.isRecordingActive() é false.

Consentimento explícito

Quando sua reunião ou chamada do Teams é configurada para exigir consentimento explícito para gravação e transcrição, é necessário coletar o consentimento de todos os participantes da chamada antes de gravá-los. Você pode fornecer consentimento de forma proativa ao ingressar na reunião ou reativamente quando a gravação for iniciada. Até que o consentimento explícito seja dado, o áudio, o vídeo e o compartilhamento de tela dos participantes serão desativados durante a gravação.

Você pode verificar se a gravação da reunião requer consentimento explícito através da propriedade isTeamsConsentRequired. Se o valor for definido como true, é necessário o consentimento explícito para o call.

boolean isConsentRequired = callRecordingFeature.isTeamsConsentRequired();

Se você já obteve o consentimento do usuário para gravação, você pode chamar grantTeamsConsent() o método para indicar consentimento explícito para o serviço. Esse consentimento é válido apenas para uma call sessão e os usuários precisam fornecer consentimento novamente se voltarem a participar da reunião.

callRecordingFeature.grantTeamsConsent();

As tentativas de ativar o compartilhamento de áudio, vídeo ou tela falham quando a gravação está ativa, o consentimento explícito é necessário, mas ainda não foi dado. Você pode reconhecer essa situação verificando a propriedade reason da classe ParticipantCapabilities para as capacidadesturnVideoOn, unmuteMic e shareScreen. Você pode encontrar esses recursos no recurso call.feature(Features.Capabilities). Esses recursos retornariam a razão ExplicitConsentRequired , pois os usuários precisam fornecer consentimento explícito.

Configure o seu sistema

Siga estes passos para configurar o seu sistema.

Criar o projeto Xcode

No Xcode, crie um novo projeto iOS e selecione o modelo Single View App . Este artigo usa a estrutura SwiftUI, portanto, você deve definir Language como Swift e Interfacecomo SwiftUI.

Você não vai criar testes neste artigo. Sinta-se à vontade para desmarcar a opção Incluir Testes.

Instale o pacote e as dependências usando o CocoaPods

1. Crie um Podfile para seu aplicativo, como este exemplo:

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

2. Execute pod install.

3. Abra .xcworkspace usando o Xcode.

Solicitar acesso ao microfone

Para acessar o microfone do dispositivo, você precisa atualizar a lista de propriedades de informações do seu aplicativo usando NSMicrophoneUsageDescription. Defina o valor associado para uma cadeia de caracteres incluída na caixa de diálogo que o sistema usa para solicitar acesso do usuário.

Clique com o botão direito do mouse na entrada Info.plist da árvore do projeto e selecione Abrir como>código-fonte. Adicione as seguintes linhas na secção de nível <dict> superior e, em seguida, guarde o ficheiro.

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

Configurar a estrutura do aplicativo

Abra o arquivo ContentView.swift do seu projeto. Adicione uma import declaração à parte superior do arquivo para importar a AzureCommunicationCalling biblioteca. Além disso, importe AVFoundation. Você precisa dele para solicitações de permissão de áudio no código.

import AzureCommunicationCalling
import AVFoundation

Inicializar CallAgent

Para criar uma CallAgent instância a partir do CallClient, você precisa usar um callClient.createCallAgent método que retorna de forma assíncrona um CallAgent objeto depois que ele é inicializado.

Para criar um cliente de chamada, passe um CommunicationTokenCredential objeto:

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

Passe o CommunicationTokenCredential objeto que você criou para CallCliente defina o nome para exibição:

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

Gravar chamadas

A gravação de chamadas é um recurso estendido do objeto principal Call .

Primeiro, você precisa obter o objeto de recurso de gravação:

let callRecordingFeature = call.feature(Features.recording)

Em seguida, para verificar se a chamada está sendo gravada, inspecione a isRecordingActive propriedade de callRecordingFeature. Ele retorna Bool.

let isRecordingActive = callRecordingFeature.isRecordingActive;

Você também pode subscrever-se para registar alterações ao implementar o delegado RecordingCallFeatureDelegate na sua classe com o evento didChangeRecordingState:

callRecordingFeature.delegate = self

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

Se você quiser começar a gravar a partir do seu aplicativo, primeiro siga a visão geral da gravação de chamadas para as etapas para configurar a gravação de chamadas.

Depois de configurar a gravação de chamadas no seu servidor, a partir do seu aplicativo iOS, você precisa obter o ServerCallId valor da chamada e, em seguida, enviá-lo para o seu servidor para iniciar o processo de gravação. Você pode encontrar o valor ServerCallId usando getServerCallId() da classe CallInfo. Você pode encontrar a CallInfo classe no objeto de classe usando getInfo().

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

Quando você inicia a gravação a partir do servidor, o evento didChangeRecordingState é acionado e o valor de recordingFeature.isRecordingActive é true.

Assim como iniciar a gravação da chamada, se você quiser parar a gravação da chamada, você precisa obter ServerCallId e enviá-lo para o seu servidor de gravação para que ele possa parar a gravação:

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

Quando você para de gravar a partir do servidor, o evento didChangeRecordingState é acionado e o valor de recordingFeature.isRecordingActive é false.

Consentimento explícito

Quando sua reunião ou chamada do Teams é configurada para exigir consentimento explícito para gravação e transcrição, é necessário coletar o consentimento de todos os participantes da chamada antes de gravá-los. Você pode fornecer consentimento de forma proativa ao ingressar na reunião ou reativamente quando a gravação for iniciada. Até que o consentimento explícito seja dado, o áudio, o vídeo e o compartilhamento de tela dos participantes serão desativados durante a gravação.

Você pode verificar se a gravação da reunião requer consentimento explícito através da propriedade isTeamsConsentRequired. Se o valor for definido como true, é necessário o consentimento explícito para o call.

let isConsentRequired = recordingFeature.isTeamsConsentRequired;

Se você já obteve o consentimento do usuário para gravação, você pode chamar grantTeamsConsent() o método para indicar consentimento explícito para o serviço. Esse consentimento é válido apenas para uma call sessão e os usuários precisam fornecer consentimento novamente se voltarem a participar da reunião.

recordingFeature.grantTeamsConsent();

As tentativas de ativar o compartilhamento de áudio, vídeo ou tela falham quando a gravação está ativa, o consentimento explícito é necessário, mas ainda não foi dado. Você pode reconhecer essa situação verificando a propriedade reason da classe ParticipantCapabilities para as capacidadesturnVideoOn, unmuteMic e shareScreen. Você pode encontrar esses recursos no recurso call.feature(Features.Capabilities). Esses recursos retornariam a razão ExplicitConsentRequired , pois os usuários precisam fornecer consentimento explícito.

Configure o seu sistema

Siga estes passos para configurar o seu sistema.

Criar o projeto do Visual Studio

Para uma aplicação da Plataforma Universal do Windows, no Visual Studio 2022, crie um novo projeto Aplicação em Branco (Windows Universal). Depois de inserir o nome do projeto, sinta-se à vontade para escolher qualquer SDK do Windows posterior a 10.0.17763.0.

Para uma aplicação WinUI 3, crie um novo projeto com o modelo Aplicação em branco, empacotada (WinUI 3 na área de trabalho) para configurar uma aplicação WinUI 3 de página única. É necessário o SDK de Aplicativos Windows versão 1.3 ou posterior.

Instalar o pacote e as dependências usando o Gerenciador de Pacotes NuGet

As APIs e bibliotecas do SDK de chamada estão disponíveis publicamente por meio de um pacote NuGet.

Para localizar, descarregar e instalar o pacote NuGet do SDK de chamadas:

1. Abra o Gerenciador de Pacotes NuGet selecionando Ferramentas>Gerenciador de Pacotes NuGet>Gerenciar Pacotes NuGet para Solução.
2. Selecione Procurar e digite Azure.Communication.Calling.WindowsClient na caixa de pesquisa.
3. Verifique se a caixa de seleção Incluir pré-lançamento está marcada.
4. Selecione o pacote Azure.Communication.Calling.WindowsClient e, em seguida, selecione Azure.Communication.Calling.WindowsClient1.4.0-beta.1 ou uma versão mais recente.
5. Marque a caixa de seleção que corresponde ao projeto dos Serviços de Comunicação do Azure no painel direito.
6. Selecione Instalar.

Gravar chamadas

A gravação de chamadas é um recurso estendido do objeto principal Call . Primeiro, você precisa obter o objeto de recurso de gravação:

RecordingCallFeature recordingFeature = call.Features.Recording;

Em seguida, para verificar se a chamada está sendo gravada, inspecione a IsRecordingActive propriedade de recordingFeature. Ele retorna boolean.

boolean isRecordingActive = recordingFeature.IsRecordingActive;

Também pode inscrever-se para registar alterações:

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

recordingFeature.IsRecordingActiveChanged += Call__OnIsRecordingActiveChanged;

Consentimento explícito

Quando sua reunião ou chamada do Teams é configurada para exigir consentimento explícito para gravação e transcrição, é necessário coletar o consentimento de todos os participantes da chamada antes de gravá-los. Você pode fornecer consentimento de forma proativa ao ingressar na reunião ou reativamente quando a gravação for iniciada. Até que o consentimento explícito seja dado, o áudio, o vídeo e o compartilhamento de tela dos participantes serão desativados durante a gravação.

Você pode verificar se a gravação da reunião requer consentimento explícito através da propriedade isTeamsConsentRequired. Se o valor for definido como true, é necessário o consentimento explícito para o call.

boolean isConsentRequired = recordingFeature.isTeamsConsentRequired;

Se você já obteve o consentimento do usuário para gravação, você pode chamar grantTeamsConsent() o método para indicar consentimento explícito para o serviço. Esse consentimento é válido apenas para uma call sessão e os usuários precisam fornecer consentimento novamente se voltarem a participar da reunião.

recordingFeature.grantTeamsConsent();

As tentativas de ativar o compartilhamento de áudio, vídeo ou tela falham quando a gravação está ativa, o consentimento explícito é necessário, mas ainda não foi dado. Você pode reconhecer essa situação verificando a propriedade reason da classe ParticipantCapabilities para as capacidadesturnVideoOn, unmuteMic e shareScreen. Você pode encontrar esses recursos no recurso call.feature(Features.Capabilities). Esses recursos retornariam a razão ExplicitConsentRequired , pois os usuários precisam fornecer consentimento explícito.