1358 lines
53 KiB
Swift
1358 lines
53 KiB
Swift
//
|
|
// Copyright (c) 2021 Open Whisper Systems. All rights reserved.
|
|
//
|
|
|
|
import Foundation
|
|
import PromiseKit
|
|
import SignalRingRTC
|
|
import WebRTC
|
|
import SessionMessagingKit
|
|
|
|
// MARK: - CallService
|
|
|
|
// This class' state should only be accessed on the main queue.
|
|
@objc final public class IndividualCallService: NSObject {
|
|
|
|
private var callManager: CallService.CallManagerType {
|
|
return callService.callManager
|
|
}
|
|
|
|
// MARK: - Properties
|
|
|
|
// Exposed by environment.m
|
|
|
|
@objc public var callUIAdapter: CallUIAdapter!
|
|
|
|
// MARK: Class
|
|
|
|
static let fallbackIceServer = RTCIceServer(urlStrings: ["stun:stun1.l.google.com:19302"])
|
|
|
|
@objc public override init() {
|
|
super.init()
|
|
|
|
SwiftSingletons.register(self)
|
|
}
|
|
|
|
/**
|
|
* Choose whether to use CallKit or a Notification backed interface for calling.
|
|
*/
|
|
@objc public func createCallUIAdapter() {
|
|
AssertIsOnMainThread()
|
|
|
|
if let call = callService.currentCall {
|
|
Logger.warn("ending current call in. Did user toggle callkit preference while in a call?")
|
|
callService.terminate(call: call)
|
|
}
|
|
|
|
self.callUIAdapter = CallUIAdapter()
|
|
}
|
|
|
|
// MARK: - Call Control Actions
|
|
|
|
/**
|
|
* Initiate an outgoing call.
|
|
*/
|
|
func handleOutgoingCall(_ call: SignalCall) {
|
|
AssertIsOnMainThread()
|
|
Logger.info("call: \(call)")
|
|
|
|
BenchEventStart(title: "Outgoing Call Connection", eventId: "call-\(call.individualCall.localId)")
|
|
|
|
guard callService.currentCall == nil else {
|
|
owsFailDebug("call already exists: \(String(describing: callService.currentCall))")
|
|
return
|
|
}
|
|
|
|
// Create a callRecord for outgoing calls immediately.
|
|
let callRecord = TSCall(
|
|
callType: .outgoingIncomplete,
|
|
offerType: call.individualCall.offerMediaType,
|
|
thread: call.individualCall.thread,
|
|
sentAtTimestamp: call.individualCall.sentAtTimestamp
|
|
)
|
|
Storage.write { transaction in
|
|
callRecord.save(with: transaction)
|
|
}
|
|
call.individualCall.callRecord = callRecord
|
|
|
|
do {
|
|
try callManager.placeCall(call: call, callMediaType: call.individualCall.offerMediaType.asCallMediaType, localDevice: 1)
|
|
} catch {
|
|
self.handleFailedCall(failedCall: call, error: error)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* User chose to answer the call. Used by the Callee only.
|
|
*/
|
|
public func handleAcceptCall(_ call: SignalCall) {
|
|
AssertIsOnMainThread()
|
|
Logger.info("\(call)")
|
|
|
|
guard callService.currentCall === call else {
|
|
let error = OWSAssertionError("accepting call: \(call) which is different from currentCall: \(callService.currentCall as Optional)")
|
|
handleFailedCall(failedCall: call, error: error)
|
|
return
|
|
}
|
|
|
|
guard let callId = call.individualCall.callId else {
|
|
handleFailedCall(failedCall: call, error: OWSAssertionError("no callId for call: \(call)"))
|
|
return
|
|
}
|
|
|
|
let callRecord = TSCall(
|
|
callType: .incomingIncomplete,
|
|
offerType: call.individualCall.offerMediaType,
|
|
thread: call.individualCall.thread,
|
|
sentAtTimestamp: call.individualCall.sentAtTimestamp
|
|
)
|
|
Storage.write { transaction in
|
|
callRecord.save(with: transaction)
|
|
}
|
|
call.individualCall.callRecord = callRecord
|
|
|
|
do {
|
|
try callManager.accept(callId: callId)
|
|
|
|
// It's key that we configure the AVAudioSession for a call *before* we fulfill the
|
|
// CXAnswerCallAction.
|
|
//
|
|
// Otherwise CallKit has been seen not to activate the audio session.
|
|
// That is, `provider(_ provider: CXProvider, didActivate audioSession: AVAudioSession)`
|
|
// was sometimes not called.`
|
|
//
|
|
// That is why we connect here, rather than waiting for a racy async response from CallManager,
|
|
// confirming that the call has connected.
|
|
handleConnected(call: call)
|
|
} catch {
|
|
self.handleFailedCall(failedCall: call, error: error)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Local user chose to end the call.
|
|
*/
|
|
func handleLocalHangupCall(_ call: SignalCall) {
|
|
AssertIsOnMainThread()
|
|
Logger.info("\(call)")
|
|
|
|
guard call === callService.currentCall else {
|
|
Logger.info("ignoring hangup for obsolete call: \(call)")
|
|
return
|
|
}
|
|
|
|
if let callRecord = call.individualCall.callRecord {
|
|
if callRecord.callType == .outgoingIncomplete {
|
|
callRecord.updateCallType(.outgoingMissed)
|
|
}
|
|
} else if call.individualCall.state == .localRinging {
|
|
let callRecord = TSCall(
|
|
callType: .incomingDeclined,
|
|
offerType: call.individualCall.offerMediaType,
|
|
thread: call.individualCall.thread,
|
|
sentAtTimestamp: call.individualCall.sentAtTimestamp
|
|
)
|
|
Storage.write { transaction in
|
|
callRecord.save(with: transaction)
|
|
}
|
|
call.individualCall.callRecord = callRecord
|
|
} else {
|
|
owsFailDebug("missing call record")
|
|
}
|
|
|
|
call.individualCall.state = .localHangup
|
|
|
|
ensureAudioState(call: call)
|
|
|
|
callService.terminate(call: call)
|
|
|
|
do {
|
|
try callManager.hangup()
|
|
} catch {
|
|
// no point in "failing" the call if the user expressed their intent to hang up
|
|
// and we've already called: `terminate(call: cal)`
|
|
owsFailDebug("error: \(error)")
|
|
}
|
|
}
|
|
|
|
// MARK: - Signaling Functions
|
|
|
|
private func allowsInboundCallsInThread(_ thread: TSContactThread) -> Bool {
|
|
// TODO: We might want to add some conditions here, like whether people have messaged
|
|
// eachother, whether the contact is blocked, etc.
|
|
return true
|
|
}
|
|
|
|
private struct CallIdentityKeys {
|
|
let localIdentityKey: Data
|
|
let contactIdentityKey: Data
|
|
}
|
|
|
|
private func getIdentityKeys(thread: TSContactThread) -> CallIdentityKeys? {
|
|
let identityManager = OWSIdentityManager.shared()
|
|
guard let localIdentityKey = identityManager.identityKeyPair()?.publicKey else {
|
|
owsFailDebug("missing localIdentityKey")
|
|
return nil
|
|
}
|
|
guard let contactIdentityKey = identityManager.recipientIdentity(forRecipientId: thread.contactSessionID())?.identityKey else {
|
|
owsFailDebug("Looks like we're not actually maintaining the identity key for contacts. How will we fix that given that CallIdentityKeys wants this?")
|
|
return nil
|
|
}
|
|
return CallIdentityKeys(localIdentityKey: localIdentityKey, contactIdentityKey: contactIdentityKey)
|
|
}
|
|
|
|
/**
|
|
* Received an incoming call Offer from call initiator.
|
|
*/
|
|
public func handleReceivedOffer(
|
|
thread: TSContactThread,
|
|
callId: UInt64,
|
|
sourceDevice: UInt32,
|
|
sdp: String?,
|
|
opaque: Data?,
|
|
sentAtTimestamp: UInt64,
|
|
serverReceivedTimestamp: UInt64,
|
|
serverDeliveryTimestamp: UInt64,
|
|
callType: SNProtoCallMessageOfferType,
|
|
supportsMultiRing: Bool
|
|
) {
|
|
AssertIsOnMainThread()
|
|
|
|
// opaque is required. sdp is obsolete, but it might still come with opaque.
|
|
guard let opaque = opaque else {
|
|
// TODO: Remove once the proto is updated to only support opaque and require it.
|
|
Logger.debug("opaque not received for offer, remote should update")
|
|
return
|
|
}
|
|
|
|
let newCall = callService.prepareIncomingIndividualCall(
|
|
thread: thread,
|
|
sentAtTimestamp: sentAtTimestamp,
|
|
callType: callType
|
|
)
|
|
|
|
BenchEventStart(title: "Incoming Call Connection", eventId: "call-\(newCall.individualCall.localId)")
|
|
|
|
/*
|
|
* We might not need the below code, since we don't have the concept of untrusted identities
|
|
if let untrustedIdentity = self.identityManager.untrustedIdentityForSending(to: thread.contactAddress) {
|
|
Logger.warn("missed a call due to untrusted identity: \(newCall)")
|
|
|
|
let callerName = self.contactsManager.displayName(for: thread.contactAddress)
|
|
|
|
let notificationPresenter = AppEnvironment.shared.notificationPresenter
|
|
switch untrustedIdentity.verificationState {
|
|
case .verified:
|
|
owsFailDebug("shouldn't have missed a call due to untrusted identity if the identity is verified")
|
|
notificationPresenter.presentMissedCall(newCall.individualCall, callerName: callerName)
|
|
case .default:
|
|
notificationPresenter.presentMissedCallBecauseOfNewIdentity(call: newCall.individualCall, callerName: callerName)
|
|
case .noLongerVerified:
|
|
notificationPresenter.presentMissedCallBecauseOfNoLongerVerifiedIdentity(call: newCall.individualCall, callerName: callerName)
|
|
}
|
|
|
|
let callRecord = TSCall(
|
|
callType: .incomingMissedBecauseOfChangedIdentity,
|
|
offerType: newCall.individualCall.offerMediaType,
|
|
thread: thread,
|
|
sentAtTimestamp: sentAtTimestamp
|
|
)
|
|
assert(newCall.individualCall.callRecord == nil)
|
|
newCall.individualCall.callRecord = callRecord
|
|
databaseStorage.asyncWrite { transaction in
|
|
callRecord.anyInsert(transaction: transaction)
|
|
}
|
|
|
|
newCall.individualCall.state = .localFailure
|
|
callService.terminate(call: newCall)
|
|
|
|
return
|
|
}
|
|
*/
|
|
|
|
guard let identityKeys = getIdentityKeys(thread: thread) else {
|
|
owsFailDebug("missing identity keys, skipping call.")
|
|
let callRecord = TSCall(
|
|
callType: .incomingMissed,
|
|
offerType: newCall.individualCall.offerMediaType,
|
|
thread: thread,
|
|
sentAtTimestamp: sentAtTimestamp
|
|
)
|
|
assert(newCall.individualCall.callRecord == nil)
|
|
newCall.individualCall.callRecord = callRecord
|
|
Storage.write { transaction in
|
|
callRecord.save(with: transaction)
|
|
}
|
|
|
|
newCall.individualCall.state = .localFailure
|
|
callService.terminate(call: newCall)
|
|
|
|
return
|
|
}
|
|
|
|
guard allowsInboundCallsInThread(thread) else {
|
|
Logger.info("Ignoring call offer from \(thread.contactSessionID()) due to insufficient permissions.")
|
|
|
|
// Send the need permission message to the caller, so they know why we rejected their call.
|
|
callManager(
|
|
callManager,
|
|
shouldSendHangup: callId,
|
|
call: newCall,
|
|
destinationDeviceId: sourceDevice,
|
|
hangupType: .needPermission,
|
|
deviceId: 1,
|
|
useLegacyHangupMessage: true
|
|
)
|
|
|
|
// Store the call as a missed call for the local user. They will see it in the conversation
|
|
// along with the message request dialog. When they accept the dialog, they can call back
|
|
// or the caller can try again.
|
|
let callRecord = TSCall(
|
|
callType: .incomingMissed,
|
|
offerType: newCall.individualCall.offerMediaType,
|
|
thread: thread,
|
|
sentAtTimestamp: sentAtTimestamp
|
|
)
|
|
assert(newCall.individualCall.callRecord == nil)
|
|
newCall.individualCall.callRecord = callRecord
|
|
Storage.write { transaction in
|
|
callRecord.save(with: transaction)
|
|
}
|
|
|
|
newCall.individualCall.state = .localFailure
|
|
callService.terminate(call: newCall)
|
|
|
|
return
|
|
}
|
|
|
|
Logger.debug("Enable backgroundTask")
|
|
let backgroundTask: OWSBackgroundTask? = OWSBackgroundTask(label: "\(#function)", completionBlock: { status in
|
|
AssertIsOnMainThread()
|
|
|
|
guard status == .expired else {
|
|
return
|
|
}
|
|
|
|
// See if the newCall actually became the currentCall.
|
|
guard case .individual(let currentCall) = self.callService.currentCall?.mode,
|
|
newCall === currentCall else {
|
|
Logger.warn("ignoring obsolete call")
|
|
return
|
|
}
|
|
|
|
self.handleFailedCall(failedCall: newCall, error: SignalCall.CallError.timeout(description: "background task time ran out before call connected"))
|
|
})
|
|
|
|
newCall.individualCall.backgroundTask = backgroundTask
|
|
|
|
var messageAgeSec: UInt64 = 0
|
|
if serverReceivedTimestamp > 0 && serverDeliveryTimestamp >= serverReceivedTimestamp {
|
|
messageAgeSec = (serverDeliveryTimestamp - serverReceivedTimestamp) / 1000
|
|
}
|
|
|
|
do {
|
|
try callManager.receivedOffer(call: newCall, sourceDevice: sourceDevice, callId: callId, opaque: opaque, messageAgeSec: messageAgeSec, callMediaType: newCall.individualCall.offerMediaType.asCallMediaType, localDevice: 1, remoteSupportsMultiRing: supportsMultiRing, isLocalDevicePrimary: true, senderIdentityKey: identityKeys.contactIdentityKey, receiverIdentityKey: identityKeys.localIdentityKey)
|
|
} catch {
|
|
handleFailedCall(failedCall: newCall, error: error)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Called by the call initiator after receiving an Answer from the callee.
|
|
*/
|
|
public func handleReceivedAnswer(thread: TSContactThread, callId: UInt64, sourceDevice: UInt32, sdp: String?, opaque: Data?, supportsMultiRing: Bool) {
|
|
AssertIsOnMainThread()
|
|
|
|
// opaque is required. sdp is obsolete, but it might still come with opaque.
|
|
guard let opaque = opaque else {
|
|
// TODO: Remove once the proto is updated to only support opaque and require it.
|
|
Logger.debug("opaque not received for answer, remote should update")
|
|
return
|
|
}
|
|
|
|
guard let identityKeys = getIdentityKeys(thread: thread) else {
|
|
if let currentCall = callService.currentCall, currentCall.individualCall?.callId == callId {
|
|
handleFailedCall(failedCall: currentCall, error: OWSAssertionError("missing identity keys"))
|
|
}
|
|
return
|
|
}
|
|
|
|
do {
|
|
try callManager.receivedAnswer(sourceDevice: sourceDevice, callId: callId, opaque: opaque, remoteSupportsMultiRing: supportsMultiRing, senderIdentityKey: identityKeys.contactIdentityKey, receiverIdentityKey: identityKeys.localIdentityKey)
|
|
} catch {
|
|
owsFailDebug("error: \(error)")
|
|
if let currentCall = callService.currentCall, currentCall.individualCall?.callId == callId {
|
|
handleFailedCall(failedCall: currentCall, error: error)
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Remote client (could be caller or callee) sent us a connectivity update.
|
|
*/
|
|
public func handleReceivedIceCandidates(thread: TSContactThread, callId: UInt64, sourceDevice: UInt32, candidates: [SNProtoCallMessageIceUpdate]) {
|
|
AssertIsOnMainThread()
|
|
|
|
let iceCandidates = candidates.filter { $0.id == callId && $0.opaque != nil }.map { $0.opaque! }
|
|
|
|
guard iceCandidates.count > 0 else {
|
|
Logger.debug("no ice candidates in ice message, remote should update")
|
|
return
|
|
}
|
|
|
|
do {
|
|
try callManager.receivedIceCandidates(sourceDevice: sourceDevice, callId: callId, candidates: iceCandidates)
|
|
} catch {
|
|
owsFailDebug("error: \(error)")
|
|
// we don't necessarily want to fail the call just because CallManager errored on an
|
|
// ICE candidate
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The remote client (caller or callee) ended the call.
|
|
*/
|
|
public func handleReceivedHangup(thread: TSContactThread, callId: UInt64, sourceDevice: UInt32, type: SNProtoCallMessageHangupType, deviceId: UInt32) {
|
|
AssertIsOnMainThread()
|
|
|
|
let hangupType: HangupType
|
|
switch type {
|
|
case .hangupNormal: hangupType = .normal
|
|
case .hangupAccepted: hangupType = .accepted
|
|
case .hangupDeclined: hangupType = .declined
|
|
case .hangupBusy: hangupType = .busy
|
|
case .hangupNeedPermission: hangupType = .needPermission
|
|
}
|
|
|
|
do {
|
|
try callManager.receivedHangup(sourceDevice: sourceDevice, callId: callId, hangupType: hangupType, deviceId: deviceId)
|
|
} catch {
|
|
owsFailDebug("\(error)")
|
|
if let currentCall = callService.currentCall, currentCall.individualCall?.callId == callId {
|
|
handleFailedCall(failedCall: currentCall, error: error)
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The callee was already in another call.
|
|
*/
|
|
public func handleReceivedBusy(thread: TSContactThread, callId: UInt64, sourceDevice: UInt32) {
|
|
AssertIsOnMainThread()
|
|
|
|
do {
|
|
try callManager.receivedBusy(sourceDevice: sourceDevice, callId: callId)
|
|
} catch {
|
|
owsFailDebug("\(error)")
|
|
if let currentCall = callService.currentCall, currentCall.individualCall?.callId == callId {
|
|
handleFailedCall(failedCall: currentCall, error: error)
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - Call Manager Events
|
|
|
|
public func callManager(_ callManager: CallService.CallManagerType, shouldStartCall call: SignalCall, callId: UInt64, isOutgoing: Bool, callMediaType: CallMediaType) {
|
|
AssertIsOnMainThread()
|
|
owsAssertDebug(call.isIndividualCall)
|
|
Logger.info("call: \(call)")
|
|
|
|
// Start the call, asynchronously.
|
|
getIceServers().done { iceServers in
|
|
guard self.callService.currentCall === call else {
|
|
Logger.debug("call has since ended")
|
|
return
|
|
}
|
|
|
|
var isUnknownCaller = false
|
|
if call.individualCall.direction == .incoming {
|
|
isUnknownCaller = !Storage.shared.getAllContacts().contains { $0.sessionID == call.individualCall.thread.contactSessionID() }
|
|
if isUnknownCaller {
|
|
Logger.warn("Using relay server because remote user is an unknown caller")
|
|
}
|
|
}
|
|
|
|
let useTurnOnly = isUnknownCaller
|
|
|
|
let useLowBandwidth = CallService.useLowBandwidthWithSneakyTransaction()
|
|
Logger.info("Configuring call for \(useLowBandwidth ? "low" : "standard") bandwidth")
|
|
|
|
// Tell the Call Manager to proceed with its active call.
|
|
try self.callManager.proceed(callId: callId, iceServers: iceServers, hideIp: useTurnOnly, videoCaptureController: call.videoCaptureController, bandwidthMode: useLowBandwidth ? .low : .normal)
|
|
}.catch { error in
|
|
owsFailDebug("\(error)")
|
|
guard call === self.callService.currentCall else {
|
|
Logger.debug("")
|
|
return
|
|
}
|
|
|
|
callManager.drop(callId: callId)
|
|
self.handleFailedCall(failedCall: call, error: error)
|
|
}
|
|
|
|
Logger.debug("")
|
|
}
|
|
|
|
public func callManager(_ callManager: CallService.CallManagerType, onEvent call: SignalCall, event: CallManagerEvent) {
|
|
AssertIsOnMainThread()
|
|
owsAssertDebug(call.isIndividualCall)
|
|
Logger.info("call: \(call), onEvent: \(event)")
|
|
|
|
switch event {
|
|
case .ringingLocal:
|
|
handleRinging(call: call)
|
|
|
|
case .ringingRemote:
|
|
handleRinging(call: call)
|
|
|
|
case .connectedLocal:
|
|
Logger.debug("")
|
|
// nothing further to do - already handled in handleAcceptCall().
|
|
|
|
case .connectedRemote:
|
|
callUIAdapter.recipientAcceptedCall(call)
|
|
handleConnected(call: call)
|
|
|
|
case .endedLocalHangup:
|
|
Logger.debug("")
|
|
// nothing further to do - already handled in handleLocalHangupCall().
|
|
|
|
case .endedRemoteHangup:
|
|
guard call === callService.currentCall else {
|
|
callService.cleanupStaleCall(call)
|
|
return
|
|
}
|
|
|
|
switch call.individualCall.state {
|
|
case .idle, .dialing, .answering, .localRinging, .localFailure, .remoteBusy, .remoteRinging:
|
|
handleMissedCall(call)
|
|
case .connected, .reconnecting, .localHangup, .remoteHangup, .remoteHangupNeedPermission, .answeredElsewhere, .declinedElsewhere, .busyElsewhere:
|
|
Logger.info("call is finished")
|
|
}
|
|
|
|
call.individualCall.state = .remoteHangup
|
|
|
|
// Notify UI
|
|
callUIAdapter.remoteDidHangupCall(call)
|
|
|
|
callService.terminate(call: call)
|
|
|
|
case .endedRemoteHangupNeedPermission:
|
|
guard call === callService.currentCall else {
|
|
callService.cleanupStaleCall(call)
|
|
return
|
|
}
|
|
|
|
switch call.individualCall.state {
|
|
case .idle, .dialing, .answering, .localRinging, .localFailure, .remoteBusy, .remoteRinging:
|
|
handleMissedCall(call)
|
|
case .connected, .reconnecting, .localHangup, .remoteHangup, .remoteHangupNeedPermission, .answeredElsewhere, .declinedElsewhere, .busyElsewhere:
|
|
Logger.info("call is finished")
|
|
}
|
|
|
|
call.individualCall.state = .remoteHangupNeedPermission
|
|
|
|
// Notify UI
|
|
callUIAdapter.remoteDidHangupCall(call)
|
|
|
|
callService.terminate(call: call)
|
|
|
|
case .endedRemoteHangupAccepted:
|
|
guard call === callService.currentCall else {
|
|
callService.cleanupStaleCall(call)
|
|
return
|
|
}
|
|
|
|
switch call.individualCall.state {
|
|
case .idle, .dialing, .remoteBusy, .remoteRinging, .answeredElsewhere, .declinedElsewhere, .busyElsewhere, .remoteHangup, .remoteHangupNeedPermission:
|
|
handleFailedCall(failedCall: call, error: OWSAssertionError("unexpected state for endedRemoteHangupAccepted: \(call.individualCall.state)"))
|
|
return
|
|
case .answering, .connected:
|
|
Logger.info("tried answering locally, but answered somewhere else first. state: \(call.individualCall.state)")
|
|
handleAnsweredElsewhere(call: call)
|
|
case .localRinging, .reconnecting:
|
|
handleAnsweredElsewhere(call: call)
|
|
case .localFailure, .localHangup:
|
|
Logger.info("ignoring 'endedRemoteHangupAccepted' since call is already finished")
|
|
}
|
|
|
|
case .endedRemoteHangupDeclined:
|
|
guard call === callService.currentCall else {
|
|
callService.cleanupStaleCall(call)
|
|
return
|
|
}
|
|
|
|
switch call.individualCall.state {
|
|
case .idle, .dialing, .remoteBusy, .remoteRinging, .answeredElsewhere, .declinedElsewhere, .busyElsewhere, .remoteHangup, .remoteHangupNeedPermission:
|
|
handleFailedCall(failedCall: call, error: OWSAssertionError("unexpected state for endedRemoteHangupDeclined: \(call.individualCall.state)"))
|
|
return
|
|
case .answering, .connected:
|
|
Logger.info("tried answering locally, but declined somewhere else first. state: \(call.individualCall.state)")
|
|
handleDeclinedElsewhere(call: call)
|
|
case .localRinging, .reconnecting:
|
|
handleDeclinedElsewhere(call: call)
|
|
case .localFailure, .localHangup:
|
|
Logger.info("ignoring 'endedRemoteHangupDeclined' since call is already finished")
|
|
}
|
|
|
|
case .endedRemoteHangupBusy:
|
|
guard call === callService.currentCall else {
|
|
callService.cleanupStaleCall(call)
|
|
return
|
|
}
|
|
|
|
switch call.individualCall.state {
|
|
case .idle, .dialing, .remoteBusy, .remoteRinging, .answeredElsewhere, .declinedElsewhere, .busyElsewhere, .remoteHangup, .remoteHangupNeedPermission:
|
|
handleFailedCall(failedCall: call, error: OWSAssertionError("unexpected state for endedRemoteHangupBusy: \(call.individualCall.state)"))
|
|
return
|
|
case .answering, .connected:
|
|
Logger.info("tried answering locally, but already in a call somewhere else first. state: \(call.individualCall.state)")
|
|
handleBusyElsewhere(call: call)
|
|
case .localRinging, .reconnecting:
|
|
handleBusyElsewhere(call: call)
|
|
case .localFailure, .localHangup:
|
|
Logger.info("ignoring 'endedRemoteHangupBusy' since call is already finished")
|
|
}
|
|
|
|
case .endedRemoteBusy:
|
|
guard call === callService.currentCall else {
|
|
callService.cleanupStaleCall(call)
|
|
return
|
|
}
|
|
|
|
assert(call.individualCall.direction == .outgoing)
|
|
if let callRecord = call.individualCall.callRecord {
|
|
callRecord.updateCallType(.outgoingMissed)
|
|
} else {
|
|
owsFailDebug("outgoing call should have call record")
|
|
}
|
|
|
|
call.individualCall.state = .remoteBusy
|
|
|
|
// Notify UI
|
|
callUIAdapter.remoteBusy(call)
|
|
|
|
callService.terminate(call: call)
|
|
|
|
case .endedRemoteGlare:
|
|
guard call === callService.currentCall else {
|
|
callService.cleanupStaleCall(call)
|
|
return
|
|
}
|
|
|
|
if let callRecord = call.individualCall.callRecord {
|
|
switch callRecord.callType {
|
|
case .outgoingMissed, .incomingDeclined, .incomingMissed, .incomingMissedBecauseOfChangedIdentity, .incomingAnsweredElsewhere, .incomingDeclinedElsewhere, .incomingBusyElsewhere:
|
|
// already handled and ended, don't update the call record.
|
|
break
|
|
case .incomingIncomplete, .incoming:
|
|
callRecord.updateCallType(.incomingMissed)
|
|
callUIAdapter.reportMissedCall(call)
|
|
case .outgoingIncomplete:
|
|
callRecord.updateCallType(.outgoingMissed)
|
|
callUIAdapter.remoteBusy(call)
|
|
case .outgoing:
|
|
callRecord.updateCallType(.outgoingMissed)
|
|
callUIAdapter.reportMissedCall(call)
|
|
@unknown default:
|
|
owsFailDebug("unknown RPRecentCallType: \(callRecord.callType)")
|
|
}
|
|
} else {
|
|
assert(call.individualCall.direction == .incoming)
|
|
let callRecord = TSCall(
|
|
callType: .incomingMissed,
|
|
offerType: call.individualCall.offerMediaType,
|
|
thread: call.individualCall.thread,
|
|
sentAtTimestamp: call.individualCall.sentAtTimestamp
|
|
)
|
|
Storage.write { transaction in
|
|
callRecord.save(with: transaction)
|
|
}
|
|
call.individualCall.callRecord = callRecord
|
|
callUIAdapter.reportMissedCall(call)
|
|
}
|
|
call.individualCall.state = .localFailure
|
|
callService.terminate(call: call)
|
|
|
|
case .endedTimeout:
|
|
let description: String
|
|
|
|
if call.individualCall.direction == .outgoing {
|
|
description = "timeout for outgoing call"
|
|
} else {
|
|
description = "timeout for incoming call"
|
|
}
|
|
|
|
handleFailedCall(failedCall: call, error: SignalCall.CallError.timeout(description: description))
|
|
|
|
case .endedSignalingFailure:
|
|
handleFailedCall(failedCall: call, error: SignalCall.CallError.timeout(description: "signaling failure for call"))
|
|
|
|
case .endedInternalFailure:
|
|
handleFailedCall(failedCall: call, error: OWSAssertionError("call manager internal error"))
|
|
|
|
case .endedConnectionFailure:
|
|
handleFailedCall(failedCall: call, error: SignalCall.CallError.disconnected)
|
|
|
|
case .endedDropped:
|
|
Logger.debug("")
|
|
|
|
// An incoming call was dropped, ignoring because we have already
|
|
// failed the call on the screen.
|
|
|
|
case .remoteVideoEnable:
|
|
guard call === callService.currentCall else {
|
|
callService.cleanupStaleCall(call)
|
|
return
|
|
}
|
|
|
|
call.individualCall.isRemoteVideoEnabled = true
|
|
|
|
case .remoteVideoDisable:
|
|
guard call === callService.currentCall else {
|
|
callService.cleanupStaleCall(call)
|
|
return
|
|
}
|
|
|
|
call.individualCall.isRemoteVideoEnabled = false
|
|
|
|
case .remoteSharingScreenEnable:
|
|
guard call === callService.currentCall else {
|
|
callService.cleanupStaleCall(call)
|
|
return
|
|
}
|
|
call.individualCall.isRemoteSharingScreen = true
|
|
|
|
case .remoteSharingScreenDisable:
|
|
guard call === callService.currentCall else {
|
|
callService.cleanupStaleCall(call)
|
|
return
|
|
}
|
|
call.individualCall.isRemoteSharingScreen = false
|
|
|
|
case .reconnecting:
|
|
self.handleReconnecting(call: call)
|
|
|
|
case .reconnected:
|
|
self.handleReconnected(call: call)
|
|
|
|
case .receivedOfferExpired:
|
|
// TODO - This is the case where an incoming offer's timestamp is
|
|
// not within the range +/- 120 seconds of the current system time.
|
|
// At the moment, this is not an issue since we are currently setting
|
|
// the timestamp separately when we receive the offer (above).
|
|
// This should not be a failure, it is just an 'old' call.
|
|
handleMissedCall(call)
|
|
call.individualCall.state = .localFailure
|
|
callService.terminate(call: call)
|
|
|
|
case .receivedOfferWhileActive:
|
|
handleMissedCall(call)
|
|
// TODO - This should not be a failure.
|
|
call.individualCall.state = .localFailure
|
|
callService.terminate(call: call)
|
|
|
|
case .receivedOfferWithGlare:
|
|
handleMissedCall(call)
|
|
// TODO - This should not be a failure.
|
|
call.individualCall.state = .localFailure
|
|
callService.terminate(call: call)
|
|
|
|
case .ignoreCallsFromNonMultiringCallers:
|
|
handleMissedCall(call)
|
|
call.individualCall.state = .localFailure
|
|
callService.terminate(call: call)
|
|
}
|
|
}
|
|
|
|
public func callManager(_ callManager: CallService.CallManagerType, onUpdateLocalVideoSession call: SignalCall, session: AVCaptureSession?) {
|
|
AssertIsOnMainThread()
|
|
owsAssertDebug(call.isIndividualCall)
|
|
Logger.info("onUpdateLocalVideoSession")
|
|
|
|
guard call === callService.currentCall else {
|
|
callService.cleanupStaleCall(call)
|
|
return
|
|
}
|
|
}
|
|
|
|
public func callManager(_ callManager: CallService.CallManagerType, onAddRemoteVideoTrack call: SignalCall, track: RTCVideoTrack) {
|
|
AssertIsOnMainThread()
|
|
owsAssertDebug(call.isIndividualCall)
|
|
Logger.info("onAddRemoteVideoTrack")
|
|
|
|
guard call === callService.currentCall else {
|
|
callService.cleanupStaleCall(call)
|
|
return
|
|
}
|
|
|
|
call.individualCall.remoteVideoTrack = track
|
|
}
|
|
|
|
// MARK: - Call Manager Signaling
|
|
|
|
public func callManager(_ callManager: CallService.CallManagerType, shouldSendOffer callId: UInt64, call: SignalCall, destinationDeviceId: UInt32?, opaque: Data, callMediaType: CallMediaType) {
|
|
AssertIsOnMainThread()
|
|
owsAssertDebug(call.isIndividualCall)
|
|
|
|
Logger.info("shouldSendOffer")
|
|
|
|
firstly { () throws -> Promise<Void> in
|
|
let message = IndividualCallMessage()
|
|
message.callID = callId
|
|
switch callMediaType {
|
|
case .audioCall: message.kind = .offer(opaque: opaque, callType: .audio)
|
|
case .videoCall: message.kind = .offer(opaque: opaque, callType: .video)
|
|
}
|
|
Storage.write { transaction in
|
|
MessageSender.send(message, in: call.individualCall.thread, using: transaction)
|
|
}
|
|
}.done {
|
|
Logger.info("sent offer message to \(call.individualCall.thread.contactSessionID()) device: \((destinationDeviceId != nil) ? String(destinationDeviceId!) : "nil")")
|
|
try self.callManager.signalingMessageDidSend(callId: callId)
|
|
}.catch { error in
|
|
Logger.error("failed to send offer message to \(call.individualCall.thread.contactSessionID()) with error: \(error)")
|
|
self.callManager.signalingMessageDidFail(callId: callId)
|
|
}
|
|
}
|
|
|
|
public func callManager(_ callManager: CallService.CallManagerType, shouldSendAnswer callId: UInt64, call: SignalCall, destinationDeviceId: UInt32?, opaque: Data) {
|
|
AssertIsOnMainThread()
|
|
owsAssertDebug(call.isIndividualCall)
|
|
Logger.info("shouldSendAnswer")
|
|
|
|
firstly { () throws -> Promise<Void> in
|
|
let message = IndividualCallMessage()
|
|
message.callID = callId
|
|
message.kind = .answer(opaque: opaque)
|
|
Storage.write { transaction in
|
|
MessageSender.send(message, in: call.individualCall.thread, using: transaction)
|
|
}
|
|
}.done {
|
|
Logger.debug("sent answer message to \(call.individualCall.thread.contactSessionID()) device: \((destinationDeviceId != nil) ? String(destinationDeviceId!) : "nil")")
|
|
try self.callManager.signalingMessageDidSend(callId: callId)
|
|
}.catch { error in
|
|
Logger.error("failed to send answer message to \(call.individualCall.thread.contactSessionID()) with error: \(error)")
|
|
self.callManager.signalingMessageDidFail(callId: callId)
|
|
}
|
|
}
|
|
|
|
public func callManager(_ callManager: CallService.CallManagerType, shouldSendIceCandidates callId: UInt64, call: SignalCall, destinationDeviceId: UInt32?, candidates: [Data]) {
|
|
AssertIsOnMainThread()
|
|
owsAssertDebug(call.isIndividualCall)
|
|
Logger.info("shouldSendIceCandidates")
|
|
|
|
guard !candidates.isEmpty else {
|
|
Logger.error("no ice updates to send")
|
|
return callManager.signalingMessageDidFail(callId: callId)
|
|
}
|
|
|
|
firstly { () throws -> Promise<Void> in
|
|
let message = IndividualCallMessage()
|
|
message.callID = callId
|
|
message.kind = .iceUpdate(candidates: candidates)
|
|
Storage.write { transaction in
|
|
MessageSender.send(message, in: call.individualCall.thread, using: transaction)
|
|
}
|
|
}.done {
|
|
Logger.debug("sent ice update message to \(call.individualCall.thread.contactSessionID()) device: \((destinationDeviceId != nil) ? String(destinationDeviceId!) : "nil")")
|
|
try self.callManager.signalingMessageDidSend(callId: callId)
|
|
}.catch { error in
|
|
Logger.error("failed to send ice update message to \(call.individualCall.thread.contactSessionID()) with error: \(error)")
|
|
callManager.signalingMessageDidFail(callId: callId)
|
|
}
|
|
}
|
|
|
|
public func callManager(_ callManager: CallService.CallManagerType, shouldSendHangup callId: UInt64, call: SignalCall, destinationDeviceId: UInt32?, hangupType: HangupType, deviceId: UInt32, useLegacyHangupMessage: Bool) {
|
|
AssertIsOnMainThread()
|
|
owsAssertDebug(call.isIndividualCall)
|
|
Logger.info("shouldSendHangup")
|
|
|
|
firstly { () throws -> Promise<Void> in
|
|
let type: IndividualCallMessage.HangupType
|
|
switch hangupType {
|
|
case .normal: type = .normal
|
|
case .accepted: type = .accepted
|
|
case .declined: type = .declined
|
|
case .busy: type = .busy
|
|
case .needPermission: type = .needPermission
|
|
}
|
|
let message = IndividualCallMessage()
|
|
message.callID = callId
|
|
message.kind = .hangup(type: type)
|
|
Storage.write { transaction in
|
|
MessageSender.send(message, in: call.individualCall.thread, using: transaction)
|
|
}
|
|
}.done {
|
|
Logger.debug("sent hangup message to \(call.individualCall.thread.contactSessionID()) device: \((destinationDeviceId != nil) ? String(destinationDeviceId!) : "nil")")
|
|
try self.callManager.signalingMessageDidSend(callId: callId)
|
|
}.catch { error in
|
|
Logger.error("failed to send hangup message to \(call.individualCall.thread.contactSessionID()) with error: \(error)")
|
|
self.callManager.signalingMessageDidFail(callId: callId)
|
|
}
|
|
}
|
|
|
|
public func callManager(_ callManager: CallService.CallManagerType, shouldSendBusy callId: UInt64, call: SignalCall, destinationDeviceId: UInt32?) {
|
|
AssertIsOnMainThread()
|
|
owsAssertDebug(call.isIndividualCall)
|
|
Logger.info("shouldSendBusy")
|
|
|
|
firstly { () throws -> Promise<Void> in
|
|
let message = IndividualCallMessage()
|
|
message.callID = callId
|
|
message.kind = .busy
|
|
Storage.write { transaction in
|
|
MessageSender.send(message, in: call.individualCall.thread, using: transaction)
|
|
}
|
|
}.done {
|
|
Logger.debug("sent busy message to \(call.individualCall.thread.contactSessionID()) device: \((destinationDeviceId != nil) ? String(destinationDeviceId!) : "nil")")
|
|
try self.callManager.signalingMessageDidSend(callId: callId)
|
|
}.catch { error in
|
|
Logger.error("failed to send busy message to \(call.individualCall.thread.contactSessionID()) with error: \(error)")
|
|
self.callManager.signalingMessageDidFail(callId: callId)
|
|
}
|
|
}
|
|
|
|
// MARK: - Support Functions
|
|
|
|
/**
|
|
* User didn't answer incoming call
|
|
*/
|
|
public func handleMissedCall(_ call: SignalCall) {
|
|
AssertIsOnMainThread()
|
|
Logger.info("call: \(call)")
|
|
|
|
let callRecord: TSCall
|
|
if let existingCallRecord = call.individualCall.callRecord {
|
|
callRecord = existingCallRecord
|
|
} else {
|
|
callRecord = TSCall(
|
|
callType: .incomingMissed,
|
|
offerType: call.individualCall.offerMediaType,
|
|
thread: call.individualCall.thread,
|
|
sentAtTimestamp: call.individualCall.sentAtTimestamp
|
|
)
|
|
call.individualCall.callRecord = callRecord
|
|
}
|
|
|
|
switch callRecord.callType {
|
|
case .incomingMissed:
|
|
Storage.write { transaction in
|
|
callRecord.save(with: transaction)
|
|
}
|
|
callUIAdapter.reportMissedCall(call)
|
|
case .incomingIncomplete, .incoming:
|
|
callRecord.updateCallType(.incomingMissed)
|
|
callUIAdapter.reportMissedCall(call)
|
|
case .outgoingIncomplete:
|
|
callRecord.updateCallType(.outgoingMissed)
|
|
case .incomingMissedBecauseOfChangedIdentity, .incomingDeclined, .outgoingMissed, .outgoing, .incomingAnsweredElsewhere, .incomingDeclinedElsewhere, .incomingBusyElsewhere:
|
|
owsFailDebug("unexpected RPRecentCallType: \(callRecord.callType)")
|
|
Storage.write { transaction in
|
|
callRecord.save(with: transaction)
|
|
}
|
|
@unknown default:
|
|
Storage.write { transaction in
|
|
callRecord.save(with: transaction)
|
|
}
|
|
owsFailDebug("unknown RPRecentCallType: \(callRecord.callType)")
|
|
}
|
|
}
|
|
|
|
func handleAnsweredElsewhere(call: SignalCall) {
|
|
if let existingCallRecord = call.individualCall.callRecord {
|
|
// There should only be an existing call record due to a race where the call is answered
|
|
// simultaneously on multiple devices, and the caller is proceeding with the *other*
|
|
// devices call.
|
|
existingCallRecord.updateCallType(.incomingAnsweredElsewhere)
|
|
} else {
|
|
let callRecord = TSCall(
|
|
callType: .incomingAnsweredElsewhere,
|
|
offerType: call.individualCall.offerMediaType,
|
|
thread: call.individualCall.thread,
|
|
sentAtTimestamp: call.individualCall.sentAtTimestamp
|
|
)
|
|
call.individualCall.callRecord = callRecord
|
|
Storage.write { transaction in
|
|
callRecord.save(with: transaction)
|
|
}
|
|
}
|
|
|
|
call.individualCall.state = .answeredElsewhere
|
|
|
|
// Notify UI
|
|
callUIAdapter.didAnswerElsewhere(call: call)
|
|
|
|
callService.terminate(call: call)
|
|
}
|
|
|
|
func handleDeclinedElsewhere(call: SignalCall) {
|
|
if let existingCallRecord = call.individualCall.callRecord {
|
|
// There should only be an existing call record due to a race where the call is answered
|
|
// simultaneously on multiple devices, and the caller is proceeding with the *other*
|
|
// devices call.
|
|
existingCallRecord.updateCallType(.incomingDeclinedElsewhere)
|
|
} else {
|
|
let callRecord = TSCall(
|
|
callType: .incomingDeclinedElsewhere,
|
|
offerType: call.individualCall.offerMediaType,
|
|
thread: call.individualCall.thread,
|
|
sentAtTimestamp: call.individualCall.sentAtTimestamp
|
|
)
|
|
call.individualCall.callRecord = callRecord
|
|
Storage.write { transaction in
|
|
callRecord.save(with: transaction)
|
|
}
|
|
}
|
|
|
|
call.individualCall.state = .declinedElsewhere
|
|
|
|
// Notify UI
|
|
callUIAdapter.didDeclineElsewhere(call: call)
|
|
|
|
callService.terminate(call: call)
|
|
}
|
|
|
|
func handleBusyElsewhere(call: SignalCall) {
|
|
if let existingCallRecord = call.individualCall.callRecord {
|
|
// There should only be an existing call record due to a race where the call is answered
|
|
// simultaneously on multiple devices, and the caller is proceeding with the *other*
|
|
// devices call.
|
|
existingCallRecord.updateCallType(.incomingBusyElsewhere)
|
|
} else {
|
|
let callRecord = TSCall(
|
|
callType: .incomingBusyElsewhere,
|
|
offerType: call.individualCall.offerMediaType,
|
|
thread: call.individualCall.thread,
|
|
sentAtTimestamp: call.individualCall.sentAtTimestamp
|
|
)
|
|
call.individualCall.callRecord = callRecord
|
|
Storage.write { transaction in
|
|
callRecord.save(with: transaction)
|
|
}
|
|
}
|
|
|
|
call.individualCall.state = .busyElsewhere
|
|
|
|
// Notify UI
|
|
callUIAdapter.reportMissedCall(call)
|
|
|
|
callService.terminate(call: call)
|
|
}
|
|
|
|
/**
|
|
* The clients can now communicate via WebRTC, so we can let the UI know.
|
|
*
|
|
* Called by both caller and callee. Compatible ICE messages have been exchanged between the local and remote
|
|
* client.
|
|
*/
|
|
private func handleRinging(call: SignalCall) {
|
|
AssertIsOnMainThread()
|
|
Logger.info("call: \(call)")
|
|
|
|
guard call === callService.currentCall else {
|
|
callService.cleanupStaleCall(call)
|
|
return
|
|
}
|
|
|
|
switch call.individualCall.state {
|
|
case .dialing:
|
|
if call.individualCall.state != .remoteRinging {
|
|
BenchEventComplete(eventId: "call-\(call.individualCall.localId)")
|
|
}
|
|
call.individualCall.state = .remoteRinging
|
|
case .answering:
|
|
if call.individualCall.state != .localRinging {
|
|
BenchEventComplete(eventId: "call-\(call.individualCall.localId)")
|
|
}
|
|
call.individualCall.state = .localRinging
|
|
self.callUIAdapter.reportIncomingCall(call, thread: call.individualCall.thread)
|
|
case .remoteRinging:
|
|
Logger.info("call already ringing. Ignoring \(#function): \(call).")
|
|
case .idle, .localRinging, .connected, .reconnecting, .localFailure, .localHangup, .remoteHangup, .remoteHangupNeedPermission, .remoteBusy, .answeredElsewhere, .declinedElsewhere, .busyElsewhere:
|
|
owsFailDebug("unexpected call state: \(call.individualCall.state): \(call).")
|
|
}
|
|
}
|
|
|
|
private func handleReconnecting(call: SignalCall) {
|
|
AssertIsOnMainThread()
|
|
Logger.info("call: \(call)")
|
|
|
|
guard call === callService.currentCall else {
|
|
callService.cleanupStaleCall(call)
|
|
return
|
|
}
|
|
|
|
switch call.individualCall.state {
|
|
case .remoteRinging, .localRinging:
|
|
Logger.debug("disconnect while ringing... we'll keep ringing")
|
|
case .connected:
|
|
call.individualCall.state = .reconnecting
|
|
default:
|
|
owsFailDebug("unexpected call state: \(call.individualCall.state): \(call).")
|
|
}
|
|
}
|
|
|
|
private func handleReconnected(call: SignalCall) {
|
|
AssertIsOnMainThread()
|
|
Logger.info("call: \(call)")
|
|
|
|
guard call === callService.currentCall else {
|
|
callService.cleanupStaleCall(call)
|
|
return
|
|
}
|
|
|
|
switch call.individualCall.state {
|
|
case .reconnecting:
|
|
call.individualCall.state = .connected
|
|
default:
|
|
owsFailDebug("unexpected call state: \(call.individualCall.state): \(call).")
|
|
}
|
|
}
|
|
|
|
/**
|
|
* For outgoing call, when the callee has chosen to accept the call.
|
|
* For incoming call, when the local user has chosen to accept the call.
|
|
*/
|
|
private func handleConnected(call: SignalCall) {
|
|
AssertIsOnMainThread()
|
|
Logger.info("call: \(call)")
|
|
|
|
guard call === callService.currentCall else {
|
|
callService.cleanupStaleCall(call)
|
|
return
|
|
}
|
|
|
|
// End the background task.
|
|
call.individualCall.backgroundTask = nil
|
|
|
|
call.individualCall.state = .connected
|
|
|
|
// We don't risk transmitting any media until the remote client has admitted to being connected.
|
|
ensureAudioState(call: call)
|
|
callService.callManager.setLocalVideoEnabled(enabled: callService.shouldHaveLocalVideoTrack, call: call)
|
|
}
|
|
|
|
/**
|
|
* Local user toggled to hold call. Currently only possible via CallKit screen,
|
|
* e.g. when another Call comes in.
|
|
*/
|
|
func setIsOnHold(call: SignalCall, isOnHold: Bool) {
|
|
AssertIsOnMainThread()
|
|
Logger.info("call: \(call)")
|
|
|
|
guard call === callService.currentCall else {
|
|
callService.cleanupStaleCall(call)
|
|
return
|
|
}
|
|
|
|
call.individualCall.isOnHold = isOnHold
|
|
|
|
ensureAudioState(call: call)
|
|
}
|
|
|
|
@objc
|
|
func handleCallKitStartVideo() {
|
|
AssertIsOnMainThread()
|
|
|
|
callService.updateIsLocalVideoMuted(isLocalVideoMuted: false)
|
|
}
|
|
|
|
/**
|
|
* RTCIceServers are used when attempting to establish an optimal connection to the other party. SignalService supplies
|
|
* a list of servers, plus we have fallback servers hardcoded in the app.
|
|
*/
|
|
private func getIceServers() -> Promise<[RTCIceServer]> {
|
|
|
|
return firstly {
|
|
AppEnvironment.shared.accountManager.getTurnServerInfo()
|
|
}.map(on: .global()) { turnServerInfo -> [RTCIceServer] in
|
|
Logger.debug("got turn server urls: \(turnServerInfo.urls)")
|
|
|
|
return turnServerInfo.urls.map { url in
|
|
if url.hasPrefix("turn") {
|
|
// Only "turn:" servers require authentication. Don't include the credentials to other ICE servers
|
|
// as 1.) they aren't used, and 2.) the non-turn servers might not be under our control.
|
|
// e.g. we use a public fallback STUN server.
|
|
return RTCIceServer(urlStrings: [url], username: turnServerInfo.username, credential: turnServerInfo.password)
|
|
} else {
|
|
return RTCIceServer(urlStrings: [url])
|
|
}
|
|
} + [IndividualCallService.fallbackIceServer]
|
|
}.recover(on: .global()) { (error: Error) -> Guarantee<[RTCIceServer]> in
|
|
Logger.error("fetching ICE servers failed with error: \(error)")
|
|
Logger.warn("using fallback ICE Servers")
|
|
|
|
return Guarantee.value([IndividualCallService.fallbackIceServer])
|
|
}
|
|
}
|
|
|
|
public func handleCallKitProviderReset() {
|
|
AssertIsOnMainThread()
|
|
Logger.debug("")
|
|
|
|
// Return to a known good state by ending the current call, if any.
|
|
if let call = callService.currentCall {
|
|
handleFailedCall(failedCall: call, error: SignalCall.CallError.providerReset)
|
|
}
|
|
callManager.reset()
|
|
}
|
|
|
|
// This method should be called when a fatal error occurred for a call.
|
|
//
|
|
// * If we know which call it was, we should update that call's state
|
|
// to reflect the error.
|
|
// * IFF that call is the current call, we want to terminate it.
|
|
public func handleFailedCall(failedCall: SignalCall, error: Error) {
|
|
AssertIsOnMainThread()
|
|
Logger.debug("")
|
|
|
|
let callError: SignalCall.CallError = {
|
|
switch error {
|
|
case let callError as SignalCall.CallError:
|
|
return callError
|
|
default:
|
|
return SignalCall.CallError.externalError(underlyingError: error)
|
|
}
|
|
}()
|
|
|
|
switch failedCall.individualCall.state {
|
|
case .answering, .localRinging:
|
|
assert(failedCall.individualCall.callRecord == nil)
|
|
// call failed before any call record could be created, make one now.
|
|
handleMissedCall(failedCall)
|
|
default:
|
|
assert(failedCall.individualCall.callRecord != nil)
|
|
}
|
|
|
|
guard !failedCall.individualCall.isEnded else {
|
|
Logger.debug("ignoring error: \(error) for already terminated call: \(failedCall)")
|
|
return
|
|
}
|
|
|
|
failedCall.error = callError
|
|
failedCall.individualCall.state = .localFailure
|
|
self.callUIAdapter.failCall(failedCall, error: callError)
|
|
|
|
Logger.error("call: \(failedCall) failed with error: \(error)")
|
|
callService.terminate(call: failedCall)
|
|
}
|
|
|
|
func ensureAudioState(call: SignalCall) {
|
|
owsAssertDebug(call.isIndividualCall)
|
|
let isLocalAudioMuted = call.individualCall.state != .connected || call.individualCall.isMuted || call.individualCall.isOnHold
|
|
callManager.setLocalAudioEnabled(enabled: !isLocalAudioMuted)
|
|
}
|
|
|
|
// MARK: CallViewController Timer
|
|
|
|
var activeCallTimer: Timer?
|
|
func startCallTimer() {
|
|
AssertIsOnMainThread()
|
|
|
|
stopAnyCallTimer()
|
|
assert(self.activeCallTimer == nil)
|
|
|
|
guard let call = callService.currentCall else {
|
|
owsFailDebug("Missing call.")
|
|
return
|
|
}
|
|
|
|
var hasUsedUpTimerSlop: Bool = false
|
|
|
|
self.activeCallTimer = WeakTimer.scheduledTimer(timeInterval: 1, target: self, userInfo: nil, repeats: true) { timer in
|
|
guard call === self.callService.currentCall else {
|
|
owsFailDebug("call has since ended. Timer should have been invalidated.")
|
|
timer.invalidate()
|
|
return
|
|
}
|
|
self.ensureCallScreenPresented(call: call, hasUsedUpTimerSlop: &hasUsedUpTimerSlop)
|
|
}
|
|
}
|
|
|
|
func ensureCallScreenPresented(call: SignalCall, hasUsedUpTimerSlop: inout Bool) {
|
|
guard callService.currentCall === call else {
|
|
owsFailDebug("obsolete call: \(call)")
|
|
return
|
|
}
|
|
|
|
guard let connectedDate = call.connectedDate else {
|
|
// Ignore; call hasn't connected yet.
|
|
return
|
|
}
|
|
|
|
let kMaxViewPresentationDelay: Double = 5
|
|
guard fabs(connectedDate.timeIntervalSinceNow) > kMaxViewPresentationDelay else {
|
|
// Ignore; call connected recently.
|
|
return
|
|
}
|
|
|
|
guard !OWSWindowManager.shared().hasCall() else {
|
|
// call screen is visible
|
|
return
|
|
}
|
|
|
|
guard hasUsedUpTimerSlop else {
|
|
// We hide the call screen synchronously, as soon as the user hangs up the call
|
|
// But it takes a while to communicate the hangup from the UI -> CallKit -> CallService
|
|
// However it's possible the timer fired the *instant* after the user hit the hangup
|
|
// button, so we allow one tick of the timer cycle as slop.
|
|
Logger.verbose("using up timer slop")
|
|
hasUsedUpTimerSlop = true
|
|
return
|
|
}
|
|
|
|
owsFailDebug("Call terminated due to missing call view.")
|
|
self.handleFailedCall(failedCall: call, error: OWSAssertionError("Call view didn't present after \(kMaxViewPresentationDelay) seconds"))
|
|
}
|
|
|
|
func stopAnyCallTimer() {
|
|
AssertIsOnMainThread()
|
|
|
|
self.activeCallTimer?.invalidate()
|
|
self.activeCallTimer = nil
|
|
}
|
|
}
|
|
|
|
extension RPRecentCallType: CustomStringConvertible {
|
|
public var description: String {
|
|
switch self {
|
|
case .incoming:
|
|
return ".incoming"
|
|
case .outgoing:
|
|
return ".outgoing"
|
|
case .incomingMissed:
|
|
return ".incomingMissed"
|
|
case .outgoingIncomplete:
|
|
return ".outgoingIncomplete"
|
|
case .incomingIncomplete:
|
|
return ".incomingIncomplete"
|
|
case .incomingMissedBecauseOfChangedIdentity:
|
|
return ".incomingMissedBecauseOfChangedIdentity"
|
|
case .incomingDeclined:
|
|
return ".incomingDeclined"
|
|
case .outgoingMissed:
|
|
return ".outgoingMissed"
|
|
default:
|
|
owsFailDebug("unexpected RPRecentCallType: \(self.rawValue)")
|
|
return "RPRecentCallTypeUnknown"
|
|
}
|
|
}
|
|
}
|
|
|
|
extension NSNumber {
|
|
convenience init?(value: UInt32?) {
|
|
guard let value = value else { return nil }
|
|
self.init(value: value)
|
|
}
|
|
}
|
|
|
|
extension TSRecentCallOfferType {
|
|
var asCallMediaType: CallMediaType {
|
|
switch self {
|
|
case .audio: return .audioCall
|
|
case .video: return .videoCall
|
|
}
|
|
}
|
|
}
|