@xmobitea/gn-typescript-client 2.1.7 → 2.3.0-esnext

package/dist/runtime/helper/ConverterService.js

@@ -0,0 +1,275 @@
+import { GNFieldDataType, getGNObjectMetadata } from "./../entity/DataMember";
+import { GNArray, GNData, GNHashtable } from "./../common/GNData";
+class DataMemberFieldInfoTypeMapper {
+    getGNEnhancedObjectFieldMetadata(cls) {
+        let declaredFields;
+        if (this.declaredFieldsMap.has(cls)) {
+            declaredFields = this.declaredFieldsMap.get(cls);
+        }
+        else {
+            let gnObjectMetadata = getGNObjectMetadata(cls);
+            declaredFields = gnObjectMetadata != null ? gnObjectMetadata.fields : [];
+            this.declaredFieldsMap.set(cls, declaredFields);
+        }
+        return declaredFields;
+    }
+    constructor() {
+        this.declaredFieldsMap = new Map();
+    }
+}
+class DeserializeConverter {
+    deserializeObject(gnHashtable, cls) {
+        if (gnHashtable == null)
+            return null;
+        let declaredFields = this.dataMemberFieldInfoMapper.getGNEnhancedObjectFieldMetadata(cls);
+        let answer = new cls();
+        declaredFields.forEach(declaredField => {
+            let value = gnHashtable.getObject(declaredField.code);
+            let typeOfValue = typeof value;
+            if (declaredField.gnFieldType == GNFieldDataType.String) {
+                if (value == null)
+                    answer[declaredField.name] = declaredField.defaultValue;
+                else if (typeOfValue == "string")
+                    answer[declaredField.name] = value;
+            }
+            else if (declaredField.gnFieldType == GNFieldDataType.Boolean) {
+                if (value == null)
+                    answer[declaredField.name] = declaredField.defaultValue;
+                else if (typeOfValue == "boolean")
+                    answer[declaredField.name] = value;
+            }
+            else if (declaredField.gnFieldType == GNFieldDataType.GNHashtable) {
+                if (value == null) {
+                    if (declaredField.defaultValue != null) {
+                        if (declaredField.cls == GNHashtable)
+                            answer[declaredField.name] = declaredField.defaultValue;
+                        else if (typeof declaredField.cls == "object")
+                            answer[declaredField.name] = declaredField.defaultValue.toData();
+                        else
+                            answer[declaredField.name] = this.deserializeObject(declaredField.defaultValue, declaredField.cls);
+                    }
+                }
+                else {
+                    if (declaredField.cls == GNHashtable)
+                        answer[declaredField.name] = value;
+                    else if (typeof declaredField.cls == "object")
+                        answer[declaredField.name] = value.toData();
+                    else
+                        answer[declaredField.name] = this.deserializeObject(value, declaredField.cls);
+                }
+            }
+            else if (declaredField.gnFieldType == GNFieldDataType.GNArray) {
+                if (value == null) {
+                    if (declaredField.defaultValue != null) {
+                        if (declaredField.cls == GNArray)
+                            answer[declaredField.name] = declaredField.defaultValue;
+                        else if (typeof declaredField.cls == "object")
+                            answer[declaredField.name] = declaredField.defaultValue.toData();
+                        else
+                            answer[declaredField.name] = this.deserializeArray(declaredField.defaultValue, declaredField.cls);
+                    }
+                }
+                else {
+                    if (declaredField.cls == GNArray)
+                        answer[declaredField.name] = value;
+                    else if (typeof declaredField.cls == "object")
+                        answer[declaredField.name] = value.toData();
+                    else
+                        answer[declaredField.name] = this.deserializeArray(value, declaredField.cls);
+                }
+            }
+            else if (declaredField.gnFieldType == GNFieldDataType.Number) {
+                if (value == null)
+                    answer[declaredField.name] = declaredField.defaultValue;
+                else if (typeOfValue == "number")
+                    answer[declaredField.name] = value;
+            }
+            else {
+                if (value == null) {
+                    if (declaredField.defaultValue != null) {
+                        if (declaredField.cls == Number)
+                            answer[declaredField.name] = declaredField.defaultValue;
+                        else if (declaredField.cls == String)
+                            answer[declaredField.name] = declaredField.defaultValue;
+                        else if (declaredField.cls == Boolean)
+                            answer[declaredField.name] = declaredField.defaultValue;
+                        else if (declaredField.cls == GNHashtable)
+                            answer[declaredField.name] = this.deserializeObject(declaredField.defaultValue, declaredField.cls);
+                        else if (declaredField.cls == GNArray)
+                            answer[declaredField.name] = this.deserializeArray(declaredField.defaultValue, declaredField.cls);
+                        else
+                            answer[declaredField.name] = declaredField.defaultValue;
+                    }
+                }
+                else {
+                    if (declaredField.cls == Number)
+                        answer[declaredField.name] = value;
+                    else if (declaredField.cls == String)
+                        answer[declaredField.name] = value;
+                    else if (declaredField.cls == Boolean)
+                        answer[declaredField.name] = value;
+                    else if (declaredField.cls == GNHashtable)
+                        answer[declaredField.name] = this.deserializeObject(value, declaredField.cls);
+                    else if (declaredField.cls == GNArray)
+                        answer[declaredField.name] = this.deserializeArray(value, declaredField.cls);
+                    else
+                        answer[declaredField.name] = value;
+                }
+            }
+        });
+        return answer;
+    }
+    deserializeArray(gnArray, cls) {
+        if (gnArray == null)
+            return null;
+        let answer = [];
+        for (let i = 0; i < gnArray.count(); i++) {
+            let value = gnArray.getObject(i);
+            if (value == null)
+                answer.push(null);
+            else {
+                let typeOfValue = typeof value;
+                if (typeOfValue == "number")
+                    answer.push(value);
+                else if (typeOfValue == "string")
+                    answer.push(value);
+                else if (typeOfValue == "boolean")
+                    answer.push(value);
+                else if (cls == GNArray)
+                    answer.push(value);
+                else if (cls == GNData)
+                    answer.push(value);
+                else if (typeOfValue == "object") {
+                    if (Array.isArray(value)) {
+                        answer.push(this.deserializeArray(gnArray.getGNArray(i), cls));
+                    }
+                    else {
+                        answer.push(this.deserializeObject(gnArray.getGNHashtable(i), cls));
+                    }
+                }
+            }
+        }
+        return answer;
+    }
+    constructor(dataMemberFieldInfoMapper) {
+        this.dataMemberFieldInfoMapper = dataMemberFieldInfoMapper;
+    }
+}
+class SerializeConverter {
+    serializeObject(obj, cls) {
+        if (obj == null)
+            return null;
+        let fieldInfos = this.dataMemberFieldInfoMapper.getGNEnhancedObjectFieldMetadata(cls);
+        let answer = new GNHashtable();
+        fieldInfos.forEach((field) => {
+            let dataMemberAnno = field;
+            let value = obj[dataMemberAnno.name];
+            if (value == null) {
+                if (!dataMemberAnno.isOptional)
+                    answer.add(dataMemberAnno.code, null);
+            }
+            else {
+                let typeOfValue = typeof value;
+                if (dataMemberAnno.gnFieldType == GNFieldDataType.String) {
+                    if (typeOfValue == "string")
+                        answer.add(dataMemberAnno.code, value);
+                }
+                else if (dataMemberAnno.gnFieldType == GNFieldDataType.Boolean) {
+                    if (typeOfValue == "boolean")
+                        answer.add(dataMemberAnno.code, value);
+                }
+                else if (dataMemberAnno.gnFieldType == GNFieldDataType.GNHashtable) {
+                    if (value instanceof GNHashtable)
+                        answer.add(dataMemberAnno.code, value);
+                    else if (typeOfValue === "object") {
+                        if (!Array.isArray(value))
+                            answer.add(dataMemberAnno.code, this.serializeObject(value, dataMemberAnno.cls));
+                    }
+                }
+                else if (dataMemberAnno.gnFieldType == GNFieldDataType.GNArray) {
+                    if (value instanceof GNArray)
+                        answer.add(dataMemberAnno.code, value);
+                    else if (typeOfValue === "object") {
+                        if (Array.isArray(value))
+                            answer.add(dataMemberAnno.code, this.serializeArray(value, dataMemberAnno.cls));
+                    }
+                }
+                else if (dataMemberAnno.gnFieldType == GNFieldDataType.Number) {
+                    if (typeOfValue == "number")
+                        answer.add(dataMemberAnno.code, value);
+                }
+                else {
+                    if (typeOfValue == "string")
+                        answer.add(dataMemberAnno.code, value);
+                    else if (typeOfValue == "boolean")
+                        answer.add(dataMemberAnno.code, value);
+                    else if (typeOfValue == "number")
+                        answer.add(dataMemberAnno.code, value);
+                    else if (value instanceof GNData)
+                        answer.add(dataMemberAnno.code, value);
+                    else if (typeOfValue == "object") {
+                        if (Array.isArray(value))
+                            answer.add(dataMemberAnno.code, this.serializeArray(value, dataMemberAnno.cls));
+                        else
+                            answer.add(dataMemberAnno.code, GNHashtable.builder().addAll(value).build());
+                    }
+                    else
+                        answer.add(dataMemberAnno.code, this.serializeObject(value, dataMemberAnno.cls));
+                }
+            }
+        });
+        return answer;
+    }
+    serializeArray(objLst, cls) {
+        if (objLst == null)
+            return null;
+        let answer = new GNArray();
+        for (let i = 0; i < objLst.length; i++) {
+            let obj = objLst[i];
+            if (obj == null)
+                answer.add(null);
+            else {
+                let typeOfValue = typeof obj;
+                if (typeOfValue === "string")
+                    answer.add(obj);
+                else if (typeOfValue === "boolean")
+                    answer.add(obj);
+                else if (typeOfValue === "number")
+                    answer.add(obj);
+                else if (obj instanceof GNData)
+                    answer.add(obj);
+                else {
+                    if (typeOfValue === "object") {
+                        if (Array.isArray(obj))
+                            answer.add(this.serializeArray(obj, cls));
+                        else
+                            answer.add(this.serializeObject(obj, cls));
+                    }
+                }
+            }
+        }
+        return answer;
+    }
+    constructor(dataMemberFieldInfoMapper) {
+        this.dataMemberFieldInfoMapper = dataMemberFieldInfoMapper;
+    }
+}
+export class ConverterService {
+    static deserializeObject(gnHashtable, cls) {
+        return ConverterService.deserializeConverter.deserializeObject(gnHashtable, cls);
+    }
+    static deserializeArray(gnArray, cls) {
+        return ConverterService.deserializeConverter.deserializeArray(gnArray, cls);
+    }
+    static serializeObject(obj, cls) {
+        return ConverterService.serializeConverter.serializeObject(obj, cls);
+    }
+    static serializeArray(objLst, cls) {
+        return ConverterService.serializeConverter.serializeArray(objLst, cls);
+    }
+    static init() {
+        let dataMemberFieldInfoMapper = new DataMemberFieldInfoTypeMapper();
+        ConverterService.serializeConverter = new SerializeConverter(dataMemberFieldInfoMapper);
+        ConverterService.deserializeConverter = new DeserializeConverter(dataMemberFieldInfoMapper);
+    }
+}

package/dist/runtime/helper/GNSupport.js

@@ -0,0 +1,8 @@
+export class GNSupport {
+    static init() {
+        this._isBrowser = (typeof window !== "undefined");
+    }
+    static isBrowser() {
+        return this._isBrowser;
+    }
+}

package/dist/runtime/logger/GNDebug.js

@@ -0,0 +1,29 @@
+export var LogType;
+(function (LogType) {
+    LogType[LogType["Off"] = 0] = "Off";
+    LogType[LogType["Exception"] = 1] = "Exception";
+    LogType[LogType["Error"] = 2] = "Error";
+    LogType[LogType["Warning"] = 3] = "Warning";
+    LogType[LogType["All"] = 4] = "All";
+})(LogType || (LogType = {}));
+export class GNDebug {
+    static setLogType(logType) {
+        this._logType = logType;
+    }
+    static log(message) {
+        if (this._logType >= LogType.All)
+            console.log(message);
+    }
+    static logException(exception) {
+        if (this._logType >= LogType.Exception)
+            console.error(exception);
+    }
+    static logWarning(message) {
+        if (this._logType >= LogType.Warning)
+            console.warn(message);
+    }
+    static logError(message) {
+        if (this._logType >= LogType.Error)
+            console.error(message);
+    }
+}

package/dist/runtime/networking/AuthenticateStatus.js

@@ -0,0 +1,14 @@
+export class AuthenticateStatus {
+    getAuthToken() {
+        return this.authToken;
+    }
+    setAuthToken(authToken) {
+        this.authToken = authToken;
+    }
+    getUserId() {
+        return this.userId;
+    }
+    setUserId(userId) {
+        this.userId = userId;
+    }
+}

package/dist/runtime/networking/IPeer.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/networking/NetworkingPeer.js

@@ -0,0 +1,129 @@
+import { Commands } from "./../constant/Commands";
+import { GNArray } from "./../common/GNData";
+import { ReturnCode } from "./../constant/ReturnCode";
+import { GNNetwork } from "./../GNNetwork";
+import { HttpPeer } from "./http/HttpPeer";
+import { SocketPeer } from "./socket/SocketPeer";
+import { AuthenticateStatus } from "./AuthenticateStatus";
+import { RequestRole } from "./../constant/enumType/RequestRole";
+export class NetworkingPeer {
+    getPing() {
+        let count = 0;
+        let totalPing = 0;
+        if (this.httpPeer.isUsing()) {
+            count++;
+            totalPing += this.httpPeer.ping;
+        }
+        if (this.socketPeer.isUsing()) {
+            count++;
+            totalPing += this.socketPeer.ping;
+        }
+        return totalPing / count;
+    }
+    getClientId() {
+        return this.socketPeer.getClientId();
+    }
+    setServerTimeMilliseconds(currentServerMilliseconds) {
+        this.lastCurrentServerMilliseconds = currentServerMilliseconds;
+        this.lastGetCurrentMilliseconds = Date.now() / 1000;
+    }
+    getServerTimestamp() {
+        return this.lastCurrentServerMilliseconds + ((Date.now() / 1000 - this.lastGetCurrentMilliseconds) * 1000);
+    }
+    initPeer() {
+        this.setServerTimeMilliseconds(new Date().getUTCMilliseconds());
+        let gnServerSettings = GNNetwork.getGNServerSettings();
+        if (gnServerSettings == null)
+            throw new Error("Null GN Server Settings, please find it now");
+        this.authenticateStatus = new AuthenticateStatus();
+        this.httpPeer = new HttpPeer();
+        this.httpPeer.initPeer();
+        this.socketPeer = new SocketPeer();
+        this.socketPeer.initPeer();
+    }
+    service() {
+        if (this.httpPeer != null)
+            this.httpPeer.service();
+        if (this.socketPeer != null)
+            this.socketPeer.service();
+    }
+    sendViaSocket(requestType, requestRole, request, onResponse = null, authToken = null, secretKey = null, customTags = null) {
+        if (authToken == null)
+            authToken = this.authenticateStatus.getAuthToken();
+        if (secretKey == null) {
+            if (requestRole == RequestRole.Admin)
+                secretKey = GNNetwork.getGNServerSettings().getAdminSecretKey();
+            else if (requestRole == RequestRole.Server)
+                secretKey = GNNetwork.getGNServerSettings().getServerSecretKey();
+            else if (requestRole == RequestRole.Client)
+                secretKey = GNNetwork.getGNServerSettings().getClientSecretKey();
+        }
+        this.socketPeer.enqueue(requestType, requestRole, request, onResponse, authToken, secretKey, customTags, this.gameId);
+    }
+    sendViaHttp(requestType, requestRole, request, onResponse = null, authToken = null, secretKey = null, customTags = null) {
+        if (authToken == null)
+            authToken = this.authenticateStatus.getAuthToken();
+        if (secretKey == null) {
+            if (requestRole == RequestRole.Admin)
+                secretKey = GNNetwork.getGNServerSettings().getAdminSecretKey();
+            else if (requestRole == RequestRole.Server)
+                secretKey = GNNetwork.getGNServerSettings().getServerSecretKey();
+            else if (requestRole == RequestRole.Client)
+                secretKey = GNNetwork.getGNServerSettings().getClientSecretKey();
+        }
+        this.httpPeer.enqueue(requestType, requestRole, request, onResponse, authToken, secretKey, customTags, this.gameId);
+    }
+    sendRequestAuthSocket() {
+        this.socketPeer.sendRequestAuthSocket();
+    }
+    connectSocket(_onSocketConnect) {
+        this.socketPeer.connect(_onSocketConnect);
+    }
+    disconnectSocket(_onSocketDisconnect) {
+        this.socketPeer.disconnect(_onSocketDisconnect);
+    }
+    setOnEventHandler(_onEventHandler) {
+        this.socketPeer.setOnEventHandler(_onEventHandler);
+    }
+    setOnConnectHandler(_onConnectHandler) {
+        this.socketPeer.setOnConnectHandler(_onConnectHandler);
+    }
+    setOnDisconnectHandler(_onDisconnectHandler) {
+        this.socketPeer.setOnDisconnectHandler(_onDisconnectHandler);
+    }
+    removeOnConnectHandler(_onConnectHandler) {
+        this.socketPeer.removeOnConnectHandler(_onConnectHandler);
+    }
+    removeOnDisconnectHandler(_onDisconnectHandler) {
+        this.socketPeer.removeOnDisconnectHandler(_onDisconnectHandler);
+    }
+    subscriberServerEventHandler(serverEventHandler) {
+        this.socketPeer.subscriberAServerEventHandler(serverEventHandler);
+    }
+    syncTs(onResponse = null) {
+        let thiz = this;
+        this.httpPeer.getRequest(NetworkingPeer.SYNC_TS, (httpAppResponse) => {
+            if (!httpAppResponse.hasError()) {
+                if (httpAppResponse.statusCode == 200) {
+                    let returnDatas = JSON.parse(httpAppResponse.text);
+                    let gnArray = GNArray.builder()
+                        .addAll(returnDatas)
+                        .build();
+                    let returnCode = gnArray.getNumber(0);
+                    if (returnCode == ReturnCode.Ok) {
+                        let gnHashtable = gnArray.getGNHashtable(1);
+                        let newServerTimestamp = gnHashtable.getNumber("1", new Date().getUTCMilliseconds());
+                        thiz.setServerTimeMilliseconds(newServerTimestamp);
+                    }
+                }
+            }
+            if (onResponse != null)
+                onResponse(thiz.getServerTimestamp());
+        });
+    }
+}
+NetworkingPeer.SYNC_TS = "ts";
+NetworkingPeer.UPLOAD_FILE = "upload";
+NetworkingPeer.DOWNLOAD_FILE = "download";
+NetworkingPeer.API_JSON = "api/" + Commands.RequestCmd_Json;
+NetworkingPeer.API_MSG_PACK = "api/" + Commands.RequestCmd_MsgPack;

package/dist/runtime/networking/OperationPending.js

@@ -0,0 +1,53 @@
+import { OperationRequest } from "./../entity/OperationRequest";
+export class OperationPending {
+    constructor(requestType, requestRole, operationRequest, onOperationResponse, authToken, secretKey, customTags, gameId) {
+        this.operationRequest = operationRequest;
+        this.onOperationResponse = onOperationResponse;
+        this.timeout = Date.now() / 1000 + OperationRequest.defaultTimeOut;
+        this.firstSend = 0;
+        this.secondsSend = 0;
+        this.requestType = requestType;
+        this.requestRole = requestRole;
+        this.authToken = authToken;
+        this.secretKey = secretKey;
+        this.gameId = gameId;
+        this.customTags = customTags;
+    }
+    getRequestType() {
+        return this.requestType;
+    }
+    getRequestRole() {
+        return this.requestRole;
+    }
+    getAuthToken() {
+        return this.authToken;
+    }
+    getSecretKey() {
+        return this.secretKey;
+    }
+    getGameId() {
+        return this.gameId;
+    }
+    getCustomTags() {
+        return this.customTags;
+    }
+    onSend() {
+        this.firstSend = Date.now() / 1000;
+        this.timeout = this.firstSend + this.operationRequest.getTimeout();
+    }
+    onRecv() {
+        this.secondsSend = Date.now() / 1000;
+    }
+    getExecuteTimerInMs() {
+        return (this.secondsSend - this.firstSend);
+    }
+    isTimeout() {
+        return this.timeout < Date.now() / 1000;
+    }
+    getOperationRequest() {
+        return this.operationRequest;
+    }
+    getCallback() {
+        return this.onOperationResponse;
+    }
+}

package/dist/runtime/networking/PeerBase.js

@@ -0,0 +1,168 @@
+import { GNArray } from "./../common/GNData";
+import { ParameterCode } from "./../constant/parameterCode/ParameterCode";
+import { ReturnCode } from "./../constant/ReturnCode";
+import { OperationResponse } from "./../entity/OperationResponse";
+import { GNNetwork } from "./../GNNetwork";
+import { GNDebug } from "./../logger/GNDebug";
+import { OperationPending } from "./OperationPending";
+import store from "store";
+export class PeerBase {
+    constructor() {
+        this.perMsgTimer = 0;
+        this.nextSendMsgTimer = 0;
+        this.checkTimeoutOperationPending = 0;
+    }
+    getSendRate() {
+        return (1000 / this.perMsgTimer);
+    }
+    setSendRate(sendRate) {
+        this.perMsgTimer = 1000 / sendRate / 1000;
+    }
+    initPeer() {
+        if (this.operationWaitingResponseDict == null)
+            this.operationWaitingResponseDict = new Map();
+        if (this.operationPendingQueue == null)
+            this.operationPendingQueue = [];
+        if (this.pingLst == null)
+            this.pingLst = [];
+        this.initSendRate();
+        this.initGNSocketObject();
+    }
+    initSendRate() {
+        let gnServerSettings = GNNetwork.getGNServerSettings();
+        if (gnServerSettings == null)
+            throw new Error("Null GN Server Settings, please find it now");
+        this.setSendRate(gnServerSettings.getSendRate());
+    }
+    enqueue(requestType, requestRole, operationRequest, onOperationResponse, authToken, secretKey, customTags, gameId) {
+        if (!this.isUsing) {
+            GNDebug.logError("[GN] Server Settings dont setup to use this to send operation request.");
+            return;
+        }
+        let operationPending = new OperationPending(requestType, requestRole, operationRequest, onOperationResponse, authToken, secretKey, customTags, gameId);
+        this.operationPendingQueue.push(operationPending);
+    }
+    isUsing() {
+        return this.isUse;
+    }
+    service() {
+        if (!this.isUsing)
+            return;
+        let nowSecond = Date.now() / 1000;
+        if (this.checkTimeoutOperationPending < nowSecond) {
+            this.checkTimeoutOperationPending = nowSecond + 0.1;
+            if (this.operationWaitingResponseDict.size != 0) {
+                let gnArrayLst = [];
+                this.operationWaitingResponseDict.forEach((operationPending, operationPendingKey) => {
+                    if (operationPending.isTimeout()) {
+                        let gnArray = new GNArray();
+                        gnArray.add(ReturnCode.OperationTimeout);
+                        gnArray.add(null);
+                        gnArray.add(operationPending.getOperationRequest().getRequestId());
+                        gnArray.add(operationPending.getOperationRequest().isEncrypted());
+                        gnArrayLst.push(gnArray);
+                    }
+                });
+                if (gnArrayLst.length != 0) {
+                    gnArrayLst.forEach(gnArray => {
+                        this.onResponseHandler(gnArray, gnArray.getBoolean(3));
+                    });
+                }
+            }
+        }
+        if (this.nextSendMsgTimer < nowSecond) {
+            if (this.operationPendingQueue.length != 0) {
+                this.nextSendMsgTimer = nowSecond + this.perMsgTimer;
+                let operationPending = this.operationPendingQueue.shift();
+                this.send(operationPending);
+            }
+        }
+    }
+    onResponseHandler(obj, isEncrypted) {
+        let responseId = obj.getNumber(2);
+        if (this.operationWaitingResponseDict.has(responseId)) {
+            let operationPending = this.operationWaitingResponseDict.get(responseId);
+            operationPending.onRecv();
+            this.operationWaitingResponseDict.delete(responseId);
+            let returnCode = obj.getNumber(0);
+            let parameters = null;
+            let debugMessage = null;
+            let array = null;
+            if (returnCode == ReturnCode.Ok)
+                parameters = obj.getGNHashtable(1);
+            else if (returnCode == ReturnCode.InvalidRequestParameters)
+                array = obj.getGNArray(1);
+            else if (returnCode == ReturnCode.OperationNotAuthorized) {
+            }
+            else
+                debugMessage = obj.getString(1);
+            let operationRequest = operationPending.getOperationRequest();
+            let operationResponse = new OperationResponse(operationRequest.getOperationCode(), operationRequest.getRequestId(), isEncrypted);
+            operationResponse.setReturnCode(returnCode);
+            operationResponse.setDebugMessage(debugMessage);
+            operationResponse.setParameters(parameters);
+            if (array != null) {
+                let invalidMembers = [];
+                for (let i = 0; i < array.count(); i++) {
+                    let arrChild = array.getGNArray(i);
+                    invalidMembers.push({
+                        code: arrChild.getString(0),
+                        invalidMemberType: arrChild.getNumber(1)
+                    });
+                }
+                operationResponse.setInvalidMembers(invalidMembers);
+            }
+            if (!operationResponse.hasError()) {
+                this.addPing(operationPending.getExecuteTimerInMs());
+                if (parameters != null) {
+                    if (parameters.containsKey(ParameterCode.AuthToken)) {
+                        let authToken = parameters.getString(ParameterCode.AuthToken);
+                        GNNetwork.getAuthenticateStatus().setAuthToken(authToken);
+                        store.set(GNNetwork.AUTH_TOKEN_KEY, authToken);
+                    }
+                    if (parameters.containsKey(ParameterCode.UserId)) {
+                        let userId = parameters.getString(ParameterCode.UserId);
+                        GNNetwork.getAuthenticateStatus().setUserId(userId);
+                        store.set(GNNetwork.USER_ID_KEY, userId);
+                    }
+                    if (parameters.containsKey(ParameterCode.Ts)) {
+                        GNNetwork.peer.setServerTimeMilliseconds(parameters.getNumber(ParameterCode.Ts, new Date().getUTCMilliseconds()));
+                    }
+                }
+            }
+            GNDebug.log("[GN RECV] " + operationResponse.toString());
+            let callback = operationPending.getCallback();
+            if (callback != null)
+                callback(operationResponse);
+        }
+        else {
+            GNDebug.logError("[GN] OnResponseHandler, unavailable request id " + obj);
+        }
+    }
+    send(operationPending) {
+        operationPending.onSend();
+        let operationRequest = operationPending.getOperationRequest();
+        if (operationRequest.getRequestId() != -1) {
+            operationRequest.setRequestId(PeerBase.requestId++);
+            if (operationPending.getCallback() != null) {
+                this.operationWaitingResponseDict.set(operationRequest.getRequestId(), operationPending);
+            }
+        }
+    }
+    addPing(value) {
+        if (this.pingLst.length > 10)
+            this.pingLst.shift();
+        this.pingLst.push(value / 2);
+        if (this.pingLst.length != 0) {
+            let total = 0;
+            for (let i = 0; i < this.pingLst.length; i++) {
+                total += this.pingLst[i];
+            }
+            let average = total / this.pingLst.length;
+            this.ping = (average * 1000);
+        }
+        else
+            this.ping = -1;
+    }
+}
+PeerBase.requestId = 0;