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

/*
 * Copyright (c) 2022 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import socket, { UDPSocket } from '@ohos.net.socket';
import { Array2Byte, dateFormat, fillZero, string2Bytes } from '../utils/tools';
import FileUtil from '../../common/utils/File';
import prompt from '@ohos.prompt';
import promptAction from '@ohos.promptAction';
import { getUDP } from './GlobalUdp';
import RearEndUnitsTool from '../rearEndUnitsTool/index'
import { getCurrentTime } from '../../common/utils/tools';

const TAG = '[UdpDemo.UdpClient]'


export default class UdpClientByCenter {
  public currentValue: string = ''
  private localIp: string = ''
  private localIpPort: string = ''
  private oppositeIp: string = ''
  private oppositeIpPort: string = ''
  private udpMsg: any = ''
  private chafenFlag: number = 0
  private num: number = 0
  private fileUtil: FileUtil
  private udp: UDPSocket = null
  private sendId: any = 0
  private lsh: string = null
  private context
  private folderPath
  private stashFn: StashFunction
  private errorStep: number = 0
  private interval
  private headLenth: number = 9
  //消息头长度
  private isWorking: Boolean = false
  private plcUdpError = false;
  private initParam
  private retClass: RearEndUnitsTool

  constructor(udplocalIp: string, udplocalIpPort: string, udpOppositeIp: string, udpOppositeIpPort: string) {
    this.localIp = udplocalIp
    this.oppositeIp = udpOppositeIp
    this.localIpPort = udplocalIpPort
    this.oppositeIpPort = udpOppositeIpPort
    this.stashFn = () => {
    }
    this.udp = socket.constructUDPSocketInstance();
    this.initPath()
    if (!globalThis.retClass) {
      globalThis.retClass = new RearEndUnitsTool(globalThis.context)
    }
    this.retClass = globalThis.retClass
    console.log(`${TAG} init UdpClientByCenter`)
  }

  getStatus() {
    return this.isWorking
  }

  rebindUdp(localIp: string, localIpPort: string, oppositeIp: string, oppositeIpPort: string) {
    this.localIp = localIp
    this.oppositeIp = oppositeIp
    this.localIpPort = localIpPort
    this.oppositeIpPort = oppositeIpPort

    let promise = this.udp.bind({
      // address: '192.168.7.170', port: 20122, family: 1
      address: this.localIp, port: parseInt(this.localIpPort), family: 1
    });

    promise.then(() => {
      //   globalThis.closeHeartSocket=false
      this.isWorking = true
      // this.writeLog({
      //   time:dateFormat(new Date()),
      //   PLC:`${TAG} getUDPudp rebind success`,
      // })
      const terType = this.retClass.terType
      //TODO 临时处理过滤掉中心udp
      if(localIpPort != '8800' && terType == 2){
        this.udp && this.udp.on('message', this.message_1Fn);
      }
    }).catch(err => {
      //globalThis.closeHeartSocket=true
      this.isWorking = false
      // this.writeLog({
      //    time:dateFormat(new Date()),
      //    PLC:`${TAG} getUDPudp rebind failed:${JSON.stringify(err)}`,
      //  })
      console.log(`${TAG} getUDPudp rebind failed:${JSON.stringify(err)}`);
    });
  }

  bindUdp() {
    let promise = this.udp.bind({
      address: this.localIp, port: parseInt(this.localIpPort), family: 1
    });
    promise.then(() => {
      const localIpPort = this.localIpPort
      this.isWorking = true
      // this.writeLog({
      //   time:dateFormat(new Date()),
      //   PLC:`${TAG} getUDPudp bind success`,
      // })
      const terType = this.retClass.terType
      //TODO 临时处理过滤掉中心udp
      if(localIpPort != '8800' && terType == 2){
        this.udp && this.udp.on('message', this.message_1Fn);
      }
    }).catch(err => {
      this.isWorking = false
      console.info('surenjun err=>', JSON.stringify(err))
      // this.writeLog({
      //   time:dateFormat(new Date()),
      //   PLC:`${TAG} getUDPudp bind error${JSON.stringify(err)},localIp:${this.localIpPort},port:${this.localIpPort}`,
      // })
    });
  }

  //异或运算
  setMessageExclusive(tmpList) {
    let result = tmpList[0];
    for (let i = 1; i < tmpList.length; i++) {
      result = result ^ tmpList[i]
    }
    return [result];
  }

  Array2Byte(array) {
    var buf = new ArrayBuffer(array.length);
    var view = new Uint8Array(buf);
    for (var i = 0; i != array.length; ++i) {
      view[i] = array[i] & 0xFF;
    }
    return view;
  }

  // {id: 31,list:[0,1,'0000000000000'],carNo:489,placeId:62}
  setWholeMsg(params) {
    let head = this.setMsgHead(params);
    let headJudge = this.setMessageExclusive(head);
    let body = this.setMsgBody(params);
    let bodyJudge = this.setMessageExclusive(body);
    let end = [13, 10];
    const arr = [...head, ...headJudge, ...body, ...bodyJudge, ...end]
    return this.Array2Byte(arr).buffer

  }

  //length消息体bufferlength   id消息类型id  bodyStr消息体string
  // setMsyBody(id,bodyByte){

  setMsgHead({ id, list, placeId=62, carNo=489 }) {
    let a = string2Bytes(`${id}${fillZero(placeId, 3)}`, 2 * 8);
    let b = string2Bytes(`${fillZero(carNo, 4)}${globalThis.lshNo}`, 4 * 8);
    let c = string2Bytes(list.length, 2 * 8);
    return [...a, ...b, ...c];
  }

  setMsgBody({ id, list }) {
    let tmpList = []
    tmpList = list

    return tmpList;

  }

  sendHeadMsg(msgData) {
    console.log('getUDPsendHeadMsg enter')
    this.sendMsg(msgData, null)
    console.log('getUDPsendHeadMsg exit')
  }

  sendMsg(msg, sendCallback?) {
    if (!this.isWorking) {
      // console.log(`${TAG}getUDPudpCLient sendMsg  is closed return `);
      // this.writeLog({
      //   time:dateFormat(new Date()),
      //   PLC:`${TAG}getUDPudpCLient  sendMsg  is closed return oppositeIp:${this.oppositeIp},oppositeIpPort:${this.oppositeIpPort},localIp:${this.localIp},localIpPort:${this.localIpPort}`,
      // })
      if (sendCallback) {
        sendCallback()
      }
      return;
    }
    let promise = this.udp.send({
      data: msg,
      address: {
        address: this.oppositeIp,
        port: parseInt(this.oppositeIpPort),
      }
    });
    promise.then(() => {
      if (sendCallback) {
        sendCallback()
      }
      // this.writeLog({
      //   time:dateFormat(new Date()),
      //   PLC:`${TAG}getUDPudpCLient udp send success: oppositeIp:${this.oppositeIp},oppositeIpPort:${this.oppositeIpPort},localIp:${this.localIp},localIpPort:${this.localIpPort}`,
      // })
    }).catch(err => {
      // this.writeLog({
      //   time:dateFormat(new Date()),
      //   PLC:`${TAG}getUDPudpCLient udp send fail:oppositeIp${this.oppositeIp},oppositeIpPort:${this.oppositeIpPort},localIp:${this.localIp},localIpPort,${this.localIpPort}${JSON.stringify(err)}`,
      // })
      promptAction.showToast({
        message: `${TAG}getUDPudpCLient udp send fail:oppositeIp${this.oppositeIp},oppositeIpPort:${this.oppositeIpPort},localIp:${this.localIp},localIpPort,${this.localIpPort}`,
        duration: 4000
      })
    });
  }

  sendMsgExt(param, context?) {
    if (context) {
      this.context = context
    }
    this.sendId = param.id
    const msgData = this.setWholeMsg(param)
    this.sendMsg(msgData, param.sendCallback)
  }

  onError_Callback(callback?) {
    this.udp.on('error', async err => {
      this.isWorking = false;
      // this.writeLog({
      //   time:dateFormat(new Date()),
      //   PLC:'getUDPUdpClientByCenter  onError err:' + JSON.stringify(err)+this.oppositeIpPort,
      // })
      callback && callback()
    });
  }

  onError_resend(callback?) {
    this.udp.on('error', async err => {
      this.isWorking = false;

      callback && callback()
    });
  }

  setMsgCallBack(callback) {
    this.stashFn = callback ? callback : () => {
    }
  }

  //中心udp回执
  onMessage_2(callback, type?) {
    this.udp.on('message', (value, remoteInfo) => {
      let arr = []
      let dataView = new DataView(value.message)
      for (let i = 0; i < dataView?.byteLength; ++i) {
        arr[i] = dataView?.getUint8(i)
      }
      if (!arr.length) {
        return
      }
      let idNum = '0x' + fillZero(arr[1].toString(16), 2) + fillZero(arr[0].toString(16), 2);
      let id = Math.floor(+idNum / 1000)

      let lengthNum = '0x' + fillZero(arr[7].toString(16), 2) + fillZero(arr[6].toString(16), 2);
      let length = +lengthNum;
      let list = []
      for (let i = this.headLenth; i <= this.headLenth + length - 1; i++) {
        list.push(arr[i])
      }
      this.stashFn({
        id,
        length,
        body: list,
        sendId: this.sendId
      })
      callback({
        id,
        length,
        body: list,
        sendId: this.sendId
      })


      // this.interval=setInterval(()=>{
      //
      // },3000)

    });
  }

  closeUdp(callback?) {
    console.log('getUDPUdpClientByCenter  enter closeUdp ip:' + this.localIp + ' port:' + this.localIpPort);
    this.udp.close(err => {
      if (err) {
        // this.writeLog({
        //   time:dateFormat(new Date()),
        //   PLC:'getUDPUdpClientByCenter  closeUdp err:' + JSON.stringify(err)+this.oppositeIpPort,
        // })
      } else {
        this.isWorking = false
        if (callback != null) {
          callback()
        }
        // this.writeLog({
        //   time:dateFormat(new Date()),
        //   PLC:'getUDPUdpClientByCenter  closeUdp succeed:' + JSON.stringify(err)+this.oppositeIpPort,
        // })
      }
    })
  }

  //plc
  onMessage_1(callback?) {
    const terType = globalThis.retClass?.terType;
    if (terType == 2) {
      //三型机
      this.onMessage_1Callback = callback;
    } else {
      this.retClass.receiveMsg(callback)
      //TODO 临时处理
      globalThis.retClass = this.retClass
    }

    // this.udp && this.udp.on('message', this.message_1Fn);
  }


  closeMessage_1() {
    console.info('surenjun', 'getUDP关闭udp message监听事件')
    this.udp.off('message', this.message_1Fn);
    console.info('surenjun', 'getUDP关闭udp message监听事件 成功')
  }

  message_1Fn = async (value) => {
    // console.info('surenjun2','set message_1Fn=>' + await getCurrentTime())
    let callback = this.onMessage_1Callback
    // 收到的是ArrayBuffer 需要进行转换解析
    this.plcUdpError = false
    if (value) {
      let dataView = new DataView(value.message)
      let str = ""
      for (let i = 0; i < dataView?.byteLength; ++i) {
        let c = String.fromCharCode(dataView?.getUint8(i))
        if (c !== "\n") {
          str += c
        }
      }

      let strachArr = str.split(',')
      if (strachArr[0] != '#DN_GD') {
        return
      }

      strachArr[28] = globalThis.chuankoMsg || strachArr[28]

      // this.stashFn(str)
      const newArr = JSON.parse(JSON.stringify(strachArr))
      // this.writeLog({
      //   time:dateFormat(new Date()),
      //   PLC: JSON.stringify(newArr.toString()),
      // })
      if (strachArr[83] != '4') {
        console.log('差分状态异常', strachArr[83], strachArr[92])
        this.writeLog({
          time: dateFormat(new Date()),
          PLC: `${TAG}差分状态异常,${strachArr[83]},${strachArr[92]}`,
        })
      } else {
        globalThis.dialogOpen = false
        this.chafenFlag = 0
      }
      // console.info('surenjun2','set message_1Fn=>' + newArr.toString())
      callback && callback(newArr.toString())
      console.info('surenjun 左方向灯=>', newArr.toString())
      this.currentValue = newArr.toString();
    } else {
      callback && callback('')
    }

    this.testIfUdpConnetced(callback)
  }

  async writeLog(param) {
    // const fileUtil = new FileUtil(globalThis.context)
    // fileUtil.editFile(`${this.folderPath}/plcLog.txt`, JSON.stringify(param)+`\n`)
  }

  async initPath() {
    // const fileUtil = new FileUtil(globalThis.context)
    // const date=dateFormat(new Date).split(' ')[0]
    // this.folderPath = await fileUtil.initFolder(`/PLC/${date}`);
  }

  //获取当前UDP信号
  getCurrentMessage = () => {
    return this.currentValue
  }

  testIfUdpConnetced(callback) {
    const arrRed = [0x55, 0xaa, 0x01, 0x01, 0x02, 0x00, 0x03, 0x00];
    const arrBlue = [0x55, 0xaa, 0x01, 0x00, 0x02, 0x01, 0x03, 0x00];
    const arrGreen = [0x55, 0xaa, 0x01, 0x00, 0x02, 0x00, 0x03, 0x01];
    const arrBlueBuffer = Array2Byte(arrBlue).buffer
    const arrRedBuffer = Array2Byte(arrRed).buffer
    const arrGreenBugger = Array2Byte(arrGreen).buffer
    let num = 0
    globalThis.dialogOpen = false

    //监听udp是否断开
    clearInterval(globalThis.messageTimer)
    globalThis.messageTimer = setInterval(() => {
      const lightLineUdp = globalThis.lightLineUdp
      const isJudge = globalThis.isJudge
      setTimeout(async () => {
        //程序断开
        lightLineUdp?.send(this.plcUdpError ? arrRedBuffer : (isJudge ? arrGreenBugger : arrBlueBuffer));
        if (this.plcUdpError) {
          num++
          this.writeLog({
            time: dateFormat(new Date()),
            PLC: 'plc udp信号丢失',
          })
          console.log(TAG, 'plc udp信号丢失')
          if (num == 3) {
            getUDP(globalThis.context, true)
            globalThis.title = 'plc udp信号丢失'
            globalThis.type = '3'
            if (!globalThis.dialogOpen) {
              // AppStorage.SetOrCreate('errorCode', 1);
              // if(this.errorStep!=1){
              //   console.log('sys.v_valuesys.v_valuesys.v_value11221')
              //
              //   this.errorStep=1
              //   this.avPlayer.playAudio(['voice/差分状态异常.wav'])
              //   getSyncData('MA_SYSSET').then(syssetParams => {
              //     console.log('sys.v_valuesys.v_valuesys.v_value11221',JSON.stringify(syssetParams))
              //     // @ts-ignore
              //     syssetParams.forEach(sys => {
              //       // 差分长时间是SINGLE状态报考车故障,停止考试（0-否 1-是）
              //       if (sys.v_no === '424'&&sys.v_value==1){
              //         //plc差分丢失
              //         AppStorage.SetOrCreate('errorCode', 0);
              //         AppStorage.SetOrCreate('errorCodeFlage', true);
              //
              //       }
              //     })
              //     // const errorParam = syssetParams.filter(sys => sys.v_no === '424') //
              //     // that.studentRefreshStatue = studentRefreshParam?.[0]?.v_value || '0'
              //
              //
              //   });
              // }
            }
            num = 0
          }

          prompt.showToast({
            message: 'plc udp信号丢失',
            duration: 2000
          });
        }

        this.plcUdpError = true;
      }, 2000)
    }, 2000)
  }

  private onMessage_1Callback: Function = () => {
  }

  // initHeartSendMsg(param,context){
  //     console.log('1111param',JSON.stringify(param))
  //     this.initParam=param
  //     this.context=context
  // }
}

interface StashFunction {
  (params: {
    id: number;
    length: number;
    body: any[];
    sendId: string
  }): void;
}