@xmobitea/gn-typescript-client 2.6.12 → 2.6.13

package/srcSwift/Sources/GearN/runtime/networking/OperationPending.swift

@@ -0,0 +1,81 @@
+import Foundation
+
+public class OperationPending {
+    private var operationRequest: OperationRequest
+    private var requestType: RequestType
+    private var role: RequestRole
+    private var authToken: String
+    private var secretKey: String
+    private var gameId: String
+    private var customTags: GNHashtable?
+    private var onOperationResponse: Action1<OperationResponse>?
+    private var timeout: Double
+
+    private var firstSend: Double = 0
+    private var secondsSend: Double = 0
+
+    public init(requestType: RequestType, role: RequestRole, operationRequest: OperationRequest, onOperationResponse: Action1<OperationResponse>?, authToken: String, secretKey: String, customTags: GNHashtable?, gameId: String) {
+        self.operationRequest = operationRequest
+        self.onOperationResponse = onOperationResponse
+
+        self.timeout = Date().timeIntervalSince1970 + Double(OperationRequest.defaultTimeOut)
+        self.firstSend = 0
+        self.secondsSend = 0
+
+        self.requestType = requestType
+        self.role = role
+        self.authToken = authToken
+        self.secretKey = secretKey
+        self.gameId = gameId
+        self.customTags = customTags
+    }
+
+    public func getRequestType() -> RequestType {
+        return self.requestType
+    }
+
+    public func getRole() -> RequestRole {
+        return self.role
+    }
+
+    public func getAuthToken() -> String {
+        return self.authToken
+    }
+
+    public func getSecretKey() -> String {
+        return self.secretKey
+    }
+
+    public func getGameId() -> String {
+        return self.gameId
+    }
+
+    public func getCustomTags() -> GNHashtable? {
+        return self.customTags
+    }
+
+    public func onSend() {
+        self.firstSend = Date().timeIntervalSince1970
+        self.timeout = self.firstSend + Double(self.operationRequest.getTimeout())
+    }
+
+    public func onRecv() {
+        self.secondsSend = Date().timeIntervalSince1970
+    }
+
+    public func getExecuteTimerInMs() -> Double {
+        return (self.secondsSend - self.firstSend)
+    }
+
+    public func isTimeout() -> Bool {
+        return self.timeout < Date().timeIntervalSince1970
+    }
+
+    public func getOperationRequest() -> OperationRequest {
+        return self.operationRequest
+    }
+
+    public func getCallback() -> Action1<OperationResponse>? {
+        return self.onOperationResponse
+    }
+}

package/srcSwift/Sources/GearN/runtime/networking/PeerBase.swift

@@ -0,0 +1,228 @@
+import Foundation
+
+public class PeerBase: IPeer {
+    internal var operationPendingQueue: [OperationPending] = []
+    internal var operationWaitingResponseDict: [Int: OperationPending] = [:]
+
+    private static var requestId: Int = 0
+
+    private var perMsgTimer: Double = 0
+    private var nextSendMsgTimer: Double = 0
+    private var checkTimeoutOperationPending: Double = 0
+
+    public var ping: Double = -1
+    private var pingLst: [Double] = []
+
+    internal var isUse: Bool = false
+
+    protected func getSendRate() -> Double {
+        return (1000 / self.perMsgTimer)
+    }
+
+    protected func setSendRate(sendRate: Int) {
+        self.perMsgTimer = 1000 / Double(sendRate) / 1000
+    }
+
+    public init() {
+         // Swift classes need init
+    }
+
+    public func initPeer() {
+        self.operationWaitingResponseDict = [:]
+        self.operationPendingQueue = []
+        self.pingLst = []
+
+        self.initSendRate()
+        self.initGNSocketObject()
+    }
+
+    private func initSendRate() {
+        if let gnServerSettings = GNNetwork.getGNServerSettings() {
+             self.setSendRate(sendRate: gnServerSettings.getSendRate())
+        } else {
+            // Fatal error or log? TS throws error
+            fatalError("Null GN Server Settings, please find it now")
+        }
+    }
+
+    // Abstract method workarounds
+    open func initGNSocketObject() {
+        fatalError("Must be implemented by subclass")
+    }
+
+    public func enqueue(requestType: RequestType, role: RequestRole, operationRequest: OperationRequest, onOperationResponse: Action1<OperationResponse>?, authToken: String?, secretKey: String?, customTags: GNHashtable?, gameId: String?) {
+        if !self.isUse {
+            GNDebug.logError("[GearN] Server Settings dont setup to use this to send operation request.")
+            return
+        }
+        
+        // Unwrap logic for optionals to match TS defaults or expectations
+        let auth = authToken ?? ""
+        let secret = secretKey ?? ""
+        let game = gameId ?? ""
+
+        if operationRequest.getRequestId() != -1 {
+            PeerBase.requestId += 1
+            let _ = operationRequest.setRequestId(requestId: PeerBase.requestId)
+        }
+
+        let operationPending = OperationPending(requestType: requestType, role: role, operationRequest: operationRequest, onOperationResponse: onOperationResponse, authToken: auth, secretKey: secret, customTags: customTags, gameId: game)
+        self.operationPendingQueue.append(operationPending)
+
+        self.onEnqueue(operationPending: operationPending)
+    }
+
+    open func onEnqueue(operationPending: OperationPending) {
+         fatalError("Must be implemented by subclass")
+    }
+
+    public func isUsing() -> Bool {
+        return self.isUse
+    }
+
+    public func service() {
+        if !self.isUse { return }
+
+        let nowSecond = Date().timeIntervalSince1970
+        if self.checkTimeoutOperationPending < nowSecond {
+            self.checkTimeoutOperationPending = nowSecond + 0.1
+
+            if !self.operationWaitingResponseDict.isEmpty {
+                var gnHashtableLst: [GNHashtable] = []
+
+                for (operationPendingKey, operationPending) in self.operationWaitingResponseDict {
+                    if operationPending.isTimeout() {
+                        let gnHashtable = GNHashtable()
+
+                        gnHashtable.add(k: ParameterCode.ReturnCode, value: ReturnCode.OperationTimeout)
+                        gnHashtable.add(k: ParameterCode.Parameters, value: nil)
+                        gnHashtable.add(k: ParameterCode.ResponseId, value: operationPending.getOperationRequest().getRequestId())
+
+                        gnHashtableLst.append(gnHashtable)
+                    }
+                }
+
+                if !gnHashtableLst.isEmpty {
+                    gnHashtableLst.forEach { gnHashtable in
+                        self.onResponseHandler(obj: gnHashtable)
+                    }
+                }
+            }
+        }
+
+        if self.nextSendMsgTimer < nowSecond {
+            if !self.operationPendingQueue.isEmpty {
+                self.nextSendMsgTimer = nowSecond + self.perMsgTimer
+
+                let operationPending = self.operationPendingQueue.removeFirst()
+
+                self.send(operationPending: operationPending)
+            }
+        }
+    }
+
+    internal func onResponseHandler(obj: GNHashtable) {
+        guard let responseId = obj.getNumber(ParameterCode.ResponseId) else { return }
+        
+        // TS key is number, Dictionary Int
+        let key = Int(responseId)
+        
+        if let operationPending = self.operationWaitingResponseDict[key] {
+            operationPending.onRecv()
+
+            self.operationWaitingResponseDict.removeValue(forKey: key)
+
+            let returnCode = Int(obj.getNumber(ParameterCode.ReturnCode) ?? Double(ReturnCode.UnknownError))
+
+            let parameters = obj.getGNHashtable(ParameterCode.Parameters) ?? GNHashtable()
+            let debugMessage = obj.getString(ParameterCode.DebugMessage) ?? ""
+            let invalidRequestParameterArray = obj.getGNArray(ParameterCode.InvalidRequestParameters)
+
+            let operationRequest = operationPending.getOperationRequest()
+            let operationResponse = OperationResponse(operationCode: operationRequest.getOperationCode(), responseId: operationRequest.getRequestId())
+
+            let _ = operationResponse.setReturnCode(returnCode: returnCode)
+            let _ = operationResponse.setDebugMessage(debugMessage: debugMessage)
+            let _ = operationResponse.setParameters(parameters: parameters)
+
+            if let invalidRequestParameterArray = invalidRequestParameterArray {
+                var invalidMembers: [InvalidMember] = []
+                for i in 0..<invalidRequestParameterArray.count() {
+                    if let arrChild = invalidRequestParameterArray.getGNArray(i) {
+                         let code = arrChild.getString(0) ?? ""
+                         let typeInt = Int(arrChild.getNumber(1) ?? 0)
+                         let type = InvalidMemberType(rawValue: typeInt) ?? .UnknownError
+                         invalidMembers.append(InvalidMember(code: code, invalidMemberType: type))
+                    }
+                }
+                let _ = operationResponse.setInvalidMembers(invalidMembers: invalidMembers)
+            }
+
+            if !operationResponse.hasError() {
+                self.addPing(value: operationPending.getExecuteTimerInMs())
+
+                // Update auth/userId/ts in GNNetwork/Storage
+                if parameters.containsKey(ParameterCode.AuthToken) {
+                    if let authToken = parameters.getString(ParameterCode.AuthToken) {
+                        GNNetwork.getAuthenticateStatus().setAuthToken(authToken: authToken)
+                        StorageService.set(key: GNNetwork.AUTH_TOKEN_KEY, value: authToken)
+                    }
+                }
+                
+                if parameters.containsKey(ParameterCode.UserId) {
+                    if let userId = parameters.getString(ParameterCode.UserId) {
+                        GNNetwork.getAuthenticateStatus().setUserId(userId: userId)
+                        StorageService.set(key: GNNetwork.USER_ID_KEY, value: userId)
+                    }
+                }
+                
+                if parameters.containsKey(ParameterCode.Ts) {
+                    // TS: GNNetwork.peer.setServerTimeMilliseconds(...)
+                    // Accessing GNNetwork.peer might be circular but Swift allows.
+                    // Assuming GNNetwork has static peer access 
+                     let ts = parameters.getNumber(ParameterCode.Ts) ?? Double(Date().timeIntervalSince1970 * 1000)
+                     GNNetwork.getPeer().setServerTimeMilliseconds(currentServerMilliseconds: ts)
+                }
+            }
+
+            GNDebug.log("[GN RECV] " + operationResponse.toString())
+
+            if let callback = operationPending.getCallback() {
+                callback(operationResponse)
+            }
+        } else {
+            GNDebug.logError("[GearN] OnResponseHandler, unavailable request id \(obj)")
+        }
+    }
+
+    internal func send(operationPending: OperationPending) {
+        operationPending.onSend()
+
+        let operationRequest = operationPending.getOperationRequest()
+
+        if operationRequest.getRequestId() != -1 {
+            if operationPending.getCallback() != nil {
+                self.operationWaitingResponseDict[operationRequest.getRequestId()] = operationPending
+            }
+        }
+    }
+
+    func addPing(value: Double) {
+        if self.pingLst.count > 10 {
+            self.pingLst.removeFirst()
+        }
+        self.pingLst.append(value / 2)
+
+        if !self.pingLst.isEmpty {
+            var total: Double = 0
+            for v in self.pingLst {
+                total += v
+            }
+
+            let average = total / Double(self.pingLst.count)
+            self.ping = (average * 1000)
+        } else {
+            self.ping = -1
+        }
+    }
+}

package/srcSwift/Sources/GearN/runtime/networking/handler/IServerEventHandler.swift

@@ -0,0 +1,20 @@
+import Foundation
+
+public protocol IServerEventHandler {
+    init()
+    func getEventCode() -> String
+    func handle(operationEvent: OperationEvent)
+}
+
+public class ServerEventHandlerRegistry {
+    private static var implementations: [IServerEventHandler.Type] = []
+
+    public static func getImplementations() -> [IServerEventHandler.Type] {
+        return implementations
+    }
+
+    public static func registerEvent<T: IServerEventHandler>(ctor: T.Type) -> T.Type {
+        implementations.append(ctor)
+        return ctor
+    }
+}

package/srcSwift/Sources/GearN/runtime/networking/http/HttpPeer.swift

@@ -0,0 +1,226 @@
+import Foundation
+
+public class HttpPeer: PeerBase {
+    private var networkingHttpPeerBase: NetworkingHttpPeerBase!
+    
+    private static let JSON_CHAR_KNOWN: Character = "{"
+    
+    // Static API Strings
+    internal static let API_JSON: String = "api/json"
+    internal static let API_MSG_PACK: String = "api/msgpack"
+    internal static let UPLOAD_FILE: String = "upload/file"
+    
+    // MARK: - GET Request for utility endpoints
+    public func getRequest(subUri: String, onResponse: @escaping (HttpAppResponse) -> Void) {
+        guard let settings = GNNetwork.getGNServerSettings() else {
+            let response = HttpAppResponse()
+            response.error = "No server settings"
+            onResponse(response)
+            return
+        }
+        
+        let url = "\(settings.getHttpUrl())/\(subUri)"
+        
+        sendRawRequest(url: url, method: "GET", body: nil) { data, response, error in
+            let httpResponse = HttpAppResponse()
+            
+            if let error = error {
+                httpResponse.error = error.localizedDescription
+            } else if let httpUrlResponse = response as? HTTPURLResponse {
+                httpResponse.statusCode = httpUrlResponse.statusCode
+                if let data = data {
+                    httpResponse.data = data
+                    httpResponse.text = String(data: data, encoding: .utf8)
+                }
+            }
+            
+            onResponse(httpResponse)
+        }
+    }
+    
+    // MARK: - Upload File
+    public func uploadFile(fileId: String, content: Data, filename: String, mimetype: String, onResponse: @escaping (HttpAppResponse) -> Void) {
+        guard let settings = GNNetwork.getGNServerSettings() else {
+            let response = HttpAppResponse()
+            response.error = "No server settings"
+            onResponse(response)
+            return
+        }
+        
+        let url = "\(settings.getHttpUrl())/\(HttpPeer.UPLOAD_FILE)"
+        let boundary = UUID().uuidString
+        
+        var body = Data()
+        
+        // Add file id field
+        body.append("--\(boundary)\r\n".data(using: .utf8)!)
+        body.append("Content-Disposition: form-data; name=\"fileId\"\r\n\r\n".data(using: .utf8)!)
+        body.append("\(fileId)\r\n".data(using: .utf8)!)
+        
+        // Add file content
+        body.append("--\(boundary)\r\n".data(using: .utf8)!)
+        body.append("Content-Disposition: form-data; name=\"file\"; filename=\"\(filename)\"\r\n".data(using: .utf8)!)
+        body.append("Content-Type: \(mimetype)\r\n\r\n".data(using: .utf8)!)
+        body.append(content)
+        body.append("\r\n".data(using: .utf8)!)
+        body.append("--\(boundary)--\r\n".data(using: .utf8)!)
+        
+        var headers: [String: String] = [:]
+        headers["Content-Type"] = "multipart/form-data; boundary=\(boundary)"
+        
+        if let authStatus = GNNetwork.getAuthenticateStatus() {
+            headers["Authorization"] = "Bearer \(authStatus.getAuthToken())"
+        }
+        
+        sendRawRequest(url: url, method: "POST", headers: headers, body: body) { data, response, error in
+            let httpResponse = HttpAppResponse()
+            
+            if let error = error {
+                httpResponse.error = error.localizedDescription
+            } else if let httpUrlResponse = response as? HTTPURLResponse {
+                httpResponse.statusCode = httpUrlResponse.statusCode
+                if let data = data {
+                    httpResponse.data = data
+                    httpResponse.text = String(data: data, encoding: .utf8)
+                }
+            }
+            
+            onResponse(httpResponse)
+        }
+    }
+
+
+    public override func initGNSocketObject() {
+        guard let gnServerSettings = GNNetwork.getGNServerSettings() else {
+             fatalError("Where is GN Server Settings")
+        }
+        
+        self.isUse = gnServerSettings.isUseHttp()
+        
+        self.networkingHttpPeerBase = NetworkingPeerUrlSession()
+        
+        let httpUrl = gnServerSettings.getHttpUrl()
+        let userAgent = "GN-swift-" + GNNetwork.getPlatform() + "@" + GNNetwork.getClientSdkVersion()
+        
+        self.networkingHttpPeerBase.initPeer(httpUrl: httpUrl, userAgent: userAgent)
+        self.networkingHttpPeerBase.setUseReverseProxy(useReverseProxy: gnServerSettings.getUseReverseProxy())
+    }
+    
+    public override func send(operationPending: OperationPending) {
+        guard let gnServerSettings = GNNetwork.getGNServerSettings() else { return }
+        
+        let operationRequest = operationPending.getOperationRequest()
+        
+        if operationRequest.getTimeout() == OperationRequest.defaultTimeOut {
+            let _ = operationRequest.setTimeout(timeout: gnServerSettings.getDefaultTimeoutInSeconds())
+        }
+        
+        super.send(operationPending: operationPending)
+        
+        GNDebug.log("[GN Http SEND] " + operationRequest.toString())
+        
+        let authToken = operationPending.getAuthToken()
+        let secretKey = operationPending.getSecretKey()
+        let gameId = operationPending.getGameId()
+        let customTags = operationPending.getCustomTags()
+        
+        var postType = gnServerSettings.getMessageType() == MessageType.Json ? PostType.Json : PostType.MsgPack
+        
+        // Assume Swift supports MsgPack effectively if lib present, otherwise fallback or error
+        // Unlike JS, Swift strictly compiled so we adhere to settings. If MsgPack not impl, HttpPeerUrlSession handles it.
+        
+        let subUri = (postType == .Json ? HttpPeer.API_JSON : HttpPeer.API_MSG_PACK) + "/" + CodeHelper.getRequestTypeName(operationPending.getRequestType().rawValue) + "/" + CodeHelper.getRequestRoleName(operationPending.getRole().rawValue) + "/" + operationRequest.getOperationCode()
+        
+        self.networkingHttpPeerBase.postRequest(subUri: subUri, param: operationRequest.getParameters() ?? GNHashtable(), postType: postType, onHttpAppResponse: { [weak self] httpAppResponse in
+            self?.onSendOperationRequestResponse(operationPending: operationPending, httpAppResponse: httpAppResponse)
+        }, timeout: operationRequest.getTimeout(), authToken: authToken, secretKey: secretKey, customTags: customTags, gameId: gameId)
+    }
+    
+    public override func onEnqueue(operationPending: OperationPending) {
+        GNDebug.log("[GN Http ENQUEUE] " + operationPending.getOperationRequest().toString())
+    }
+    
+    private func onSendOperationRequestResponse(operationPending: OperationPending, httpAppResponse: HttpAppResponse) {
+        let operationRequest = operationPending.getOperationRequest()
+        let obj = GNHashtable()
+        
+        if !httpAppResponse.hasError() {
+            if httpAppResponse.statusCode == 200 {
+                var gnHashtable: GNHashtable? = nil
+                
+                if let text = httpAppResponse.text, !text.isEmpty {
+                     if text.first == HttpPeer.JSON_CHAR_KNOWN {
+                         // Parse JSON
+                         if let data = text.data(using: .utf8),
+                            let json = try? JSONSerialization.jsonObject(with: data, options: []) as? [String: Any] {
+                             gnHashtable = GNHashtable()
+                             // Simple populate, assuming GNHashtable can ingest dictionary
+                             // Or builder pattern
+                             // Quick hack:
+                             for (k, v) in json {
+                                 gnHashtable!.add(k: k, value: v)
+                             }
+                         }
+                     }
+                }
+                
+                // If msgpack
+                if gnHashtable == nil {
+                     if let data = httpAppResponse.data {
+                         // MsgPack deserialize
+                         // Placeholder
+                     }
+                }
+                
+                if let table = gnHashtable {
+                    obj.add(k: ParameterCode.ReturnCode, value: table.getNumber(ParameterCode.ReturnCode))
+                    obj.add(k: ParameterCode.Parameters, value: table.getGNHashtable(ParameterCode.Parameters))
+                    obj.add(k: ParameterCode.InvalidRequestParameters, value: table.getGNArray(ParameterCode.InvalidRequestParameters))
+                    obj.add(k: ParameterCode.DebugMessage, value: table.getString(ParameterCode.DebugMessage))
+                    obj.add(k: ParameterCode.ResponseId, value: operationRequest.getRequestId())
+                    
+                    self.onResponseHandler(obj: obj)
+                    return
+                }
+            }
+        }
+        
+        obj.add(k: ParameterCode.ReturnCode, value: ReturnCode.UnknownError)
+        obj.add(k: ParameterCode.DebugMessage, value: httpAppResponse.error ?? "Unknown Error")
+        obj.add(k: ParameterCode.ResponseId, value: operationRequest.getRequestId())
+        
+        self.onResponseHandler(obj: obj)
+    }
+    
+    // MARK: - Raw Request Method
+    public func sendRawRequest(
+        url: String,
+        method: String,
+        headers: [String: String]? = nil,
+        body: Data?,
+        completion: @escaping (Data?, URLResponse?, Error?) -> Void
+    ) {
+        guard let requestUrl = URL(string: url) else {
+            completion(nil, nil, NSError(domain: "HttpPeer", code: -1, userInfo: [NSLocalizedDescriptionKey: "Invalid URL"]))
+            return
+        }
+        
+        var request = URLRequest(url: requestUrl)
+        request.httpMethod = method
+        request.httpBody = body
+        
+        if let headers = headers {
+            for (key, value) in headers {
+                request.setValue(value, forHTTPHeaderField: key)
+            }
+        }
+        
+        let task = URLSession.shared.dataTask(with: request) { data, response, error in
+            DispatchQueue.main.async {
+                completion(data, response, error)
+            }
+        }
+        task.resume()
+    }
+}
+

package/srcSwift/Sources/GearN/runtime/networking/http/HttpTypes.swift

@@ -0,0 +1,24 @@
+import Foundation
+
+public class HttpAppResponse {
+    public var statusCode: Int = 0
+    public var error: String?
+    public var data: Data?
+    public var text: String?
+
+    public func hasError() -> Bool {
+        return self.error != nil
+    }
+
+    public func toString() -> String {
+        var answer = " StatusCode: \(self.statusCode)"
+        if let err = self.error { answer += ", Error: \(err)" }
+        if let txt = self.text { answer += ", Text: \(txt)" }
+        return answer
+    }
+}
+
+public enum PostType: Int {
+    case Json = 0
+    case MsgPack = 1
+}

package/srcSwift/Sources/GearN/runtime/networking/http/NetworkingHttpPeerBase.swift

@@ -0,0 +1,13 @@
+import Foundation
+
+public protocol NetworkingHttpPeerBase {
+    func initPeer(httpUrl: String, userAgent: String)
+    
+    func setUseReverseProxy(useReverseProxy: Bool)
+    
+    func getRequest(subUri: String, onHttpAppResponse: @escaping Action1<HttpAppResponse>, timeout: Int, authToken: String, secretKey: String, gameId: String)
+    
+    func postRequest(subUri: String, param: GNHashtable, postType: PostType, onHttpAppResponse: @escaping Action1<HttpAppResponse>, timeout: Int, authToken: String, secretKey: String, customTags: GNHashtable?, gameId: String)
+    
+    func postRequestUpload(subUri: String, content: Data, filename: String, mimetype: String, onHttpAppResponse: @escaping Action1<HttpAppResponse>, timeout: Int)
+}