@xmobitea/gn-typescript-client 2.4.3 → 2.4.4-esnext

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

@@ -0,0 +1,13 @@
+export var IServerEventHandler;
+(function (IServerEventHandler) {
+    const implementations = [];
+    function getImplementations() {
+        return implementations;
+    }
+    IServerEventHandler.getImplementations = getImplementations;
+    function registerEvent(ctor) {
+        implementations.push(ctor);
+        return ctor;
+    }
+    IServerEventHandler.registerEvent = registerEvent;
+})(IServerEventHandler || (IServerEventHandler = {}));

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

@@ -0,0 +1,39 @@
+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 OnCharacterPlayerFriendUpdateEventHandler_1;
+import { EventCode } from "./../../constant/EventCode";
+import { GNParameterCode } from "./../../constant/parameterCode/GNParameterCode";
+import { GNArrayDataMember, StringDataMember } from "./../../entity/DataMember";
+import { GenericModels } from "./../../entity/models/GenericModels";
+import { ConverterService } from "./../../helper/ConverterService";
+import { IServerEventHandler } from "./IServerEventHandler";
+export class CharacterPlayerFriendUpdate {
+}
+__decorate([
+    StringDataMember({ code: GNParameterCode.CharacterId }),
+    __metadata("design:type", String)
+], CharacterPlayerFriendUpdate.prototype, "characterId", void 0);
+__decorate([
+    GNArrayDataMember({ code: GNParameterCode.PlayerFriends, elementCls: GenericModels.FriendItem }),
+    __metadata("design:type", Array)
+], CharacterPlayerFriendUpdate.prototype, "playerFriends", void 0);
+let OnCharacterPlayerFriendUpdateEventHandler = OnCharacterPlayerFriendUpdateEventHandler_1 = class OnCharacterPlayerFriendUpdateEventHandler {
+    getEventCode() {
+        return EventCode.OnCharacterPlayerFriendUpdate;
+    }
+    handle(operationEvent) {
+        if (OnCharacterPlayerFriendUpdateEventHandler_1.onUpdate != null)
+            OnCharacterPlayerFriendUpdateEventHandler_1.onUpdate(ConverterService.deserializeObject(operationEvent.getParameters(), CharacterPlayerFriendUpdate));
+    }
+};
+OnCharacterPlayerFriendUpdateEventHandler = OnCharacterPlayerFriendUpdateEventHandler_1 = __decorate([
+    IServerEventHandler.registerEvent
+], OnCharacterPlayerFriendUpdateEventHandler);
+export { OnCharacterPlayerFriendUpdateEventHandler };

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

@@ -0,0 +1,39 @@
+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 OnCharacterPlayerGroupUpdateEventHandler_1;
+import { EventCode } from "./../../constant/EventCode";
+import { GNParameterCode } from "./../../constant/parameterCode/GNParameterCode";
+import { GNArrayDataMember, StringDataMember } from "./../../entity/DataMember";
+import { GenericModels } from "./../../entity/models/GenericModels";
+import { ConverterService } from "./../../helper/ConverterService";
+import { IServerEventHandler } from "./IServerEventHandler";
+export class CharacterPlayerGroupUpdate {
+}
+__decorate([
+    StringDataMember({ code: GNParameterCode.CharacterId }),
+    __metadata("design:type", String)
+], CharacterPlayerGroupUpdate.prototype, "characterId", void 0);
+__decorate([
+    GNArrayDataMember({ code: GNParameterCode.PlayerGroups, elementCls: GenericModels.GroupItem }),
+    __metadata("design:type", Array)
+], CharacterPlayerGroupUpdate.prototype, "playerGroups", void 0);
+let OnCharacterPlayerGroupUpdateEventHandler = OnCharacterPlayerGroupUpdateEventHandler_1 = class OnCharacterPlayerGroupUpdateEventHandler {
+    getEventCode() {
+        return EventCode.OnCharacterPlayerGroupUpdate;
+    }
+    handle(operationEvent) {
+        if (OnCharacterPlayerGroupUpdateEventHandler_1.onUpdate != null)
+            OnCharacterPlayerGroupUpdateEventHandler_1.onUpdate(ConverterService.deserializeObject(operationEvent.getParameters(), CharacterPlayerGroupUpdate));
+    }
+};
+OnCharacterPlayerGroupUpdateEventHandler = OnCharacterPlayerGroupUpdateEventHandler_1 = __decorate([
+    IServerEventHandler.registerEvent
+], OnCharacterPlayerGroupUpdateEventHandler);
+export { OnCharacterPlayerGroupUpdateEventHandler };

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

@@ -0,0 +1,39 @@
+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 OnGamePlayerFriendUpdateEventHandler_1;
+import { EventCode } from "./../../constant/EventCode";
+import { GNParameterCode } from "./../../constant/parameterCode/GNParameterCode";
+import { GNArrayDataMember, StringDataMember } from "./../../entity/DataMember";
+import { GenericModels } from "./../../entity/models/GenericModels";
+import { ConverterService } from "./../../helper/ConverterService";
+import { IServerEventHandler } from "./IServerEventHandler";
+export class GamePlayerFriendUpdate {
+}
+__decorate([
+    StringDataMember({ code: GNParameterCode.CharacterId, isOptional: true }),
+    __metadata("design:type", String)
+], GamePlayerFriendUpdate.prototype, "characterId", void 0);
+__decorate([
+    GNArrayDataMember({ code: GNParameterCode.PlayerFriends, elementCls: GenericModels.FriendItem }),
+    __metadata("design:type", Array)
+], GamePlayerFriendUpdate.prototype, "playerFriends", void 0);
+let OnGamePlayerFriendUpdateEventHandler = OnGamePlayerFriendUpdateEventHandler_1 = class OnGamePlayerFriendUpdateEventHandler {
+    getEventCode() {
+        return EventCode.OnGamePlayerFriendUpdate;
+    }
+    handle(operationEvent) {
+        if (OnGamePlayerFriendUpdateEventHandler_1.onUpdate != null)
+            OnGamePlayerFriendUpdateEventHandler_1.onUpdate(ConverterService.deserializeObject(operationEvent.getParameters(), GamePlayerFriendUpdate));
+    }
+};
+OnGamePlayerFriendUpdateEventHandler = OnGamePlayerFriendUpdateEventHandler_1 = __decorate([
+    IServerEventHandler.registerEvent
+], OnGamePlayerFriendUpdateEventHandler);
+export { OnGamePlayerFriendUpdateEventHandler };

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

@@ -0,0 +1,39 @@
+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 OnGamePlayerGroupUpdateEventHandler_1;
+import { EventCode } from "./../../constant/EventCode";
+import { GNParameterCode } from "./../../constant/parameterCode/GNParameterCode";
+import { GNArrayDataMember, StringDataMember } from "./../../entity/DataMember";
+import { GenericModels } from "./../../entity/models/GenericModels";
+import { ConverterService } from "./../../helper/ConverterService";
+import { IServerEventHandler } from "./IServerEventHandler";
+export class GamePlayerGroupUpdate {
+}
+__decorate([
+    StringDataMember({ code: GNParameterCode.CharacterId, isOptional: true }),
+    __metadata("design:type", String)
+], GamePlayerGroupUpdate.prototype, "characterId", void 0);
+__decorate([
+    GNArrayDataMember({ code: GNParameterCode.PlayerGroups, elementCls: GenericModels.GroupItem }),
+    __metadata("design:type", Array)
+], GamePlayerGroupUpdate.prototype, "playerGroups", void 0);
+let OnGamePlayerGroupUpdateEventHandler = OnGamePlayerGroupUpdateEventHandler_1 = class OnGamePlayerGroupUpdateEventHandler {
+    getEventCode() {
+        return EventCode.OnGamePlayerGroupUpdate;
+    }
+    handle(operationEvent) {
+        if (OnGamePlayerGroupUpdateEventHandler_1.onUpdate != null)
+            OnGamePlayerGroupUpdateEventHandler_1.onUpdate(ConverterService.deserializeObject(operationEvent.getParameters(), GamePlayerGroupUpdate));
+    }
+};
+OnGamePlayerGroupUpdateEventHandler = OnGamePlayerGroupUpdateEventHandler_1 = __decorate([
+    IServerEventHandler.registerEvent
+], OnGamePlayerGroupUpdateEventHandler);
+export { OnGamePlayerGroupUpdateEventHandler };

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

@@ -0,0 +1,35 @@
+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 OnGroupMemberUpdateEventHandler_1;
+import { EventCode } from "./../../constant/EventCode";
+import { GNParameterCode } from "./../../constant/parameterCode/GNParameterCode";
+import { GNArrayDataMember } from "./../../entity/DataMember";
+import { GenericModels } from "./../../entity/models/GenericModels";
+import { ConverterService } from "./../../helper/ConverterService";
+import { IServerEventHandler } from "./IServerEventHandler";
+export class GroupMemberUpdate {
+}
+__decorate([
+    GNArrayDataMember({ code: GNParameterCode.Members, elementCls: GenericModels.FriendItem }),
+    __metadata("design:type", Array)
+], GroupMemberUpdate.prototype, "members", void 0);
+let OnGroupMemberUpdateEventHandler = OnGroupMemberUpdateEventHandler_1 = class OnGroupMemberUpdateEventHandler {
+    getEventCode() {
+        return EventCode.OnGroupMemberUpdate;
+    }
+    handle(operationEvent) {
+        if (OnGroupMemberUpdateEventHandler_1.onUpdate != null)
+            OnGroupMemberUpdateEventHandler_1.onUpdate(ConverterService.deserializeObject(operationEvent.getParameters(), GroupMemberUpdate));
+    }
+};
+OnGroupMemberUpdateEventHandler = OnGroupMemberUpdateEventHandler_1 = __decorate([
+    IServerEventHandler.registerEvent
+], OnGroupMemberUpdateEventHandler);
+export { OnGroupMemberUpdateEventHandler };

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

@@ -0,0 +1,35 @@
+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 { GNParameterCode } from "./../../constant/parameterCode/GNParameterCode";
+import { GNArrayDataMember } from "./../../entity/DataMember";
+import { GroupModels } from "./../../entity/models/GroupModels";
+import { ConverterService } from "./../../helper/ConverterService";
+import { IServerEventHandler } from "./IServerEventHandler";
+export class GroupMessageUpdate {
+}
+__decorate([
+    GNArrayDataMember({ code: GNParameterCode.GroupMessages, elementCls: GroupModels.GroupMessageResponseData }),
+    __metadata("design:type", Array)
+], GroupMessageUpdate.prototype, "groupMessages", 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,121 @@
+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 { NetworkingSocketPeerBase } from "./../socket/NetworkingSocketPeerBase";
+import { GNSupport } from "./../../helper/GNSupport";
+import { decode } from "@msgpack/msgpack";
+import { NetworkingPeerAxiosRequest } from "./NetworkingPeerAxiosRequest";
+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);
+    }
+    send(operationPending) {
+        super.send(operationPending);
+        GNDebug.log("[GN Http SEND] " + operationPending.getOperationRequest().toString());
+        let operationRequest = operationPending.getOperationRequest();
+        let authToken = operationPending.getAuthToken();
+        let secretKey = operationPending.getSecretKey();
+        let gameId = operationPending.getGameId();
+        let customTags = operationPending.getCustomTags();
+        if (GNSupport.isBrowser()) {
+            if (operationRequest.isEncrypted()) {
+                GNDebug.logWarning("GN JS client sdk does not support send encrypted request via HTTP, so we will send this request via HTTP non encrypted");
+                operationRequest.setEncrypted(false);
+            }
+        }
+        let postType = !operationRequest.isEncrypted() ? PostType.Json : PostType.MsgPack;
+        let subUri = (postType == PostType.Json ? NetworkingPeer.API_JSON : NetworkingPeer.API_MSG_PACK) + "/" + operationRequest.getOperationCode() + "/" + operationPending.getRequestType() + "/" + operationPending.getRequestRole();
+        let thiz = this;
+        this.networkingHttpPeerBase.postRequest(subUri, operationRequest.getParameters(), postType, (httpAppResponse) => {
+            thiz.onSendOperationRequestResponse(operationPending, httpAppResponse);
+        }, operationRequest.getTimeout(), authToken, secretKey, customTags, gameId);
+    }
+    onSendOperationRequestResponse(operationPending, httpAppResponse) {
+        let operationRequest = operationPending.getOperationRequest();
+        let obj = new GNArray();
+        if (!httpAppResponse.hasError()) {
+            if (httpAppResponse.statusCode == 200) {
+                let encrypted = false;
+                let gnArray = null;
+                if (httpAppResponse.text) {
+                    if (httpAppResponse.text[0] === HttpPeer.JSON_CHAR_KNOWN) {
+                        let returnDatas = JSON.parse(httpAppResponse.text);
+                        gnArray = GNArray.builder()
+                            .addAll(returnDatas)
+                            .build();
+                    }
+                }
+                if (gnArray == null) {
+                    if (httpAppResponse.data != null) {
+                        let iList = decode(httpAppResponse.data);
+                        gnArray = GNArray.builder()
+                            .addAll(NetworkingSocketPeerBase.fromMsgList(iList))
+                            .build();
+                        encrypted = true;
+                    }
+                }
+                if (gnArray != null) {
+                    let returnCode = gnArray.getNumber(0);
+                    obj.add(returnCode);
+                    if (returnCode == ReturnCode.Ok)
+                        obj.add(gnArray.getGNHashtable(1, new GNHashtable()));
+                    else if (returnCode == ReturnCode.InvalidRequestParameters)
+                        obj.add(gnArray.getGNArray(1, new GNArray()));
+                    else
+                        obj.add(gnArray.getString(1));
+                    obj.add(operationRequest.getRequestId());
+                    this.onResponseHandler(obj, encrypted);
+                    return;
+                }
+            }
+        }
+        obj.add(ReturnCode.UnknownError);
+        obj.add(httpAppResponse.error);
+        obj.add(operationRequest.getRequestId());
+        this.onResponseHandler(obj, operationRequest.isEncrypted());
+    }
+    getRequest(subUri, onHttpAppResponse, timeout = 15, authToken = null, secretKey = null, gameId = null) {
+        this.networkingHttpPeerBase.getRequest(subUri, onHttpAppResponse, timeout, authToken, secretKey, gameId);
+    }
+    uploadFile(fileId, content, mimetype, onHttpAppResponse, timeout = 60) {
+        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, mimetype, onHttpAppResponse, timeout);
+    }
+}
+HttpPeer.JSON_CHAR_KNOWN = "[";

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

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

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

@@ -0,0 +1,146 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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 { GNParameterCode } from "./../../constant/parameterCode/GNParameterCode";
+import { encode } from "@msgpack/msgpack";
+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, 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);
+    }
+    getRequestAxios(subUri, onHttpAppResponse, timeout, authToken, secretKey, gameId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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();
+            try {
+                let result = yield axios.get(this.httpUrl + "/" + subUri, {
+                    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);
+        });
+    }
+    postRequestAxios(subUri, param, postType, onHttpAppResponse, timeout, authToken, secretKey, customTags, gameId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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(GNParameterCode.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 = Buffer.from(encode(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();
+            try {
+                if (postType == PostType.Json) {
+                    let result = yield axios.post(this.httpUrl + "/" + subUri, 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 = yield axios.post(this.httpUrl + "/" + subUri, 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);
+        });
+    }
+    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,126 @@
+import { Commands } from "./../../constant/Commands";
+import { GNDebug } from "./../../logger/GNDebug";
+import { NetworkingSocketPeerBase, SocketPacket } from "./NetworkingSocketPeerBase";
+import { GNNetwork } from "./../../GNNetwork";
+import { OperationHelper } from "./../../entity/OperationHelper";
+import { Manager } from "socket.io-client";
+import { encode } from "@msgpack/msgpack";
+import { GNParameterCode } from "./../../constant/parameterCode/GNParameterCode";
+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) {
+            this.socketManager = new Manager(this.url + "/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.io.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, requestRole, operationRequest, authToken, secretKey, customTags, gameId) {
+        super.emit(requestType, requestRole, 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(GNParameterCode.CustomTags, customTags);
+        let dataSend = OperationHelper.toSocketData(requestType, requestRole, operationRequest);
+        if (operationRequest.isEncrypted())
+            socket.emit(Commands.RequestCmd_MsgPack, encode(dataSend));
+        else
+            socket.emit(Commands.RequestCmd_Json, 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();
+    }
+}