forked from mirrors/linphone-iphone
320 lines
10 KiB
Swift
320 lines
10 KiB
Swift
/*
|
|
* Copyright (c) 2010-2023 Belledonne Communications SARL.
|
|
*
|
|
* This file is part of linphone-iphone
|
|
*
|
|
* 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 linphonesw
|
|
import Combine
|
|
|
|
class StartConversationViewModel: ObservableObject {
|
|
|
|
static let TAG = "[StartConversationViewModel]"
|
|
|
|
private var coreContext = CoreContext.shared
|
|
|
|
@Published var searchField: String = ""
|
|
|
|
var domain: String = ""
|
|
|
|
@Published var messageText: String = ""
|
|
|
|
@Published var participants: [SelectedAddressModel] = []
|
|
|
|
@Published var operationInProgress: Bool = false
|
|
@Published var displayedConversation: ConversationModel?
|
|
|
|
private var chatRoomSuscriptions = Set<AnyCancellable?>()
|
|
|
|
init() {
|
|
coreContext.doOnCoreQueue { core in
|
|
self.domain = core.defaultAccount?.params?.domain ?? ""
|
|
}
|
|
}
|
|
|
|
func addParticipants(participantsToAdd: [SelectedAddressModel]) {
|
|
var list = participants
|
|
for selectedAddr in participantsToAdd {
|
|
if let found = list.first(where: { $0.address.weakEqual(address2: selectedAddr.address) }) {
|
|
Log.info("\(StartConversationViewModel.TAG) Participant \(found.address.asStringUriOnly()) already in list, skipping")
|
|
continue
|
|
}
|
|
|
|
list.append(selectedAddr)
|
|
Log.info("\(StartConversationViewModel.TAG) Added participant \(selectedAddr.address.asStringUriOnly())")
|
|
}
|
|
Log.info("\(StartConversationViewModel.TAG) [\(list.count - participants.count) participants added, now there are \(list.count) participants in list")
|
|
|
|
participants = list
|
|
}
|
|
|
|
/*
|
|
func createGroupChatRoom() {
|
|
coreContext.doOnCoreQueue { core in
|
|
let account = core.defaultAccount
|
|
if (account == nil) {
|
|
Log.error(
|
|
"\(StartConversationViewModel.TAG) No default account found, can't create group conversation!"
|
|
)
|
|
return
|
|
}
|
|
|
|
operationInProgress = true
|
|
|
|
let groupChatRoomSubject = subject
|
|
val params: ChatRoomParams = coreContext.core.createDefaultChatRoomParams()
|
|
params.isGroupEnabled = true
|
|
params.subject = groupChatRoomSubject
|
|
params.backend = ChatRoom.Backend.FlexisipChat
|
|
params.isEncryptionEnabled = true
|
|
|
|
val participants = arrayListOf<Address>()
|
|
for (participant in selection.value.orEmpty()) {
|
|
participants.add(participant.address)
|
|
}
|
|
val localAddress = account.params.identityAddress
|
|
|
|
val participantsArray = arrayOf<Address>()
|
|
val chatRoom = core.createChatRoom(
|
|
params,
|
|
localAddress,
|
|
participants.toArray(participantsArray)
|
|
)
|
|
if (chatRoom != null) {
|
|
if (params.backend == ChatRoom.Backend.FlexisipChat) {
|
|
if (chatRoom.state == ChatRoom.State.Created) {
|
|
val id = LinphoneUtils.getChatRoomId(chatRoom)
|
|
Log.i(
|
|
"$TAG Group conversation [$id] ($groupChatRoomSubject) has been created"
|
|
)
|
|
operationInProgress.postValue(false)
|
|
chatRoomCreatedEvent.postValue(
|
|
Event(
|
|
Pair(
|
|
chatRoom.localAddress.asStringUriOnly(),
|
|
chatRoom.peerAddress.asStringUriOnly()
|
|
)
|
|
)
|
|
)
|
|
} else {
|
|
Log.i(
|
|
"$TAG Conversation [$groupChatRoomSubject] isn't in Created state yet, wait for it"
|
|
)
|
|
chatRoom.addListener(chatRoomListener)
|
|
}
|
|
} else {
|
|
val id = LinphoneUtils.getChatRoomId(chatRoom)
|
|
Log.i("$TAG Conversation successfully created [$id] ($groupChatRoomSubject)")
|
|
operationInProgress.postValue(false)
|
|
chatRoomCreatedEvent.postValue(
|
|
Event(
|
|
Pair(
|
|
chatRoom.localAddress.asStringUriOnly(),
|
|
chatRoom.peerAddress.asStringUriOnly()
|
|
)
|
|
)
|
|
)
|
|
}
|
|
} else {
|
|
Log.e("$TAG Failed to create group conversation [$groupChatRoomSubject]!")
|
|
operationInProgress.postValue(false)
|
|
chatRoomCreationErrorEvent.postValue(
|
|
Event(R.string.conversation_failed_to_create_toast)
|
|
)
|
|
}
|
|
}
|
|
}
|
|
*/
|
|
|
|
func createOneToOneChatRoomWith(remote: Address) {
|
|
coreContext.doOnCoreQueue { core in
|
|
let account = core.defaultAccount
|
|
if account == nil {
|
|
Log.error(
|
|
"\(StartConversationViewModel.TAG) No default account found, can't create conversation with \(remote.asStringUriOnly())!"
|
|
)
|
|
return
|
|
}
|
|
|
|
DispatchQueue.main.async {
|
|
self.operationInProgress = true
|
|
}
|
|
|
|
do {
|
|
let params: ChatRoomParams = try core.createDefaultChatRoomParams()
|
|
params.groupEnabled = false
|
|
params.subject = "Dummy subject"
|
|
params.ephemeralLifetime = 0 // Make sure ephemeral is disabled by default
|
|
|
|
let sameDomain = remote.domain == account?.params?.domain ?? ""
|
|
if self.isEndToEndEncryptionMandatory() && sameDomain {
|
|
Log.info("\(StartConversationViewModel.TAG) Account is in secure mode & domain matches, creating a E2E conversation")
|
|
params.backend = ChatRoom.Backend.FlexisipChat
|
|
params.encryptionEnabled = true
|
|
} else if !self.isEndToEndEncryptionMandatory() {
|
|
if LinphoneUtils.isEndToEndEncryptedChatAvailable(core: core) {
|
|
Log.info(
|
|
"\(StartConversationViewModel.TAG) Account is in interop mode but LIME is available, creating a E2E conversation"
|
|
)
|
|
params.backend = ChatRoom.Backend.FlexisipChat
|
|
params.encryptionEnabled = true
|
|
} else {
|
|
Log.info(
|
|
"\(StartConversationViewModel.TAG) Account is in interop mode but LIME isn't available, creating a SIP simple conversation"
|
|
)
|
|
params.backend = ChatRoom.Backend.Basic
|
|
params.encryptionEnabled = false
|
|
}
|
|
} else {
|
|
Log.error(
|
|
"\(StartConversationViewModel.TAG) Account is in secure mode, can't chat with SIP address of different domain \(remote.asStringUriOnly())"
|
|
)
|
|
DispatchQueue.main.async {
|
|
self.operationInProgress = false
|
|
}
|
|
/*
|
|
chatRoomCreationErrorEvent.postValue(
|
|
Event(R.string.conversation_invalid_participant_due_to_security_mode_toast)
|
|
)
|
|
*/
|
|
return
|
|
}
|
|
|
|
let participants = [remote]
|
|
let localAddress = account?.params?.identityAddress
|
|
let existingChatRoom = core.searchChatRoom(params: params, localAddr: localAddress, remoteAddr: nil, participants: participants)
|
|
if existingChatRoom == nil {
|
|
Log.info(
|
|
"\(StartConversationViewModel.TAG) No existing 1-1 conversation between local account "
|
|
+ "\(localAddress?.asStringUriOnly() ?? "") and remote \(remote.asStringUriOnly()) was found for given parameters, let's create it"
|
|
)
|
|
let chatRoom = try core.createChatRoom(params: params, localAddr: localAddress, participants: participants)
|
|
if params.backend == ChatRoom.Backend.FlexisipChat {
|
|
if chatRoom.state == ChatRoom.State.Created {
|
|
let id = LinphoneUtils.getChatRoomId(room: chatRoom)
|
|
Log.info("\(StartConversationViewModel.TAG) 1-1 conversation \(id) has been created")
|
|
|
|
/*
|
|
chatRoomCreatedEvent.postValue(
|
|
Event(
|
|
Pair(
|
|
chatRoom.localAddress.asStringUriOnly(),
|
|
chatRoom.peerAddress.asStringUriOnly()
|
|
)
|
|
)
|
|
)
|
|
*/
|
|
} else {
|
|
Log.info("\(StartConversationViewModel.TAG) Conversation isn't in Created state yet, wait for it")
|
|
self.chatRoomAddDelegate(core: core, chatRoom: chatRoom)
|
|
}
|
|
} else {
|
|
let id = LinphoneUtils.getChatRoomId(room: chatRoom)
|
|
Log.info("\(StartConversationViewModel.TAG) Conversation successfully created \(id)")
|
|
|
|
let model = ConversationModel(chatRoom: chatRoom)
|
|
DispatchQueue.main.async {
|
|
self.operationInProgress = false
|
|
self.displayedConversation = model
|
|
}
|
|
/*
|
|
chatRoomCreatedEvent.postValue(
|
|
Event(
|
|
Pair(
|
|
chatRoom.localAddress.asStringUriOnly(),
|
|
chatRoom.peerAddress.asStringUriOnly()
|
|
)
|
|
)
|
|
)
|
|
*/
|
|
}
|
|
} else {
|
|
Log.warn(
|
|
"\(StartConversationViewModel.TAG) A 1-1 conversation between local account \(localAddress?.asStringUriOnly() ?? "") and remote \(remote.asStringUriOnly()) for given parameters already exists!"
|
|
)
|
|
|
|
let model = ConversationModel(chatRoom: existingChatRoom!)
|
|
DispatchQueue.main.async {
|
|
self.operationInProgress = false
|
|
self.displayedConversation = model
|
|
}
|
|
|
|
|
|
/*
|
|
chatRoomCreatedEvent.postValue(
|
|
Event(
|
|
Pair(
|
|
existingChatRoom.localAddress.asStringUriOnly(),
|
|
existingChatRoom.peerAddress.asStringUriOnly()
|
|
)
|
|
)
|
|
)
|
|
*/
|
|
}
|
|
} catch {
|
|
DispatchQueue.main.async {
|
|
self.operationInProgress = false
|
|
}
|
|
Log.error("\(StartConversationViewModel.TAG) Failed to create 1-1 conversation with \(remote.asStringUriOnly())!")
|
|
}
|
|
}
|
|
}
|
|
|
|
func chatRoomAddDelegate(core: Core, chatRoom: ChatRoom) {
|
|
self.chatRoomSuscriptions.insert(chatRoom.publisher?.onConferenceJoined?.postOnCoreQueue {
|
|
(chatRoom: ChatRoom, eventLog: EventLog) in
|
|
let state = chatRoom.state
|
|
let id = LinphoneUtils.getChatRoomId(room: chatRoom)
|
|
Log.info("\(StartConversationViewModel.TAG) Conversation \(id) \(chatRoom.subject) state changed: \(state)")
|
|
if state == ChatRoom.State.Created {
|
|
Log.info("\(StartConversationViewModel.TAG) Conversation \(id) successfully created")
|
|
self.chatRoomSuscriptions.removeAll()
|
|
|
|
DispatchQueue.main.async {
|
|
let model = ConversationModel(chatRoom: chatRoom)
|
|
self.operationInProgress = false
|
|
self.displayedConversation = model
|
|
}
|
|
|
|
/*
|
|
chatRoomCreatedEvent.postValue(
|
|
Event(
|
|
Pair(
|
|
chatRoom.localAddress.asStringUriOnly(),
|
|
chatRoom.peerAddress.asStringUriOnly()
|
|
)
|
|
)
|
|
)
|
|
*/
|
|
} else if state == ChatRoom.State.CreationFailed {
|
|
Log.error("\(StartConversationViewModel.TAG) Conversation \(id) creation has failed!")
|
|
self.chatRoomSuscriptions.removeAll()
|
|
DispatchQueue.main.async {
|
|
self.operationInProgress = false
|
|
}
|
|
/*
|
|
chatRoomCreationErrorEvent.postValue(
|
|
Event(R.string.conversation_failed_to_create_toast)
|
|
)
|
|
*/
|
|
}
|
|
})
|
|
}
|
|
|
|
func isEndToEndEncryptionMandatory() -> Bool {
|
|
return false // TODO: Will be done later in SDK
|
|
}
|
|
}
|