Fehlersuche

Dieser Abschnitt bietet einen kurzen Überblick über plattform-, geräte- und browserspezifische bekannte Probleme, die bei der Integration des Vonage Client SDK in Ihre Webanwendungen auftreten können.

Client SDK Integration

User Media Devices Not Being Released

In Safari wurde ein Problem festgestellt, bei dem die Mediengeräte der Benutzer nicht freigegeben werden, obwohl die Peer-Verbindung getrennt wurde. Dies kann zu unerwartetem Verhalten und einer erhöhten Ressourcenauslastung führen. Bitte berücksichtigen Sie dies bei der Implementierung Ihrer Web-Applications mit dem Vonage Client SDK für das Web.

Dieser Abschnitt bietet einen kurzen Überblick über plattform- und gerätespezifische bekannte Probleme, die bei der Integration des Vonage Client SDK in Ihre Android-Applications auftreten können.

Voice SDK Integration

Handling isIncomingCallPermitted Exception

Wenn Sie die isIncomingCallPermitted Methode aus dem TelecomManager – beachten Sie, dass auf bestimmten Geräten, wie z. B. Xiaomi, Ausnahmen ausgelöst werden können. Um einen reibungslosen Betrieb zu gewährleisten, wird empfohlen, diesen Methodenaufruf in einen try-catch-Block einzuschließen und für den Fall einer Ausnahme den Standardwert auf „true“ zu setzen. Andernfalls kann es bei der App zu Problemen beim Tätigen von ausgehenden Anrufen kommen. So können Sie dies implementieren:

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

Durch diesen Ansatz kann Ihre Anwendung potenzielle Ausnahmen reibungslos verarbeiten und so einen unterbrechungsfreien Betrieb gewährleisten – insbesondere auf Geräten, auf denen die Methode „isIncomingCallPermitted“ Fehler auslösen kann.

ConnectionService Unavailability Workaround

Auf bestimmten Geräten, wie beispielsweise Samsung-Smartphones im Flugmodus, steht der ConnectionService möglicherweise nicht für ausgehende Anrufe zur Verfügung, was zu möglichen Problemen führen kann. Um dieses Problem zu beheben, stellen wir eine Abhilfemaßnahme vor, mit der Anrufe trotz der Nichtverfügbarkeit des ConnectionService getätigt werden können.

Workaround for Placing Outgoing Calls

Um die Nichtverfügbarkeit des ConnectionService zu umgehen, verwenden Sie den folgenden Codeausschnitt in Ihrer Anwendung, um ausgehende Anrufe zu tätigen:

// 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

Stellen Sie anschließend sicher, dass Ihre Klasse die erforderlichen ConnectionService-Methoden wie unten gezeigt implementiert:

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

Die TimerManager Bei der in der Problemumgehung verwendeten Klasse handelt es sich lediglich um eine benutzerdefinierte Hilfsklasse, mit der Sie einen Timer für eine Callback-Funktion setzen können. Sie stellt sicher, dass die Funktion ausgeführt wird, sofern der Timer nicht vor Ablauf der angegebenen Dauer abgebrochen wird.

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

Durch die Einbindung dieser Umgehungslösung und des TimerManager-Dienstprogramms kann Ihre Anwendung ausgehende Anrufe auch auf Geräten, auf denen der ConnectionService möglicherweise nicht korrekt funktioniert, effektiv verwalten.

Dieser Abschnitt bietet einen kurzen Überblick über plattform- und gerätespezifische bekannte Probleme, die bei der Integration des Vonage Client SDK in Ihre iOS-Applications auftreten können.

Voice SDK Integration

Speakerphone Issues

Sollten bei Anrufen Probleme mit Ihrer Freisprechtaste auftreten, wie z. B. Abstürze oder ein Ausbleiben der Reaktion, stellen Sie sicher, dass Sie die AVAudioSession.sharedInstance().

Das Client SDK übernimmt bereits die Verwaltung der Audiositzung für Sie, daher vermeiden indem man es direkt mit Code wie dem folgenden bearbeitet:

AVAudioSession.sharedInstance().setCategory(.playAndRecord)   

Seien Sie versichert, dass das Client SDK die Verwaltung der Audiositzung übernimmt.