@xmobitea/gn-typescript-client 2.6.12 → 2.6.13

package/srcSwift/Sources/GearN/runtime/GNNetwork.swift

@@ -0,0 +1,530 @@
+import Foundation
+
+private let VERSION: String = "2.6"
+
+public class GNNetwork {
+    
+    // MARK: - Constants
+    public static let AUTH_TOKEN_KEY: String = "[GearN]_AUTH_TOKEN_KEY"
+    public static let USER_ID_KEY: String = "[GearN]_USER_ID_KEY"
+    public static let GAME_ID_KEY: String = "[GearN]_GAME_ID_KEY"
+    
+    // MARK: - Private Properties
+    private static var gnServerSettings: GNServerSettings!
+    private static var _peer: NetworkingPeer!
+    
+    // MARK: - Public Properties
+    public static var serverTimeOffset: Double = 0
+    
+    // MARK: - API Instances
+    public static var authenticate: AuthenticateApi!
+    public static var characterPlayer: CharacterPlayerApi!
+    public static var content: ContentApi!
+    public static var dashboard: DashboardApi!
+    public static var gamePlayer: GamePlayerApi!
+    public static var group: GroupApi!
+    public static var inventory: InventoryApi!
+    public static var masterPlayer: MasterPlayerApi!
+    public static var storeInventory: StoreInventoryApi!
+    public static var multiplayer: MultiplayerApi!
+    public static var cloudScript: CloudScriptApi!
+//    public static var generic: GenericApi!
+    
+    // MARK: - Getters
+    public static func getGNServerSettings() -> GNServerSettings? {
+        return gnServerSettings
+    }
+    
+    public static func getPeer() -> NetworkingPeer? {
+        return _peer
+    }
+    
+    public static func getPing() -> Int {
+        return _peer != nil ? _peer.getPing() : -1
+    }
+    
+    public static func getSocketSId() -> String {
+        return _peer != nil ? _peer.getClientId() : ""
+    }
+    
+    public static func isSocketConnected() -> Bool {
+        let socketSId = getSocketSId()
+        return !socketSId.isEmpty
+    }
+    
+    public static func getServerTimestamp() -> Int64 {
+        return _peer != nil ? _peer.getServerTimestamp() : Int64(Date().timeIntervalSince1970 * 1000)
+    }
+    
+    public static func getAuthenticateStatus() -> AuthenticateStatus? {
+        return _peer?.authenticateStatus
+    }
+    
+    public static func getGameId() -> String {
+        return _peer?.gameId ?? ""
+    }
+    
+    public static func getPlatform() -> Int {
+        #if os(iOS)
+        return 18 // iOS platform code
+        #elseif os(macOS)
+        return 19 // macOS platform code
+        #else
+        return 17 // Default platform code
+        #endif
+    }
+    
+    public static func getClientSdkVersion() -> String {
+        return VERSION
+    }
+    
+    // MARK: - Initialization
+    public static func initialize(gnServerSettings: GNServerSettings) {
+        if self.gnServerSettings != nil {
+            GNDebug.log("GNNetwork has been initialized!")
+            return
+        }
+        
+        GNSupport.initialize()
+        CodeHelper.initialize()
+        ConverterService.initialize()
+        
+        self.gnServerSettings = gnServerSettings
+        
+        initServerSettings()
+        initGNDebug()
+        
+        GNDebug.log("GNNetwork initialized. Version: \(getClientSdkVersion())")
+        
+        initNetworkPeer()
+        
+        // Restore auth status
+        _peer.authenticateStatus.setAuthToken(authToken: StorageService.get(key: AUTH_TOKEN_KEY) as? String ?? "")
+        _peer.authenticateStatus.setUserId(userId: StorageService.get(key: USER_ID_KEY) as? String ?? "")
+        _peer.gameId = StorageService.get(key: GAME_ID_KEY) as? String ?? ""
+        
+        // Initialize API instances
+        authenticate = AuthenticateApi()
+        characterPlayer = CharacterPlayerApi()
+        content = ContentApi()
+        dashboard = DashboardApi()
+        gamePlayer = GamePlayerApi()
+        group = GroupApi()
+        inventory = InventoryApi()
+        masterPlayer = MasterPlayerApi()
+        storeInventory = StoreInventoryApi()
+        multiplayer = MultiplayerApi()
+        cloudScript = CloudScriptApi()
+//        generic = GenericApi()
+    }
+    
+    private static func initServerSettings() {
+        // Server settings initialization handled externally
+    }
+    
+    private static func initGNDebug() {
+        guard gnServerSettings != nil else {
+            fatalError("Null GN Server Settings, please configure first")
+        }
+        GNDebug.setLogType(logType: gnServerSettings.getLogType())
+    }
+    
+    private static func initNetworkPeer() {
+        let peer = NetworkingPeer()
+        peer.initPeer()
+        _peer = peer
+    }
+    
+    // MARK: - Authentication Management
+    public static func setNewAuthenticateStatus(authenticateStatus: AuthenticateStatus) {
+        StorageService.set(key: AUTH_TOKEN_KEY, value: authenticateStatus.getAuthToken())
+        StorageService.set(key: USER_ID_KEY, value: authenticateStatus.getUserId())
+        
+        _peer.authenticateStatus.setAuthToken(authToken: authenticateStatus.getAuthToken())
+        _peer.authenticateStatus.setUserId(userId: authenticateStatus.getUserId())
+    }
+    
+    public static func setGameId(gameId: String) {
+        StorageService.set(key: GAME_ID_KEY, value: gameId)
+        _peer.gameId = gameId
+    }
+    
+    // MARK: - Service Loop
+    public static func service() {
+        _peer?.service()
+    }
+    
+    // MARK: - Socket Methods
+    public static func sendRequestAuthSocket() {
+        _peer?.sendRequestAuthSocket()
+    }
+    
+    public static func connectSocket(onSocketConnect: Action0? = nil) {
+        _peer?.connectSocket(onSocketConnect: onSocketConnect)
+    }
+    
+    public static func disconnectSocket(onSocketDisconnect: Action0? = nil) {
+        _peer?.disconnectSocket(onSocketDisconnect: onSocketDisconnect)
+    }
+    
+    // MARK: - Event Handlers
+    public static func setOnEventHandler(onEventHandler: Action1<OperationEvent>?) {
+        _peer?.setOnEventHandler(onEventHandler: onEventHandler)
+    }
+    
+    public static func subscribeOnConnectHandler(onConnectHandler: @escaping Action0) {
+        _peer?.setOnConnectHandler(onConnectHandler: onConnectHandler)
+    }
+    
+    public static func subscribeOnDisconnectHandler(onDisconnectHandler: @escaping Action0) {
+        _peer?.setOnDisconnectHandler(onDisconnectHandler: onDisconnectHandler)
+    }
+    
+    public static func unsubscribeOnConnectHandler(onConnectHandler: @escaping Action0) {
+        _peer?.removeOnConnectHandler(onConnectHandler: onConnectHandler)
+    }
+    
+    public static func unsubscribeOnDisconnectHandler(onDisconnectHandler: @escaping Action0) {
+        _peer?.removeOnDisconnectHandler(onDisconnectHandler: onDisconnectHandler)
+    }
+    
+    public static func subscribeServerEventHandler(serverEventHandler: IServerEventHandler) {
+        _peer?.subscribeServerEventHandler(serverEventHandler: serverEventHandler)
+    }
+    
+    // MARK: - Raw Send Methods
+    public static func sendViaSocket(
+        requestType: RequestType,
+        role: RequestRole,
+        request: OperationRequest,
+        onResponse: Action1<OperationResponse>?,
+        overrideAuthToken: String? = nil,
+        overrideSecretKey: String? = nil,
+        customTags: GNHashtable? = nil
+    ) {
+        _peer?.sendViaSocket(
+            requestType: requestType,
+            role: role,
+            request: request,
+            onResponse: onResponse,
+            overrideAuthToken: overrideAuthToken ?? "",
+            overrideSecretKey: overrideSecretKey ?? "",
+            customTags: customTags
+        )
+    }
+    
+    public static func sendViaSocketAsync(
+        requestType: RequestType,
+        role: RequestRole,
+        request: OperationRequest,
+        overrideAuthToken: String? = nil,
+        overrideSecretKey: String? = nil,
+        customTags: GNHashtable? = nil
+    ) async -> OperationResponse {
+        return await withCheckedContinuation { continuation in
+            sendViaSocket(
+                requestType: requestType,
+                role: role,
+                request: request,
+                onResponse: { response in
+                    continuation.resume(returning: response)
+                },
+                overrideAuthToken: overrideAuthToken,
+                overrideSecretKey: overrideSecretKey,
+                customTags: customTags
+            )
+        }
+    }
+    
+    public static func sendViaHttp(
+        requestType: RequestType,
+        role: RequestRole,
+        request: OperationRequest,
+        onResponse: Action1<OperationResponse>?,
+        overrideAuthToken: String? = nil,
+        overrideSecretKey: String? = nil,
+        customTags: GNHashtable? = nil
+    ) {
+        _peer?.sendViaHttp(
+            requestType: requestType,
+            role: role,
+            request: request,
+            onResponse: onResponse,
+            overrideAuthToken: overrideAuthToken ?? "",
+            overrideSecretKey: overrideSecretKey ?? "",
+            customTags: customTags
+        )
+    }
+    
+    public static func sendViaHttpAsync(
+        requestType: RequestType,
+        role: RequestRole,
+        request: OperationRequest,
+        overrideAuthToken: String? = nil,
+        overrideSecretKey: String? = nil,
+        customTags: GNHashtable? = nil
+    ) async -> OperationResponse {
+        return await withCheckedContinuation { continuation in
+            sendViaHttp(
+                requestType: requestType,
+                role: role,
+                request: request,
+                onResponse: { response in
+                    continuation.resume(returning: response)
+                },
+                overrideAuthToken: overrideAuthToken,
+                overrideSecretKey: overrideSecretKey,
+                customTags: customTags
+            )
+        }
+    }
+    
+    // MARK: - Typed Send Methods (Socket)
+    public static func sendViaSocketTRequestTResponse<TReq: CustomOperationRequest, TRes: CustomOperationResponse>(
+        request: TReq,
+        onResponse: Action1<TRes>?,
+        overrideAuthToken: String? = nil,
+        overrideSecretKey: String? = nil,
+        customTags: GNHashtable? = nil,
+        responseType: TRes.Type
+    ) {
+        sendViaSocketTResponse(
+            requestType: request.getRequestType(),
+            role: request.getRole(),
+            request: request.build(),
+            onResponse: onResponse,
+            overrideAuthToken: overrideAuthToken,
+            overrideSecretKey: overrideSecretKey,
+            customTags: customTags,
+            responseType: responseType
+        )
+    }
+    
+    public static func sendViaSocketTRequestTResponseAsync<TReq: CustomOperationRequest, TRes: CustomOperationResponse>(
+        request: TReq,
+        overrideAuthToken: String? = nil,
+        overrideSecretKey: String? = nil,
+        customTags: GNHashtable? = nil,
+        responseType: TRes.Type
+    ) async -> TRes {
+        return await withCheckedContinuation { continuation in
+            sendViaSocketTRequestTResponse(
+                request: request,
+                onResponse: { response in
+                    continuation.resume(returning: response)
+                },
+                overrideAuthToken: overrideAuthToken,
+                overrideSecretKey: overrideSecretKey,
+                customTags: customTags,
+                responseType: responseType
+            )
+        }
+    }
+    
+    public static func sendViaSocketTResponse<TRes: CustomOperationResponse>(
+        requestType: RequestType,
+        role: RequestRole,
+        request: OperationRequest,
+        onResponse: Action1<TRes>?,
+        overrideAuthToken: String? = nil,
+        overrideSecretKey: String? = nil,
+        customTags: GNHashtable? = nil,
+        responseType: TRes.Type
+    ) {
+        sendViaSocket(
+            requestType: requestType,
+            role: role,
+            request: request,
+            onResponse: { response in
+                let customResponse = TRes()
+                customResponse.setupOperationResponse(operationResponse: response)
+                onResponse?(customResponse)
+            },
+            overrideAuthToken: overrideAuthToken,
+            overrideSecretKey: overrideSecretKey,
+            customTags: customTags
+        )
+    }
+    
+    public static func sendViaSocketTResponseAsync<TRes: CustomOperationResponse>(
+        requestType: RequestType,
+        role: RequestRole,
+        request: OperationRequest,
+        overrideAuthToken: String? = nil,
+        overrideSecretKey: String? = nil,
+        customTags: GNHashtable? = nil,
+        responseType: TRes.Type
+    ) async -> TRes {
+        return await withCheckedContinuation { continuation in
+            sendViaSocketTResponse(
+                requestType: requestType,
+                role: role,
+                request: request,
+                onResponse: { (response: TRes) in
+                    continuation.resume(returning: response)
+                },
+                overrideAuthToken: overrideAuthToken,
+                overrideSecretKey: overrideSecretKey,
+                customTags: customTags,
+                responseType: responseType
+            )
+        }
+    }
+    
+    // MARK: - Typed Send Methods (HTTP)
+    public static func sendViaHttpTRequestTResponse<TReq: CustomOperationRequest, TRes: CustomOperationResponse>(
+        request: TReq,
+        onResponse: Action1<TRes>?,
+        overrideAuthToken: String? = nil,
+        overrideSecretKey: String? = nil,
+        customTags: GNHashtable? = nil,
+        responseType: TRes.Type
+    ) {
+        sendViaHttpTResponse(
+            requestType: request.getRequestType(),
+            role: request.getRole(),
+            request: request.build(),
+            onResponse: onResponse,
+            overrideAuthToken: overrideAuthToken,
+            overrideSecretKey: overrideSecretKey,
+            customTags: customTags,
+            responseType: responseType
+        )
+    }
+    
+    public static func sendViaHttpTRequestTResponseAsync<TReq: CustomOperationRequest, TRes: CustomOperationResponse>(
+        request: TReq,
+        overrideAuthToken: String? = nil,
+        overrideSecretKey: String? = nil,
+        customTags: GNHashtable? = nil,
+        responseType: TRes.Type
+    ) async -> TRes {
+        return await withCheckedContinuation { continuation in
+            sendViaHttpTRequestTResponse(
+                request: request,
+                onResponse: { response in
+                    continuation.resume(returning: response)
+                },
+                overrideAuthToken: overrideAuthToken,
+                overrideSecretKey: overrideSecretKey,
+                customTags: customTags,
+                responseType: responseType
+            )
+        }
+    }
+    
+    public static func sendViaHttpTResponse<TRes: CustomOperationResponse>(
+        requestType: RequestType,
+        role: RequestRole,
+        request: OperationRequest,
+        onResponse: Action1<TRes>?,
+        overrideAuthToken: String? = nil,
+        overrideSecretKey: String? = nil,
+        customTags: GNHashtable? = nil,
+        responseType: TRes.Type
+    ) {
+        sendViaHttp(
+            requestType: requestType,
+            role: role,
+            request: request,
+            onResponse: { response in
+                let customResponse = TRes()
+                customResponse.setupOperationResponse(operationResponse: response)
+                onResponse?(customResponse)
+            },
+            overrideAuthToken: overrideAuthToken,
+            overrideSecretKey: overrideSecretKey,
+            customTags: customTags
+        )
+    }
+    
+    public static func sendViaHttpTResponseAsync<TRes: CustomOperationResponse>(
+        requestType: RequestType,
+        role: RequestRole,
+        request: OperationRequest,
+        overrideAuthToken: String? = nil,
+        overrideSecretKey: String? = nil,
+        customTags: GNHashtable? = nil,
+        responseType: TRes.Type
+    ) async -> TRes {
+        return await withCheckedContinuation { continuation in
+            sendViaHttpTResponse(
+                requestType: requestType,
+                role: role,
+                request: request,
+                onResponse: { (response: TRes) in
+                    continuation.resume(returning: response)
+                },
+                overrideAuthToken: overrideAuthToken,
+                overrideSecretKey: overrideSecretKey,
+                customTags: customTags,
+                responseType: responseType
+            )
+        }
+    }
+    
+    // MARK: - Utility Methods
+    public static func syncTs(onResponse: Action1<Int64>? = nil) {
+        _peer?.syncTs(onResponse: onResponse)
+    }
+    
+    public static func syncTsAsync() async -> Int64 {
+        return await withCheckedContinuation { continuation in
+            syncTs { response in
+                continuation.resume(returning: response)
+            }
+        }
+    }
+    
+    public static func getAuthInfo(authToken: String, onResponse: Action1<GetAuthInfoResponse>? = nil) {
+        _peer?.getAuthInfo(authToken: authToken, onResponse: onResponse)
+    }
+    
+    public static func getAuthInfoAsync(authToken: String) async -> GetAuthInfoResponse {
+        return await withCheckedContinuation { continuation in
+            getAuthInfo(authToken: authToken) { response in
+                continuation.resume(returning: response)
+            }
+        }
+    }
+    
+    public static func healthCheck(onResponse: Action1<HealthCheckResponse>? = nil) {
+        _peer?.healthCheck(onResponse: onResponse)
+    }
+    
+    public static func healthCheckAsync() async -> HealthCheckResponse {
+        return await withCheckedContinuation { continuation in
+            healthCheck { response in
+                continuation.resume(returning: response)
+            }
+        }
+    }
+    
+    public static func uploadFile(
+        fileId: String,
+        content: Data,
+        filename: String,
+        mimetype: String,
+        onResponse: Action1<UploadFileResponse>? = nil
+    ) {
+        _peer?.uploadFile(fileId: fileId, content: content, filename: filename, mimetype: mimetype, onResponse: onResponse)
+    }
+    
+    public static func uploadFileAsync(
+        fileId: String,
+        content: Data,
+        filename: String,
+        mimetype: String
+    ) async -> UploadFileResponse {
+        return await withCheckedContinuation { continuation in
+            uploadFile(fileId: fileId, content: content, filename: filename, mimetype: mimetype) { response in
+                continuation.resume(returning: response)
+            }
+        }
+    }
+    
+    public static func getDownloadFileUrl(downloadToken: String) -> String {
+        guard let settings = gnServerSettings else { return "" }
+        return "\(settings.getHttpUrl())/\(NetworkingPeer.DOWNLOAD_FILE)/\(downloadToken)"
+    }
+}