another.im-ios/ConversationsClassic/AppData/Client/Client+MartinOMEMO.swift

import Foundation
import GRDB
import Martin
import MartinOMEMO

final class ClientMartinOMEMO {
    let credentials: Credentials

    init(_ credentials: Credentials) {
        self.credentials = credentials
    }

    var signal: (SignalStorage, SignalContext) {
        let signalStorage = SignalStorage(sessionStore: self, preKeyStore: self, signedPreKeyStore: self, identityKeyStore: self, senderKeyStore: self)
        // swiftlint:disable:next force_unwrapping
        let signalContext = SignalContext(withStorage: signalStorage)!
        signalStorage.setup(withContext: signalContext)
        return (signalStorage, signalContext)
    }
}

extension ClientMartinOMEMO: SignalSessionStoreProtocol, SignalPreKeyStoreProtocol, SignalSignedPreKeyStoreProtocol, SignalIdentityKeyStoreProtocol, SignalSenderKeyStoreProtocol {
    func sessionRecord(forAddress address: MartinOMEMO.SignalAddress) -> Data? {
        // static let omemoSessionRecordLoad = Query("SELECT key FROM omemo_sessions WHERE account = :account AND name = :name AND device_id = :deviceId")

        // do {
        //     let data = try Database.shared.dbQueue.read { db in
        //
        //         try Row.fetchOne(db, sql: "SELECT key FROM omemo_sessions WHERE account = :account AND name = :name AND device_id = :deviceId", arguments: ["account": address.account, "name": address.name, "deviceId": address.deviceId])
        //     }
        //     return data?["key"]
        // } catch {
        //     logIt(.error, "Error fetching chats: \(error.localizedDescription)")
        //     return nil
        // }
        print(address)
        return nil
    }

    func allDevices(for _: String, activeAndTrusted: Bool) -> [Int32] {
        print(activeAndTrusted, "allDevices")
        return []
    }

    func storeSessionRecord(_ data: Data, forAddress: MartinOMEMO.SignalAddress) -> Bool {
        print(data, forAddress)
        return false
    }

    func containsSessionRecord(forAddress: MartinOMEMO.SignalAddress) -> Bool {
        print(forAddress)
        return false
    }

    func deleteSessionRecord(forAddress: MartinOMEMO.SignalAddress) -> Bool {
        print(forAddress)
        return false
    }

    func deleteAllSessions(for _: String) -> Bool {
        print("deleteAllSessions")
        return false
    }

    func currentPreKeyId() -> UInt32 {
        0
    }

    func loadPreKey(withId: UInt32) -> Data? {
        print(withId)
        return nil
    }

    func storePreKey(_ data: Data, withId: UInt32) -> Bool {
        print(data, withId)
        return false
    }

    func containsPreKey(withId: UInt32) -> Bool {
        print(withId)
        return false
    }

    func deletePreKey(withId: UInt32) -> Bool {
        print(withId)
        return false
    }

    func flushDeletedPreKeys() -> Bool {
        false
    }

    func countSignedPreKeys() -> Int {
        0
    }

    func loadSignedPreKey(withId: UInt32) -> Data? {
        print(withId)
        return nil
    }

    func storeSignedPreKey(_ data: Data, withId: UInt32) -> Bool {
        print(data, withId)
        return false
    }

    func containsSignedPreKey(withId: UInt32) -> Bool {
        print(withId)
        return false
    }

    func deleteSignedPreKey(withId: UInt32) -> Bool {
        print(withId)
        return false
    }

    func keyPair() -> (any MartinOMEMO.SignalIdentityKeyPairProtocol)? {
        nil
    }

    func localRegistrationId() -> UInt32 {
        0
    }

    func save(identity: MartinOMEMO.SignalAddress, key: (any MartinOMEMO.SignalIdentityKeyProtocol)?) -> Bool {
        print(identity, key)
        return false
    }

    func isTrusted(identity: MartinOMEMO.SignalAddress, key: (any MartinOMEMO.SignalIdentityKeyProtocol)?) -> Bool {
        print(identity, key)
        return false
    }

    func save(identity: MartinOMEMO.SignalAddress, publicKeyData: Data?) -> Bool {
        print(identity, publicKeyData)
        return false
    }

    func isTrusted(identity: MartinOMEMO.SignalAddress, publicKeyData: Data?) -> Bool {
        print(identity, publicKeyData)
        return false
    }

    func setStatus(_ status: MartinOMEMO.IdentityStatus, forIdentity: MartinOMEMO.SignalAddress) -> Bool {
        print(status, forIdentity)
        return false
    }

    func setStatus(active: Bool, forIdentity: MartinOMEMO.SignalAddress) -> Bool {
        print(active, forIdentity)
        return false
    }

    func identities(forName: String) -> [MartinOMEMO.Identity] {
        print(forName)
        return []
    }

    func identityFingerprint(forAddress address: MartinOMEMO.SignalAddress) -> String? {
        print(address)
        return nil
    }

    func storeSenderKey(_ key: Data, address: MartinOMEMO.SignalAddress?, groupId: String?) -> Bool {
        print(key, address, groupId)
        return false
    }

    func loadSenderKey(forAddress: MartinOMEMO.SignalAddress?, groupId: String?) -> Data? {
        print(forAddress, groupId)
        return nil
    }
}