@xmobitea/gn-typescript-client 2.6.12 → 2.6.13-tsc

package/dist/runtime/networking/handler/OnGroupMessageUpdateEventHandler.js

@@ -0,0 +1,43 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var OnGroupMessageUpdateEventHandler_1;
+import { EventCode } from "./../../constant/EventCode";
+import { ParameterCode } from "./../../constant/parameterCode/ParameterCode";
+import { GNArrayDataMember, StringDataMember } from "./../../entity/DataMember";
+import { GroupModels } from "./../../entity/models/GroupModels";
+import { ConverterService } from "./../../helper/ConverterService";
+import { IServerEventHandler } from "./IServerEventHandler";
+export class GroupMessageUpdate {
+}
+__decorate([
+    GNArrayDataMember({ code: ParameterCode.GroupMessages, elementCls: GroupModels.GroupMessageResponseData }),
+    __metadata("design:type", Array)
+], GroupMessageUpdate.prototype, "groupMessages", void 0);
+__decorate([
+    StringDataMember({ code: ParameterCode.GroupId }),
+    __metadata("design:type", String)
+], GroupMessageUpdate.prototype, "groupId", void 0);
+__decorate([
+    StringDataMember({ code: ParameterCode.CharacterId, isOptional: true }),
+    __metadata("design:type", String)
+], GroupMessageUpdate.prototype, "characterId", void 0);
+let OnGroupMessageUpdateEventHandler = OnGroupMessageUpdateEventHandler_1 = class OnGroupMessageUpdateEventHandler {
+    getEventCode() {
+        return EventCode.OnGroupMessageUpdate;
+    }
+    handle(operationEvent) {
+        if (OnGroupMessageUpdateEventHandler_1.onUpdate != null)
+            OnGroupMessageUpdateEventHandler_1.onUpdate(ConverterService.deserializeObject(operationEvent.getParameters(), GroupMessageUpdate));
+    }
+};
+OnGroupMessageUpdateEventHandler = OnGroupMessageUpdateEventHandler_1 = __decorate([
+    IServerEventHandler.registerEvent
+], OnGroupMessageUpdateEventHandler);
+export { OnGroupMessageUpdateEventHandler };

package/dist/runtime/networking/http/HttpPeer.js

@@ -0,0 +1,123 @@
+import { GNArray, GNHashtable } from "./../../common/GNData";
+import { ReturnCode } from "./../../constant/ReturnCode";
+import { GNNetwork } from "./../../GNNetwork";
+import { GNDebug } from "./../../logger/GNDebug";
+import { NetworkingPeer } from "./../NetworkingPeer";
+import { PeerBase } from "./../PeerBase";
+import { GNSupport } from "./../../helper/GNSupport";
+import { NetworkingPeerAxiosRequest } from "./NetworkingPeerAxiosRequest";
+import { MessagePackConverterService } from "./../../helper/MessagePackConverterService";
+import { MessageType } from "./../../config/GNServerSettings";
+import { ParameterCode } from "./../../constant/parameterCode/ParameterCode";
+import { OperationRequest } from "./../../entity/OperationRequest";
+import { CodeHelper } from "./../../helper/CodeHelper";
+export class HttpAppResponse {
+    hasError() {
+        return this.error != null;
+    }
+    toString() {
+        let answer = " StatusCode: " + this.statusCode;
+        if (this.error)
+            answer += ", <color=red>Error: " + this.error + "</color>";
+        answer += ", Text: " + this.text;
+        return answer;
+    }
+}
+export var PostType;
+(function (PostType) {
+    PostType[PostType["Json"] = 0] = "Json";
+    PostType[PostType["MsgPack"] = 1] = "MsgPack";
+})(PostType || (PostType = {}));
+export class HttpPeer extends PeerBase {
+    initGNSocketObject() {
+        let gnServerSettings = GNNetwork.getGNServerSettings();
+        if (gnServerSettings == null)
+            throw new Error("Where is GN Server Settings");
+        this.isUse = gnServerSettings.isUseHttp();
+        this.networkingHttpPeerBase = new NetworkingPeerAxiosRequest();
+        let httpUrl = gnServerSettings.getHttpUrl();
+        let userAgent = "GN-ts-" + GNNetwork.getPlatform() + "@" + GNNetwork.getClientSdkVersion();
+        this.networkingHttpPeerBase.init(httpUrl, userAgent);
+        this.networkingHttpPeerBase.setUseReverseProxy(gnServerSettings.getUseReverseProxy());
+    }
+    send(operationPending) {
+        let gnServerSettings = GNNetwork.getGNServerSettings();
+        let operationRequest = operationPending.getOperationRequest();
+        if (operationRequest.getTimeout() == OperationRequest.defaultTimeOut)
+            operationRequest.setTimeout(gnServerSettings.getDefaultTimeoutInSeconds());
+        super.send(operationPending);
+        GNDebug.log("[GN Http SEND] " + operationRequest.toString());
+        let authToken = operationPending.getAuthToken();
+        let secretKey = operationPending.getSecretKey();
+        let gameId = operationPending.getGameId();
+        let customTags = operationPending.getCustomTags();
+        let postType = gnServerSettings.getMessageType() == MessageType.Json ? PostType.Json : PostType.MsgPack;
+        if (GNSupport.isBrowser() && postType == PostType.MsgPack) {
+            GNDebug.logWarning("GN JS client sdk does not support send msgpack request via HTTP, so we will send this request via HTTP json");
+            postType = PostType.Json;
+        }
+        let subUri = (postType == PostType.Json ? NetworkingPeer.API_JSON : NetworkingPeer.API_MSG_PACK) + "/" + CodeHelper.getRequestTypeName(operationPending.getRequestType()) + "/" + CodeHelper.getRequestRoleName(operationPending.getRole()) + "/" + operationRequest.getOperationCode();
+        let thiz = this;
+        this.networkingHttpPeerBase.postRequest(subUri, operationRequest.getParameters(), postType, (httpAppResponse) => {
+            thiz.onSendOperationRequestResponse(operationPending, httpAppResponse);
+        }, operationRequest.getTimeout(), authToken, secretKey, customTags, gameId);
+    }
+    onEnqueue(operationPending) {
+        GNDebug.log("[GN Http ENQUEUE] " + operationPending.getOperationRequest().toString());
+    }
+    onSendOperationRequestResponse(operationPending, httpAppResponse) {
+        let operationRequest = operationPending.getOperationRequest();
+        let obj = new GNHashtable();
+        if (!httpAppResponse.hasError()) {
+            if (httpAppResponse.statusCode == 200) {
+                let gnHashtable = null;
+                if (httpAppResponse.text) {
+                    if (httpAppResponse.text[0] === HttpPeer.JSON_CHAR_KNOWN) {
+                        let returnDatas = JSON.parse(httpAppResponse.text);
+                        gnHashtable = GNHashtable.builder()
+                            .addAll(returnDatas)
+                            .build();
+                    }
+                }
+                if (gnHashtable == null) {
+                    if (httpAppResponse.data != null) {
+                        let iDict = MessagePackConverterService.deserialize(httpAppResponse.data);
+                        gnHashtable = GNHashtable.builder()
+                            .addAll(iDict)
+                            .build();
+                    }
+                }
+                if (gnHashtable != null) {
+                    obj.add(ParameterCode.ReturnCode, gnHashtable.getNumber(ParameterCode.ReturnCode));
+                    obj.add(ParameterCode.Parameters, gnHashtable.getGNHashtable(ParameterCode.Parameters, new GNHashtable()));
+                    obj.add(ParameterCode.InvalidRequestParameters, gnHashtable.getGNArray(ParameterCode.InvalidRequestParameters, new GNArray()));
+                    obj.add(ParameterCode.DebugMessage, gnHashtable.getString(ParameterCode.DebugMessage));
+                    obj.add(ParameterCode.ResponseId, operationRequest.getRequestId());
+                    this.onResponseHandler(obj);
+                    return;
+                }
+            }
+        }
+        obj.add(ParameterCode.ReturnCode, ReturnCode.UnknownError);
+        obj.add(ParameterCode.DebugMessage, httpAppResponse.error);
+        obj.add(ParameterCode.ResponseId, operationRequest.getRequestId());
+        this.onResponseHandler(obj);
+    }
+    getRequest(subUri, onHttpAppResponse, timeout = OperationRequest.defaultTimeOut, authToken = null, secretKey = null, gameId = null) {
+        this.networkingHttpPeerBase.getRequest(subUri, onHttpAppResponse, timeout, authToken, secretKey, gameId);
+    }
+    uploadFile(fileId, content, filename, mimetype, onHttpAppResponse, timeout = 6000) {
+        let authToken = GNNetwork.getAuthenticateStatus().getAuthToken();
+        if (!authToken) {
+            let httpAppResponse = new HttpAppResponse();
+            httpAppResponse.statusCode = 401;
+            httpAppResponse.error = "Auth token null";
+            if (onHttpAppResponse != null)
+                onHttpAppResponse(httpAppResponse);
+            return;
+        }
+        let subUri = NetworkingPeer.UPLOAD_FILE + "/" + fileId;
+        this.networkingHttpPeerBase.postRequestUpload(subUri, content, filename, mimetype, onHttpAppResponse, timeout);
+    }
+}
+HttpPeer.JSON_CHAR_KNOWN = "{";

package/dist/runtime/networking/http/NetworkingHttpPeerBase.js

@@ -0,0 +1,9 @@
+export class NetworkingHttpPeerBase {
+    init(httpUrl, userAgent) {
+        this.httpUrl = httpUrl;
+        this.userAgent = userAgent;
+    }
+    setUseReverseProxy(useReverseProxy) {
+        this.useReverseProxy = useReverseProxy;
+    }
+}

package/dist/runtime/networking/http/NetworkingPeerAxiosRequest.js

@@ -0,0 +1,179 @@
+import axios from "axios";
+import { GNHashtable } from "./../../common/GNData";
+import { Commands } from "./../../constant/Commands";
+import { GNSupport } from "./../../helper/GNSupport";
+import { GNDebug } from "./../../logger/GNDebug";
+import { HttpAppResponse, PostType } from "./HttpPeer";
+import { NetworkingHttpPeerBase } from "./NetworkingHttpPeerBase";
+import { ParameterCode } from "./../../constant/parameterCode/ParameterCode";
+import { GNNetwork } from "./../../GNNetwork";
+import { MessagePackConverterService } from "./../../helper/MessagePackConverterService";
+export class NetworkingPeerAxiosRequest extends NetworkingHttpPeerBase {
+    getRequest(subUri, onHttpAppResponse, timeout, authToken, secretKey, gameId) {
+        this.getRequestAxios(subUri, onHttpAppResponse, timeout, authToken, secretKey, gameId);
+    }
+    postRequest(subUri, param, postType, onHttpAppResponse, timeout, authToken, secretKey, customTags, gameId) {
+        this.postRequestAxios(subUri, param, postType, onHttpAppResponse, timeout, authToken, secretKey, customTags, gameId);
+    }
+    postRequestUpload(subUri, content, filename, mimetype, onHttpAppResponse, timeout) {
+        //GNDebug.logWarning("GN JS client sdk does not support upload file yet.");
+        // let httpAppResponse = new HttpAppResponse();
+        // httpAppResponse.error = "Upload file does not support in GN JS client sdk.";
+        // httpAppResponse.statusCode = -1;
+        // httpAppResponse.text = "[-3]";
+        // if (onHttpAppResponse != null) onHttpAppResponse(httpAppResponse);
+        this.postRequestUploadAxios(subUri, content, filename, mimetype, onHttpAppResponse, timeout);
+    }
+    async getRequestAxios(subUri, onHttpAppResponse, timeout, authToken, secretKey, gameId) {
+        let headers = {};
+        if (authToken)
+            headers[Commands.RequestAuthTokenCmd] = authToken;
+        if (secretKey)
+            headers[Commands.RequestSecretCmd] = secretKey;
+        if (gameId)
+            headers[Commands.RequestGameIdCmd] = gameId;
+        if (!GNSupport.isBrowser())
+            headers[Commands.USER_AGENT] = this.userAgent;
+        let httpAppResponse = new HttpAppResponse();
+        let targetUrl = this.httpUrl + "/" + subUri;
+        if (this.useReverseProxy) {
+            targetUrl = "/" + subUri;
+            headers[Commands.BaseUrl] = this.httpUrl;
+        }
+        try {
+            let result = await axios.get(targetUrl, {
+                headers: headers,
+                timeout: timeout * 1000,
+                responseType: "arraybuffer",
+            });
+            httpAppResponse.statusCode = result.status;
+            let buffers = this.toBuffers(result.data);
+            httpAppResponse.data = buffers[0];
+            httpAppResponse.text = buffers[1];
+        }
+        catch (error) {
+            httpAppResponse.error = error.toString();
+            httpAppResponse.statusCode = -1;
+            httpAppResponse.text = "[-2]";
+            GNDebug.logError(error);
+        }
+        if (onHttpAppResponse != null)
+            onHttpAppResponse(httpAppResponse);
+    }
+    async postRequestAxios(subUri, param, postType, onHttpAppResponse, timeout, authToken, secretKey, customTags, gameId) {
+        let headers = {};
+        if (authToken)
+            headers[Commands.RequestAuthTokenCmd] = authToken;
+        if (secretKey)
+            headers[Commands.RequestSecretCmd] = secretKey;
+        if (gameId)
+            headers[Commands.RequestGameIdCmd] = gameId;
+        if (!GNSupport.isBrowser())
+            headers[Commands.USER_AGENT] = this.userAgent;
+        if (param == null)
+            param = new GNHashtable();
+        if (customTags != null)
+            param.add(ParameterCode.CustomTags, customTags);
+        let body = null;
+        if (postType == PostType.Json) {
+            let content = param.toData();
+            body = content;
+            if (!GNSupport.isBrowser()) {
+                headers[Commands.CONTENT_LENGTH] = JSON.stringify(body).length;
+                headers[Commands.CONTENT_TYPE] = Commands.APPLICATION_JSON;
+            }
+            headers[Commands.ACCEPT] = Commands.APPLICATION_JSON;
+        }
+        else if (postType == PostType.MsgPack) {
+            let content = param.toData();
+            body = new Uint8Array(MessagePackConverterService.serialize(content));
+            headers[Commands.CONTENT_TYPE] = Commands.APPLICATION_MSGPACK;
+            headers[Commands.ACCEPT] = Commands.APPLICATION_MSGPACK;
+            if (!GNSupport.isBrowser())
+                headers[Commands.CONTENT_LENGTH] = body.length;
+        }
+        let httpAppResponse = new HttpAppResponse();
+        let targetUrl = this.httpUrl + "/" + subUri;
+        if (this.useReverseProxy) {
+            targetUrl = "/" + subUri;
+            headers[Commands.BaseUrl] = this.httpUrl;
+        }
+        try {
+            if (postType == PostType.Json) {
+                let result = await axios.post(targetUrl, body, {
+                    headers: headers,
+                    timeout: timeout * 1000,
+                    responseType: "text",
+                });
+                httpAppResponse.statusCode = result.status;
+                // let buffers = this.toBuffers(result.data);
+                // httpAppResponse.data = buffers[0];
+                httpAppResponse.text = result.data;
+            }
+            else {
+                let result = await axios.post(targetUrl, body, {
+                    headers: headers,
+                    timeout: timeout * 1000,
+                    responseType: "arraybuffer",
+                });
+                httpAppResponse.statusCode = result.status;
+                let buffers = this.toBuffers(result.data);
+                httpAppResponse.data = buffers[0];
+                httpAppResponse.text = buffers[1];
+            }
+        }
+        catch (error) {
+            httpAppResponse.error = error.toString();
+            httpAppResponse.statusCode = -1;
+            httpAppResponse.text = "[-2]";
+            GNDebug.logError(error);
+        }
+        if (onHttpAppResponse != null)
+            onHttpAppResponse(httpAppResponse);
+    }
+    async postRequestUploadAxios(subUri, content, filename, mimetype, onHttpAppResponse, timeout) {
+        let formData = new FormData();
+        formData.append(Commands.File, new Blob([content.buffer.slice(0)], { type: mimetype }), filename);
+        let headers = {};
+        headers[Commands.RequestAuthTokenCmd] = GNNetwork.getAuthenticateStatus().getAuthToken();
+        ;
+        // if (!GNSupport.isBrowser()) {
+        //     headers[Commands.CONTENT_TYPE] = "multipart/form-data";
+        // }
+        let httpAppResponse = new HttpAppResponse();
+        let targetUrl = this.httpUrl + "/" + subUri;
+        if (this.useReverseProxy) {
+            targetUrl = "/" + subUri;
+            headers[Commands.BaseUrl] = this.httpUrl;
+        }
+        try {
+            let result = await axios.post(targetUrl, formData, {
+                headers: headers,
+                timeout: timeout * 1000,
+                responseType: "arraybuffer",
+            });
+            httpAppResponse.statusCode = result.status;
+            let buffers = this.toBuffers(result.data);
+            httpAppResponse.data = buffers[0];
+            httpAppResponse.text = buffers[1];
+        }
+        catch (error) {
+            httpAppResponse.error = error.toString();
+            httpAppResponse.statusCode = -1;
+            httpAppResponse.text = "[-2]";
+            GNDebug.logError(error);
+        }
+        if (onHttpAppResponse != null)
+            onHttpAppResponse(httpAppResponse);
+    }
+    uint8ArrayToString(uint8Array) {
+        return decodeURIComponent(escape(String.fromCharCode(...uint8Array)));
+    }
+    toBuffers(data) {
+        if (GNSupport.isBrowser()) {
+            data = new Uint8Array(data);
+            return [data, this.uint8ArrayToString(data)];
+        }
+        return [data, data.toString()];
+    }
+}

package/dist/runtime/networking/socket/NetworkingPeerSocketIOClient.js

@@ -0,0 +1,130 @@
+import { Commands } from "./../../constant/Commands";
+import { GNDebug } from "./../../logger/GNDebug";
+import { NetworkingSocketPeerBase, SocketPacket } from "./NetworkingSocketPeerBase";
+import { GNNetwork } from "./../../GNNetwork";
+import { OperationHelper } from "./../../helper/OperationHelper";
+import { Manager } from "socket.io-client";
+import { ParameterCode } from "./../../constant/parameterCode/ParameterCode";
+import { MessagePackConverterService } from "./../../helper/MessagePackConverterService";
+import { MessageType } from "./../../config/GNServerSettings";
+export class NetworkingPeerSocketIOClient extends NetworkingSocketPeerBase {
+    sendRequestAuthSocket() {
+        super.sendRequestAuthSocket();
+        if (this.clientId) {
+            this.socketManager.socket("/").emit(Commands.RequestAuthTokenCmd, GNNetwork.getAuthenticateStatus().getAuthToken());
+        }
+        ;
+    }
+    reInitNewSocket() {
+        super.reInitNewSocket();
+        if (this.socketManager == null) {
+            const url = new URL(this.url);
+            this.socketManager = new Manager(url.origin, {
+                path: url.pathname + "socket.io",
+                reconnection: true,
+                reconnectionDelay: this.reconnectDelay,
+                timeout: this.pingTimeout,
+                autoConnect: false,
+                transports: ["websocket"]
+            });
+            let socket = this.socketManager.socket("/");
+            socket.on("connect", () => {
+                this.onConnect();
+            });
+            socket.on("disconnect", () => {
+                this.onDisconnect();
+            });
+            socket.on("error", (error) => {
+                this.onError(error);
+            });
+            socket.on(Commands.ResponseCmd_MsgPack, (args) => {
+                this.onResponseMsgPack(args);
+            });
+            socket.on(Commands.EventCmd_MsgPack, (args) => {
+                this.onEventMsgPack(args);
+            });
+            socket.on(Commands.ResponseCmd_Json, (args) => {
+                this.onResponseJson(args);
+            });
+            socket.on(Commands.EventCmd_Json, (args) => {
+                this.onEventJson(args);
+            });
+            this.socket = socket;
+        }
+    }
+    onResponseMsgPack(...args) {
+        this.responsePacketLst.push(new SocketPacket(args[0], true));
+    }
+    onEventMsgPack(...args) {
+        this.eventPacketLst.push(new SocketPacket(args[0], true));
+    }
+    onResponseJson(...args) {
+        this.responsePacketLst.push(new SocketPacket(args[0], false));
+    }
+    onEventJson(...args) {
+        this.eventPacketLst.push(new SocketPacket(args[0], false));
+    }
+    onConnect() {
+        GNDebug.log("[GN Socket RECV] HandleOpen " + this.socket.id);
+        this.clientId = this.socket.id;
+        this.onConnectHandler();
+    }
+    onDisconnect() {
+        GNDebug.log("[GN Socket RECV] HandleClose ");
+        this.clientId = "";
+        this.onDisconnectHandler();
+    }
+    onError(error) {
+        GNDebug.logError(error);
+    }
+    init(url, reconnectDelay, pingInterval, pingTimeout) {
+        super.init(url, reconnectDelay, pingInterval, pingTimeout);
+    }
+    emit(requestType, role, operationRequest, authToken, secretKey, customTags, gameId) {
+        super.emit(requestType, role, operationRequest, authToken, secretKey, customTags, gameId);
+        if (this.socketManager == null) {
+            // callback here
+            return;
+        }
+        let socket = this.socketManager.socket("/");
+        if (socket == null) {
+            // callback here
+            return;
+        }
+        if (customTags != null)
+            operationRequest.setParameter(ParameterCode.CustomTags, customTags);
+        let dataSend = OperationHelper.toSocketData(requestType, role, operationRequest);
+        let gnServerSettings = GNNetwork.getGNServerSettings();
+        if (gnServerSettings.getMessageType() == MessageType.Json)
+            socket.emit(Commands.RequestCmd_Json, dataSend);
+        else
+            socket.emit(Commands.RequestCmd_MsgPack, MessagePackConverterService.serialize(dataSend));
+    }
+    close(_onSocketDisconnect) {
+        super.close(_onSocketDisconnect);
+        this.isConnected = false;
+        if (this.socketManager != null) {
+            if (this.socketManager._readyState != "closed") {
+                this.socketManager._close();
+                return;
+            }
+        }
+        if (this.socket != null)
+            this.socket.disconnect();
+        GNDebug.log("[GN Socket] Disconnecting via SocketIO client");
+        this.onDisconnectHandler();
+    }
+    connect(_onSocketConnect) {
+        super.connect(_onSocketConnect);
+        if (this.isConnected) {
+            GNDebug.log("[GN Socket] Reconnecting");
+            return;
+        }
+        this.isConnected = true;
+        GNDebug.log("[GN Socket] Connecting via SocketIO client");
+        if (this.socketManager != null)
+            this.socketManager.open();
+        if (this.socket != null)
+            this.socket.connect();
+    }
+}

package/dist/runtime/networking/socket/NetworkingSocketPeerBase.js

@@ -0,0 +1,165 @@
+import { MessagePackConverterService } from "./../../helper/MessagePackConverterService";
+import { GNHashtable } from "./../../common/GNData";
+import { GNNetwork } from "./../../GNNetwork";
+import { GNDebug } from "./../../logger/GNDebug";
+export class SocketPacket {
+    constructor(obj, isMsgPack) {
+        this.obj = obj;
+        this.isMsgPack = isMsgPack;
+    }
+}
+class Action0List {
+    subscriber(action) {
+        this.handlers.push(action);
+    }
+    unsubscriber(action) {
+        let indexOf = this.handlers.indexOf(action);
+        if (indexOf != -1)
+            this.handlers.splice(indexOf, 1);
+    }
+    invoke() {
+        this.handlers.forEach((a) => {
+            if (a != null)
+                a();
+        });
+    }
+    constructor() {
+        this.handlers = [];
+    }
+}
+export class NetworkingSocketPeerBase {
+    constructor() {
+        this.clientId = "";
+        this._onConnectHandler = new Action0List();
+        this._onDisconnectHandler = new Action0List();
+    }
+    init(url, reconnectDelay, pingInterval, pingTimeout) {
+        this.responsePacketLst = [];
+        this.eventPacketLst = [];
+        this.url = url;
+        this.reconnectDelay = reconnectDelay;
+        this.pingInterval = pingInterval;
+        this.pingTimeout = pingTimeout;
+    }
+    connect(_onSocketConnect) {
+        this._onSocketConnect = _onSocketConnect;
+    }
+    close(_onSocketDisconnect) {
+        this._onSocketDisconnect = _onSocketDisconnect;
+    }
+    sendRequestAuthSocket() {
+    }
+    send(requestType, role, operationRequest, authToken, secretKey, customTags, gameId) {
+        this.emit(requestType, role, operationRequest, authToken, secretKey, customTags, gameId);
+    }
+    emit(requestType, role, operationRequest, authToken, secretKey, customTags, gameId) {
+    }
+    reInitNewSocket() {
+    }
+    setOnConnectHandler(_onConnectHandler) {
+        this._onConnectHandler.subscriber(_onConnectHandler);
+    }
+    setOnDisconnectHandler(_onDisconnectHandler) {
+        this._onDisconnectHandler.subscriber(_onDisconnectHandler);
+    }
+    removeOnConnectHandler(_onConnectHandler) {
+        this._onConnectHandler.unsubscriber(_onConnectHandler);
+    }
+    removeOnDisconnectHandler(_onDisconnectHandler) {
+        this._onDisconnectHandler.unsubscriber(_onDisconnectHandler);
+    }
+    onConnectHandler() {
+        this._onConnectHandler.invoke();
+        let authToken = GNNetwork.getAuthenticateStatus().getAuthToken();
+        if (authToken != null) {
+            this.sendRequestAuthSocket();
+        }
+        if (this._onSocketConnect != null) {
+            this._onSocketConnect();
+            this._onSocketConnect = null;
+        }
+    }
+    onDisconnectHandler() {
+        this._onDisconnectHandler.invoke();
+        if (this._onSocketDisconnect != null) {
+            this._onSocketDisconnect();
+            this._onSocketDisconnect = null;
+        }
+    }
+    setOnEventHandler(_onEventHandler) {
+        this._onEventHandler = _onEventHandler;
+    }
+    onEventHandler(obj) {
+        if (this._onEventHandler != null)
+            this._onEventHandler(obj);
+    }
+    setOnResponseHandler(_onResponseHandler) {
+        this._onResponseHandler = _onResponseHandler;
+    }
+    onResponseHandler(obj) {
+        if (this._onResponseHandler != null)
+            this._onResponseHandler(obj);
+    }
+    service() {
+        if (this.responsePacketLst.length > 0) {
+            for (let i = 0; i < this.responsePacketLst.length; i++) {
+                let responsePacket = this.responsePacketLst[i];
+                if (responsePacket.isMsgPack) {
+                    try {
+                        let iDict = MessagePackConverterService.deserialize(responsePacket.obj);
+                        let gnHashtable = GNHashtable.builder()
+                            .addAll(iDict)
+                            .build();
+                        this.onResponseHandler(gnHashtable);
+                    }
+                    catch (ex) {
+                        GNDebug.logException(ex);
+                    }
+                }
+                else {
+                    try {
+                        let iDict = responsePacket.obj;
+                        let gnHashtable = GNHashtable.builder()
+                            .addAll(iDict)
+                            .build();
+                        this.onResponseHandler(gnHashtable);
+                    }
+                    catch (ex) {
+                        GNDebug.logException(ex);
+                    }
+                }
+            }
+            this.responsePacketLst.length = 0;
+        }
+        if (this.eventPacketLst.length > 0) {
+            for (let i = 0; i < this.eventPacketLst.length; i++) {
+                let eventPacket = this.eventPacketLst[i];
+                if (eventPacket.isMsgPack) {
+                    try {
+                        let iDict = MessagePackConverterService.deserialize(eventPacket.obj);
+                        let gnHashtable = GNHashtable.builder()
+                            .addAll(iDict)
+                            .build();
+                        this.onEventHandler(gnHashtable);
+                    }
+                    catch (ex) {
+                        GNDebug.logException(ex);
+                    }
+                }
+                else {
+                    try {
+                        let iDict = eventPacket.obj;
+                        let gnHashtable = GNHashtable.builder()
+                            .addAll(iDict)
+                            .build();
+                        this.onEventHandler(gnHashtable);
+                    }
+                    catch (ex) {
+                        GNDebug.logException(ex);
+                    }
+                }
+            }
+            this.eventPacketLst.length = 0;
+        }
+    }
+}