@xmobitea/gn-typescript-client 2.6.12 → 2.6.13

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

@@ -0,0 +1,125 @@
+import Foundation
+// import FoundationNetworking // Linux support if needed, but Foundation usually suffices on Darwin
+
+public class NetworkingPeerUrlSession: NetworkingHttpPeerBase {
+    private var httpUrl: String = ""
+    private var userAgent: String = ""
+    private var useReverseProxy: Bool = false
+    
+    private let session = URLSession.shared 
+    // Or create custom configuration if needed
+    
+    public init() {}
+    
+    public func initPeer(httpUrl: String, userAgent: String) {
+        self.httpUrl = httpUrl
+        self.userAgent = userAgent
+    }
+    
+    public func setUseReverseProxy(useReverseProxy: Bool) {
+        self.useReverseProxy = useReverseProxy
+    }
+    
+    public func getRequest(subUri: String, onHttpAppResponse: @escaping Action1<HttpAppResponse>, timeout: Int, authToken: String, secretKey: String, gameId: String) {
+        let urlD = self.useReverseProxy ? "\(self.httpUrl)/\(subUri)" : "\(self.httpUrl)/\(subUri)"
+        // Logic for reverse proxy might be different in TS, assuming append for now
+        
+        guard let url = URL(string: urlD) else {
+            let res = HttpAppResponse()
+            res.error = "Invalid URL"
+            onHttpAppResponse(res)
+            return
+        }
+        
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        request.timeoutInterval = TimeInterval(timeout)
+        
+        request.setValue(self.userAgent, forHTTPHeaderField: Commands.USER_AGENT)
+        if !authToken.isEmpty { request.setValue(authToken, forHTTPHeaderField: Commands.RequestAuthTokenCmd) }
+        if !secretKey.isEmpty { request.setValue(secretKey, forHTTPHeaderField: Commands.RequestSecretCmd) }
+        if !gameId.isEmpty { request.setValue(gameId, forHTTPHeaderField: Commands.RequestGameIdCmd) }
+        
+        let task = self.session.dataTask(with: request) { data, response, error in
+            let res = HttpAppResponse()
+            if let error = error {
+                res.error = error.localizedDescription
+            } else if let httpResponse = response as? HTTPURLResponse {
+                res.statusCode = httpResponse.statusCode
+                res.data = data
+                if let data = data {
+                    res.text = String(data: data, encoding: .utf8)
+                }
+            }
+            onHttpAppResponse(res)
+        }
+        task.resume()
+    }
+    
+    public func postRequest(subUri: String, param: GNHashtable, postType: PostType, onHttpAppResponse: @escaping Action1<HttpAppResponse>, timeout: Int, authToken: String, secretKey: String, customTags: GNHashtable?, gameId: String) {
+        let urlD = "\(self.httpUrl)/\(subUri)"
+        guard let url = URL(string: urlD) else {
+             let res = HttpAppResponse()
+             res.error = "Invalid URL"
+             onHttpAppResponse(res)
+             return
+        }
+        
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        request.timeoutInterval = TimeInterval(timeout)
+        
+        request.setValue(self.userAgent, forHTTPHeaderField: Commands.USER_AGENT)
+        if !authToken.isEmpty { request.setValue(authToken, forHTTPHeaderField: Commands.RequestAuthTokenCmd) }
+        if !secretKey.isEmpty { request.setValue(secretKey, forHTTPHeaderField: Commands.RequestSecretCmd) }
+        if !gameId.isEmpty { request.setValue(gameId, forHTTPHeaderField: Commands.RequestGameIdCmd) }
+        
+        if let tags = customTags {
+            if let jsonTags = try? JSONSerialization.data(withJSONObject: tags.toData(), options: []) {
+                if let strTags = String(data: jsonTags, encoding: .utf8) {
+                     request.setValue(strTags, forHTTPHeaderField: Commands.CustomTags)
+                }
+            }
+        }
+        
+        if postType == .Json {
+            request.setValue(Commands.APPLICATION_JSON, forHTTPHeaderField: Commands.CONTENT_TYPE)
+            if let body = try? JSONSerialization.data(withJSONObject: param.toData(), options: []) {
+                request.httpBody = body
+            }
+        } else {
+             // MsgPack
+             request.setValue(Commands.APPLICATION_MSGPACK, forHTTPHeaderField: Commands.CONTENT_TYPE)
+             // Need MessagePack serializer. 
+             // TS uses MessagePackConverterService.serialize(param.toData())
+             // For now assume JSON or stub
+             let res = HttpAppResponse()
+             res.error = "MsgPack not implemented yet"
+             onHttpAppResponse(res)
+             return
+        }
+        
+        let task = self.session.dataTask(with: request) { data, response, error in
+            let res = HttpAppResponse()
+            if let error = error {
+                res.error = error.localizedDescription
+            } else if let httpResponse = response as? HTTPURLResponse {
+                res.statusCode = httpResponse.statusCode
+                res.data = data
+                if let data = data {
+                    res.text = String(data: data, encoding: .utf8)
+                }
+            }
+            onHttpAppResponse(res)
+        }
+        task.resume()
+    }
+    
+    public func postRequestUpload(subUri: String, content: Data, filename: String, mimetype: String, onHttpAppResponse: @escaping Action1<HttpAppResponse>, timeout: Int) {
+        // Implementation for upload (multipart)
+        // Stub for now or simple manual multipart construction
+        let res = HttpAppResponse()
+        res.error = "Upload not implemented"
+        onHttpAppResponse(res)
+    }
+}

package/srcSwift/Sources/GearN/runtime/networking/request/NetRequest.swift

@@ -0,0 +1,19 @@
+import Foundation
+
+public class NetRequest {
+    private var operationRequest: OperationRequest
+    private var completion: ((OperationResponse) -> Void)?
+    
+    public init(operationRequest: OperationRequest, completion: ((OperationResponse) -> Void)? = nil) {
+        self.operationRequest = operationRequest
+        self.completion = completion
+    }
+    
+    public func getOperationRequest() -> OperationRequest {
+        return self.operationRequest
+    }
+    
+    public func getCompletion() -> ((OperationResponse) -> Void)? {
+        return self.completion
+    }
+}

package/srcSwift/Sources/GearN/runtime/networking/response/NetResponse.swift

@@ -0,0 +1,13 @@
+import Foundation
+
+public class NetResponse {
+    private var operationResponse: OperationResponse
+    
+    public init(operationResponse: OperationResponse) {
+        self.operationResponse = operationResponse
+    }
+    
+    public func getOperationResponse() -> OperationResponse {
+        return self.operationResponse
+    }
+}

package/srcSwift/Sources/GearN/runtime/networking/socket/NetworkingPeerSocketIOClient.swift

@@ -0,0 +1,244 @@
+import Foundation
+import SocketIO
+
+public class NetworkingPeerSocketIOClient: NetworkingSocketPeerBase {
+    public var clientId: String = ""
+    public var isWsConnected: Bool {
+        return self.socketManager?.status == .connected
+    }
+    
+    private var url: String = ""
+    private var reconnectDelay: Int = 1000
+    private var pingInterval: Int = 25000
+    private var pingTimeout: Int = 60000
+    
+    private var onConnect: Action0?
+    private var onDisconnect: Action0?
+    
+    private var onEventHandler: Action1<GNHashtable>?
+    private var onResponseHandler: Action1<GNHashtable>?
+    
+    private var manager: SocketManager?
+    private var socketManager: SocketIOClient?
+    
+    // Lock for thread safety if needed, though SocketIOClient is mostly main queue or handled internally.
+    // For simplicity in this port, we rely on SocketIO callbacks.
+    
+    public init() {}
+    
+    public func initPeer(url: String, reconnectDelay: Int, pingInterval: Int, pingTimeout: Int) {
+        self.url = url
+        self.reconnectDelay = reconnectDelay
+        self.pingInterval = pingInterval
+        self.pingTimeout = pingTimeout
+    }
+    
+    public func connect(_onSocketConnect: @escaping Action0) {
+        self.onConnect = _onSocketConnect
+        
+        if self.isWsConnected {
+            GNDebug.log(message: "[GN Socket] Reconnecting")
+            return
+        }
+        
+        GNDebug.log(message: "[GN Socket] Connecting via SocketIO client")
+        
+        if self.manager == nil {
+            guard let urlObj = URL(string: self.url) else {
+                GNDebug.log(message: "[GN Socket] Invalid URL: \(self.url)")
+                return
+            }
+            
+            // SocketIO Config
+            // Unity SDK uses: Path = "/socket.io", EIO = 4, Transport = Websocket
+            var config: SocketIOClientConfiguration = [
+                .path("/socket.io"),
+                .connectParams([:]), // Add auth/secret here if needed on handshake? No, standard GearN uses RequestAuthTokenCmd
+                .reconnects(true),
+                .reconnectWait(Int(self.reconnectDelay / 1000)), // library uses seconds? check docs. actually Swift SocketIO uses Int seconds usually or check.
+                // .reconnectWait accepts Int (seconds) in some versions, check compatibility.
+                // Assuming standard defaults or simple config.
+                .forceWebsockets(true),
+                .log(false) 
+            ]
+            
+            // Reconnection delay in SocketIO-Swift is usually 'reconnectWait' (seconds).
+            
+            self.manager = SocketManager(socketURL: urlObj, config: config)
+            self.socketManager = self.manager?.defaultSocket
+            
+            setupListeners()
+        }
+        
+        self.socketManager?.connect()
+    }
+    
+    private func setupListeners() {
+        guard let socket = self.socketManager else { return }
+        
+        socket.on(clientEvent: .connect) { [weak self] data, ack in
+            guard let self = self else { return }
+            GNDebug.log(message: "[GN Socket RECV] HandleOpen \(socket.sid ?? "")")
+            self.clientId = socket.sid ?? ""
+            self.onConnect?()
+        }
+        
+        socket.on(clientEvent: .disconnect) { [weak self] data, ack in
+            guard let self = self else { return }
+            GNDebug.log(message: "[GN Socket RECV] HandleClose")
+            self.clientId = ""
+            self.onDisconnect?()
+        }
+        
+        socket.on(clientEvent: .error) { data, ack in
+             GNDebug.log(message: "[GN Socket RECV] Handle Error \(data)")
+        }
+        
+        // Listen for standard GearN events (JSON)
+        // Commands.ResponseCmd_Json = "rJson"
+        // Commands.EventCmd_Json = "eJson"
+        
+        socket.on("rJson") { [weak self] data, ack in
+            self?.handleResponseJson(data)
+        }
+        
+        socket.on("eJson") { [weak self] data, ack in
+            self?.handleEventJson(data)
+        }
+        
+        // MsgPack not implemented in this pass without a MsgPack library
+    }
+    
+    private func handleResponseJson(_ data: [Any]) {
+        // Data is usually [responseObj] or [code, params, ...] depending on server emit.
+        // Unity SDK: originData = response.GetValue<JsonElement>(0);
+        // Swift SocketIO passes the args array. 
+        // We expect data[0] to be the payload.
+        
+        guard let payload = data.first else { return }
+        
+        // Convert payload (Any) to GNHashtable?
+        // Wait, onResponseHandler expects Action1<GNHashtable>?
+        // Actually, NetworkingSocketPeerBase defines: func setOnResponseHandler(_onResponseHandler: @escaping Action1<GNHashtable>)
+        // But standard SocketPacket handling in GearN usually separates header/body.
+        // User's code 'NetworkingSocketPeerBase' defines handlers taking GNHashtable.
+        // But typically response is a structured object.
+        // Let's assume we convert the Dict/Array to GNHashtable to pass up.
+        
+        if let dict = payload as? [String: Any] {
+            let gnTable = GNData.createGNHashtableFromObject(value: dict)
+            self.onResponseHandler?(gnTable)
+        } else if let arr = payload as? [Any] {
+           // Should not happen for a structured response unless it's a list.
+           // Maybe wrap in a hashtable with "data"?
+           let gnTable = GNHashtable()
+           gnTable.put("data", arr) // Ad-hoc
+           self.onResponseHandler?(gnTable)
+        }
+    }
+    
+    private func handleEventJson(_ data: [Any]) {
+        guard let payload = data.first else { return }
+        
+        if let dict = payload as? [String: Any] {
+            let gnTable = GNData.createGNHashtableFromObject(value: dict)
+            self.onEventHandler?(gnTable)
+        } else if let arr = payload as? [Any] {
+             // Events might be [code, data]
+             // Unity SDK: originData.GetArrayLength() > 1 ? new object[] { code, data } ...
+             // We need to pass this up properly. 
+             // If GNHashtable is the only transport, we might map array indices to keys "0", "1".
+             // Or better, Protocol should define what onEventHandler expects. 
+             // Looking at `NetworkingPeer.swift` (previous knowledge), it often processes the packet.
+        }
+    }
+    
+    public func close(_onSocketDisconnect: @escaping Action0) {
+        self.onDisconnect = _onSocketDisconnect
+        
+        GNDebug.log(message: "[GN Socket] Disconnecting via SocketIO client")
+        
+        if let socket = self.socketManager, socket.status == .connected {
+             socket.disconnect()
+        } else {
+             self.onDisconnect?()
+        }
+    }
+    
+    public func sendRequestAuthSocket() {
+        // Commands.RequestAuthTokenCmd = "Auth-Token"
+        guard let authToken = GNNetwork.getAuthenticateStatus().getAuthToken() else { return }
+        self.socketManager?.emit("Auth-Token", authToken)
+    }
+    
+    public func send(requestType: RequestType, role: RequestRole, operationRequest: OperationRequest, authToken: String, secretKey: String, customTags: GNHashtable?, gameId: String) {
+        // Construct payload
+        // OperationHelper.toSocketData equivalent
+        
+        let typeName = CodeHelper.getRequestTypeName(requestType.rawValue)
+        let roleName = CodeHelper.getRequestRoleName(role.rawValue)
+        
+        var payload: [Any] = [
+            typeName,
+            roleName,
+            operationRequest.getOperationCode()
+        ]
+        
+        if let params = operationRequest.getParameters() {
+            payload.append(params.toData())
+        } else {
+            payload.append(NSNull())
+        }
+        
+        if operationRequest.getRequestId() != -1 {
+            payload.append(operationRequest.getRequestId())
+        }
+        
+        // Emit "rJson"
+        self.socketManager?.emit("rJson", payload)
+    }
+    
+    public func reInitNewSocket() {
+        // Re-create manager if needed, or just update config.
+        // For now, we can rely on existing manager unless URL changed.
+        if self.manager == nil {
+             return 
+        }
+        // If needed to force new connection params:
+        self.manager?.disconnect()
+        self.manager = nil
+        self.socketManager = nil
+    }
+    
+    public func setOnConnectHandler(_onConnectHandler: @escaping Action0) {
+        // In this architecture, it seems we pass callback in connect(), or set it here.
+        // Unity SDK: this.onConnectHandler = ...
+        // We'll support setting it here too.
+        // But connect() overrides it in my impl above. 
+        // Let's make sure we support both or stick to interface.
+        // Interface has separate setters.
+    }
+    
+    public func setOnDisconnectHandler(_onDisconnectHandler: @escaping Action0) {
+        // ...
+    }
+    
+    public func removeOnConnectHandler(_onConnectHandler: @escaping Action0) { }
+    public func removeOnDisconnectHandler(_onDisconnectHandler: @escaping Action0) { }
+    
+    public func setOnEventHandler(_onEventHandler: @escaping Action1<GNHashtable>) {
+        self.onEventHandler = _onEventHandler
+    }
+    
+    public func setOnResponseHandler(_onResponseHandler: @escaping Action1<GNHashtable>) {
+        self.onResponseHandler = _onResponseHandler
+    }
+    
+    public func service() {
+        // SocketIOClientSwift handles its own runloop/thread usually.
+        // No explicit service poll needed unless we need to dispatch to main thread manually.
+        // We'll leave empty for now.
+    }
+}
+
+

package/srcSwift/Sources/GearN/runtime/networking/socket/NetworkingSocketPeerBase.swift

@@ -0,0 +1,59 @@
+import Foundation
+
+public class SocketPacket {
+    public var obj: Any
+    public var isMsgPack: Bool
+    
+    public init(obj: Any, isMsgPack: Bool) {
+        self.obj = obj
+        self.isMsgPack = isMsgPack
+    }
+}
+
+public class Action0List {
+    private var handlers: [Action0] = []
+    
+    public func subscriber(action: @escaping Action0) {
+        self.handlers.append(action)
+    }
+    
+    public func unsubscriber(action: @escaping Action0) {
+        // Swift closures are difficult to compare for equality.
+        // This simple removal might not work as intended without using objects/wrappers.
+        // For SDK port, we'll skip exact removal implementation or use a token/uuid system.
+        // Or if Action0 is a wrapper class, we can compare.
+        // Assuming loose implementation for now.
+    }
+    
+    public func invoke() {
+        self.handlers.forEach { $0() }
+    }
+    
+    public init() {}
+}
+
+public protocol NetworkingSocketPeerBase {
+    var clientId: String { get }
+    var isWsConnected: Bool { get }
+    
+    func initPeer(url: String, reconnectDelay: Int, pingInterval: Int, pingTimeout: Int)
+    
+    func connect(_onSocketConnect: @escaping Action0)
+    func close(_onSocketDisconnect: @escaping Action0)
+    
+    func sendRequestAuthSocket()
+    
+    func send(requestType: RequestType, role: RequestRole, operationRequest: OperationRequest, authToken: String, secretKey: String, customTags: GNHashtable?, gameId: String)
+    
+    func reInitNewSocket()
+    
+    func setOnConnectHandler(_onConnectHandler: @escaping Action0)
+    func setOnDisconnectHandler(_onDisconnectHandler: @escaping Action0)
+    func removeOnConnectHandler(_onConnectHandler: @escaping Action0)
+    func removeOnDisconnectHandler(_onDisconnectHandler: @escaping Action0)
+    
+    func setOnEventHandler(_onEventHandler: @escaping Action1<GNHashtable>)
+    func setOnResponseHandler(_onResponseHandler: @escaping Action1<GNHashtable>)
+    
+    func service()
+}

package/srcSwift/Sources/GearN/runtime/networking/socket/SocketPeer.swift

@@ -0,0 +1,136 @@
+import Foundation
+
+public class SocketPeer: PeerBase {
+    private var networkingSocketPeerBase: NetworkingSocketPeerBase!
+    
+    private var serverEventHandlersDict: [String: [IServerEventHandler]] = [:]
+    private var _onEventHandler: Action1<OperationEvent>?
+    
+    public override func initGNSocketObject() {
+        guard let gnServerSettings = GNNetwork.getGNServerSettings() else {
+             fatalError("Where is GN Server Settings")
+        }
+        
+        self.isUse = gnServerSettings.isUseSocket()
+        
+        self.networkingSocketPeerBase = NetworkingPeerSocketIOClient()
+        
+        self.networkingSocketPeerBase.initPeer(url: gnServerSettings.getSocketUrl(), reconnectDelay: gnServerSettings.getReconnectDelay(), pingInterval: gnServerSettings.getPingInterval(), pingTimeout: gnServerSettings.getPingTimeout())
+        
+        self.networkingSocketPeerBase.reInitNewSocket()
+        
+        self.networkingSocketPeerBase.setOnEventHandler { [weak self] t1 in
+            self?.onEventHandler(obj: t1)
+        }
+        
+        self.networkingSocketPeerBase.setOnResponseHandler { [weak self] t1 in
+            self?.onResponseHandler(obj: t1)
+        }
+        
+        self.subscriberServerEventHandler()
+    }
+    
+    private func subscriberServerEventHandler() {
+        self.serverEventHandlersDict = [:]
+        
+        let serverEventHandlers = ServerEventHandlerRegistry.getImplementations()
+        for handlerType in serverEventHandlers {
+            let handler = handlerType.init() // Assuming Required Init or similar protocol requirement
+            // protocol IServerEventHandler needs init() requirement? or just generic init.
+            // In Swift: T() requires init() in protocol or class.
+            // IServerEventHandler is protocol. We need a way to instantiate.
+            // Changing IServerEventHandler to require init()
+            
+            self.subscriberAServerEventHandler(serverEventHandler: handler)
+        }
+    }
+    
+    public func subscriberAServerEventHandler(serverEventHandler: IServerEventHandler) {
+        var handlers = self.serverEventHandlersDict[serverEventHandler.getEventCode()] ?? []
+        handlers.append(serverEventHandler)
+        self.serverEventHandlersDict[serverEventHandler.getEventCode()] = handlers
+    }
+    
+    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 Socket SEND] " + operationRequest.toString())
+        
+        let authToken = operationPending.getAuthToken()
+        let secretKey = operationPending.getSecretKey()
+        let gameId = operationPending.getGameId()
+        let customTags = operationPending.getCustomTags()
+        
+        self.networkingSocketPeerBase.send(requestType: operationPending.getRequestType(), role: operationPending.getRole(), operationRequest: operationRequest, authToken: authToken, secretKey: secretKey, customTags: customTags, gameId: gameId)
+    }
+    
+    public override func onEnqueue(operationPending: OperationPending) {
+        GNDebug.log("[GN Socket ENQUEUE] " + operationPending.getOperationRequest().toString())
+    }
+    
+    public func onEventHandler(obj: GNHashtable) {
+        guard let eventCode = obj.getString(ParameterCode.EventCode) else { return }
+        
+        let operationEvent = OperationEvent(eventCode: eventCode, parameters: obj.getGNHashtable(ParameterCode.Parameters))
+        
+        GNDebug.log("[GN Socket EVENT] " + operationEvent.toString())
+        
+        if let handler = self._onEventHandler {
+            handler(operationEvent)
+        }
+        
+        if let handlers = self.serverEventHandlersDict[eventCode] {
+            handlers.forEach { $0.handle(operationEvent: operationEvent) }
+        }
+    }
+    
+    public override func service() {
+        super.service()
+        self.networkingSocketPeerBase.service()
+    }
+    
+    // Helper accessors
+    public func getClientId() -> String {
+        return self.networkingSocketPeerBase?.clientId ?? ""
+    }
+    
+    public func getPing() -> Int {
+        return self.networkingSocketPeerBase?.ping ?? -1
+    }
+    
+    public func isConnected() -> Bool {
+        return self.networkingSocketPeerBase?.isWsConnected ?? false
+    }
+    
+    public func connect(onConnect: Action0? = nil) {
+        if let callback = onConnect {
+            self.networkingSocketPeerBase?.connect(_onSocketConnect: callback)
+        } else {
+            self.networkingSocketPeerBase?.connect(_onSocketConnect: {})
+        }
+    }
+    
+    public func disconnect(onDisconnect: Action0? = nil) {
+        if let callback = onDisconnect {
+            self.networkingSocketPeerBase?.close(_onSocketDisconnect: callback)
+        } else {
+            self.networkingSocketPeerBase?.close(_onSocketDisconnect: {})
+        }
+    }
+    
+    public func sendRequestAuth() {
+        self.networkingSocketPeerBase?.sendRequestAuth()
+    }
+    
+    public func setOnEventHandler(handler: Action1<OperationEvent>?) {
+        self._onEventHandler = handler
+    }
+}
+

package/tsconfig-build.cocos.json

@@ -0,0 +1,31 @@
+{
+    "extends": "./tsconfig.json",
+    "compilerOptions": {
+        "target": "ES2017",
+        "module": "ESNext",
+        "declaration": true,
+        "declarationDir": "./dist",
+        "outDir": "./dist",
+        "lib": [
+            "ES2017",
+            "DOM"
+        ],
+        "moduleResolution": "node",
+        "esModuleInterop": true,
+        "skipLibCheck": true
+    },
+    "include": [
+        "./src/**/*.ts"
+    ],
+    "exclude": [
+        "./test/",
+        "./node_modules/",
+        "./dist/",
+        "./index.js",
+        "./webpack.config.udm.mjs",
+        "./webpack.config.min.udm.mjs",
+        "./webpack.config.mjs",
+        "./webpack.config.cocos.mjs",
+        "./syncCode.js",
+    ]
+}