forked from mirrors/linphone-iphone
281 lines
9.7 KiB
Swift
281 lines
9.7 KiB
Swift
/*
|
|
* Copyright (c) 2010-2021 Belledonne Communications SARL.
|
|
*
|
|
* This file is part of linphone-android
|
|
* (see https://www.linphone.org).
|
|
*
|
|
* 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
|
|
* aDouble with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
|
|
import Foundation
|
|
import linphonesw
|
|
|
|
class ConferenceSchedulingViewModel {
|
|
|
|
var core : Core { get { Core.get() } }
|
|
static let shared = ConferenceSchedulingViewModel()
|
|
|
|
let subject = MutableLiveData<String>()
|
|
let description = MutableLiveData<String>()
|
|
|
|
let mode = MutableLiveData<Int>()
|
|
static let modeList: [Mode] = computeModeList()
|
|
|
|
let scheduleForLater = MutableLiveData<Bool>()
|
|
let scheduledDate = MutableLiveData<Date>()
|
|
let scheduledTime = MutableLiveData<Date>()
|
|
|
|
var scheduledTimeZone = MutableLiveData<Int>()
|
|
static let timeZones: [TimeZoneData] = computeTimeZonesList()
|
|
|
|
var scheduledDuration = MutableLiveData<Int>()
|
|
static let durationList: [Duration] = computeDurationList()
|
|
|
|
let isEncrypted = MutableLiveData<Bool>()
|
|
|
|
let sendInviteViaChat = MutableLiveData<Bool>()
|
|
let sendInviteViaEmail = MutableLiveData<Bool>()
|
|
|
|
let address = MutableLiveData<Address>()
|
|
|
|
let conferenceCreationInProgress = MutableLiveData<Bool>()
|
|
|
|
let conferenceCreationCompletedEvent: MutableLiveData<Pair<String?,String?>> = MutableLiveData()
|
|
let onErrorEvent = MutableLiveData<String>()
|
|
|
|
let continueEnabled: MutableLiveData<Bool> = MutableLiveData()
|
|
|
|
let selectedAddresses = MutableLiveData<[Address]>([])
|
|
let selectedSpeakerAddresses = MutableLiveData<[Address]>([])
|
|
|
|
private var conferenceScheduler: ConferenceScheduler? = nil
|
|
|
|
|
|
private var hour: Int = 0
|
|
private var minutes: Int = 0
|
|
|
|
private var chatRoomDelegate : ChatRoomDelegate? = nil
|
|
private var conferenceSchedulerDelegate : ConferenceSchedulerDelegateStub? = nil
|
|
|
|
var existingConfInfo:MutableLiveData<ConferenceInfo?> = MutableLiveData()
|
|
|
|
init () {
|
|
|
|
conferenceSchedulerDelegate = ConferenceSchedulerDelegateStub(
|
|
onStateChanged: { scheduler, state in
|
|
Log.i("[Conference Creation] Conference scheduler state is \(state)")
|
|
if (state == .Ready) {
|
|
Log.i("[Conference Creation] Conference info created, address will be \(scheduler.info?.uri?.asStringUriOnly())")
|
|
guard let conferenceAddress = scheduler.info?.uri else {
|
|
Log.e("[Conference Creation] conference address is null")
|
|
return
|
|
}
|
|
self.address.value = conferenceAddress
|
|
|
|
if (self.scheduleForLater.value == true && self.sendInviteViaChat.value == true) {
|
|
// Send conference info even when conf is not scheduled for later
|
|
// as the conference server doesn't invite participants automatically
|
|
if let chatRoomParams = self.getConferenceInvitationsChatRoomParams() {
|
|
scheduler.sendInvitations(chatRoomParams: chatRoomParams)
|
|
}
|
|
} else {
|
|
self.conferenceCreationInProgress.value = false
|
|
self.conferenceCreationCompletedEvent.value = Pair(conferenceAddress.asStringUriOnly(),self.conferenceScheduler?.info?.subject)
|
|
}
|
|
}
|
|
}, onInvitationsSent: { conferenceScheduler, failedInvitations in
|
|
Log.i("[Conference Creation] Conference information successfully sent to all participants")
|
|
self.conferenceCreationInProgress.value = false
|
|
|
|
if (failedInvitations.count > 0) {
|
|
failedInvitations.forEach { address in
|
|
Log.e("[Conference Creation] Conference information wasn't sent to participant \(address.asStringUriOnly())")
|
|
self.onErrorEvent.value = VoipTexts.conference_schedule_info_not_sent_to_participant+" (\(address.username))"
|
|
}
|
|
}
|
|
|
|
guard let conferenceAddress = conferenceScheduler.info?.uri else {
|
|
Log.e("[Conference Creation] conference address is null")
|
|
return
|
|
}
|
|
self.conferenceCreationCompletedEvent.value = Pair(conferenceAddress.asStringUriOnly(),self.conferenceScheduler?.info?.subject)
|
|
}
|
|
)
|
|
|
|
chatRoomDelegate = ChatRoomDelegateStub(
|
|
onStateChanged : { (room: ChatRoom, state: ChatRoom.State) -> Void in
|
|
if (state == ChatRoom.State.Created) {
|
|
Log.i("[Conference Creation] Chat room created")
|
|
room.removeDelegate(delegate: self.chatRoomDelegate!)
|
|
} else if (state == ChatRoom.State.CreationFailed) {
|
|
Log.e("[Conference Creation] Group chat room creation has failed !")
|
|
room.removeDelegate(delegate: self.chatRoomDelegate!)
|
|
}
|
|
}
|
|
)
|
|
|
|
reset()
|
|
|
|
subject.observe { _ in
|
|
self.continueEnabled.value = self.allMandatoryFieldsFilled()
|
|
}
|
|
scheduleForLater.observe { _ in
|
|
self.continueEnabled.value = self.allMandatoryFieldsFilled()
|
|
}
|
|
scheduledDate.observe { _ in
|
|
self.continueEnabled.value = self.allMandatoryFieldsFilled()
|
|
}
|
|
scheduledTime.observe { _ in
|
|
self.continueEnabled.value = self.allMandatoryFieldsFilled()
|
|
}
|
|
|
|
|
|
}
|
|
|
|
func isEndToEndEncryptedChatAvailable() -> Bool {
|
|
let core = Core.get()
|
|
return core.limeX3DhEnabled &&
|
|
((core.limeX3DhServerUrl != nil && core.limeX3DhServerUrl.count > 0) || core.defaultAccount?.params?.limeServerUrl != nil) &&
|
|
core.defaultAccount?.params?.conferenceFactoryUri != nil
|
|
}
|
|
|
|
func reset() {
|
|
|
|
subject.value = ""
|
|
scheduleForLater.value = false
|
|
isEncrypted.value = false
|
|
sendInviteViaChat.value = true
|
|
sendInviteViaEmail.value = false
|
|
scheduledDate.value = nil
|
|
scheduledTime.value = nil
|
|
|
|
mode.value = ConferenceSchedulingViewModel.modeList.indices.filter {
|
|
ConferenceSchedulingViewModel.modeList[$0].value == 0
|
|
}.first
|
|
|
|
scheduledTimeZone.value = ConferenceSchedulingViewModel.timeZones.indices.filter {
|
|
ConferenceSchedulingViewModel.timeZones[$0].timeZone.identifier == NSTimeZone.default.identifier
|
|
}.first
|
|
|
|
scheduledDuration.value = ConferenceSchedulingViewModel.durationList.indices.filter {
|
|
ConferenceSchedulingViewModel.durationList[$0].value == 60
|
|
}.first
|
|
continueEnabled.value = false
|
|
selectedAddresses.value = []
|
|
existingConfInfo.value = nil
|
|
description.value = ""
|
|
|
|
}
|
|
|
|
|
|
|
|
func destroy() {
|
|
conferenceScheduler?.removeDelegate(delegate: conferenceSchedulerDelegate!)
|
|
}
|
|
|
|
|
|
func gotoChatRoom() {
|
|
|
|
}
|
|
|
|
func createConference() {
|
|
|
|
if (selectedAddresses.value?.count == 0) {
|
|
Log.e("[Conference Creation] Couldn't create conference without any participant!")
|
|
return
|
|
}
|
|
|
|
do {
|
|
conferenceCreationInProgress.value = true
|
|
guard let localAccount = core.defaultAccount, let localAddress = localAccount.params?.identityAddress else {
|
|
Log.e("[Conference Creation] Couldn't get local address from default account!")
|
|
return
|
|
}
|
|
|
|
conferenceScheduler = try? Core.get().createConferenceScheduler()
|
|
conferenceScheduler?.addDelegate(delegate: conferenceSchedulerDelegate!)
|
|
|
|
guard let conferenceInfo = existingConfInfo.value != nil ? existingConfInfo.value??.clone() : try Factory.Instance.createConferenceInfo() else {
|
|
Log.e("[Conference Creation/Update] Failed, unable to get conf info.")
|
|
return
|
|
}
|
|
conferenceInfo.organizer = localAddress
|
|
subject.value.map { conferenceInfo.subject = $0}
|
|
description.value.map { conferenceInfo.description = $0}
|
|
conferenceInfo.participants = selectedAddresses.value!
|
|
if (scheduleForLater.value == true) {
|
|
let timestamp = getConferenceStartTimestamp()
|
|
conferenceInfo.dateTime = time_t(timestamp)
|
|
scheduledDuration.value.map { conferenceInfo.duration = UInt(ConferenceSchedulingViewModel.durationList[$0].value) }
|
|
}
|
|
conferenceScheduler?.account = localAccount
|
|
conferenceScheduler?.info = conferenceInfo // Will trigger the conference creation automatically
|
|
existingConfInfo.value = conferenceInfo
|
|
|
|
} catch {
|
|
Log.e("[Conference Creation] Failed \(error)")
|
|
}
|
|
}
|
|
|
|
|
|
|
|
private func allMandatoryFieldsFilled() -> Bool {
|
|
return subject.value != nil && subject.value!.count > 0 && (scheduleForLater.value != true || (scheduledDate.value != nil && scheduledTime.value != nil) );
|
|
}
|
|
|
|
|
|
private func getConferenceStartTimestamp() -> Double {
|
|
let days = Int32(scheduledDate.value!.timeIntervalSince1970)/86400
|
|
let time = Int32(scheduledTime.value!.timeIntervalSince1970)%86400
|
|
|
|
return scheduleForLater.value == true ? TimeInterval(days * 86400 + time) + Double(ConferenceSchedulingViewModel.timeZones[scheduledTimeZone.value!].timeZone.secondsFromGMT()-TimeZone.current.secondsFromGMT())
|
|
: Date().timeIntervalSince1970
|
|
}
|
|
|
|
|
|
private static func computeTimeZonesList() -> [TimeZoneData] {
|
|
return TimeZone.knownTimeZoneIdentifiers.map {
|
|
(ident) in TimeZoneData(timeZone:TimeZone(identifier:ident)!)
|
|
}.sorted()
|
|
}
|
|
|
|
private static func computeModeList() -> [Mode] {
|
|
return [Mode(value: 0, display: "Meeting"), Mode(value: 1, display: "Broadcast")]
|
|
}
|
|
|
|
private static func computeDurationList() -> [Duration] {
|
|
return [Duration(value: 30, display: "30min"), Duration(value: 60, display: "1h"), Duration(value: 120, display: "2h")]
|
|
}
|
|
|
|
func getConferenceInvitationsChatRoomParams() -> ChatRoomParams? {
|
|
if let chatRoomParams = try?self.core.createDefaultChatRoomParams() {
|
|
chatRoomParams.encryptionEnabled = self.isEndToEndEncryptedChatAvailable()
|
|
chatRoomParams.groupEnabled = false
|
|
chatRoomParams.backend = chatRoomParams.encryptionEnabled ? .FlexisipChat : .Basic
|
|
chatRoomParams.subject = self.subject.value!
|
|
return chatRoomParams
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func getMode() -> Int {
|
|
if mode.value != nil {
|
|
return mode.value!
|
|
} else {
|
|
return 0
|
|
}
|
|
}
|
|
|
|
}
|