Troubleshooting

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

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

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

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

AVAudioSession.sharedInstance().setCategory(.playAndRecord)