zgty-mas-m/nx/helper/print.js

import { getConfigReportTemplateByKey, getBusinessSubSample } from '@/nx/api/report'
export default {
  //打印机Map对象
  printMap: new Map(),
  //检测连接
  checkConnect(printer) {
    printer.intervalID = setInterval(() => {
      let iv = new Date().getTime() - printer.lastReceiveMessageTime //多久没接收到消息
      if (iv > 30000) {
        //如果超过30秒未接收到服务器消息，则关闭连接
        console.log('已经' + iv + 'ms没接收到消息了，服务器估计没在了！')
        clearInterval(printer.intervalID)
        printer.socketTask.close()
      }
    }, 20000)
  },
  //开始心跳
  heartbeatStart(printer) {
    printer.timeoutID = setTimeout(() => {
      let heartbeatData = {
        cmd: 'heartbeat',
        data: 'ping'
      }
      console.log(printer.printServerIp + ': 发送心跳。。。')
      printer.socketTask.send({
        data: JSON.stringify(heartbeatData)
      })
    }, 10000)
  },
  //清理心跳
  heartbeatClear(printer) {
    clearTimeout(printer.timeoutID)
  },
  //重置心跳
  heartbeatReset(printer) {
    this.heartbeatClear(printer)
    this.heartbeatStart(printer)
  },
  //打开连接
  open(printServerIp, printServerPort = 22333) {
    //判断是否存在
    let printer = this.printMap.get(printServerIp)
    if (!printer) {
      printer = {
        isOpen: false,
        isOpening: false, //打开中
        socketTask: false,
        timeoutID: -1,
        intervalID: -1,
        reConnectCount: 0, //重新连接次数
        printServerIp: printServerIp,
        printServerPort: printServerPort,
        lastReceiveMessageTime: new Date().getTime()
      }
    }
    //如果为正在打开，则返回
    if (printer.isOpening) {
      // console.log("已经正在打开中。。。");
      return
    }
    //防止重复连接
    if (printer.isOpen && printer.socketTask) {
      console.log('websocket连接已打开。。。')
      return
    }
    // console.log(printServerIp + ": WebSocket开始连接。。。");
    printer.isOpening = true
    let socketTask = uni.connectSocket({
      url: 'ws://' + printServerIp + ':' + printServerPort + '/',
      header: {
        'content-type': 'application/json'
      },
      success: e => {
        //连接成功，是需要监听onOpen。这里的成功只是创建（接口调用成功）
        //console.log(e);
      },
      complete: () => {}
    })
    if (!socketTask) return
    // console.log(socketTask);
    printer.socketTask = socketTask
    this.printMap.set(printServerIp, printer)

    //监听开启
    socketTask.onOpen(res => {
      printer.isOpen = true
      printer.isOpening = false
      printer.reConnectCount = 0
      uni.$emit('printStatus', {})
      console.log(socketTask)
      console.log(printServerIp + ': WebSocket连接成功。。。')
      this.heartbeatStart(printer)
      this.checkConnect(printer) //检测连接是否正常
    })

    //监听消息
    socketTask.onMessage(res => {
      printer.lastReceiveMessageTime = new Date().getTime()
      let data = JSON.parse(res.data)
      this.message(printer, data)
    })

    //监听关闭
    socketTask.onClose(res => {
      printer.isOpen = false
      printer.isOpening = false
      printer.socketTask = false
      uni.$emit('printStatus', {})
      // console.log(printer.printServerIp + ": WebSocket连接关闭。。。");
      this.heartbeatClear(printer)
      this.printMap.delete(printServerIp)
      if (printer.reConnectCount <= 100) {
        printer.reConnectCount += 1
        this.reOpen(printer.printServerIp, printer.printServerPort)
      }
    })

    //监听错误
    socketTask.onError(res => {
      printer.isOpen = false
      printer.isOpening = false
      printer.socketTask = false
      uni.$emit('printStatus', {})
      // console.log(printServerIp + ": WebSocket连接失败。。。");
      // console.log(res);
      this.heartbeatClear(printer)
      this.printMap.delete(printServerIp)
      if (printer.reConnectCount <= 100) {
        printer.reConnectCount += 1
        this.reOpen(printer.printServerIp, printer.printServerPort)
      }
    })
  },
  //重新打开
  reOpen(printServerIp, printServerPort) {
    this.timeoutID = setTimeout(() => {
      // console.log("开始重连。。。");
      this.open(printServerIp, printServerPort)
    }, 5000)
  },
  //消息处理
  message(printer, data) {
    console.log(data)
    switch (data.cmd) {
      case 'heartbeat':
        this.heartbeatReset(printer)
        break
    }
    // switch (data.type){
    //     case "ycbm":
    //         console.log("一次编密");
    //         break;
    //     case "ecbm":
    //         console.log("二次编密");
    //         break;
    //     case "jmsy":
    //         console.log("简码收样");
    //         break;
    //     case "heartbeat":
    //         console.log("接收到心跳包回复：" + data.sampleCode);
    //         this.heartbeatReset(printer);
    //         break;
    // }
  },
  //关闭连接
  close(printServerIp) {
    let printer = this.printMap.get(printServerIp)
    if (!printer) return //不存在直接返回
    if (printer.isOpen) {
      printer.socketTask.close()
      printer.isOpen = false
    }
  },
  //发送消息
  send(printServerIp, data) {
    let printer = this.printMap.get(printServerIp)
    if (!printer) {
      //不存在则打开
      this.open(printServerIp)
    }
    if (printer?.socketTask) {
      printer.socketTask.send({
        data: data
      })
    }
  },
  //获取打印模板并执行打印
  getPrintTemplateAndPrint(businessSubId) {
    getBusinessSubSample(businessSubId)
      .then(res => {
        this.print(res)
      })
      .catch(err => {
        console.log(err)
      })
  },
  //调用send方法执行打印
  print(businessSubData) {
    const { printTemplate } = businessSubData
    if (!printTemplate) return uni.showToast({ title: '样品未配置打印模板' })
    const me = this
    me.getReportData(printTemplate, function (res) {
      const reportData = {
        data: [businessSubData]
      }
      let printData = {
        type: 'preview',
        reportTemplate: res.content,
        reportData: JSON.stringify(reportData)
      }
      //连接打印服务
      let printList = uni.getStorageSync('KEY_PRINT_LIST')
      if (printList && printList.length > 0) {
        let print = printList[0]
        let printServerIp = print.printIp
        me.send(printServerIp, JSON.stringify(printData))
      }
    })
  },
  //获取打印模板
  getReportData(templateKey, onComplete) {
    const param = {
      key: templateKey
    }
    getConfigReportTemplateByKey(param).then(res => {
      onComplete(res)
    })
  }
}