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

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

@@ -0,0 +1,115 @@
+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";
+import { ParameterCode } from "./../../constant/parameterCode/ParameterCode";
+import { OperationRequest } from "./../../entity/OperationRequest";
+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) => {
+            thiz.onEventHandler(t1);
+        });
+        this.networkingSocketPeerBase.setOnResponseHandler((t1) => {
+            thiz.onResponseHandler(t1);
+        });
+        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) {
+        let gnServerSettings = GNNetwork.getGNServerSettings();
+        let operationRequest = operationPending.getOperationRequest();
+        if (operationRequest.getTimeout() == OperationRequest.defaultTimeOut)
+            operationRequest.setTimeout(gnServerSettings.getDefaultTimeoutInSeconds());
+        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.getRole(), operationPending.getOperationRequest(), authToken, secretKey, customTags, gameId);
+    }
+    onEnqueue(operationPending) {
+        GNDebug.log("[GN Socket ENQUEUE] " + operationPending.getOperationRequest().toString());
+    }
+    onEventHandler(obj) {
+        let eventCode = obj.getString(ParameterCode.EventCode);
+        let operationEvent = new OperationEvent(eventCode, obj.getGNHashtable(ParameterCode.Parameters));
+        GNDebug.log("[GN Socket EVENT] " + operationEvent.toString());
+        if (this._onEventHandler != null)
+            this._onEventHandler(operationEvent);
+        let serverEventHandlers = this.serverEventHandlersDict[eventCode];
+        if (serverEventHandlers == null)
+            return;
+        serverEventHandlers.forEach(serverEventHandler => {
+            if (serverEventHandler != null) {
+                serverEventHandler.handle(operationEvent);
+            }
+        });
+    }
+    service() {
+        super.service();
+        this.networkingSocketPeerBase.service();
+    }
+}

package/dist/runtime/typescript/ServiceUpdate.d.ts

@@ -1,6 +1,8 @@
 import { NetworkingPeer } from "./../networking/NetworkingPeer";
 export declare class ServiceUpdate {
+    private intervalId;
     peer: NetworkingPeer;
     run(): void;
+    stop(): void;
     private update;
 }

package/dist/runtime/typescript/ServiceUpdate.js

@@ -0,0 +1,22 @@
+export class ServiceUpdate {
+    constructor() {
+        this.intervalId = null;
+    }
+    run() {
+        if (this.intervalId)
+            return;
+        this.intervalId = setInterval(() => {
+            this.update();
+        }, 50);
+    }
+    stop() {
+        if (!this.intervalId)
+            return;
+        clearInterval(this.intervalId);
+        this.intervalId = null;
+    }
+    update() {
+        if (this.peer != null)
+            this.peer.service();
+    }
+}

package/docs/COCOS_CREATOR_INTEGRATION.md

@@ -0,0 +1,116 @@
+# GearN SDK - Cocos Creator 3.x Integration Guide
+
+## Overview
+
+GearN TypeScript SDK hỗ trợ đầy đủ Cocos Creator 3.x thông qua npm package.
+
+## Installation
+
+### 1. Cài đặt qua npm
+
+Trong thư mục project Cocos Creator của bạn:
+
+```bash
+npm install @xmobitea/gn-typescript-client
+```
+
+### 2. TypeScript Configuration
+
+Đảm bảo `tsconfig.json` của Cocos Creator project có cài đặt tương thích:
+
+```json
+{
+  "compilerOptions": {
+    "esModuleInterop": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true
+  }
+}
+```
+
+## Basic Usage
+
+### Initialize SDK
+
+```typescript
+import { GNNetwork, GNServerSettings, LogType, MessageType } from '@xmobitea/gn-typescript-client';
+
+// Tạo server settings
+const settings = new GNServerSettings({
+    httpUrl: "http://your-server:8080",
+    socketUrl: "ws://your-server:8080",
+    secretKey: "your-secret-key",
+    useSocket: true,
+    useHttp: true,
+    logType: LogType.All,
+    sendRate: 30,
+    messageType: MessageType.MsgPack,
+});
+
+// Initialize
+GNNetwork.init(settings);
+```
+
+### Authentication
+
+```typescript
+// Login với Device ID
+const response = await GNNetwork.authenticate.loginDeviceIdAsync({
+    deviceId: "unique-device-id",
+    createAccount: true,
+});
+
+if (!response.hasError()) {
+    console.log("User ID:", GNNetwork.getAuthenticateStatus().getUserId());
+}
+```
+
+### Socket Connection
+
+```typescript
+// Subscribe events
+GNNetwork.subscriberOnConnectHandler(() => {
+    console.log("Connected!");
+    GNNetwork.sendRequestAuthSocket();
+});
+
+GNNetwork.subscriberOnDisconnectHandler(() => {
+    console.log("Disconnected!");
+});
+
+// Connect
+GNNetwork.connectSocket();
+```
+
+## Example Component
+
+Xem file mẫu hoàn chỉnh tại: [examples/cocos-creator/GearNExample.ts](../examples/cocos-creator/GearNExample.ts)
+
+## Platform Detection
+
+SDK tự động phát hiện Cocos Creator environment:
+
+```typescript
+import { GNSupport } from '@xmobitea/gn-typescript-client';
+
+if (GNSupport.isCocosCreator()) {
+    console.log("Running in Cocos Creator");
+}
+```
+
+## Storage
+
+SDK tự động sử dụng `cc.sys.localStorage` trong Cocos Creator để lưu auth token.
+
+## Troubleshooting
+
+### Module not found
+Đảm bảo đã chạy `npm install` trong project folder.
+
+### Build errors
+Kiểm tra `tsconfig.json` có `esModuleInterop: true`.
+
+## Support
+
+- GitHub Issues: https://github.com/XmobiTea-Family/GearN-typescript-client-sdk/issues
+- Homepage: https://gearn.net

package/examples/cocos-creator/GearNExample.ts.txt

@@ -0,0 +1,176 @@
+/**
+ * GearNExample.ts - Example Cocos Creator 3.x Component using GearN SDK
+ * 
+ * This component demonstrates how to integrate the GearN SDK
+ * with a Cocos Creator 3.x project.
+ * 
+ * Installation:
+ * 1. npm install @xmobitea/gn-typescript-client
+ * 2. Copy this file to your Cocos Creator project's scripts folder
+ * 3. Attach to a Node in your scene
+ */
+
+import { _decorator, Component, log, warn, error } from 'cc';
+
+// Import GearN SDK
+import {
+    GNNetwork,
+    GNServerSettings,
+    GNServerSettingsOptions,
+    LogType,
+    MessageType
+} from '@xmobitea/gn-typescript-client';
+
+const { ccclass, property } = _decorator;
+
+@ccclass('GearNExample')
+export class GearNExample extends Component {
+
+    @property({ tooltip: "GearN Server HTTP URL" })
+    httpUrl: string = "http://localhost:8080";
+
+    @property({ tooltip: "GearN Server Socket URL" })
+    socketUrl: string = "ws://localhost:8080";
+
+    @property({ tooltip: "Your Game/App Secret Key" })
+    secretKey: string = "";
+
+    @property({ tooltip: "Enable debug logging" })
+    enableDebugLog: boolean = true;
+
+    start() {
+        this.initializeGearN();
+    }
+
+    /**
+     * Initialize GearN SDK
+     */
+    private initializeGearN(): void {
+        try {
+            // Create server settings
+            const settings: GNServerSettingsOptions = {
+                httpUrl: this.httpUrl,
+                socketUrl: this.socketUrl,
+                secretKey: this.secretKey,
+                useSocket: true,
+                useHttp: true,
+                logType: this.enableDebugLog ? LogType.All : LogType.None,
+                sendRate: 30,
+                messageType: MessageType.MsgPack,
+                socketReconnectDelay: 1000,
+                socketPingInterval: 3000,
+                socketPingTimeout: 5000,
+                httpRequestTimeout: 10,
+            };
+
+            const gnServerSettings = new GNServerSettings(settings);
+
+            // Initialize GearN
+            GNNetwork.init(gnServerSettings);
+
+            log('[GearN] SDK initialized successfully!');
+            log('[GearN] Platform:', GNNetwork.getPlatform());
+
+            // Subscribe to connection events
+            this.setupConnectionHandlers();
+
+        } catch (err) {
+            error('[GearN] Failed to initialize SDK:', err);
+        }
+    }
+
+    /**
+     * Setup socket connection event handlers
+     */
+    private setupConnectionHandlers(): void {
+        GNNetwork.subscriberOnConnectHandler(() => {
+            log('[GearN] Socket connected! SID:', GNNetwork.getSocketSId());
+
+            // Authenticate after connection
+            this.onSocketConnected();
+        });
+
+        GNNetwork.subscriberOnDisconnectHandler(() => {
+            warn('[GearN] Socket disconnected!');
+        });
+    }
+
+    /**
+     * Called when socket is connected
+     */
+    private onSocketConnected(): void {
+        // Example: Send auth token if already logged in
+        const authStatus = GNNetwork.getAuthenticateStatus();
+        if (authStatus.getAuthToken()) {
+            GNNetwork.sendRequestAuthSocket();
+            log('[GearN] Auth token sent to socket');
+        }
+    }
+
+    /**
+     * Connect to socket server
+     */
+    public connectSocket(): void {
+        log('[GearN] Connecting to socket...');
+        GNNetwork.connectSocket(() => {
+            log('[GearN] Socket connection initiated');
+        });
+    }
+
+    /**
+     * Disconnect from socket server
+     */
+    public disconnectSocket(): void {
+        log('[GearN] Disconnecting from socket...');
+        GNNetwork.disconnectSocket(() => {
+            log('[GearN] Socket disconnected');
+        });
+    }
+
+    /**
+     * Example: Login with device ID
+     */
+    public async loginWithDeviceId(deviceId: string): Promise<void> {
+        try {
+            log('[GearN] Logging in with device ID:', deviceId);
+
+            const response = await GNNetwork.authenticate.loginDeviceIdAsync({
+                deviceId: deviceId,
+                createAccount: true,
+            });
+
+            if (response.hasError()) {
+                error('[GearN] Login failed:', response.getDebugMessage());
+                return;
+            }
+
+            log('[GearN] Login successful!');
+            log('[GearN] User ID:', GNNetwork.getAuthenticateStatus().getUserId());
+
+            // Connect socket after successful login
+            this.connectSocket();
+
+        } catch (err) {
+            error('[GearN] Login error:', err);
+        }
+    }
+
+    /**
+     * Example: Get server health status
+     */
+    public async checkServerHealth(): Promise<void> {
+        try {
+            const response = await GNNetwork.healthCheckAsync();
+            log('[GearN] Server health:', response);
+        } catch (err) {
+            error('[GearN] Health check failed:', err);
+        }
+    }
+
+    onDestroy() {
+        // Cleanup: disconnect socket when component is destroyed
+        if (GNNetwork.isSocketConnected()) {
+            GNNetwork.disconnectSocket();
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xmobitea/gn-typescript-client",
-  "version": "2.6.12",
+  "version": "2.6.13-tsc",
   "description": "GearN Typescript Client SDK by XmobiTea (Pro)",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",
@@ -12,7 +12,8 @@
     "build:udm": "webpack --config webpack.config.udm.mjs --mode production --stats-modules",
     "build:minudm": "webpack --config webpack.config.min.udm.mjs --mode production --stats-modules",
     "build": "rm -rf ./dist && npm run build:node && npm run build:udm && npm run build:minudm",
-    "build:withoutwebpack": "rm -rf ./dist && tsc",
+    "build:tsc": "rm -rf ./dist && tsc",
+    "build:cocos": "rm -rf ./dist && webpack --config webpack.config.cocos.mjs --mode production --stats-modules",
     "push": "npm run build && npm publish && git push"
   },
   "author": "changx.develop@gmail.com (https://xmobitea.com)",
@@ -62,4 +63,4 @@
   "engines": {
     "node": ">=20.0.0"
   }
-}
+}

package/srcSwift/Package.swift

@@ -0,0 +1,32 @@
+// swift-tools-version: 5.7
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "GearN",
+    products: [
+        // Products define the executables and libraries a package produces, making them visible to other packages.
+        .library(
+            name: "GearN",
+            targets: ["GearN"]),
+    ],
+    dependencies: [
+        // Dependencies declare other packages that this package depends on.
+        .package(url: "https://github.com/socketio/socket.io-client-swift", from: "16.1.1"),
+    ],
+    targets: [
+        // Targets are the basic building blocks of a package, defining a module or a test suite.
+        // Targets can depend on other targets in this package and products from dependencies.
+        .target(
+            name: "GearN",
+            dependencies: [
+                .product(name: "SocketIO", package: "socket.io-client-swift")
+            ],
+            path: "Sources/GearN"),
+        .testTarget(
+            name: "GearNTests",
+            dependencies: ["GearN"],
+            path: "Tests/GearNTests"),
+    ]
+)