94 lines
3.4 KiB
Swift
94 lines
3.4 KiB
Swift
import Foundation
|
|
import CryptoKit
|
|
|
|
final class Client {
|
|
|
|
// TODO: Use or delete
|
|
private let delegate = NeverCacheDelegate()
|
|
|
|
init() {}
|
|
|
|
func deviceStatus(authToken: Data, server: String) async -> ClientState {
|
|
await send(path: .getDeviceStatus, server: server, data: authToken).state
|
|
}
|
|
|
|
func sendMessageOverLocalNetwork(_ message: Message, server: String) async -> (state: ClientState, response: Message?) {
|
|
let data = message.encoded.hexEncoded
|
|
guard let url = URL(string: server + "message?m=\(data)") else {
|
|
return (.internalError("Invalid server url"), nil)
|
|
}
|
|
|
|
var request = URLRequest(url: url)
|
|
request.httpMethod = "POST"
|
|
return await requestAndDecode(request)
|
|
}
|
|
|
|
func send(_ message: Message, server: String, authToken: Data) async -> (state: ClientState, response: Message?) {
|
|
let serverMessage = ServerMessage(authToken: authToken, message: message)
|
|
return await send(path: .postMessage, server: server, data: serverMessage.encoded)
|
|
}
|
|
|
|
private func send(path: RouteAPI, server: String, data: Data) async -> (state: ClientState, response: Message?) {
|
|
guard let url = URL(string: server) else {
|
|
return (.internalError("Invalid server url"), nil)
|
|
}
|
|
let fullUrl = url.appendingPathComponent(path.rawValue)
|
|
return await send(to: fullUrl, data: data)
|
|
}
|
|
|
|
private func send(to url: URL, data: Data) async -> (state: ClientState, response: Message?) {
|
|
var request = URLRequest(url: url)
|
|
request.httpBody = data
|
|
request.httpMethod = "POST"
|
|
request.timeoutInterval = 10
|
|
return await requestAndDecode(request)
|
|
}
|
|
|
|
private func requestAndDecode(_ request: URLRequest) async -> (state: ClientState, response: Message?) {
|
|
guard let data = await fulfill(request) else {
|
|
return (.deviceNotAvailable(.serverNotReached), nil)
|
|
}
|
|
guard let byte = data.first else {
|
|
return (.internalError("Empty response"), nil)
|
|
}
|
|
guard let status = MessageResult(rawValue: byte) else {
|
|
return (.internalError("Invalid message response: \(byte)"), nil)
|
|
}
|
|
let result = ClientState(keyResult: status)
|
|
guard data.count == Message.length + 1 else {
|
|
if data.count != 1 {
|
|
print("Device response with only \(data.count) bytes")
|
|
}
|
|
return (result, nil)
|
|
}
|
|
let messageData = Array(data.advanced(by: 1))
|
|
let message = Message(decodeFrom: messageData)
|
|
return (result, message)
|
|
}
|
|
|
|
private func fulfill(_ request: URLRequest) async -> Data? {
|
|
do {
|
|
let (data, response) = try await URLSession.shared.data(for: request)
|
|
guard let code = (response as? HTTPURLResponse)?.statusCode else {
|
|
print("No response from server")
|
|
return nil
|
|
}
|
|
guard code == 200 else {
|
|
print("Invalid server response \(code)")
|
|
return nil
|
|
}
|
|
return data
|
|
} catch {
|
|
print("Request failed: \(error)")
|
|
return nil
|
|
}
|
|
}
|
|
}
|
|
|
|
class NeverCacheDelegate: NSObject, NSURLConnectionDataDelegate {
|
|
|
|
func connection(_ connection: NSURLConnection, willCacheResponse cachedResponse: CachedURLResponse) -> CachedURLResponse? {
|
|
return nil
|
|
}
|
|
}
|