Guia de início rápido: gerenciar uma chamada de sala

Introdução

Durante uma chamada de sala dos Serviços de Comunicação do Azure (ACS), você pode gerenciar a chamada usando SDKs de Chamada ou SDKs de Automação de Chamadas ou ambos. Em uma chamada de sala, você pode controlar as ações na chamada usando as funções atribuídas aos participantes e as propriedades configuradas na sala. Os recursos de controle de funções do participante são permitidos por participante, enquanto as propriedades da sala se aplicam à chamada de sala como um todo.

Chamando SDKs

O SDK de chamada é uma biblioteca de chamadas do lado do cliente que permite que os participantes de uma chamada de sala executem várias operações na chamada, como compartilhamento de tela, ativar/desativar vídeo, silenciar/desativar o som e assim por diante. Para obter a lista completa de recursos, consulte Visão geral do SDK de chamada.

Você controla os recursos com base nas funções atribuídas aos participantes da chamada. Por exemplo, apenas o apresentador pode compartilhar a tela. Para funções e permissões de participantes, consulte Conceitos de salas.

SDKs de automação de chamadas

O SDK de Automação de Chamadas é uma biblioteca do lado do servidor que permite aos administradores gerenciar uma chamada de sala em andamento em um ambiente central e controlado. Ao contrário do SDK de Chamada, as operações do SDK de Automação de Chamadas são agnósticas de funções. Portanto, um administrador de chamada pode executar várias operações de chamada em nome dos participantes da chamada de sala.

As listas a seguir descrevem ações comuns em chamada disponíveis em uma chamada de sala.

Conectar-se a uma chamada de sala

A Automação de Chamadas deve se conectar a uma chamada de sala existente antes de executar qualquer operação de chamada. Os CallConnected eventos or ConnectFailed são gerados usando mecanismos de retorno de chamada para indicar se uma operação de conexão foi bem-sucedida ou falhou, respectivamente.

Afiado

Uri callbackUri = new Uri("https://<myendpoint>/Events"); //the callback endpoint where you want to receive subsequent events
CallLocator roomCallLocator = new RoomCallLocator("<RoomId>");
ConnectCallResult response = await client.ConnectAsync(roomCallLocator, callbackUri);

Java

String callbackUri = "https://<myendpoint>/Events"; //the callback endpoint where you want to receive subsequent events
CallLocator roomCallLocator =  new RoomCallLocator("<RoomId>");
ConnectCallResult response = client.connectCall(roomCallLocator, callbackUri).block();

JavaScript

const roomCallLocator = { kind: "roomCallLocator", id: "<RoomId>" };
const callbackUri = "https://<myendpoint>/Events"; // the callback endpoint where you want to receive subsequent events 
const response = await client.connectCall(roomCallLocator, callbackUri);

Python

callback_uri = "https://<myendpoint>/Events"  # the callback endpoint where you want to receive subsequent events
room_call_locator = RoomCallLocator("<room_id>")
call_connection_properties = client.connect_call(call_locator=room_call_locator, callback_url=callback_uri)

Uma vez conectado com êxito a uma chamada de sala, um CallConnect evento é notificado via URI de retorno de chamada. Você pode usar callConnectionId para recuperar uma conexão de chamada na chamada de sala, conforme necessário. Os trechos de código de exemplo a seguir usam o callConnectionId para demonstrar essa função.

Adicionar participante PSTN

Usando a Automação de Chamadas, você pode discar para um número PSTN e adicionar o participante a uma chamada de sala. No entanto, você deve configurar uma sala para habilitar a opção de discagem PSTN (EnabledPSTNDialout definida como true) e o recurso Serviços de Comunicação do Azure deve ter um número de telefone válido provisionado.

Para obter mais informações, consulte Início rápido de salas.

Afiado

var callerIdNumber = new PhoneNumberIdentifier("+16044561234"); // This is the ACS-provisioned phone number for the caller  
var callThisPerson = new CallInvite(new PhoneNumberIdentifier("+16041234567"), callerIdNumber); // The target phone number to dial out to
CreateCallResult response = await client.GetCallConnection(callConnectionId).AddParticipantAsync(callThisPerson);

Java

PhoneNumberIdentifier callerIdNumber = new PhoneNumberIdentifier("+16044561234"); // This is the ACS-provisioned phone number for the caller
CallInvite callInvite = new CallInvite(new PhoneNumberIdentifier("+16041234567"), callerIdNumber); // The phone number participant to dial out to
AddParticipantOptions addParticipantOptions = new AddParticipantOptions(callInvite);
Response<AddParticipantResult> addParticipantResultResponse = client.getCallConnectionAsync(callConnectionId)
    .addParticipantWithResponse(addParticipantOptions).block();

JavaScript

const callInvite = {
    targetParticipant: { phoneNumber: "+18008008800" }, // The phone number participant to dial out to
    sourceCallIdNumber: { phoneNumber: "+18888888888" } // This is the ACS-provisioned phone number for the caller
};
const response = await client.getCallConnection(callConnectionId).addParticipant(callInvite);

Python

caller_id_number = PhoneNumberIdentifier(
    "+18888888888"
) # TThis is the ACS-provisioned phone number for the caller
target = PhoneNumberIdentifier("+18008008800"), # The phone number participant to dial out to

call_connection_client = call_automation_client.get_call_connection(
    "call_connection_id"
)
result = call_connection_client.add_participant(
    target,
    operation_context="Your context",
    operationCallbackUrl="<url_endpoint>"
)

Remover participante PSTN

Afiado

var removeThisUser = new PhoneNumberIdentifier("+16044561234");

// Remove a participant from the call with optional parameters
var removeParticipantOptions = new RemoveParticipantOptions(removeThisUser)
{
    OperationContext = "operationContext",
    OperationCallbackUri = new Uri("uri_endpoint"); // Sending event to a non-default endpoint
}

RemoveParticipantsResult result = await client.GetCallConnection(callConnectionId).RemoveParticipantAsync(removeParticipantOptions);

Java

CommunicationIdentifier removeThisUser = new PhoneNumberIdentifier("+16044561234");
RemoveParticipantOptions removeParticipantOptions = new RemoveParticipantOptions(removeThisUser)
                .setOperationContext("<operation_context>")
                .setOperationCallbackUrl("<url_endpoint>");
Response<RemoveParticipantResult> removeParticipantResultResponse = client.getCallConnectionAsync(callConnectionId)
    .removeParticipantWithResponse(removeParticipantOptions);

JavaScript

const removeThisUser = { phoneNumber: "+16044561234" };
const removeParticipantResult = await client.getCallConnection(callConnectionId).removeParticipant(removeThisUser);

Python

remove_this_user = PhoneNumberIdentifier("+16044561234")
call_connection_client = call_automation_client.get_call_connection(
    "call_connection_id"
)
result = call_connection_client.remove_participant(remove_this_user, operation_context="Your context", operationCallbackUrl="<url_endpoint>")

Enviar DTMF

Envie uma lista de tons DTMF para um participante externo.

Afiado

var tones = new DtmfTone[] { DtmfTone.One, DtmfTone.Two, DtmfTone.Three, DtmfTone.Pound }; 
var sendDtmfTonesOptions = new SendDtmfTonesOptions(tones, new PhoneNumberIdentifier(calleePhonenumber))
{ 
	OperationContext = "dtmfs-to-ivr" 
}; 

var sendDtmfAsyncResult = await callAutomationClient.GetCallConnection(callConnectionId).GetCallMedia().SendDtmfTonesAsync(sendDtmfTonesOptions);

Java

List<DtmfTone> tones = Arrays.asList(DtmfTone.ONE, DtmfTone.TWO, DtmfTone.THREE, DtmfTone.POUND); 
SendDtmfTonesOptions options = new SendDtmfTonesOptions(tones, new PhoneNumberIdentifier(c2Target)); 
options.setOperationContext("dtmfs-to-ivr"); 
client.getCallConnectionAsync(callConnectionId)
	.getCallMediaAsync() 
	.sendDtmfTonesWithResponse(options) 
	.block(); 

JavaScript

const tones = [DtmfTone.One, DtmfTone.Two, DtmfTone.Three];
const sendDtmfTonesOptions: SendDtmfTonesOptions = {
	operationContext: "dtmfs-to-ivr"
};
const result: SendDtmfTonesResult = await client.getCallConnection(callConnectionId)
	.getCallMedia()
	.sendDtmfTones(tones, {
		phoneNumber: c2Target
	}, sendDtmfTonesOptions);
console.log("sendDtmfTones, result=%s", result);

Python

tones = [DtmfTone.ONE, DtmfTone.TWO, DtmfTone.THREE]
call_connection_client = call_automation_client.get_call_connection(
    "call_connection_id"
)

result = call_connection_client.send_dtmf_tones(
	tones = tones,
	target_participant = PhoneNumberIdentifier(c2_target),
	operation_context = "dtmfs-to-ivr")

Gravação de chamadas

As salas dos Serviços de Comunicação do Azure oferecem suporte a recursos de gravação, incluindo start, stop, pause, resumee assim por diante, fornecidos pela Automação de Chamadas. Consulte os seguintes trechos de código para iniciar/parar/pausar/retomar uma gravação em uma chamada de sala. Para obter uma lista completa de ações, consulte Gravação de automação de chamadas.

Afiado

// Start recording
StartRecordingOptions recordingOptions = new StartRecordingOptions(new ServerCallLocator("<ServerCallId>"))
{
   RecordingContent = RecordingContent.Audio,
   RecordingChannel = RecordingChannel.Unmixed,
   RecordingFormat = RecordingFormat.Wav,
   RecordingStateCallbackUri = new Uri("<CallbackUri>"),
   RecordingStorage = RecordingStorage.CreateAzureBlobContainerRecordingStorage(new Uri("<YOUR_STORAGE_CONTAINER_URL>"))
};
Response<RecordingStateResult> response = await callAutomationClient.GetCallRecording()
.StartAsync(recordingOptions);

// Pause recording using recordingId received in response of start recording.
var pauseRecording = await callAutomationClient.GetCallRecording ().PauseAsync(recordingId);

// Resume recording using recordingId received in response of start recording.
var resumeRecording = await callAutomationClient.GetCallRecording().ResumeAsync(recordingId);

// Stop recording using recordingId received in response of start recording.
var stopRecording = await callAutomationClient.GetCallRecording().StopAsync(recordingId);

Java

// Start recording
StartRecordingOptions recordingOptions = new StartRecordingOptions(new ServerCallLocator("<serverCallId>"))
                    .setRecordingChannel(RecordingChannel.UNMIXED)
                    .setRecordingFormat(RecordingFormat.WAV)
                    .setRecordingContent(RecordingContent.AUDIO)
                    .setRecordingStateCallbackUrl("<recordingStateCallbackUrl>");

Response<RecordingStateResult> response = callAutomationClient.getCallRecording()
.startWithResponse(recordingOptions, null);

// Pause recording using recordingId received in response of start recording
Response<Void> response = callAutomationClient.getCallRecording()
              .pauseWithResponse(recordingId, null);

// Resume recording using recordingId received in response of start recording
Response<Void> response = callAutomationClient.getCallRecording()
               .resumeWithResponse(recordingId, null);

// Stop recording using recordingId received in response of start recording
Response<Void> response = callAutomationClient.getCallRecording()
               .stopWithResponse(recordingId, null);

JavaScript

// Start recording
var locator: CallLocator = { id: "<ServerCallId>", kind: "serverCallLocator" };

var options: StartRecordingOptions =
{
  callLocator: locator,
  recordingContent: "audio",
  recordingChannel:"unmixed",
  recordingFormat: "wav",
  recordingStateCallbackEndpointUrl: "<CallbackUri>"
};
var response = await callAutomationClient.getCallRecording().start(options);

// Pause recording using recordingId received in response of start recording
var pauseRecording = await callAutomationClient.getCallRecording().pause(recordingId);

// Resume recording using recordingId received in response of start recording.
var resumeRecording = await callAutomationClient.getCallRecording().resume(recordingId);

// Stop recording using recordingId received in response of start recording
var stopRecording = await callAutomationClient.getCallRecording().stop(recordingId);

Python

# Start recording
response = call_automation_client.start_recording(call_locator=ServerCallLocator(server_call_id),
            recording_content_type = RecordingContent.Audio,
            recording_channel_type = RecordingChannel.Unmixed,
            recording_format_type = RecordingFormat.Wav,
            recording_state_callback_url = "<CallbackUri>")

# Pause recording using recording_id received in response of start recording
pause_recording = call_automation_client.pause_recording(recording_id = recording_id)

# Resume recording using recording_id received in response of start recording
resume_recording = call_automation_client.resume_recording(recording_id = recording_id)

# Stop recording using recording_id received in response of start recording
stop_recording = call_automation_client.stop_recording(recording_id = recording_id)

Encerrar uma chamada

Você pode usar a ação de desligamento do SDK de automação de chamadas para encerrar uma chamada. Quando a ação Desligar for concluída, o SDK publicará um CallDisconnected evento.

Afiado

_ = await client.GetCallConnection(callConnectionId).HangUpAsync(forEveryone: true); 

Java

Response<Void> response = client.getCallConnectionAsync(callConnectionId).hangUpWithResponse(true).block();

JavaScript

await callConnection.hangUp(true);

Python

call_connection_client = call_automation_client.get_call_connection(
    "call_connection_id"
)

call_connection_client.hang_up(is_for_everyone=True)

Outras ações

As seguintes ações em chamada também são suportadas em uma chamada de sala.

1. Adicionar participante (identificador ACS)
2. Remover participante (identificador ACS)
3. Cancelar adicionar participante (identificador ACS e número PSTN)
4. Desligue a chamada
5. Obter participante (identificador ACS e número PSTN)
6. Obter vários participantes (identificador ACS e número PSTN)
7. Obter as informações mais recentes sobre uma chamada
8. Reproduza arquivos de áudio e texto
9. Reproduza todos os arquivos de áudio e texto
10. Reconhecer DTMF e fala
11. Reconhecer DTMF contínuo

Para obter mais informações, consulte Ações de chamada e ações de mídia.

Próximos passos

Nesta seção, você aprendeu como:

• Participe de uma chamada de sala a partir do seu aplicativo
• Adicionar ações em chamada em uma chamada de sala usando SDKs de chamada
• Adicionar ações em chamada em uma chamada de sala usando SDKs de automação de chamada

Você também pode querer:

• Saiba mais sobre o conceito de quartos
• Saiba mais sobre os recursos de Chamando SDKs
• Saiba mais sobre os conceitos de Call Automation