subject-two/entry/src/main/ets/common/utils/TcpRequest.ts

import socket from '@ohos.net.socket';
import util from '@ohos.util';


interface RequestKey {
  time: string
}

interface RequestCallback {
  url: string
  type: number
  resolve: Function
  reject: Function
  timeout: number
}

interface RequestParams {
  method: string
  data: object
  type: 0 | 1
  contentType: string
  timeout: number
}

interface Response {
  serialNumber: string
  data: string
  isForwordHttp: string
}

let tag = "tcp request"

class TcpUtils {
  private static instance: TcpUtils
  private socket: socket.TCPSocket = socket.constructTCPSocketInstance()
  private requestMap: Map<string, RequestCallback> = new Map<string, RequestCallback>()
  private tick: number
  private heartbeat: number
  private cache: string = ''
  private fileUtil = new FileUtil(AppStorage.get('context'))
  private path = ""

  constructor() {
    if (!TcpUtils.instance) {
      TcpUtils.instance = this
    }
    return TcpUtils.instance
  }

  async init() {
    this.path = await this.fileUtil.initFolder('/config/tcpRequest')
    this.socket.on("message", (res) => {
      let decoder = util.TextDecoder.create()
      let message = decoder.decodeWithStream(new Uint8Array(res.message))
      console.log(tag, "on message", message)
      this.cache += message
      let start = this.cache.indexOf("^#")
      let end = this.cache.indexOf("#$")
      try {
        if (start !== -1 && end !== -1) {
          let message = this.cache.slice(start + 2, end)
          this.cache = this.cache.slice(end + 2)
          let tempIndex = message.indexOf("^#")
          while (tempIndex > -1) {
            message = message.slice(tempIndex + 2)
            tempIndex = message.indexOf("^#")
          }
          let result: Response = JSON.parse(message)
          let key = result.serialNumber
          let data = result.data
          let isSuccess = result.isForwordHttp === "1"
          console.log(tag, "complete message")
          let item = this.requestMap.get(key)
          console.log(tag, "============", item?.url)
          if (this.requestMap.get(key)?.type === 0) {
            console.log(tag, "resolve message")
            if (isSuccess) {
              item?.resolve(JSON.parse(data))
            } else {
              item?.reject({
                code: -1,
                message: data || "request failed"
              })
            }
          } else {
            console.log(tag, "resolve message")
            if (isSuccess) {
              item?.resolve(data)
            } else {
              item?.reject({
                code: -1,
                message: data || "request failed"
              })
            }
          }
          this.requestMap.delete(key)
        }
      } catch (e) {
        console.log(tag, "解析相应失败", JSON.stringify(e))
      }
    })

    this.loop()
    return this.socket.connect({
      address: { address: "172.37.55.191", port: 19998 }
    }).then(() => {
      this.heartbeat = setInterval(() => {
        this.send("heart", JSON.stringify({
          isHeartBeat: 1
        }), false)
      }, 1000 * 6)
      console.log(tag, "connect success")
    }).catch(err => {
      console.log(tag, JSON.stringify(err))
    })
  }

  request(url: string, option: RequestParams, resolve, reject) {
    let key = new Date().getTime()
    this.requestMap.set(key + "", {
      url,
      resolve,
      reject,
      timeout: option.timeout,
      type: option.type,
    })

    let message = {
      url,
      serialNumber: key,
      type: option.type,
      method: option.method,
      data: option.data,
      contentType: option.contentType,
      isHeartBeat: "0",
    }

    this.send(key + "", JSON.stringify(message))
  }

  destroy() {
    clearInterval(this.tick)
    clearInterval(this.heartbeat)
  }

  private loop() {
    this.tick = setInterval(() => {
      let now = new Date().getTime()
      this.requestMap.forEach((value, key) => {
        if (now - Number(key) >= value.timeout) {
          console.log("tcp request timeout url: ", value.url)
          console.log("tcp request timeout key: ", key)
          value.reject({
            message: "tcp request timeout",
            code: 2300028
          })
          this.requestMap.delete(key)
        }
      })
    }, 100)
  }

  private async send(key: string, message: string, log: boolean = true) {
    if (log) {
      console.log(tag, 'send', message)
    }
    this.fileUtil.addFile(this.path + 'temp.txt', `^#${message}#$`)
    this.socket.send({
      data: `^#${message}#$`
    }).then(() => {
      if (log) {
        console.log(tag, 'send success')
      }
    }).catch(async err => {
      if (key !== "heart") {
        console.log("tcp request send failed", this.requestMap.get(key).url)
        this.requestMap.get(key).reject({
          message: "tcp request send failed",
          code: 2300007
        })
      }
      await this.socket.close()
      this.socket = socket.constructTCPSocketInstance()
      await this.socket.connect({
        address: { address: "172.37.55.191", port: 19998 }
      }).then(res => {
        console.log("tcp request reconnect success", JSON.stringify(res))
      }).catch(err => {
        console.log("tcp request reconnect failed", JSON.stringify(err))
      })
      console.log(tag, JSON.stringify(err))
    })
  }
}

export const tcpUtil = new TcpUtils()