pogCocos/assets/resources/scripts/net/PogWebsocket.ts

export interface PogWebsocketListener {
  OnMessage(data: any): void;
}

export class PogWebsocket {
  clearReconnectTimes() {
    this._reconnectTimes = 0;
  }
  public static create(url: string, message: PogWebsocketListener) {
    let pogWebsocket = new PogWebsocket();
    pogWebsocket.init(url, message);
    return pogWebsocket;
  }

  public get connected(): boolean {
    return this._connected;
  }

  ping() {
    if (!this._connected) {
      return;
    }
    let pingData = "ping";
    this._ws.send(pingData);
  }

  //   private _url: string;
  private _ws: WebSocket;

  private _connected: boolean = false;

  private _message: PogWebsocketListener;
  private _url: string;
  private init(url: string, message: PogWebsocketListener) {
    this._url = url;
    this._message = message;

    this._ws = new WebSocket(url);

    this._ws.onopen = null;
    this._ws.onmessage = null;
    this._ws.onclose = null;
    this._ws.onerror = null;

    this._ws.onopen = this.onOpen.bind(this);
    this._ws.onmessage = this.onMessage.bind(this);
    this._ws.onclose = this.onClose.bind(this);
    this._ws.onerror = this.onError.bind(this);
  }

  private onOpen() {
    console.log("onOpen");
    this._connected = true;
    this._reconnectTimes = 0;
    // this._ws.send(
    //   JSON.stringify({
    //     type: "test",
    //     data: "test",
    //   })
    // );
  }

  private onMessage(data: MessageEvent) {
    if (data.data == "pong") {
      return;
    }
    this._message.OnMessage(data);
  }

  private _reconnectTimes: number = 0;

  private onClose(event: CloseEvent) {
    console.log("onClose", event);
    this._connected = false;

    this.reconnect();
  }
  reconnect() {
    this._reconnectTimes++;
    if (this._reconnectTimes >= 3) {
      return;
    }

    console.warn("reconnect", this._reconnectTimes);

    // if (this._ws.readyState == WebSocket.CONNECTING) {
    //   return;
    // }

    let self = this;

    setTimeout(() => {
      self.init(self._url, self._message);
    }, 2000 * self._reconnectTimes);
  }

  private onError(event: Event) {
    console.log("onError", event);
    this._connected = false;
    this._reconnectTimes = 0;
    this.reconnect();
  }

  public async send(data: any) {
    if (!this._connected) {
      return;
    }
    await this._ws.send(data);
  }

  public close() {
    this._ws.close();
  }
}