Как программно объединить звонки в Android? - PullRequest
Новая
       60

Как программно объединить звонки в Android?

2 голосов
/ 07 апреля 2020

В службе вызовов

Использую InCallService для прослушивания входящего вызова и в onCallStateChanged Обратный вызов обновляет состояние вызова, я успешно достигается до удержания «вызова 1» и соединения «вызова 2», поэтому «вызов 1» включен HOLD , а «вызов 2» включен в состояние ACTIVE соответственно, теперь, когда я нажимаю на объединить, выдает ошибку как

«Невозможно объединить вызовы»

Использую Метод конференции для объединения вызовов

Для лучшего понимания я выкладываю мой код ниже 

 class CallService : InCallService() {

    override fun onCallAdded(call: Call) {
        super.onCallAdded(call)
        CallManager.updateCall(call)

    }

    private val callCallback = object : Call.Callback() {
        override fun onStateChanged(call: Call, state: Int) {
            CallManager.updateCall(call)
        }
    }

    override fun onCallRemoved(call: Call) {
        super.onCallRemoved(call)
        call.unregisterCallback(callCallback)
        CallManager.updateCall(null)
    }
}


@TargetApi(Build.VERSION_CODES.M)
object CallManager {
    private const val LOG_TAG = "CallManager"
    private val subject = BehaviorSubject.create<GsmCall>()
    private var currentCall: Call? = null
    private var anotherCall: Call? = null
    fun updates(): Observable<GsmCall> = subject


    fun updateCall(call: Call?) {
        if (currentCall != null) {
            call?.let {
                if (it.details.handle.schemeSpecificPart ==
                    currentCall!!.details.handle.schemeSpecificPart
                )
                    currentCall = call
                else anotherCall = call
            }
        } else currentCall = call
        call?.let {
            subject.onNext(it.toGsmCall())
        }
    }


    fun cancelCall() {
        currentCall?.let {
            when (it.state) {
                Call.STATE_RINGING -> rejectCall()
                else -> disconnectCall()
            }
        }
    }


    fun holdCall() {
        currentCall?.let {
            when (it.state) {
                Call.STATE_ACTIVE -> currentCall?.hold()
                else -> Log.i(LOG_TAG, "Call not in connected state")
            }
        }
    }

//Conference call method
    fun conferenceCall() {
        anotherCall?.conference(currentCall)
    }

    fun swapConferenceCall() {
        currentCall?.swapConference()
    }

    fun mergeConferenceCall() {
        currentCall?.mergeConference()
    }

    fun unHoldCall() {
        currentCall?.let {
            when (it.state) {
                Call.STATE_HOLDING -> currentCall?.unhold()
                else -> Log.i(LOG_TAG, "Call not in connected state")
            }
        }
    }

    fun isCallOnHold(): Boolean {
        currentCall?.let {

            return when (it.state) {
                Call.STATE_HOLDING -> true
                else -> false
            }
        }
        return false
    }

    fun acceptCall() {
        Log.i(LOG_TAG, "acceptCall")
        currentCall?.let {
            it.answer(it.details.videoState)
        }
    }

    private fun rejectCall() {
        Log.i(LOG_TAG, "rejectCall")
        currentCall?.reject(false, "")
    }

    private fun disconnectCall() {
        Log.i(LOG_TAG, "disconnectCall")
        currentCall?.disconnect()
    }

}
...