♻️ Use fully native implmentation of app intents on iOS

ios/Runner/Services/NetworkService.swift

@@ -0,0 +1,164 @@
+//
+//  NetworkService.swift
+//  Runner
+//
+//  Created by LittleSheep on 2026/1/16.
+//
+
+import Foundation
+
+final class NetworkService {
+    static let shared = NetworkService()
+
+    private let session: URLSession
+    private let decoder: JSONDecoder
+
+    private init() {
+        let config = URLSessionConfiguration.default
+        config.timeoutIntervalForRequest = 10
+        config.timeoutIntervalForResource = 30
+        self.session = URLSession(configuration: config)
+
+        self.decoder = JSONDecoder()
+        self.decoder.keyDecodingStrategy = .convertFromSnakeCase
+    }
+
+    private var baseUrl: String {
+        UserDefaults.shared.getServerUrl()
+    }
+
+    private var authHeaders: [String: String] {
+        var headers = [
+            "Accept": "application/json",
+            "Content-Type": "application/json"
+        ]
+        if let token = UserDefaults.shared.getAuthToken() {
+            headers["Authorization"] = "AtField \(token)"
+        }
+        return headers
+    }
+
+    func getNotificationCount() async throws -> Int {
+        let url = try buildUrl(path: SharedConstants.API.notificationsCount)
+        let response: NotificationCountResponse = try await get(url: url)
+        return response.count
+    }
+
+    func markNotificationsRead() async throws {
+        let url = try buildUrl(path: SharedConstants.API.notificationsMarkRead)
+        let _: EmptyResponse = try await post(url: url, body: nil)
+    }
+
+    func getUnreadChatsCount() async throws -> Int {
+        let url = try buildUrl(path: SharedConstants.API.unreadChats)
+        let response: UnreadChatsResponse = try await get(url: url)
+        return response.unreadCount
+    }
+
+    func getMessages(channelId: String, offset: Int = 0, take: Int = 5) async throws -> [MessageResponse] {
+        let path = String(format: SharedConstants.API.messages, channelId)
+        let url = try buildUrl(path: path, queryItems: [
+            URLQueryItem(name: "offset", value: String(offset)),
+            URLQueryItem(name: "take", value: String(take))
+        ])
+        let response: MessagesResponse = try await get(url: url)
+        return response.messages
+    }
+
+    func sendMessage(channelId: String, content: String) async throws {
+        let path = String(format: SharedConstants.API.sendMessage, channelId)
+        let url = try buildUrl(path: path)
+        let body = SendMessageBody(content: content, nonce: generateNonce())
+        let _: EmptyResponse = try await post(url: url, body: body)
+    }
+
+    private func buildUrl(path: String, queryItems: [URLQueryItem]? = nil) throws -> URL {
+        var components = URLComponents(string: baseUrl + path)
+        if let queryItems = queryItems, !queryItems.isEmpty {
+            components?.queryItems = queryItems
+        }
+        guard let url = components?.url else {
+            throw NetworkError.invalidUrl
+        }
+        return url
+    }
+
+    private func get<T: Decodable>(url: URL) async throws -> T {
+        var request = URLRequest(url: url)
+        authHeaders.forEach { request.setValue($1, forHTTPHeaderField: $0) }
+
+        let (data, response) = try await session.data(for: request)
+        try validateResponse(response)
+        return try decoder.decode(T.self, from: data)
+    }
+
+    private func post<T: Decodable, B: Encodable>(url: URL, body: B?) async throws -> T {
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        authHeaders.forEach { request.setValue($1, forHTTPHeaderField: $0) }
+
+        if let body = body {
+            request.httpBody = try JSONEncoder().encode(body)
+        }
+
+        let (data, response) = try await session.data(for: request)
+        try validateResponse(response)
+
+        if T.self == EmptyResponse.self {
+            return EmptyResponse() as! T
+        }
+
+        return try decoder.decode(T.self, from: data)
+    }
+
+    private func validateResponse(_ response: URLResponse) throws {
+        guard let httpResponse = response as? HTTPURLResponse else {
+            throw NetworkError.invalidResponse
+        }
+        guard (200...299).contains(httpResponse.statusCode) else {
+            throw NetworkError.httpError(statusCode: httpResponse.statusCode)
+        }
+    }
+
+    private func generateNonce() -> String {
+        "\(Date().timeIntervalSince1970)"
+    }
+}
+
+enum NetworkError: Error {
+    case invalidUrl
+    case invalidResponse
+    case httpError(statusCode: Int)
+}
+
+private struct NotificationCountResponse: Decodable {
+    let count: Int
+}
+
+private struct UnreadChatsResponse: Decodable {
+    let unreadCount: Int
+}
+
+private struct MessagesResponse: Decodable {
+    let messages: [MessageResponse]
+}
+
+private struct MessageResponse: Decodable {
+    let content: String?
+    let sender: SenderResponse?
+
+    struct SenderResponse: Decodable {
+        let account: AccountResponse?
+
+        struct AccountResponse: Decodable {
+            let name: String?
+        }
+    }
+}
+
+private struct SendMessageBody: Encodable {
+    let content: String
+    let nonce: String
+}
+
+private struct EmptyResponse: Decodable {}