import Combine import Foundation import GRDB import Martin enum ClientState: Equatable { enum ClientConnectionState { case connected case disconnected } case disabled case enabled(ClientConnectionState) } final class Client: ObservableObject { @Published private(set) var state: ClientState = .enabled(.disconnected) @Published private(set) var credentials: Credentials @Published private(set) var rosters: [Roster] = [] private var connection: XMPPClient private var connectionCancellable: AnyCancellable? private var rostersCancellable: AnyCancellable? private var rosterManager = ClientMartinRosterManager() private var chatsManager = ClientMartinChatsManager() private var messageManager: ClientMartinMessagesManager init(credentials: Credentials) { self.credentials = credentials state = credentials.isActive ? .enabled(.disconnected) : .disabled connection = Self.prepareConnection(credentials, rosterManager, chatsManager) messageManager = ClientMartinMessagesManager(connection) connectionCancellable = connection.$state .sink { [weak self] state in guard let self = self else { return } guard self.credentials.isActive else { self.state = .disabled return } rostersCancellable = ValueObservation .tracking { db in try Roster .filter(Column("bareJid") == self.credentials.bareJid) .filter(Column("locallyDeleted") == false) .fetchAll(db) } .publisher(in: Database.shared.dbQueue) .catch { _ in Just([]) } .sink { rosters in self.rosters = rosters } switch state { case .connected: self.state = .enabled(.connected) default: self.state = .enabled(.disconnected) } } } } extension Client { func addRoster(_ jid: String, name: String?, groups: [String]) async throws { _ = try await connection.module(.roster).addItem( jid: JID(jid), name: name, groups: groups ) } func deleteRoster(_ roster: Roster) async throws { _ = try await connection.module(.roster).removeItem(jid: JID(roster.contactBareJid)) } func connect() async { guard credentials.isActive, state == .enabled(.disconnected) else { return } try? await connection.loginAndWait() } func disconnect() { _ = connection.disconnect() } } extension Client { func sendMessage(_ message: Message) async throws { guard let to = message.to else { return } guard let chat = connection.module(MessageModule.self).chatManager.chat(for: connection.context, with: BareJID(to)) else { return } let msg = chat.createMessage(text: message.body ?? "??", id: message.id) try await chat.send(message: msg) } func uploadFile(_ localPath: String) async throws -> String { guard let localPath = URL(string: localPath) else { throw ClientStoreError.invalidPath } guard let data = try? Data(contentsOf: localPath) else { throw ClientStoreError.noData } let httpModule = connection.module(HttpFileUploadModule.self) let components = try await httpModule.findHttpUploadComponents() guard let component = components.first(where: { $0.maxSize > data.count }) else { throw ClientStoreError.fileTooBig } let slot = try await httpModule.requestUploadSlot( componentJid: component.jid, filename: localPath.lastPathComponent, size: data.count, contentType: localPath.mimeType ) var request = URLRequest(url: slot.putUri) for (key, value) in slot.putHeaders { request.addValue(value, forHTTPHeaderField: key) } request.httpMethod = "PUT" request.httpBody = data request.addValue(String(data.count), forHTTPHeaderField: "Content-Length") request.addValue(localPath.mimeType, forHTTPHeaderField: "Content-Type") let (_, response) = try await URLSession.shared.data(for: request) switch response { case let httpResponse as HTTPURLResponse where httpResponse.statusCode == 200: return slot.getUri.absoluteString default: throw URLError(.badServerResponse) } } } extension Client { static func tryLogin(with credentials: Credentials) async throws -> Client { let client = Client(credentials: credentials) try await client.connection.loginAndWait() return client } } private extension Client { static func prepareConnection(_ credentials: Credentials, _ roster: RosterManager, _ chat: ChatManager) -> XMPPClient { let client = XMPPClient() // register modules // core modules RFC 6120 client.modulesManager.register(StreamFeaturesModule()) client.modulesManager.register(SaslModule()) client.modulesManager.register(AuthModule()) client.modulesManager.register(SessionEstablishmentModule()) client.modulesManager.register(ResourceBinderModule()) client.modulesManager.register(DiscoveryModule(identity: .init(category: "client", type: "iOS", name: Const.appName))) // messaging modules RFC 6121 client.modulesManager.register(RosterModule(rosterManager: roster)) client.modulesManager.register(PresenceModule()) client.modulesManager.register(PubSubModule()) client.modulesManager.register(MessageModule(chatManager: chat)) // client.modulesManager.register(MessageArchiveManagementModule()) // client.modulesManager.register(MessageCarbonsModule()) // file transfer modules client.modulesManager.register(HttpFileUploadModule()) // extensions client.modulesManager.register(SoftwareVersionModule()) client.modulesManager.register(PingModule()) client.connectionConfiguration.userJid = .init(credentials.bareJid) client.connectionConfiguration.credentials = .password(password: credentials.pass) // group chats // client.modulesManager.register(MucModule(roomManager: manager)) // channels // client.modulesManager.register(MixModule(channelManager: manager)) // add client to clients return client } }