258 lines
8.8 KiB
TypeScript
258 lines
8.8 KiB
TypeScript
/*
|
|
* 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 from '@ohos.net.socket';
|
|
import fs from '@ohos.file.fs'
|
|
import mediaLibrary from '@ohos.multimedia.mediaLibrary'
|
|
import FileUtil from '../../common/utils/File'
|
|
import {fillZero,string2Bytes} from '../utils/tools'
|
|
import { GlobalConfig } from '../../config/index'
|
|
const TAG = '[UdpDemo.UdpClient]'
|
|
// import common from '@ohos.app.ability.common';
|
|
import hilog from '@ohos.hilog';
|
|
import prompt from '@ohos.prompt'
|
|
import call from '@ohos.telephony.call';
|
|
|
|
|
|
export default class UdpClientByCenter {
|
|
private localIp: string = ''
|
|
private localIpPort: string = ''
|
|
private oppositeIp: string = ''
|
|
private oppositeIpPort: string = ''
|
|
private udpMsg: any=''
|
|
private num:number = 0
|
|
private fileUtil: FileUtil
|
|
private udp: any = null
|
|
private sendId: any = 0
|
|
private lsh: string = null
|
|
private context
|
|
private stashFn:StashFunction
|
|
private headLenth:number=9 //消息头长度
|
|
private initParam
|
|
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();
|
|
}
|
|
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
|
|
console.log(`${TAG} udp bind success`);
|
|
}).catch(err => {
|
|
globalThis.closeHeartSocket=true
|
|
console.log(`${TAG} udp bind failed:${JSON.stringify(err)}`);
|
|
});
|
|
}
|
|
initHeartSendMsg(param,context){
|
|
console.log('1111param',JSON.stringify(param))
|
|
this.initParam=param
|
|
this.context=context
|
|
}
|
|
bindUdp() {
|
|
let promise = this.udp.bind({
|
|
address: this.localIp, port: parseInt(this.localIpPort), family: 1
|
|
});
|
|
promise.then(() => {
|
|
globalThis.closeHeartSocket=false
|
|
console.log(`${TAG} udp bind success`);
|
|
}).catch(err => {
|
|
globalThis.closeHeartSocket=true
|
|
console.log(`${TAG} udp bind failed:${JSON.stringify(err)}`);
|
|
});
|
|
}
|
|
|
|
//异或运算
|
|
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;
|
|
}
|
|
//length消息体bufferlength id消息类型id bodyStr消息体string
|
|
// setMsyBody(id,bodyByte){
|
|
|
|
// {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]
|
|
console.log('BitArray',arr)
|
|
return this.Array2Byte(arr).buffer
|
|
|
|
}
|
|
setMsgHead({id, list, placeId=62, carNo=489}){
|
|
console.log('globalThis.lshNo',globalThis.lshNo)
|
|
let a = string2Bytes(`${id}${fillZero(placeId,3)}`, 2*8);
|
|
console.log('aaa',a)
|
|
let b = string2Bytes(`${fillZero(carNo,4)}${globalThis.lshNo}`, 4*8);
|
|
console.log('bbb',b)
|
|
let c = string2Bytes(list.length, 2*8);
|
|
return [...a,...b,...c];
|
|
}
|
|
setMsgBody({id,list}) {
|
|
let tmpList = []
|
|
tmpList = list
|
|
|
|
return tmpList ;
|
|
|
|
}
|
|
|
|
sendHeadMsg(msgData){
|
|
console.log('sendsnd1')
|
|
//udpOppositeIp
|
|
let promise = this.udp.send({
|
|
data: msgData,
|
|
address: {
|
|
address: this.oppositeIp,
|
|
port: parseInt(this.oppositeIpPort),
|
|
}
|
|
});
|
|
promise.then(() => {
|
|
console.log(`${TAG} udpLine send success:`);
|
|
}).catch(err => {
|
|
console.log(`${TAG} udpLine send fail:${JSON.stringify(err)}`);
|
|
});
|
|
}
|
|
onError(callback?){
|
|
this.udp.on('error',async err => {
|
|
globalThis.closeHeartSocket=true
|
|
callback&&callback()
|
|
// callback&&callback()
|
|
// this.closeUdp(()=>{
|
|
// this.bindUdp()
|
|
// })
|
|
});
|
|
}
|
|
setMsgCallBack(callback){
|
|
this.stashFn=callback?callback:()=>{}
|
|
}
|
|
sendMsg(param,context?) {
|
|
this.udp.getState((err, data) => {
|
|
if (err) {
|
|
globalThis.closeHeartSocket=true
|
|
return;
|
|
}else{
|
|
console.log('paramparam',JSON.stringify(param))
|
|
if(context){
|
|
this.context=context
|
|
}
|
|
this.sendId=param.id
|
|
console.log('sendMsg',JSON.stringify(param))
|
|
const msgData=this.setWholeMsg(param)
|
|
// const msgData=this.setMsyBody('31','010000000000000')
|
|
let promise = this.udp.send({
|
|
data: msgData,
|
|
address: {
|
|
address: this.oppositeIp,
|
|
port: parseInt(this.oppositeIpPort),
|
|
}
|
|
});
|
|
promise.then(() => {
|
|
if(param.sendCallback){
|
|
param.sendCallback()
|
|
}
|
|
// if(this.sendId=='46'&¶m.callback){
|
|
// param.callback()
|
|
// }
|
|
console.log(`${TAG} udp send success:`);
|
|
}).catch(err => {
|
|
console.log(`${TAG} udp send fail:${JSON.stringify(err)}`);
|
|
});
|
|
}
|
|
})
|
|
|
|
}
|
|
onMessage(callback,type?) {
|
|
this.udp.on('message', value => {
|
|
let arr=[]
|
|
let dataView = new DataView(value.message)
|
|
for (let i = 0;i < dataView?.byteLength; ++i) {
|
|
arr[i]=dataView?.getUint8(i)
|
|
}
|
|
let idNum = '0x' + fillZero(arr[1].toString(16),2) + fillZero(arr[0].toString(16),2) ;
|
|
let id = Math.floor(+idNum/1000)
|
|
hilog.info(0x0000, 'bitbit', JSON.stringify(arr));
|
|
|
|
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})
|
|
});
|
|
}
|
|
|
|
closeUdp(callback) {
|
|
globalThis.closeHeartSocket=true
|
|
this.udp.close(err=>{
|
|
if(err){
|
|
|
|
}else{
|
|
this.udp.getState((err, data) => {
|
|
if (err) {
|
|
return;
|
|
}else{
|
|
globalThis.closeHeartSocket=true
|
|
if(!data.isisClose){
|
|
setTimeout(()=>{
|
|
callback()
|
|
},1000)
|
|
}
|
|
}
|
|
})
|
|
// let promise = this.udp.getState({});
|
|
// promise.then(data => {
|
|
//
|
|
// console.log('getState success:' + JSON.stringify(data));
|
|
// }).catch(err => {
|
|
// callback()
|
|
// console.log('getState fail');
|
|
// });
|
|
}
|
|
});
|
|
|
|
}
|
|
}
|
|
interface StashFunction {
|
|
(params: { id: number; length: number; body: any[]; sendId: string }): void;
|
|
} |