forked from mirrors/linphone-iphone
235 lines
8 KiB
Swift
235 lines
8 KiB
Swift
/*
|
|
* Copyright (c) 2010-2020 Belledonne Communications SARL.
|
|
*
|
|
* This file is part of linhome
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
|
|
import Foundation
|
|
import linphonesw
|
|
import AVFoundation
|
|
|
|
|
|
class CallsViewModel {
|
|
|
|
let currentCallData = MutableLiveData<CallData?>(nil)
|
|
let callsData = MutableLiveData<[CallData]>([])
|
|
let inactiveCallsCount = MutableLiveData(0)
|
|
let currentCallUnreadChatMessageCount = MutableLiveData(0)
|
|
let chatAndCallsCount = MutableLiveData(0)
|
|
let callConnectedEvent = MutableLiveData<Call>()
|
|
let callUpdateEvent = MutableLiveData<Call>()
|
|
let noMoreCallEvent = MutableLiveData(false)
|
|
|
|
var core : Core { get { Core.get() } }
|
|
|
|
static let shared = CallsViewModel()
|
|
|
|
private var coreDelegate : CoreDelegateStub?
|
|
|
|
init () {
|
|
coreDelegate = CoreDelegateStub(
|
|
onCallStateChanged : { (core: Core, call: Call, state: Call.State, message:String) -> Void in
|
|
Log.i("[Calls] Call state changed: \(call) : \(state)")
|
|
if (state == .IncomingEarlyMedia || state == .IncomingReceived || state == .OutgoingInit) {
|
|
self.addCallToList(call:call)
|
|
}
|
|
let currentCall = core.currentCall
|
|
Log.i("[Calls] Current call is \(currentCall)")
|
|
if (currentCall != nil && self.currentCallData.value??.call.getCobject != currentCall?.getCobject) {
|
|
self.updateCurrentCallData(currentCall: currentCall)
|
|
} else if (currentCall == nil && core.callsNb > 0) {
|
|
self.updateCurrentCallData(currentCall: currentCall)
|
|
}
|
|
if ([.End,.Released,.Error].contains(state)) {
|
|
self.removeCallFromList(call: call)
|
|
} else if ([.OutgoingInit].contains(state)) {
|
|
self.addCallToList(call:call)
|
|
} else if ([.IncomingReceived].contains(state)) {
|
|
self.addCallToList(call:call)
|
|
} else if (state == .UpdatedByRemote) {
|
|
let remoteVideo = call.remoteParams?.videoEnabled == true
|
|
let localVideo = call.currentParams?.videoEnabled == true
|
|
let autoAccept = call.core?.videoActivationPolicy?.automaticallyAccept == true
|
|
if (remoteVideo && !localVideo && !autoAccept) {
|
|
if (core.videoCaptureEnabled || core.videoDisplayEnabled) && Core.get().config?.getBool(section: "app", key: "disable_video_feature", defaultValue: false) == false {
|
|
try?call.deferUpdate()
|
|
self.callUpdateEvent.value = call
|
|
} else {
|
|
call.answerVideoUpdateRequest(accept: false)
|
|
}
|
|
}
|
|
} else if (state == Call.State.Connected) {
|
|
self.callConnectedEvent.value = call
|
|
} else if (state == Call.State.StreamsRunning) {
|
|
self.callUpdateEvent.value = call
|
|
}
|
|
self.updateInactiveCallsCount()
|
|
self.callsData.notifyValue()
|
|
self.currentCallData.notifyValue()
|
|
},
|
|
|
|
onMessageReceived : { (core: Core, room: ChatRoom, message: ChatMessage) -> Void in
|
|
self.updateUnreadChatCount()
|
|
},
|
|
onChatRoomRead : { (core: Core, room: ChatRoom) -> Void in
|
|
self.updateUnreadChatCount()
|
|
},
|
|
onLastCallEnded: { (core: Core) -> Void in
|
|
self.currentCallData.value??.destroy()
|
|
self.currentCallData.value = nil
|
|
self.noMoreCallEvent.value = true
|
|
}
|
|
)
|
|
|
|
Core.get().addDelegate(delegate: coreDelegate!)
|
|
|
|
if let currentCall = core.currentCall {
|
|
currentCallData.value??.destroy()
|
|
currentCallData.value = CallData(call:currentCall)
|
|
}
|
|
|
|
chatAndCallsCount.value = 0
|
|
inactiveCallsCount.readCurrentAndObserve { (_) in
|
|
self.updateCallsAndChatCount()
|
|
}
|
|
currentCallUnreadChatMessageCount.readCurrentAndObserve { (_) in
|
|
self.updateCallsAndChatCount()
|
|
}
|
|
|
|
initCallList()
|
|
updateInactiveCallsCount()
|
|
updateUnreadChatCount()
|
|
|
|
}
|
|
|
|
private func initCallList() {
|
|
core.calls.forEach { addCallToList(call: $0) }
|
|
}
|
|
|
|
private func removeCallFromList(call: Call) {
|
|
Log.i("[Calls] Removing call \(call) from calls list")
|
|
if let removeCandidate = callsData.value?.filter{$0.call.getCobject == call.getCobject}.first {
|
|
removeCandidate.destroy()
|
|
}
|
|
|
|
callsData.value = callsData.value?.filter(){$0.call.getCobject != call.getCobject}
|
|
callsData.notifyValue()
|
|
}
|
|
|
|
private func addCallToList(call: Call) {
|
|
Log.i("[Calls] Adding call \(call) to calls list")
|
|
guard self.callsData.value?.filter({$0.call.getCobject == call.getCobject}).first == nil else {
|
|
Log.i("[Calls] \(call) already present in the list")
|
|
return
|
|
}
|
|
callsData.value?.append(CallData(call: call))
|
|
callsData.notifyValue()
|
|
}
|
|
|
|
private func updateUnreadChatCount() {
|
|
guard let unread = currentCallData.value??.chatRoom?.unreadMessagesCount else {
|
|
currentCallUnreadChatMessageCount.value = 0
|
|
return
|
|
}
|
|
currentCallUnreadChatMessageCount.value = unread
|
|
}
|
|
|
|
private func updateInactiveCallsCount() {
|
|
inactiveCallsCount.value = core.callsNb - 1
|
|
}
|
|
|
|
private func updateCallsAndChatCount() {
|
|
var value = 0
|
|
if let calls = inactiveCallsCount.value {
|
|
value += calls
|
|
}
|
|
if let chats = currentCallUnreadChatMessageCount.value {
|
|
value += chats
|
|
}
|
|
chatAndCallsCount.value = value
|
|
}
|
|
|
|
func mergeCallsIntoLocalConference() {
|
|
CallManager.instance().startLocalConference()
|
|
}
|
|
|
|
private func updateCurrentCallData(currentCall: Call?) {
|
|
var callToUse = currentCall
|
|
if (currentCall == nil) {
|
|
Log.w("[Calls] Current call is now null")
|
|
|
|
if (Core.get().callsNb == 1) {
|
|
let firstData = callsData.value?.first
|
|
if (firstData != nil && currentCallData.value??.call.getCobject != firstData?.call.getCobject) {
|
|
Log.i("[Calls] Only one call in Core and the current call data doesn't match it, updating it")
|
|
currentCallData.value = firstData
|
|
}
|
|
return
|
|
}
|
|
|
|
let firstCall = core.calls.filter {$0.state != .Error && $0.state != .End && $0.state != .Released}.first
|
|
if (firstCall != nil && currentCallData.value??.call.getCobject != firstCall?.getCobject) {
|
|
Log.i("[Calls] Using \(firstCall?.callLog?.callId) as \"current\" call")
|
|
callToUse = firstCall
|
|
}
|
|
}
|
|
|
|
guard let callToUse = callToUse else {
|
|
Log.w("[Calls] No call found to be used as \"current\"")
|
|
return
|
|
}
|
|
|
|
let firstToUse = callsData.value?.filter{$0.call.getCobject == callToUse.getCobject}.first
|
|
if (firstToUse != nil) {
|
|
Log.i("[Calls] Updating current call to : \(firstToUse?.call)")
|
|
currentCallData.value = firstToUse
|
|
} else {
|
|
Log.w("[Calls] Call not found in calls data list, shouldn't happen! currentCallData is \(callToUse)")
|
|
currentCallData.value = CallData(call: callToUse)
|
|
}
|
|
ControlsViewModel.shared.updateMicState()
|
|
//updateUnreadChatCount()
|
|
}
|
|
}
|
|
|
|
@objc class CallsViewModelBridge : NSObject {
|
|
@objc static func callViewToDisplay() -> UICompositeViewDescription? {
|
|
if let call = CallsViewModel.shared.currentCallData.value??.call {
|
|
if (call.conference != nil) {
|
|
return ConferenceCallView.compositeDescription
|
|
} else {
|
|
return SingleCallView.compositeDescription
|
|
}
|
|
} else {
|
|
return DialerView.compositeViewDescription()
|
|
}
|
|
}
|
|
@objc static func setupCallsViewNavigation() {
|
|
CallsViewModel.shared.currentCallData.readCurrentAndObserve { currentCallData in
|
|
guard currentCallData != nil && currentCallData??.call != nil && currentCallData??.isOutgoing.value != true && currentCallData??.isIncoming.value != true else {
|
|
PhoneMainView.instance().popView(SingleCallView.compositeDescription)
|
|
PhoneMainView.instance().popView(ConferenceCallView.compositeDescription)
|
|
return
|
|
}
|
|
if (currentCallData??.call.conference != nil) {
|
|
PhoneMainView.instance().pop(toView:ConferenceCallView.compositeDescription)
|
|
} else {
|
|
PhoneMainView.instance().pop(toView:SingleCallView.compositeDescription)
|
|
}
|
|
}
|
|
}
|
|
}
|