144 lines
4.4 KiB
Swift
144 lines
4.4 KiB
Swift
import AVFoundation
|
|
import Combine
|
|
import Foundation
|
|
import GRDB
|
|
import Photos
|
|
|
|
@MainActor
|
|
final class ConversationStore: ObservableObject {
|
|
@Published private(set) var messages: [Message] = []
|
|
@Published var replyText = ""
|
|
|
|
private(set) var roster: Roster
|
|
private let client: Client
|
|
|
|
private var messagesCancellable: AnyCancellable?
|
|
|
|
init(roster: Roster, client: Client) {
|
|
self.client = client
|
|
self.roster = roster
|
|
subscribe()
|
|
}
|
|
}
|
|
|
|
extension ConversationStore {
|
|
func sendMessage(_ message: String) async {
|
|
var msg = Message.blank
|
|
msg.from = roster.bareJid
|
|
msg.to = roster.contactBareJid
|
|
msg.body = message
|
|
|
|
// store as pending on db, and send
|
|
do {
|
|
try await msg.save()
|
|
try await client.sendMessage(msg)
|
|
try await msg.setStatus(.sent)
|
|
} catch {
|
|
try? await msg.setStatus(.error)
|
|
}
|
|
}
|
|
|
|
func sendContact(_ jidStr: String) async {
|
|
await sendMessage("contact:\(jidStr)")
|
|
}
|
|
|
|
func sendLocation(_ lat: Double, _ lon: Double) async {
|
|
await sendMessage("geo:\(lat),\(lon)")
|
|
}
|
|
|
|
private func upload(_ message: Message) async {
|
|
do {
|
|
try await message.setStatus(.pending)
|
|
var message = message
|
|
guard case .attachment(let attachment) = message.contentType else {
|
|
throw ClientStoreError.invalidContentType
|
|
}
|
|
guard let localName = attachment.localPath else {
|
|
throw ClientStoreError.invalidLocalName
|
|
}
|
|
let remotePath = try await client.uploadFile(localName)
|
|
message.contentType = .attachment(
|
|
Attachment(
|
|
type: attachment.type,
|
|
localName: attachment.localName,
|
|
thumbnailName: nil,
|
|
remotePath: remotePath
|
|
)
|
|
)
|
|
message.body = remotePath
|
|
message.oobUrl = remotePath
|
|
try await message.save()
|
|
try await client.sendMessage(message)
|
|
try await message.setStatus(.sent)
|
|
} catch {
|
|
try? await message.setStatus(.error)
|
|
}
|
|
}
|
|
|
|
func downloadAttachment(_ message: Message) async {
|
|
guard case .attachment(let attachment) = message.contentType else {
|
|
return
|
|
}
|
|
guard let remotePath = attachment.remotePath, let remoteUrl = URL(string: remotePath) else {
|
|
return
|
|
}
|
|
do {
|
|
let localName = "\(message.id)_\(UUID().uuidString).\(remoteUrl.lastPathComponent)"
|
|
let localUrl = Const.fileFolder.appendingPathComponent(localName)
|
|
|
|
// Download the file
|
|
let (tempUrl, _) = try await URLSession.shared.download(from: remoteUrl)
|
|
try FileManager.default.moveItem(at: tempUrl, to: localUrl)
|
|
|
|
var message = message
|
|
message.contentType = .attachment(
|
|
Attachment(
|
|
type: attachment.type,
|
|
localName: localName,
|
|
thumbnailName: attachment.thumbnailName,
|
|
remotePath: remotePath
|
|
)
|
|
)
|
|
try await message.save()
|
|
} catch {
|
|
logIt(.error, "Can't download attachment: \(error)")
|
|
}
|
|
}
|
|
}
|
|
|
|
extension ConversationStore {
|
|
var contacts: [Roster] {
|
|
get async {
|
|
do {
|
|
let rosters = try await Database.shared.dbQueue.read { db in
|
|
try Roster
|
|
.filter(Column("locallyDeleted") == false)
|
|
.fetchAll(db)
|
|
}
|
|
return rosters
|
|
} catch {
|
|
return []
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private extension ConversationStore {
|
|
func subscribe() {
|
|
messagesCancellable = ValueObservation.tracking(Message
|
|
.filter(
|
|
(Column("to") == roster.bareJid && Column("from") == roster.contactBareJid) ||
|
|
(Column("from") == roster.bareJid && Column("to") == roster.contactBareJid)
|
|
)
|
|
.order(Column("date").desc)
|
|
.fetchAll
|
|
)
|
|
.publisher(in: Database.shared.dbQueue, scheduling: .immediate)
|
|
.receive(on: DispatchQueue.main)
|
|
.sink { _ in
|
|
} receiveValue: { [weak self] messages in
|
|
self?.messages = messages
|
|
}
|
|
}
|
|
}
|