Controles multimedia

Estas API te permiten controlar el comportamiento del audio local y remoto durante una llamada activa.

Controles del lado del cliente frente a controles del lado del servidor

Silenciar y supresión del ruido se aplican localmente en el dispositivo: impiden que se envíe el audio o lo filtran antes de la transmisión. Orejera se aplica en el lado del servidor: la API de Vonage suprime el flujo de audio entrante antes de que llegue al cliente.

Disponibilidad de la plataforma

Controlar	Android	iOS	Web
Silenciar / Activar el sonido	Sí	Sí	Sí
Orejera	Sí	Sí	Sí
DTMF	Sí	Sí	Sí
Supresión del ruido	Sí	Sí	No

Silenciar

Silencia el micrófono local para que la otra persona no pueda oírte. La llamada seguirá activa.

const callId = 'callId';
await client.mute(callId);

// Callback
 client.mute("callId") {
     it?.let { err ->
         // Handle Error in muting call
         println("Error in muting call: $err")
     }
 }

 // Coroutine
 try {
     client.mute("callId")
 } catch (e: Error) {
     // Handle Error in muting call
 }

client.mute("callId", it -> {
     if (it != null) {
         // Handle Error in muting call
         System.out.println("Error in muting call: " + it);
     }
     return null;
 });

// Callback
 client.mute("someCallId"){ error in
     if let error = error {
         print("Mute Failed with error: \(error)")
         return
     }
 }
 
 // Async Await
 Task.detached {
     do {
         try await client.mute("someCallId")
     } catch {
         print("Failed to mute \(error.localizedDescription)")
     }
 }

[client mute:@"someCallId" callback:^(NSError * _Nullable error) {
     if(error){
         NSLog(@"Mute Failed with error: %@", error);
     }
 }];

Desactivar

Vuelve a activar el micrófono local después de silenciarlo.

const callId = 'callId';
await client.unmute(callId);

// Callback
 client.unmute("callId") {
     it?.let { err ->
         // Handle Error in unmuting call
         println("Error in unmuting call: $err")
     }
 }

 // Coroutine
 try {
     client.unmute("callId")
 } catch (e: Error) {
     // Handle Error in unmuting call
 }

client.unmute("callId", it -> {
     if (it != null) {
         // Handle Error in unmuting call
         System.out.println("Error in unmuting call: " + it);
     }
     return null;
 });

// Callback
 client.unmute("someCallId"){ error in
     if let error = error {
         print("Unmute Failed with error: \(error)")
         return
     }
 }
 
 // Async Await
 Task.detached {
     do {
         try await client.unmute("someCallId")
     } catch {
         print("Failed to unmute \(error.localizedDescription)")
     }
 }

[client unmute:@"someCallId" callback:^(NSError * _Nullable error) {
         if(error){
             NSLog(@"Unmute Failed with error: %@", error);
         }
 }];

Evento de actualización «onMute»

Se activa cuando cambia el estado de silencio, incluidos los cambios provocados por el dispositivo remoto o por el servidor.

client.on('mute', (callId, legId, mute) => {
  if (mute) {
    console.log(`Leg ${legId} of call ${callId} was muted`);
  } else {
    console.log(`Leg ${legId} of call ${callId} was unmuted`);
  }
});

 client.setOnMutedListener { call, legId, isMuted ->
     if (isMuted) {
         // leg is muted
         println("leg:$legId for call: $call was muted")
     } else {
         // leg is unmuted
         println("leg:$legId for call: $call was un-muted")
     }
 }

client.setOnMutedListener((call, legId, isMuted) -> {
     if (isMuted) {
         System.out.println("Leg " + legId + " for call " + call + " was muted");
     } else {
         System.out.println("Leg " + legId + " for call " + call + " was unmuted");
     }
     return null;
 });

class MuteUpdateExampleDelegate: NSObject, VGVoiceClientDelegate {
     func voiceClient(_ client: VGVoiceClient, didReceiveMuteForCall callId: VGCallId, withLegId legId: VGCallId, andStatus isMuted: Bool) {
         if (isMuted) {
             print("Leg:\(legId) has been muted")
         } else {
             print("Leg:\(legId) has been unmuted")
         }
     }
     
     func voiceClient(_ client: VGVoiceClient, didReceiveInviteForCall callId: VGCallId, from caller: String, with type: VGVoiceChannelType) {}
     func voiceClient(_ client: VGVoiceClient, didReceiveHangupForCall callId: VGCallId, withQuality callQuality: VGRTCQuality, reason: VGHangupReason) {}
     func voiceClient(_ client: VGVoiceClient, didReceiveInviteCancelForCall callId: VGCallId, with reason: VGVoiceInviteCancelReason) {}
     func client(_ client: VGBaseClient, didReceiveSessionErrorWith reason: VGSessionErrorReason) {}
 }

- (void) voiceClient:(VGVoiceClient *)client didReceiveMuteForCall:(VGCallId)callId withLegId:(NSString *)legId andStatus:(Boolean)isMuted {

     if(isMuted){
         NSLog(@"Leg: %@ has been muted", legId);
     } else {
         NSLog(@"Leg: %@ has been unmuted", legId);
     }
 }

Activar orejeras

La función «Earmuff» impide que el usuario local escuche el audio remoto. A diferencia de la función «silenciar», «Earmuff» se aplica en el servidor: la transmisión de audio se suprime antes de que llegue al cliente.

const callId = 'callId';
await client.enableEarmuff(callId);

 // Callback
 client.enableEarmuff("callId") {
     it?.let { err ->
         // Handle Error in enabling earmuff
         println("Error in enabling earmuff: $err")
     }
 }

 // Coroutine
 try {
     client.enableEarmuff("callId")
 } catch (e: Error) {
     // Handle Error in enabling earmuff
 }

 client.enableEarmuff("callId", it -> {
     if (it != null) {
         // Handle Error in enabling earmuff
         System.out.println("Error in enabling earmuff: " + it);
     }
     return null;
 });

// Callback
 client.enableEarmuff("someCallId"){ error in
     if let error = error {
         print("Enable Earmuff Failed with error: \(error)")
         return
     }
 }
 
 // Async Await
 Task.detached {
     do {
         try await client.enableEarmuff("someCallId")
     } catch {
         print("Failed to enableEarmuff \(error.localizedDescription)")
     }
 }

 [client enableEarmuff:@"someCallId" callback:^(NSError * _Nullable error) {
     if(error){
         NSLog(@"Enable Earmuff Failed with error: %@", error);
     }
 }];

Desactivar Orejera

Restablecer el audio entrante tras silenciarlo.

const callId = 'callId';
await client.disableEarmuff(callId);

 // Callback
 client.disableEarmuff("callId") {
     it?.let { err ->
         // Handle Error in disabling earmuff
         println("Error in disabling earmuff: $err")
     }
 }

 // Coroutine
 try {
     client.disableEarmuff("callId")
 } catch (e: Error) {
     // Handle Error in disabling earmuff
 }

 client.disableEarmuff("callId", it -> {
     if (it != null) {
         // Handle Error in disabling earmuff
         System.out.println("Error in disabling earmuff: " + it);
     }
     return null;
 });

 // Callback
 client.disableEarmuff("someCallId"){ error in
     if let error = error {
         print("Disable Earmuff Failed with error: \(error)")
         return
     }
 }
 
 // Async Await
 Task.detached {
     do {
         try await client.disableEarmuff("someCallId")
     } catch {
         print("Failed to disableEarmuff \(error.localizedDescription)")
     }
 }

 [client disableEarmuff:@"someCallId" callback:^(NSError * _Nullable error) {
     if(error){
         NSLog(@"Disable Earmuff Failed with error: %@", error);
     }
 }];

Evento de actualización de onEarmuff

Se activa cuando cambia el estado de las orejeras.

client.on('earmuff', (callId, legId, earmuff) => {
  if (earmuff) {
    console.log(`Leg ${legId} of call ${callId} had earmuff enabled`);
  } else {
    console.log(`Leg ${legId} of call ${callId} had earmuff disabled`);
  }
});

 client.setOnEarmuffListener {call, legId, earmuffStatus ->
     if (earmuffStatus) {
         // earmuff enabled
         println("earmuff is enabled for leg:$legId with Call $call")
     } else {
         // earmuff disabled
         println("earmuff is disabled for leg:$legId with Call $call")
     }
 }

 client.setOnEarmuffListener((call, legId, earmuffStatus) -> {
     if (earmuffStatus) {
         System.out.println("Leg " + legId + " for call " + call + " was earmuffed");
     } else {
         System.out.println("Leg " + legId + " for call " + call + " was unearmuffed");
     }
     return null;
 });

 class EarmuffListenerExampleDelegate : NSObject, VGVoiceClientDelegate {
     func voiceClient(_ client: VGVoiceClient, didReceiveEarmuffForCall callId: VGCallId, withLegId legId: VGCallId, andStatus earmuffStatus: Bool) {
         if (earmuffStatus) {
             print("Leg:\(legId) has enabled earmuff")
         } else {
             print("Leg:\(legId) has disabled earmuff")
         }
     }
     
     func voiceClient(_ client: VGVoiceClient, didReceiveInviteForCall callId: VGCallId, from caller: String, with type: VGVoiceChannelType) {}
     func voiceClient(_ client: VGVoiceClient, didReceiveHangupForCall callId: VGCallId, withQuality callQuality: VGRTCQuality, reason: VGHangupReason) {}
     func voiceClient(_ client: VGVoiceClient, didReceiveInviteCancelForCall callId: VGCallId, with reason: VGVoiceInviteCancelReason) {}
     func client(_ client: VGBaseClient, didReceiveSessionErrorWith reason: VGSessionErrorReason) {}
 }

 - (void)voiceClient:(VGVoiceClient *)client didReceiveEarmuffForCall:(VGCallId)callId withLegId:(NSString *)legId andStatus:(Boolean)earmuffStatus {
     if(earmuffStatus){
         NSLog(@"Leg: %@ has enabled earmuff", legId);
     } else {
         NSLog(@"Leg: %@ has disabled earmuff", legId);
     }
 }

Enviar DTMF

Envía señales de doble tono y multifrecuencia durante una llamada activa. Los dígitos válidos son 0-9, *y #. El DTMF se utiliza habitualmente para la navegación por los sistemas de respuesta de voz interactiva (IVR) y la interacción con los sistemas telefónicos.

const callId = 'callId';
await client.sendDTMF(callId, '1234');

 // Callback
 client.sendDTMF("callId", "1234") {
     it?.let { err ->
         // Handle Error in sending DTMF
         println("Error in sending DTMF: $err")
     }
 }

 // Coroutine
 try {
     client.sendDTMF("callId", "1234")
 } catch (e: Error) {
     // Handle Error in sending DTMF
 }

 client.sendDTMF("callId", "1234", it -> {
     if (it != null) {
         // Handle Error in sending DTMF
         System.out.println("Error in sending DTMF: " + it);
     }
     return null;
 });

 // Callback
 client.sendDTMF("someCallId", withDigits: "1234"){ error in
     if let error = error {
         print("DTMF Failed with error: \(error)")
         return
     }
 }
 
 // Async Await
 Task.detached {
     do {
         try await client.sendDTMF("someCallId", withDigits: "1234")
     } catch {
         print("Failed to sendDTMF \(error.localizedDescription)")
     }
 }

 [client sendDTMF:@"someCallId" withDigits:@"1234" callback:^(NSError * _Nullable error) {
     if(error){
         NSLog(@"DTMF Failed with error: %@", error);
     }
 }];

Evento de actualización «onDTMF»

Se activa cuando se reciben dígitos DTMF de la otra parte.

client.on('dtmf', (callId, legId, dtmf) => {
  console.log(`Leg ${legId} of call ${callId} sent DTMF ${dtmf}`);
});

 client.setOnDTMFListener {call, legId, digits ->
     println("Received DTMF digits: $digits for leg:$legId with Call $call")
 }

 client.setOnDTMFListener((call, legId, dtmf) -> {
     System.out.println("Leg " + legId + " for call " + call + " sent DTMF: " + dtmf);
     return null;
 });

 class DTMFListenerExampleDelegate : NSObject, VGVoiceClientDelegate {
     func voiceClient(_ client: VGVoiceClient, didReceiveDTMFForCall callId: VGCallId, withLegId legId: VGCallId, andDigits digits: String) {
         print("Leg:\(legId) has sent DTMF: \(digits)")
     }
     
     func voiceClient(_ client: VGVoiceClient, didReceiveInviteForCall callId: VGCallId, from caller: String, with type: VGVoiceChannelType) {}
     func voiceClient(_ client: VGVoiceClient, didReceiveHangupForCall callId: VGCallId, withQuality callQuality: VGRTCQuality, reason: VGHangupReason) {}
     func voiceClient(_ client: VGVoiceClient, didReceiveInviteCancelForCall callId: VGCallId, with reason: VGVoiceInviteCancelReason) {}
     func client(_ client: VGBaseClient, didReceiveSessionErrorWith reason: VGSessionErrorReason) {}
 }

 - (void)voiceClient:(VGVoiceClient *)client didReceiveDTMFForCall:(VGCallId)callId withLegId:(NSString *)legId andDigits:(NSString *)digits {
     NSLog(@"Leg %@ has sent DTMF: %@", legId, digits);
 }

Activar la supresión de ruido (Android/iOS)

Activa la supresión de ruido en el dispositivo para filtrar el ruido de fondo de la entrada del micrófono local. No disponible en la web.

 // Callback
 client.enableNoiseSuppression("callId") { err ->
     err?.let {
         println("Error enabling noise suppression: $it")
     } ?: println("Noise suppression successfully enabled")
 }

 // Coroutine
 try {
     client.enableNoiseSuppression("callId")
 } catch (e: Error) {
     println("Error enabling noise suppression: $e")
 }

 client.enableNoiseSuppression("callId", err -> {
     if(err != null){
         System.out.println("Error enabling noise suppression: " + err);
     }
     System.out.println("Noise suppression successfully enabled");
     return null;
 });

 // Callback
 client.enableNoiseSuppression("someCallId"){ error in
     if let error = error {
         print("Failed to enable noise suppression: \(error.localizedDescription)")
     } else {
         print("Noise suppression successfully enabled")
     }
 }

 // Async Await
 Task.detached {
     do {
         try await client.enableNoiseSuppression("someCallId")
         print("Noise suppression successfully enabled")
     }
     catch {
         print("Failed to enable noise suppression: \(error.localizedDescription)")
     }
 }

 [client enableNoiseSuppression:@"someCallId" callback:^(NSError * _Nullable error) {
     if(error){
         NSLog(@"Failed to enable noise suppression: %@", error);
     } else {
         NSLog(@"Noise suppression successfully enabled");
     }
 }];

Desactivar la supresión de ruido (Android/iOS)

Desactiva la supresión de ruido integrada en el dispositivo.

 // Callback
 client.disableNoiseSuppression("callId") { err ->
     err?.let {
         println("Error disabling noise suppression: $it")
     } ?: println("Noise suppression successfully disabled")
 }

 // Coroutine
 try {
     client.disableNoiseSuppression("callId")
     println("Noise suppression successfully disabled")
 } catch (e: Error) {
     println("Error disabling noise suppression: $e")
 }

 client.disableNoiseSuppression("callId", err -> {
     if(err != null){
         System.out.println("Error disabling noise suppression: " + err);
     }
     System.out.println("Noise suppression successfully disabled");
     return null;
 });

 // Callback
 client.disableNoiseSuppression("someCallId"){ error in
     if let error = error {
         print("Failed to disable noise suppression: \(error.localizedDescription)")
     } else {
         print("Noise suppression successfully disabled")
     }
 }

 // Async Await
 Task.detached {
     do {
         try await client.disableNoiseSuppression("someCallId")
         print("Noise suppression successfully disabled")
     }
     catch {
         print("Failed to disable noise suppression: \(error.localizedDescription)")
     }
 }

 [client disableNoiseSuppression:@"someCallId" callback:^(NSError * _Nullable error) {
     if(error){
         NSLog(@"Failed to disable noise suppression: %@", error);
     } else {
         NSLog(@"Noise suppression successfully disabled");
     }
 }];