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

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

@@ -0,0 +1,176 @@
+import { GNArray } from "./../../common/GNData";
+import { GNNetwork } from "./../../GNNetwork";
+import { GNDebug } from "./../../logger/GNDebug";
+import { decode } from "@msgpack/msgpack";
+export class SocketPacket {
+    constructor(obj, encrypted) {
+        this.obj = obj;
+        this.encrypted = encrypted;
+    }
+}
+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, requestRole, operationRequest, authToken, secretKey, customTags, gameId) {
+        this.emit(requestType, requestRole, operationRequest, authToken, secretKey, customTags, gameId);
+    }
+    emit(requestType, requestRole, 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, isEncrypted) {
+        if (this._onEventHandler != null)
+            this._onEventHandler(obj, isEncrypted);
+    }
+    setOnResponseHandler(_onResponseHandler) {
+        this._onResponseHandler = _onResponseHandler;
+    }
+    onResponseHandler(obj, isEncrypted) {
+        if (this._onResponseHandler != null)
+            this._onResponseHandler(obj, isEncrypted);
+    }
+    static fromMsgList(objects) {
+        let answer = [];
+        for (let i = 0; i < objects.length; i++) {
+            let value = objects[i];
+            answer.push(value);
+        }
+        return answer;
+    }
+    static fromJsonList(objects) {
+        return objects;
+    }
+    service() {
+        if (this.responsePacketLst.length > 0) {
+            for (let i = 0; i < this.responsePacketLst.length; i++) {
+                let responsePacket = this.responsePacketLst[i];
+                if (responsePacket.encrypted) {
+                    try {
+                        let iList = decode(responsePacket.obj);
+                        let gnArray = GNArray.builder()
+                            .addAll(NetworkingSocketPeerBase.fromMsgList(iList))
+                            .build();
+                        this.onResponseHandler(gnArray, responsePacket.encrypted);
+                    }
+                    catch (ex) {
+                        GNDebug.logException(ex);
+                    }
+                }
+                else {
+                    try {
+                        let iList = responsePacket.obj;
+                        let gnArray = GNArray.builder()
+                            .addAll(NetworkingSocketPeerBase.fromJsonList(iList))
+                            .build();
+                        this.onResponseHandler(gnArray, responsePacket.encrypted);
+                    }
+                    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.encrypted) {
+                    try {
+                        let iList = decode(eventPacket.obj);
+                        let gnArray = GNArray.builder()
+                            .addAll(NetworkingSocketPeerBase.fromMsgList(iList))
+                            .build();
+                        this.onEventHandler(gnArray, eventPacket.encrypted);
+                    }
+                    catch (ex) {
+                        GNDebug.logException(ex);
+                    }
+                }
+                else {
+                    try {
+                        let iList = eventPacket.obj;
+                        let gnArray = GNArray.builder()
+                            .addAll(NetworkingSocketPeerBase.fromJsonList(iList))
+                            .build();
+                        this.onEventHandler(gnArray, eventPacket.encrypted);
+                    }
+                    catch (ex) {
+                        GNDebug.logException(ex);
+                    }
+                }
+            }
+            this.eventPacketLst.length = 0;
+        }
+    }
+}

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

@@ -0,0 +1,105 @@
+import { OperationEvent } from "./../../entity/OperationEvent";
+import { GNNetwork } from "./../../GNNetwork";
+import { GNDebug } from "./../../logger/GNDebug";
+import { IServerEventHandler } from "./../handler/IServerEventHandler";
+import { NetworkingPeerSocketIOClient } from "./NetworkingPeerSocketIOClient";
+import { PeerBase } from "./../PeerBase";
+export class SocketPeer extends PeerBase {
+    getClientId() {
+        return this.networkingSocketPeerBase.clientId;
+    }
+    isConnected() {
+        return this.networkingSocketPeerBase.isWsConnected;
+    }
+    sendRequestAuthSocket() {
+        this.networkingSocketPeerBase.sendRequestAuthSocket();
+    }
+    subscriberServerEventHandler() {
+        this.serverEventHandlersDict = {};
+        let serverEventHandlers = IServerEventHandler.getImplementations();
+        for (let i = 0; i < serverEventHandlers.length; i++) {
+            let serverEventHandler = new serverEventHandlers[i]();
+            if (serverEventHandler != null) {
+                let serverEventHandlers2 = this.serverEventHandlersDict[serverEventHandler.getEventCode()];
+                if (serverEventHandlers2 == null) {
+                    serverEventHandlers2 = [];
+                    this.serverEventHandlersDict[serverEventHandler.getEventCode()] = serverEventHandlers2;
+                }
+                serverEventHandlers2.push(serverEventHandler);
+            }
+        }
+    }
+    subscriberAServerEventHandler(serverEventHandler) {
+        let serverEventHandlers2 = this.serverEventHandlersDict[serverEventHandler.getEventCode()];
+        if (serverEventHandlers2 == null) {
+            serverEventHandlers2 = [];
+            this.serverEventHandlersDict[serverEventHandler.getEventCode()] = serverEventHandlers2;
+        }
+        serverEventHandlers2.push(serverEventHandler);
+    }
+    initGNSocketObject() {
+        let gnServerSettings = GNNetwork.getGNServerSettings();
+        if (gnServerSettings == null)
+            throw new Error("Where is GN Server Settings");
+        this.isUse = gnServerSettings.isUseSocket();
+        this.networkingSocketPeerBase = new NetworkingPeerSocketIOClient();
+        this.networkingSocketPeerBase.init(gnServerSettings.getSocketUrl(), gnServerSettings.getReconnectDelay(), gnServerSettings.getPingInterval(), gnServerSettings.getPingTimeout());
+        this.networkingSocketPeerBase.reInitNewSocket();
+        let thiz = this;
+        this.networkingSocketPeerBase.setOnEventHandler((t1, t2) => {
+            thiz.onEventHandler(t1, t2);
+        });
+        this.networkingSocketPeerBase.setOnResponseHandler((t1, t2) => {
+            thiz.onResponseHandler(t1, t2);
+        });
+        this.subscriberServerEventHandler();
+    }
+    setOnConnectHandler(_onConnectHandler) {
+        this.networkingSocketPeerBase.setOnConnectHandler(_onConnectHandler);
+    }
+    setOnDisconnectHandler(_onDisconnectHandler) {
+        this.networkingSocketPeerBase.setOnDisconnectHandler(_onDisconnectHandler);
+    }
+    removeOnConnectHandler(_onConnectHandler) {
+        this.networkingSocketPeerBase.removeOnConnectHandler(_onConnectHandler);
+    }
+    removeOnDisconnectHandler(_onDisconnectHandler) {
+        this.networkingSocketPeerBase.removeOnDisconnectHandler(_onDisconnectHandler);
+    }
+    connect(_onSocketConnect) {
+        this.networkingSocketPeerBase.connect(_onSocketConnect);
+    }
+    disconnect(_onSocketDisconnect) {
+        this.networkingSocketPeerBase.close(_onSocketDisconnect);
+    }
+    setOnEventHandler(_onEventHandler) {
+        this._onEventHandler = _onEventHandler;
+    }
+    send(operationPending) {
+        super.send(operationPending);
+        GNDebug.log("[GN Socket SEND] " + operationPending.getOperationRequest().toString());
+        let authToken = operationPending.getAuthToken();
+        let secretKey = operationPending.getSecretKey();
+        let gameId = operationPending.getGameId();
+        let customTags = operationPending.getCustomTags();
+        this.networkingSocketPeerBase.send(operationPending.getRequestType(), operationPending.getRequestRole(), operationPending.getOperationRequest(), authToken, secretKey, customTags, gameId);
+    }
+    onEventHandler(obj, isEncrypted) {
+        let eventCode = obj.getNumber(0);
+        let operationEvent = new OperationEvent(eventCode, obj.getGNHashtable(1));
+        operationEvent.setEncrypted(isEncrypted);
+        GNDebug.log("[GN Socket EVENT] " + operationEvent.toString());
+        if (this._onEventHandler != null)
+            this._onEventHandler(operationEvent);
+        let serverEventHandlers = this.serverEventHandlersDict[eventCode];
+        serverEventHandlers.forEach(serverEventHandler => {
+            if (serverEventHandler != null) {
+                serverEventHandler.handle(operationEvent);
+            }
+        });
+    }
+    service() {
+        super.service();
+        this.networkingSocketPeerBase.service();
+    }
+}

package/dist/runtime/typescript/ServiceUpdate.js

@@ -0,0 +1,12 @@
+export class ServiceUpdate {
+    run() {
+        let thiz = this;
+        setInterval(() => {
+            thiz.update();
+        }, 50);
+    }
+    update() {
+        if (this.peer != null)
+            this.peer.service();
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xmobitea/gn-typescript-client",
-  "version": "2.4.2",
+  "version": "2.4.3-esnext",
   "description": "",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",