@kkarum/framework 2.3.17

package/render.meta

@@ -0,0 +1,13 @@
+{
+  "ver": "1.1.3",
+  "uuid": "d49ee3cc-a25e-4c14-8a04-5f22d03b8164",
+  "importer": "folder",
+  "isBundle": false,
+  "bundleName": "",
+  "priority": 1,
+  "compressionType": {},
+  "optimizeHotUpdate": {},
+  "inlineSpriteFrames": {},
+  "isRemoteBundle": {},
+  "subMetas": {}
+}

package/scene/FWScene.ts

@@ -0,0 +1,23 @@
+const { ccclass, property } = cc._decorator;
+
+@ccclass
+export abstract class FWScene extends cc.Component {
+  readonly entry: FW.Entry = FW.Entry;
+
+  @FWSocketAutoProcessResume()
+  onLoad(): void {
+    this.entry.scene = this;
+  }
+
+  update(dt: number): void {
+    this.entry?.update?.(dt);
+  }
+
+  onDestroy(): void {
+    this.entry?.evtMgr.targetOff(this);
+    this.entry?.timeMgr.unSchedule(this);
+    this.entry?.uiMgr.unRegisterTarget(this);
+    this?.unscheduleAllCallbacks?.();
+    this?.node?.stopAllActions?.();
+  }
+}

package/scene/FWScene.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "9d78ed88-e34f-455b-9d0f-73978b74107a",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/scene.meta

@@ -0,0 +1,13 @@
+{
+  "ver": "1.1.3",
+  "uuid": "f8d1e84d-5adb-468b-9dcf-c84901b90bce",
+  "importer": "folder",
+  "isBundle": false,
+  "bundleName": "",
+  "priority": 1,
+  "compressionType": {},
+  "optimizeHotUpdate": {},
+  "inlineSpriteFrames": {},
+  "isRemoteBundle": {},
+  "subMetas": {}
+}

package/service/FWService.ts

@@ -0,0 +1,11 @@
+import { FrameworkBase } from '../FrameworkBase';
+
+export abstract class FWService extends FrameworkBase {
+  public abstract initialize();
+  public abstract onDestroy(): void;
+
+  protected onRestart() {
+    this.onDestroy();
+    this.initialize();
+  }
+}

package/service/FWService.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "02e35f42-98e4-45c5-8139-e90f226d3782",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/service/http/FWHttp.ts

@@ -0,0 +1,103 @@
+import { FWSystemConfig } from "../../config/FWSystemConfig";
+
+export class FWHttp extends FW.Service {
+  public initialize() {}
+  public onDestroy(): void {}
+  protected onRestart(): void {}
+
+  protected async getMessage(
+    url: string,
+    params?: string,
+    cb?: (response: string) => void,
+    tag?: string,
+  ): Promise<string> {
+    return this.process(
+      url,
+      params,
+      cb,
+      tag,
+      FW.SystemDefine.FWHttpRequestType.GET,
+    );
+  }
+
+  protected async postMessage(
+    url: string,
+    params?: string,
+    cb?: (response: string) => void,
+    tag?: string,
+  ): Promise<string> {
+    return this.process(
+      url,
+      params,
+      cb,
+      tag,
+      FW.SystemDefine.FWHttpRequestType.POST,
+    );
+  }
+
+  private async process(
+    url: string,
+    params: string,
+    cb: (response: any) => void,
+    tag: string,
+    type: FW.SystemDefine.FWHttpRequestType,
+  ): Promise<string> {
+    let xhr: XMLHttpRequest;
+
+    const promiseProxy: FW.PromiseProxy<string> =
+      FW.Entry.promiseMgr.execute<string>(
+        (resolve, reject, signal, reason) => {
+          xhr = new XMLHttpRequest();
+
+          xhr.onreadystatechange = () => {
+            if (xhr.readyState !== 4) return;
+
+            if (xhr.status >= 200 && xhr.status < 300) {
+              cb?.(xhr.response);
+              resolve(xhr.response);
+              return;
+            }
+
+            const errMsg = `http request failed, status: ${xhr.status}, url: ${url}`;
+            FW.Log.warn(errMsg);
+            reject(errMsg);
+          };
+
+          xhr.onerror = (err: any) => {
+            FW.Log.error("http request error:", err);
+            this.onError?.(err);
+            reject(`http request error:${err}`);
+          };
+
+          xhr.ontimeout = () => {
+            this.onTimeout?.();
+            reject(`http request timeout!`);
+          };
+
+          xhr.open(type as string, url, true);
+          xhr.send(params);
+        },
+        {
+          ...FWSystemConfig.PromiseConfig.http,
+          retryCondition(error, retryCount) {
+            return (
+              !!error &&
+              retryCount < (FWSystemConfig.PromiseConfig.http.retryCount || 0)
+            );
+          },
+        },
+      );
+
+    promiseProxy.addAbortEventListener(() => {
+      xhr.abort();
+    });
+
+    return await this.invoke(
+      promiseProxy.promise,
+      tag ? `http request ->${tag}` : "",
+    );
+  }
+
+  onError?(err: any);
+  onTimeout?();
+}

package/service/http/FWHttp.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "f0ad42b9-3784-4643-9175-bffd9d96570a",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/service/http.meta

@@ -0,0 +1,13 @@
+{
+  "ver": "1.1.3",
+  "uuid": "8af24859-b6c3-4ead-8cf8-386570d860a8",
+  "importer": "folder",
+  "isBundle": false,
+  "bundleName": "",
+  "priority": 1,
+  "compressionType": {},
+  "optimizeHotUpdate": {},
+  "inlineSpriteFrames": {},
+  "isRemoteBundle": {},
+  "subMetas": {}
+}

package/service/socket/FWSocket.ts

@@ -0,0 +1,367 @@
+import { FWSystemConfig } from '../../config/FWSystemConfig';
+
+/**
+ * TODO 犹豫socket没有改版暂时已老的cmd字符串映射方式做,后期优化
+ */
+export default class FWSocket extends FW.Service implements FW.Socket {
+  /** 发送心跳时间抽 */
+  private sendHeartTimestamp: number;
+  /** 接收心跳时间戳 */
+  private receiveTimeStamp: number;
+  /** socket */
+  socket: WebSocket = null;
+  /** 消息发送者 */
+  protected socketSender: FW.Sender;
+  /** 消息处理者 */
+  protected socketHandle: FW.Handle;
+  /** 重连次数 */
+  protected reconnectTimes: number;
+  /** 心跳间隔时间 */
+  protected heartInternal: number;
+  /** 心跳超时时间 */
+  protected heartTimeout: number;
+  /** 心跳弱网时间 */
+  protected heartWeakTime: number;
+  /** 最大重连次数 */
+  protected maxReconnectTimes: number;
+  /** 重连间隔 */
+  protected reconnectInternal: number;
+  /** 地址 */
+  protected address: string;
+  /** 标签 */
+  protected tag: string;
+  /** 是否暂停消息处理 */
+  protected isPausedMessageHandle: boolean = false;
+  /** 代理 */
+  private promiseProxy: FW.SocketPromiseProxy;
+  /** 协议符号 */
+  private protocolSymbol: FW.Symbol;
+  /** 协议轮询时间 */
+  private protocolPollingTime: number;
+  /** 协议注册表 */
+  private protocolRegistry: Map<string, Set<Symbol>>;
+  /** 协议符号容器 */
+  private protocolContainer: Map<Symbol, FW.ProtocolPolling>;
+  /** 证书 */
+  private certificate: cc.Asset;
+  /** 是否强制关闭 */
+  private forceClose: boolean;
+
+  /**
+   *  消息事件列表
+   * TODO 目前没有消息协议号,暂时无用
+   */
+  protected messageEvents: { [key: string]: (msg: any) => void };
+
+  public initialize(): void {
+    this.messageEvents = cc.js.createMap();
+    this.protocolContainer = new Map<Symbol, FW.ProtocolPolling>();
+    this.protocolRegistry = new Map<string, Set<Symbol>>();
+    this.reconnectTimes = 0;
+  }
+
+  createSocket(
+    address: string,
+    tag: string,
+    socketSender: FW.Sender,
+    socketHandle: FW.Handle,
+    config: FW.SocketConfig,
+  ): FW.SocketPromiseProxy {
+    try {
+      FW.Entry.timeMgr.unSchedule(this);
+
+      this.tag = tag;
+      this.address = address;
+      this.forceClose = false;
+      this.clear();
+
+      this.messageEvents = {};
+      this.sendHeartTimestamp = 0;
+      this.receiveTimeStamp = new Date().getTime();
+
+      if (cc.sys.isBrowser) {
+        this.socket = new WebSocket(address);
+      } else {
+        if (config.certificate) {
+          this.certificate = config.certificate;
+
+          let url = config.certificate.nativeUrl;
+          if (cc.assetManager.cacheManager) {
+            url =
+              cc.assetManager.cacheManager.getCache(url) ||
+              cc.assetManager.cacheManager.getTemp(url) ||
+              url;
+          }
+
+          //@ts-ignore
+          this.socket = new WebSocket(address, [], url);
+        } else {
+          this.socket = new WebSocket(address);
+        }
+      }
+      this.socket.onopen = this.onSocketOpen.bind(this);
+      this.socket.onclose = this.onSocketClose.bind(this);
+      this.socket.onerror = this.onSocketError.bind(this);
+      this.socket.onmessage = this.onSocketMessage.bind(this);
+
+      this.socketSender = socketSender;
+      this.socketHandle = socketHandle;
+
+      const defaultConfig = FWSystemConfig.SocketDefaultConfig;
+      this.heartInternal = config?.heartInternal || defaultConfig.heartInternal;
+      this.heartTimeout = config?.heartTimeout || defaultConfig.heartTimeout;
+      this.heartWeakTime = config?.heartWeakTime || defaultConfig.heartWeakTime;
+      this.maxReconnectTimes = config?.maxReconnectTimes || defaultConfig.maxReconnectTimes;
+      this.reconnectInternal = config?.reconnectInternal || defaultConfig.reconnectInternal;
+      this.protocolSymbol = config?.protocolSymbol || defaultConfig.protocolSymbol;
+      this.protocolPollingTime = config?.protocolPollingTime || defaultConfig.protocolPollingTime;
+
+      this.promiseProxy = {
+        promise: undefined,
+        resolve: undefined,
+        socket: this,
+      };
+
+      this.promiseProxy.promise = new Promise<FW.Socket>((resolve) => {
+        this.promiseProxy.resolve = resolve;
+      });
+
+      return this.promiseProxy;
+    } catch (e) {
+      FW.Log.error('创建socket失败:', e);
+    }
+  }
+  /**
+   * 注册消息事件
+   * @param msgId
+   * @param cb
+   */
+  registerMessage(msgId: string, cb: (msg: any) => void) {
+    this.messageEvents[msgId] = cb;
+  }
+
+  public onDestroy(): void {
+    this.messageEvents = cc.js.createMap();
+    this.close();
+  }
+
+  public getTag() {
+    return this.tag;
+  }
+
+  /**
+   * 获取地址
+   * @returns
+   */
+  public getAddress() {
+    return this.address;
+  }
+
+  /**
+   * 获取socket状态
+   * @returns
+   */
+  public getReadyState() {
+    return this.socket?.readyState;
+  }
+  /**
+   * 关闭连接
+   */
+  public close() {
+    this.clear();
+    this.forceClose = true;
+    this.onSocketClose();
+    this.socket?.close();
+    this.socket = null;
+    FW.Entry.timeMgr.unSchedule(this);
+  }
+
+  public pauseMessageHandle() {
+    this.isPausedMessageHandle = true;
+  }
+
+  public resumeMessageHandle() {
+    this.isPausedMessageHandle = false;
+  }
+
+  public get isReconnect() {
+    return this.getReadyState() === WebSocket.CONNECTING;
+  }
+
+  public clear() {
+    this.protocolContainer.clear();
+    this.protocolRegistry.clear();
+  }
+
+  reconnect(force?: boolean) {
+    if (force) this.reconnectTimes = 0;
+
+    FW.Log.debug(
+      `socket reconnect : reconnectTimes->${this.reconnectTimes},maxReconnectTimes->${this.maxReconnectTimes}`,
+    );
+    if (++this.reconnectTimes >= this.maxReconnectTimes) {
+      this.socketHandle?.onTimeout?.();
+      return;
+    }
+    this.clear();
+
+    this.socket?.close();
+    this.socket = null;
+
+    this.createSocket(this.address, this.tag, this.socketSender, this.socketHandle, {
+      heartInternal: this.heartInternal,
+      heartTimeout: this.heartTimeout,
+      heartWeakTime: this.heartWeakTime,
+      maxReconnectTimes: this.maxReconnectTimes,
+      reconnectInternal: this.reconnectInternal,
+      protocolSymbol: this.protocolSymbol,
+      protocolPollingTime: this.protocolPollingTime,
+      certificate: this.certificate,
+    });
+  }
+
+  async send(msg: string) {
+    if (this.getReadyState() != WebSocket.OPEN) return;
+    if (this.isPausedMessageHandle) return;
+    if (!(await this.socketSender.onHeart?.(msg))) {
+      const protocolKey = this.socketSender.getProtocolKey?.(msg);
+      if (protocolKey) {
+        const symbol = Symbol(protocolKey);
+        const registry = this.protocolRegistry.get(protocolKey) || new Set<Symbol>();
+        const protocolPolling: FW.ProtocolPolling = {
+          msg: msg,
+          schedule: FW.Entry.timeMgr.schedule(
+            () => {
+              this.sendMessage(msg);
+            },
+            this.protocolPollingTime / 1000,
+            cc.macro.REPEAT_FOREVER,
+            this,
+          ),
+        };
+        this.protocolRegistry.set(protocolKey, registry.add(symbol));
+        this.protocolContainer.set(symbol, protocolPolling);
+      }
+    }
+    this.sendMessage(msg);
+  }
+
+  /** 连接打开 */
+  private onSocketOpen() {
+    FW.Log.debug('on open!');
+    FW.Entry.timeMgr.unSchedule(this);
+    this.reconnectTimes = 0;
+    this.sendHeartTimestamp = 0;
+    this.receiveTimeStamp = new Date().getTime();
+    this.socketHandle?.onOpen?.();
+    this.heartHandle();
+    this.promiseProxy?.resolve(this);
+  }
+
+  private heartHandle() {
+    FW.Entry?.timeMgr?.schedule(
+      () => {
+        const interval = this.sendHeartTimestamp - this.receiveTimeStamp;
+        if (interval >= this.heartWeakTime) {
+          this.socketHandle.onWeakNetWork?.();
+          if (interval >= this.heartTimeout) {
+            this.reconnect();
+            return;
+          }
+        }
+        this.sendHeart();
+      },
+      this.heartInternal / 1000,
+      cc.macro.REPEAT_FOREVER,
+      this,
+    );
+  }
+
+  private sendHeart() {
+    this.sendHeartTimestamp = new Date().getTime();
+    this.socketSender?.sendHeart?.();
+  }
+
+  private sendMessage(msg: any) {
+    try {
+      this.socket?.send(this.socketSender.onBeforeSendingMessage?.(msg) || msg);
+    } catch (e) {
+      this.socket?.send(msg);
+    }
+  }
+
+  /** socket关闭 */
+  private onSocketClose() {
+    FW.Log.debug('on close!');
+    this.socketHandle?.onClose?.();
+
+    if (this.socket) {
+      this.socket.onclose = null;
+      this.socket.onerror = null;
+      this.socket.onmessage = null;
+      this.socket.onopen = null;
+    }
+
+    FW.Entry.timeMgr.scheduleOnce(
+      () => {
+        if (
+          !this.forceClose &&
+          (this.getReadyState() == WebSocket.CLOSING || this.getReadyState() == WebSocket.CLOSED)
+        ) {
+          FW.Log.debug('on close!');
+          this.reconnect();
+        }
+      },
+      this.reconnectInternal / 1000,
+      this,
+    );
+  }
+
+  /** 消息处理 */
+  private async onSocketMessage(originalMsg: any) {
+    const msg = await this.socketHandle.onBeforeReceivingMessage(originalMsg);
+
+    if (!msg || msg?.error) {
+      this.onSocketError(msg);
+      return;
+    }
+
+    if (await this.socketHandle?.onHeart?.(msg)) {
+      this.receiveTimeStamp = new Date().getTime();
+      return;
+    }
+
+    this.remoteProtocol(msg);
+
+    if (this.isPausedMessageHandle) return;
+
+    this.socketHandle?.onMessage?.(msg);
+  }
+  /** 错误处理 */
+  private async onSocketError(msg: any) {
+    await this.remoteProtocol(msg);
+    this.socketHandle?.onError?.(msg);
+  }
+
+  private async remoteProtocol(msg: any) {
+    const protocolKey = await this.socketHandle.getProtocolKey?.(msg);
+    if (protocolKey && this.protocolRegistry.has(protocolKey)) {
+      const symbolSet = this.protocolRegistry.get(protocolKey);
+
+      if (symbolSet && symbolSet.size > 0) {
+        const [symbol] = symbolSet;
+        const protocolPolling = this.protocolContainer.get(symbol);
+
+        symbolSet.delete(symbol);
+
+        protocolPolling.schedule.unSchedule();
+
+        this.protocolContainer.delete(symbol);
+
+        if (symbolSet.size === 0) {
+          this.protocolRegistry.delete(protocolKey);
+        }
+      }
+    }
+  }
+}

package/service/socket/FWSocket.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "6bff4169-033b-4745-842d-fdb124b9ac6c",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/service/socket/FWSocketHandle.ts

@@ -0,0 +1,16 @@
+import { injectable } from 'inversify';
+import { FrameworkBase } from '../../FrameworkBase';
+@injectable()
+export abstract class FWSocketHandle extends FrameworkBase {
+  initialize?();
+  onDestroy?();
+  onWeakNetWork?(): void;
+  abstract onMessage(msg: any): void;
+  abstract onHeart?(msg: any): Promise<boolean>;
+  abstract onClose?(): void;
+  abstract onOpen?(): void;
+  abstract onError?(msg: any): void;
+  abstract onTimeout?(): void;
+  abstract getProtocolKey?(msg: any): string;
+  abstract onBeforeReceivingMessage?(msg: any): Promise<FW.SocketMessage>;
+}

package/service/socket/FWSocketHandle.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "2e34eee4-ca3e-4ffd-9ff5-3fab23ea4f76",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/service/socket/FWSocketSender.ts

@@ -0,0 +1,14 @@
+import { injectable } from 'inversify';
+import { FrameworkBase } from '../../FrameworkBase';
+@injectable()
+export abstract class FWSocketSender extends FrameworkBase {
+  initialize?();
+  onDestroy?();
+  sendHeart?();
+  onHeart?(msg: any): Promise<boolean>;
+  abstract onBeforeSendingMessage?(msg: any): Promise<FW.SocketMessage>;
+  abstract getProtocolKey?(msg: any): string;
+  send(msg: any) {
+    FW.Entry.socketMgr.getSocket()?.send(msg);
+  }
+}

package/service/socket/FWSocketSender.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "5ef12e31-ee4f-443b-9de1-9075ecdde103",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}