Gestión de las llamadas en espera
El Vonage Client SDK no cuenta con una API específica para la «puesta en espera». En su lugar, La función «hold» se implementa combinando las opciones «silenciar» y «orejeras»:
mute(callId)— deja de enviar tu audio a la otra parteenableEarmuff(callId)— deja de recibir el audio de la otra parte
A desbloquear, invertir ambos: llamar a unmute(callId) y disableEarmuff(callId).
En iOS y Android, la interfaz de usuario de llamadas del sistema (CallKit / framework Telecom) ofrece un botón de espera nativo. Las guías de la plataforma que se incluyen a continuación muestran cómo conectar ese botón a las funciones de silencio y auricular del SDK.
Esta guía te guiará paso a paso por el proceso de implementación de la función de puesta en espera de llamadas en tus aplicaciones para iOS y Android utilizando nuestro SDK de VoIP.
Actualmente, la función de retención de llamadas no está disponible en el SDK web.
Integración de telecomunicaciones
Antes de empezar con este tutorial, asegúrate de haber integrado el marco de trabajo de Android Telecom en tu aplicación.
Puedes seguir la guía oficial aquí o echa un vistazo a nuestra aplicación «Android Voice Sample», disponible aquí.
Compatibilidad con la retención mediante la implementación de la conexión
Una vez que hayas creado tu implementación del Conexión clase,
tendrás que añadir el CAPABILITY_SUPPORT_HOLD a las capacidades de conexión
y anular el onHold() y onUnhold() métodos.
A continuación se muestra un ejemplo en Kotlin:
class CallConnection(val callId: CallId) : Connection() {
private lateinit var clientManager: VoiceClientManager
var isOnHold = false
private set
init {
connectionProperties = connectionProperties or PROPERTY_SELF_MANAGED
connectionCapabilities = connectionCapabilities or CAPABILITY_SUPPORT_HOLD /** add other capabilities */
audioModeIsVoip = true
}
// ... Other methods ...
override fun onHold() {
if (!isOnHold) {
clientManager.holdCall(this)
}
}
override fun onUnhold() {
if (isOnHold) {
clientManager.unholdCall(this)
}
}
fun toggleHoldState() {
isOnHold = !isOnHold
if (isOnHold) setOnHold() else setActive()
}
}
Interacción con el SDK de voz
Para aplicar el estado de espera a una llamada, active silenciar y orejeras al mismo tiempo.
El siguiente código dentro del VoiceClientManager La clase lo ilustra así:
class VoiceClientManager(private val context: Context) {
private lateinit var client : VoiceClient
fun holdCall(call: CallConnection){
call.apply{
client.mute(callId){ error ->
error?.let {
println("Error muting when holding call with id: $callId")
} ?: run {
client.enableEarmuff(callId){ error ->
error?.let {
println("Error enabling earmuff when holding with id: $callId")
} ?: run {
println("Call $callId successfully put on hold")
toggleHoldState()
}
}
}
}
}
}
fun unholdCall(call: CallConnection){
call.apply{
client.unmute(callId){ error ->
error?.let {
println("Error unmuting when unholding call with id: $callId")
} ?: run {
client.disableEarmuff(callId){ error ->
error?.let {
println("Error disabling earmuff unholding call with id: $callId")
} ?: run {
println("Call $callId successfully removed from hold")
toggleHoldState()
}
}
}
}
}
}
}
No dudes en adaptar los fragmentos de código para que se ajusten a tu implementación y requisitos específicos.
Integración con Callkit
Antes de empezar con este tutorial, asegúrate de haber integrado el framework Callkit en tu aplicación.
Puedes seguir el guía oficial, o echa un vistazo a nuestra aplicación de muestras de voz para iOS, disponible aquí.
Asistencia técnica a través de CXUpdate
Una vez que hayas creado tu CallController clase, que contiene una referencia a un CXProvider y un CXCallController Tendrás que activar el supportsHolding bandera en el CXCallUpdate tanto para las llamadas salientes como para las entrantes.
A continuación se muestra un ejemplo en Swift:
import CallKit
class CallController {
let callProvider: CXProvider
let cxController = CXCallController()
// ... Other methods ...
func reportOutgoingCall(callId: String){
self.callProvider.reportOutgoingCall(with: callId, connectedAt: Date.now)
let update = CXCallUpdate()
/** add other capabilities */
update.supportsHolding = true
self.callProvider.reportCall(with: callId, updated: update)
}
func reportIncomingCall(callId: String){
let update = CXCallUpdate()
/** add other capabilities */
update.supportsHolding = true
self.callProvider.reportNewIncomingCall(with: callId, update: update)
}
}
Interacción con el SDK de voz
Una vez que hayas creado tu CXProviderDelegate implementación,
escucha el CXSetHeldCallAction para poner llamadas en espera mediante el SDK de voz.
Para aplicar el estado de espera a una llamada, active silenciar y orejeras al mismo tiempo.
El siguiente código dentro del CallController La clase lo ilustra así:
import VonageClientSDKVoice
class CallController: NSObject {
let callProvider: CXProvider
let cxController = CXCallController()
let client: VGVoiceClient
var activeCalls: [UUID: String] = [:] // Maps CallKit UUID to Vonage callId
// ... initialization and other methods ...
}
extension CallController: CXProviderDelegate {
func provider(_ provider: CXProvider, perform action: CXSetHeldCallAction) {
guard let callId = self.activeCalls[action.callUUID] else {
action.fail()
return
}
if action.isOnHold {
self.client.mute(callId) { error in
if let error = error {
print("Error muting when holding call: \(error)")
return
}
self.client.enableEarmuff(callId) { error in
if let error = error {
print("Error enabling earmuff when holding call: \(error)")
return
}
print("Call \(callId) successfully put on hold")
}
}
} else {
self.client.unmute(callId) { error in
if let error = error {
print("Error unmuting when unholding call: \(error)")
return
}
self.client.disableEarmuff(callId) { error in
if let error = error {
print("Error disabling earmuff when unholding call: \(error)")
return
}
print("Call \(callId) successfully removed from hold")
}
}
}
// CallKit requires fulfilling the action synchronously
action.fulfill()
}
}
No dudes en adaptar los fragmentos de código para que se ajusten a tu implementación y requisitos específicos.