Solución de problemas

En esta sección se ofrece una descripción general concisa de los problemas conocidos específicos de cada plataforma, dispositivo y navegador que pueden surgir al integrar el Vonage Client SDK en tus aplicaciones web.

Client SDK Integration

User Media Devices Not Being Released

Se ha detectado un problema en Safari por el que los dispositivos multimedia de los usuarios no se liberan a pesar de que la conexión entre pares se haya desconectado. Esto puede provocar un comportamiento inesperado y un consumo excesivo de recursos. Tenlo en cuenta a la hora de implementar tus aplicaciones web utilizando el Vonage Client SDK para web.

En esta sección se ofrece una descripción general concisa de los problemas conocidos, específicos de la plataforma y del dispositivo, que pueden surgir al integrar el Vonage Client SDK en tus aplicaciones de Android.

Voice SDK Integration

Handling isIncomingCallPermitted Exception

Si estás utilizando el isIncomingCallPermitted método de TelecomManager; ten en cuenta que puede lanzar excepciones en determinados dispositivos, como los de Xiaomi. Para garantizar un funcionamiento fluido, se recomienda incluir esta llamada al método dentro de un bloque «try-catch» y establecer un valor por defecto de «true» en caso de que se produzca una excepción. De lo contrario, la aplicación podría tener problemas a la hora de realizar llamadas entrantes. A continuación te explicamos cómo puedes implementarlo:

// Get the TelecomManager instance
val telecomManager = context.getSystemService(AppCompatActivity.TELECOM_SERVICE) as TelecomManager

// Check permissions for incoming calls and handle exceptions
val isIncomingCallPermitted = try {
    telecomManager.isIncomingCallPermitted(phoneAccountHandle)
} catch (_: Exception) {
    // Exception occurred, default to true
    true
}

Al adoptar este enfoque, tu aplicación podrá gestionar correctamente las posibles excepciones, garantizando un funcionamiento ininterrumpido, especialmente en aquellos dispositivos en los que el método `isIncomingCallPermitted` pueda generar errores.

ConnectionService Unavailability Workaround

En determinados dispositivos, como los smartphones Samsung en modo avión, es posible que el ConnectionService no esté disponible para gestionar las llamadas salientes, lo que puede provocar problemas. Para solucionar esto, proponemos una solución alternativa que permite realizar llamadas a pesar de que el ConnectionService no esté disponible.

Workaround for Placing Outgoing Calls

Para solucionar la indisponibilidad del ConnectionService, utiliza el siguiente fragmento de código en tu aplicación para realizar llamadas salientes:

// Workaround for placing outgoing calls when ConnectionService is not available
private fun placeOutgoingCall(callId: CallId, callee: String) {
    try {
        coreContext.telecomHelper.startOutgoingCall(callId, callee)

        // If ConnectionService does not respond within 3 seconds,
        // we mock an outgoing connection
        TimerManager.startTimer(TimerManager.CONNECTION_SERVICE_TIMER, 3000) {
            mockOutgoingConnection(callId, callee)
        }
    } catch (e: Exception) {
        abortOutboundCall(callId, e.message)
    }
}

/**
 * This method will mock `ConnectionService#onCreateOutgoingConnection`,
 * allowing outgoing calls without direct interaction with the Telecom framework.
 */
private fun mockOutgoingConnection(callId: CallId, to: String): CallConnection {
    showToast(context, "ConnectionService Not Available")

    val connection = CallConnection(callId).apply {
        setAddress(Uri.parse(to), TelecomManager.PRESENTATION_ALLOWED)
        setCallerDisplayName(to, TelecomManager.PRESENTATION_ALLOWED)
        setDialing()
    }

    return connection
}

ConnectionService Implementation

A continuación, asegúrate de que tu clase implemente los métodos necesarios de ConnectionService tal y como se muestra a continuación:

import android.telecom.Connection
import android.telecom.ConnectionRequest
import android.telecom.PhoneAccountHandle
import android.telecom.ConnectionService
import android.telecom.TelecomManager

// Your class implementing ConnectionService
class YourConnectionService : ConnectionService() {

    override fun onCreateOutgoingConnection(
        connectionManagerPhoneAccount: PhoneAccountHandle?,
        request: ConnectionRequest?
    ): Connection {
        // Cancel the timer set in the workaround
        TimerManager.cancelTimer(TimerManager.CONNECTION_SERVICE_TIMER)

        // Your implementation of ConnectionService onCreateOutgoingConnection method
        // ... (code snippet)

        return connection
    }

    override fun onCreateOutgoingConnectionFailed(connectionManagerPhoneAccount: PhoneAccountHandle?, request: ConnectionRequest?) {
        // Cancel the timer set in the workaround
        TimerManager.cancelTimer(TimerManager.CONNECTION_SERVICE_TIMER)

        // Your implementation of ConnectionService onCreateOutgoingConnectionFailed method
        // ... (code snippet)
    }
}

TimerManager Utility

El TimerManager La clase utilizada en la solución alternativa es simplemente una clase de utilidad personalizada que permite configurar un temporizador para una función de devolución de llamada. Garantiza que la función se ejecute si el temporizador no se cancela antes de que transcurra el tiempo especificado.

object TimerManager {
    private val handler: Handler = Handler(Looper.getMainLooper())
    private val timerMap: MutableMap<String, Runnable> = mutableMapOf()

    const val CONNECTION_SERVICE_TIMER = "ConnectionServiceTimer"

    fun startTimer(timerId: String, delayMillis: Long, callback: () -> Unit) {
        val runnable = Runnable {
            callback.invoke()
            timerMap.remove(timerId)
        }
        timerMap[timerId] = runnable
        handler.postDelayed(runnable, delayMillis)
    }

    fun cancelTimer(timerId: String) {
        val runnable = timerMap[timerId]
        if (runnable != null) {
            handler.removeCallbacks(runnable)
            timerMap.remove(timerId)
        }
    }
}

Al incorporar esta solución alternativa y la utilidad TimerManager, tu aplicación gestionará de forma eficaz las llamadas salientes, incluso en dispositivos en los que el ConnectionService pueda no funcionar correctamente.

En esta sección se ofrece una descripción general concisa de los problemas conocidos, específicos de la plataforma y del dispositivo, que pueden surgir al integrar el Vonage Client SDK en tus aplicaciones para iOS.

Voice SDK Integration

Speakerphone Issues

Si tienes problemas con el botón de altavoz durante las llamadas, como fallos o falta de respuesta, asegúrate de que no estés interfiriendo con el AVAudioSession.sharedInstance().

El Client SDK ya se encarga de gestionar la sesión de audio por ti, así que evitar manipularlo directamente con código como:

AVAudioSession.sharedInstance().setCategory(.playAndRecord)   

Ten por seguro que el Client SDK se encarga de gestionar la sesión de audio.