//build: 20240617
|
// 系统的一些基本操作、还有一些常用的工具函数，基本上每个项目都需要依赖这个组件，另外dxLogger也依赖这个组件
|
// 依赖组件：dxDriver，dxMap
|
import { commonClass } from './libvbar-m-dxcommon.so'
|
import dxMap from './dxMap.js'
|
import * as std from 'std';
|
import * as os from "os"
|
|
const commonObj = new commonClass();
|
|
const common = {}
|
/**
|
* 获取系统启动的运行时间(单位是秒)
|
* @returns
|
*/
|
common.getUptime = function () {
|
return commonObj.getUptime();
|
}
|
|
/**
|
* 获取系统的总内存(单位是字节)
|
* @returns
|
*/
|
common.getTotalmem = function () {
|
return commonObj.getTotalmem();
|
}
|
|
/**
|
* 获取系统剩余内存(单位是字节)
|
* @returns
|
*/
|
common.getFreemem = function () {
|
return commonObj.getFreemem();
|
}
|
|
/**
|
* Deprcated, Please use `common.logMemory` instead.
|
*/
|
common.logMem = function (logger, interval = 10) {
|
if (logger) {
|
logger.debug("Deprcated, Please use `common.logMemory` instead.")
|
}
|
}
|
/**
|
* Logs the current memory usage at regular intervals for debugging and monitoring purposes.
|
* @param {object} logger The dxLogger module object.
|
* @param {number} interval The logging interval in seconds, defaulting to 10 seconds.
|
*/
|
common.logMemory = function (logger, interval = 10) {
|
if (!logger) return;
|
|
let first = new Date().getTime();
|
let min = common.getFreemem() / 1024;
|
let max = min;
|
const _logmemory = () => {
|
try {
|
const now = new Date().getTime();
|
const pass = (now - first) / 1000;
|
const free = common.getFreemem() / 1024;
|
|
min = Math.min(min, free);
|
max = Math.max(max, free);
|
|
// Format time
|
let passStr;
|
if (pass > 1700000000) {
|
first = now;
|
passStr = 'time synced, 0s';
|
} else if (pass >= 3600) {
|
const hours = Math.floor(pass / 3600);
|
const minutes = Math.floor((pass % 3600) / 60);
|
const seconds = Math.floor(pass % 60);
|
passStr = `${hours}h ${minutes}m ${seconds}s`;
|
} else if (pass >= 60) {
|
const minutes = Math.floor(pass / 60);
|
const seconds = Math.floor(pass % 60);
|
passStr = `${minutes}m ${seconds}s`;
|
} else {
|
passStr = `${Math.floor(pass)}s`;
|
}
|
const log = `------ ${passStr} passed, free memory (k): ${free}, min free memory (k): ${min}, max free memory (k): ${max} ------`;
|
logger.info(log);
|
} catch (err) {
|
logger.error('Error in logMemory:', err);
|
} finally {
|
os.setTimeout(_logmemory, interval * 1000);
|
}
|
};
|
|
os.setTimeout(_logmemory, interval * 1000);
|
};
|
|
/**
|
* The principle of converting asynchronous to synchronous is as follows:
|
* the `request` function periodically checks a designated variable in memory for a value.
|
* If the value is found within the timeout period, the result is returned; otherwise,
|
* it is considered a timeout. The `response` function is responsible for storing the result
|
* in the designated variable once the asynchronous request is completed.
|
*/
|
common.sync = {
|
/**
|
* Block and wait for data
|
* Usage:
|
common.sync.request(topic, 200)
|
.then((data) => {
|
log.info("Received data:", data);
|
})
|
.catch((err) => {
|
log.error("Request failed:", err.message);
|
});
|
* @param {string} topic The unique identifier for each request
|
* @param {int} timeout waitting timeout(microsecond)，default is 200 ms
|
* @returns
|
*/
|
request: function (topic, timeout = 200) {
|
return new Promise((resolve, reject) => {
|
let map = dxMap.get("SYNC");
|
let startTime = Date.now();
|
|
const checkData = () => {
|
let data = map.get(topic);
|
if (data) {
|
map.del(topic); //del data in map
|
resolve(data); //return data
|
} else if (Date.now() - startTime >= timeout) {
|
map.del(topic); // del data in map with timeout
|
reject(new Error(`Timeout exceeded for topic: ${topic}`));
|
} else {
|
os.setTimeout(checkData, 10); //every 10 ms to check
|
}
|
};
|
|
os.setTimeout(checkData, 10); // first check
|
});
|
},
|
|
/**
|
* notify data to requester
|
* @param {string} topic The unique identifier for each request
|
* @param {*} data
|
* @returns
|
*/
|
response: function (topic, data) {
|
let map = dxMap.get("SYNC");
|
map.put(topic, data); // save data in map
|
}
|
};
|
|
/**
|
* 获取系统可用磁盘总量(单位是字节)
|
* @param {string} path 不同的磁盘分区名称（不是目录名），非必填，缺省是'/'
|
*/
|
common.getTotaldisk = function (path) {
|
return commonObj.getTotaldisk(!path ? "/" : path);
|
}
|
|
/**
|
* 获取系统磁盘剩余可用量(单位是字节)
|
* @param {string} path 不同的磁盘分区名称（不是目录名），非必填，缺省是'/'
|
* @returns
|
*/
|
common.getFreedisk = function (path) {
|
return commonObj.getFreedisk(!path ? "/" : path);
|
}
|
|
/**
|
* 获取CPU ID
|
* @param {number} len 非必填，缺省长度是33位长
|
* @returns
|
*/
|
common.getCpuid = function () {
|
return commonObj.getCpuid(33);
|
}
|
|
/**
|
* 获取设备uuid（字符串）
|
* @returns
|
*/
|
common.getUuid = function () {
|
return commonObj.getUuid(19);
|
}
|
|
/**
|
* 获取设备唯一标识
|
* @returns
|
*/
|
common.getSn = function () {
|
let sn = std.loadFile('/etc/.sn')
|
if (sn) {
|
return sn
|
} else {
|
return commonObj.getUuid(19);
|
}
|
}
|
|
/**
|
* 获取通过uuid计算的mac地址，这个可以用来初始化网卡的时候用
|
* @returns 格式类似：b2:a1:63:3f:99:b6
|
*/
|
common.getUuid2mac = function () {
|
return commonObj.getUuid2mac(19);
|
}
|
|
/**
|
* 获取cpu占用率（不大于100的数字）
|
* @returns
|
*/
|
common.getFreecpu = function () {
|
return commonObj.getFreecpu();
|
}
|
|
|
/**
|
* RSA 解密 （私钥加密公钥解密）
|
* 比如公钥是
|
* @param {ArrayBuffer} data 要解密的数据，必填
|
* @param {string} publicKey 公钥，必填
|
* @returns
|
*/
|
common.arrayBufferRsaDecrypt = function (data, publicKey) {
|
if (data === undefined || data === null) {
|
throw new Error("dxCommon.arrayBufferRsaDecrypt:'data' parameter should not be null or empty")
|
}
|
if (publicKey === undefined || publicKey === null || publicKey.length < 1) {
|
throw new Error("dxCommon.arrayBufferRsaDecrypt:'publicKey' parameter should not be null or empty")
|
}
|
return commonObj.arrayBufferRsaDecrypt(data, publicKey)
|
}
|
|
/**
|
* @brief Stirng aes 加密
|
*/
|
common.aes128EcbEncrypt = function (input, key) {
|
return commonObj.aes128EcbEncrypt(input, key)
|
}
|
/**
|
* @brief Stirng aes 解密
|
*/
|
common.aes128EcbDecrypt = function (input, key) {
|
return commonObj.aes128EcbDecrypt(input, key)
|
}
|
|
/**
|
* arraybuffer ecb 128bit Pkcs5Padding aes 加密
|
* @param {ArrayBuffer} input 明文
|
* @param {ArrayBuffer} key 密钥
|
* @returns ArrayBuffer 密文
|
*/
|
common.aes128EcbPkcs5PaddingEncode = function (input, key) {
|
return commonObj.aes128Pkcs7PaddingEncode(input, key)
|
}
|
|
/**
|
* arraybuffer ecb 128bit Pkcs5Padding aes 解密
|
*
|
* @param {ArrayBuffer} input 密文
|
* @param {ArrayBuffer} key 密钥
|
* @returns ArrayBuffer 明文
|
*/
|
common.aesEcb128Pkcs5PaddingDecode = function (input, key) {
|
return commonObj.aes128Pkcs7PaddingDecode(input, key)
|
}
|
|
/**
|
* aes ECB Pkcs5Padding 128 加密
|
* 示例：common.aes128EcbPkcs5PaddingEncrypt("stamp=202008文&tic", "1234567890123456")
|
* 结果：ef7c3cff9df57b3bcb0951938c574f969e13ffdcc1eadad298ddbd1fb1a4d2f7
|
* 参考 https://www.devglan.com/online-tools/aes-encryption-decryption
|
* @param {string} input 明文数据
|
* @param {string} key 密钥 16字节字符串
|
* @return 密文 16进制字符串
|
*/
|
common.aes128EcbPkcs5PaddingEncrypt = function (input, key) {
|
let data = common.hexStringToArrayBuffer(common.strToUtf8Hex(input))
|
key = common.hexStringToArrayBuffer(common.strToUtf8Hex(key))
|
// 加密
|
let hex = common.arrayBufferToHexString(common.aes128EcbPkcs5PaddingEncode(data, key))
|
return hex
|
}
|
/**
|
* aes ECB Pkcs5Padding 128 解密
|
* @param {string} input 密文 16进制字符串
|
* @param {string} key 密钥 16字节字符串
|
* @return 明文
|
*/
|
common.aes128EcbPkcs5PaddingDecrypt = function (input, key) {
|
key = common.hexStringToArrayBuffer(common.strToUtf8Hex(key))
|
let res = common.aesEcb128Pkcs5PaddingDecode(common.hexStringToArrayBuffer(input), key)
|
return common.utf8HexToStr(common.arrayBufferToHexString(res))
|
}
|
|
/**
|
* @brief Stirng aes gcm 加密
|
* @param {string} plainText 明文
|
* @param {string} key 密钥
|
* @returns {object} {cipherData: ArrayBuffer, key: String, iv: ArrayBuffer, tag: ArrayBuffer}
|
*/
|
common.aes128GcmEncrypt = function (plainText, key) {
|
return commonObj.aes128GcmEncrypt(plainText, key)
|
}
|
|
/**
|
* @brief Stirng aes gcm 解密
|
* @param {ArrayBuffer} cipherData 密文
|
* @param {string} key 密钥
|
* @param {ArrayBuffer} iv iv
|
* @param {ArrayBuffer} tag tag
|
*/
|
common.aes128GcmDecrypt = function (chiperData, key, iv, tag) {
|
return commonObj.aes128GcmDecrypt(chiperData, key, iv, tag)
|
}
|
|
/**
|
* 执行操作系统的命令
|
* @param {*} cmd 命令
|
* @returns
|
*/
|
common.system = function (cmd) {
|
return commonObj.system(cmd)
|
}
|
|
/**
|
* 执行操作系统的命令
|
* @param {*} cmd 命令 操作系统常用指令(linux绝大部分指令都支持)，必填
|
* @returns
|
*/
|
common.systemBrief = function (cmd) {
|
return commonObj.systemBrief(cmd)
|
}
|
|
/**
|
* 执行操作系统的命令并返回结果
|
* @param {*} cmd 命令 操作系统常用指令(linux绝大部分指令都支持)，必填
|
* @param {*} resLen 接收数据长度 有时候返回的数据很大，可以通过这个值来返回固定长度的数据，必填
|
* @returns
|
*/
|
common.systemWithRes = function (cmd, resLen) {
|
return commonObj.systemWithRes(cmd, resLen)
|
}
|
|
/**
|
* 执行操作系统的命令阻塞执行
|
* @param {*} cmd 命令 操作系统常用指令(linux绝大部分指令都支持)，必填
|
* @returns
|
*/
|
common.systemBlocked = function (cmd) {
|
return commonObj.systemBlocked(cmd)
|
}
|
|
/**
|
* 异步延迟重启
|
* @param {*} delay_s 延迟时间
|
* @returns
|
*/
|
common.asyncReboot = function (delay_s) {
|
return commonObj.asyncReboot(delay_s)
|
}
|
|
/**
|
* bcc校验
|
* @param {array} data eg:[49,50,51,52,53,54]对应的值是7
|
* @returns 校验计算结果
|
*/
|
common.calculateBcc = function (data) {
|
return commonObj.calculateBcc(data)
|
}
|
|
/**
|
* crc校验 比如字符串'123456'校验计算的结果是数字 158520161
|
* @param {string} content 要校验的字符串数据，
|
* @returns
|
*/
|
common.crc32 = function (content) {
|
if (content === undefined || content === null || typeof (content) != "string" || content.length < 1) {
|
throw new Error("dxCommon.crc32:'content' paramter should not be empty")
|
}
|
return commonObj.crc32(content)
|
}
|
|
/**
|
* 计算MD5哈希，比如'123456'对应的数字数组是[49,50,51,52,53,54] 对应的md5是'e10adc3949ba59abbe56e057f20f883e'，
|
* 但是返回的不是16进制字符串，是数字数组，可以使用arrToHex函数转换
|
* @param {array} arr 数字数组
|
* @returns 数字数组
|
*/
|
common.md5Hash = function (arr) {
|
return commonObj.md5Hash(arr)
|
}
|
|
/**
|
* 文件计算MD5哈希,比如文件里的内容是'123456'，对应的md5是'e10adc3949ba59abbe56e057f20f883e'
|
* 但是返回的不是16进制字符串，是数字数组，可以使用arrToHex函数转换
|
* @param {string} 文件路径，绝对路径，必填，通常是以/app/code开头
|
* @returns 数字数组
|
*/
|
common.md5HashFile = function (filePath) {
|
if (filePath === undefined || filePath === null || typeof (filePath) != "string") {
|
return null
|
}
|
return commonObj.md5HashFile(filePath)
|
}
|
|
/**
|
* 计算HMAC MD5加密,比如加密的数据是'123456',密钥是'654321'，对应的结果是'357cbe6d81a8ec770799879dc8629a53'
|
* 但是参数和返回的值都是ArrayBuffer
|
* @param {ArrayBuffer} data 需要加密的内容,必填
|
* @param {ArrayBuffer} key 密钥 ,必填
|
* @returns ArrayBuffer
|
*/
|
common.hmacMd5Hash = function (data, key) {
|
return commonObj.hmacMd5Hash(data, key)
|
}
|
|
/**
|
* 计算HMAC MD5加密,比如加密的数据是'123456',密钥是'654321'，对应的结果是'357cbe6d81a8ec770799879dc8629a53'
|
* @param {string} data 需要加密的内容,必填
|
* @param {string} key 密钥 ,必填
|
* @returns ArrayBuffer
|
*/
|
common.hmac = function (data, key) {
|
return commonObj.hmac(data, key)
|
}
|
|
/**
|
* 文件计算HMAC MD5加密，比如文件里的内容是'123456'，密钥是'654321'，对应的结果是'357cbe6d81a8ec770799879dc8629a53'
|
* @param {string} filePath 需要加密的内容存储的文件路径，绝对路径，必填，通常是以/app/code开头
|
* @param {array} key 密钥 ,数字数组,必填
|
* @returns 数字数组
|
*/
|
common.hmacMd5HashFile = function (filePath, key) {
|
return commonObj.hmacMd5HashFile(filePath, key)
|
}
|
|
|
/**
|
* base64转bin文件
|
* @param {string} file_path 文件路径，必填
|
* @param {string} base64Data base64数据，必填
|
* @returns
|
*/
|
common.base64_2binfile = function (file_path, base64Data) {
|
return commonObj.base64_2binfile(file_path, base64Data);
|
}
|
|
/**
|
* bin文件转base64
|
* @param {string} file_path 文件路径，必填
|
* @returns base64Data base64数据，必填
|
*/
|
common.binfile_2base64 = function (file_path) {
|
return commonObj.binfile_2base64(file_path);
|
}
|
|
/**
|
* 切换设备模式
|
* @description 模式切换后会重启设备，进入指定模式，使用方法时需完整维护相互切换的逻辑，切换为业务模式后不能使用IDE功能
|
* @param {number} mode 注意：旧版本模式切换使用（1、2、3），新版本模式切换使用（dev、test、prod、safe）
|
* @returns true false
|
*/
|
common.setMode = function (mode) {
|
// 注意：旧版本模式切换使用（1、2、3）
|
if (mode == 1) {
|
//生产模式
|
commonObj.systemWithRes(`echo 'app' > /etc/.mode`, 2)
|
// 1.0版本切换为其他模式后删除工厂检测（后续版本可能会调整）
|
commonObj.systemWithRes(`rm -rf /test`, 2)
|
} else if (mode == 2) {
|
//调试模式
|
commonObj.systemWithRes(`echo 'debug' > /etc/.mode`, 2)
|
// 1.0版本切换为其他模式后删除工厂检测（后续版本可能会调整）
|
commonObj.systemWithRes(`rm -rf /test`, 2)
|
} else if (mode == 3) {
|
//试产模式
|
commonObj.systemWithRes(`echo 'pp' > /etc/.mode`, 2)
|
}
|
|
// 注意：新版本模式切换使用（dev、test、prod、safe）
|
else if (mode == "dev") {
|
//开发模式
|
commonObj.systemWithRes(`echo 'dev' > /etc/.mode_v1`, 2)
|
} else if (mode == "test") {
|
//测试模式（试产模式）
|
commonObj.systemWithRes(`echo 'test' > /etc/.mode_v1`, 2)
|
} else if (mode == "prod") {
|
//生产模式
|
commonObj.systemWithRes(`echo 'prod' > /etc/.mode_v1`, 2)
|
} else if (mode == "safe") {
|
//安全模式
|
commonObj.systemWithRes(`echo 'safe' > /etc/.mode_v1`, 2)
|
} else {
|
return false
|
}
|
commonObj.systemWithRes(`sync`, 2)
|
commonObj.asyncReboot(2)
|
return true
|
}
|
|
/**
|
* 查询设备模式
|
* @description 获取设备当前模式
|
* @returns 业务模式：1，开发模式：2，工厂模式：28， 异常模式：-1
|
*/
|
common.getMode = function () {
|
let ret = commonObj.systemWithRes(`test -e "/etc/.mode" && echo "OK" || echo "NO"`, 2)
|
if (ret.includes('NO')) {
|
return 28
|
}
|
let mode = commonObj.systemWithRes(`cat "/etc/.mode"`, 10)
|
if (mode.includes('app')) {
|
return 1
|
} else if (mode.includes('debug')) {
|
return 2
|
} else {
|
return -1
|
}
|
}
|
/**
|
* 十六进制转字节数组 eg:313233616263->[49,50,51,97,98,99]
|
* @param {string} str 16进制字符串 小写且中间无空隔的十六进制字符串
|
* @returns 数字数字
|
*/
|
common.hexToArr = function (str) {
|
if (str === undefined || str === null || (typeof str) != 'string' || str.length < 1) {
|
throw new Error("dxCommon.hexToArr:'str' parameter should not be empty")
|
}
|
let regex = /.{2}/g;
|
let arr = str.match(regex);
|
return arr.map(item => parseInt(item, 16));
|
}
|
/**
|
* 字节数组转十六进制 eg:[49,50,51,97,98,99]->313233616263
|
* @param {array}numbers 数字数组
|
* @returns str 16进制字符串 小写且中间无空隔的十六进制字符串
|
*/
|
common.arrToHex = function (numbers) {
|
const hexArray = numbers.map(num => num.toString(16).padStart(2, '0').toLowerCase());
|
const hexString = hexArray.join('');
|
return hexString;
|
}
|
/**
|
* 十六进制转字符串 eg:313233616263->123abc
|
* 注意如果16进制字符串是由中文转过去的，再转回中文字符串会有乱码，因为是一个一个字节的转换
|
* @param {string} str 要转的16进制字符串
|
* @returns
|
*/
|
common.hexToString = function (str) {
|
let regex = /.{2}/g;
|
let arr = str.match(regex);
|
arr = arr.map(item => String.fromCharCode(parseInt(item, 16)));
|
return arr.join("");
|
}
|
// 将字符串转换为 UTF-8 编码的16进制字符串
|
common.strToUtf8Hex = function (str) {
|
const bytes = [];
|
for (let i = 0; i < str.length; i++) {
|
let code = str.charCodeAt(i);
|
if (code < 0x80) {
|
bytes.push(code);
|
} else if (code < 0x800) {
|
bytes.push(0xc0 | (code >> 6), 0x80 | (code & 0x3f));
|
} else if (code < 0xd800 || code >= 0xe000) {
|
bytes.push(0xe0 | (code >> 12), 0x80 | ((code >> 6) & 0x3f), 0x80 | (code & 0x3f));
|
} else {
|
// 处理 Unicode 编码
|
i++;
|
code = 0x10000 + (((code & 0x3ff) << 10) | (str.charCodeAt(i) & 0x3ff));
|
bytes.push(
|
0xf0 | (code >> 18),
|
0x80 | ((code >> 12) & 0x3f),
|
0x80 | ((code >> 6) & 0x3f),
|
0x80 | (code & 0x3f)
|
);
|
}
|
}
|
return this.arrToHex(bytes);
|
}
|
/**
|
* 传递过来的utf-8的16进制字符串转换成字符串
|
* @param {string} hex
|
* @returns
|
*/
|
common.utf8HexToStr = function (hex) {
|
let array = this.hexToArr(hex)
|
var out, i, len, c;
|
var char2, char3;
|
|
out = "";
|
len = array.length;
|
i = 0;
|
while (i < len) {
|
c = array[i++];
|
switch (c >> 4) {
|
case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
|
// 0xxxxxxx
|
out += String.fromCharCode(c);
|
break;
|
case 12: case 13:
|
// 110x xxxx 10xx xxxx
|
char2 = array[i++];
|
out += String.fromCharCode(((c & 0x1F) << 6) | (char2 & 0x3F));
|
break;
|
case 14:
|
// 1110 xxxx 10xx xxxx 10xx xxxx
|
char2 = array[i++];
|
char3 = array[i++];
|
out += String.fromCharCode(((c & 0x0F) << 12) |
|
((char2 & 0x3F) << 6) |
|
((char3 & 0x3F) << 0));
|
break;
|
}
|
}
|
|
return out;
|
}
|
/**
|
* 字符串转十六进制 eg:123abc->313233616263
|
* @param {string} str 要转的字符串
|
* @returns
|
*/
|
common.stringToHex = function (str) {
|
if (str === undefined || str === null || typeof (str) != "string") {
|
return null
|
}
|
let val = "";
|
for (let i = 0; i < str.length; i++) {
|
val += str.charCodeAt(i).toString(16)
|
}
|
return val
|
}
|
|
/**
|
* 小端格式转十进制数 eg:001001->69632
|
* @param {string} hexString 16进制字符串 小写且中间无空隔的十六进制字符串
|
* @returns 数字
|
*/
|
common.littleEndianToDecimal = function (hexString) {
|
// 将小端格式的十六进制字符串进行反转
|
let reversedHexString = hexString
|
.match(/.{2}/g) // 每两个字符分隔
|
.reverse() // 反转数组
|
.join(""); // 合并为字符串
|
|
// 将反转后的十六进制字符串转换为十进制数
|
let decimal = parseInt(reversedHexString, 16);
|
return decimal;
|
}
|
|
|
/**
|
* 十进制数转换为16进制小端格式字符串
|
* eg:300->2c01
|
* eg:230->e600
|
* @param {number} decimalNumber 十进制数字,必填
|
* @param {number} byteSize 生成位数 字节的个数，如果超出实际字节个数，会在右边补0，低于会截取，非必填，缺省是2
|
* @returns
|
*/
|
common.decimalToLittleEndianHex = function (decimalNumber, byteSize) {
|
if (decimalNumber === undefined || decimalNumber === null || (typeof decimalNumber) != 'number') {
|
throw new Error("dxCommon.decimalToLittleEndianHex:'decimalNumber' parameter should be number")
|
}
|
if (byteSize === undefined || byteSize === null || (typeof byteSize) != 'number' || byteSize <= 0) {
|
byteSize = 2
|
}
|
const littleEndianBytes = [];
|
for (let i = 0; i < byteSize; i++) {
|
littleEndianBytes.push(decimalNumber & 0xFF);
|
decimalNumber >>= 8;//相当于除以256
|
}
|
const littleEndianHex = littleEndianBytes
|
.map((byte) => byte.toString(16).padStart(2, '0'))
|
.join('');
|
return littleEndianHex;
|
}
|
|
/**
|
* 将16进制字符串转换为ArrayBuffer
|
* @param {*} hexString 要转换的16进制字符串
|
* @returns
|
*/
|
common.hexStringToArrayBuffer = function (hexString) {
|
return this.hexStringToUint8Array(hexString).buffer;
|
}
|
|
/**
|
* 将16进制字符串转换为Uint8Array
|
* @param {string} hexString 要转换的16进制字符串，小写且中间无空隔的十六进制字符串
|
* @returns Uint8Array对象
|
*/
|
common.hexStringToUint8Array = function (hexString) {
|
if (hexString === undefined || hexString === null || (typeof hexString) != 'string' || hexString.length <= 0) {
|
throw new Error("dxCommon.hexStringToUint8Array:'hexString' parameter should not be empty")
|
}
|
let byteString = hexString.match(/.{1,2}/g);
|
let byteArray = byteString.map(function (byte) {
|
return parseInt(byte, 16);
|
});
|
let buffer = new Uint8Array(byteArray);
|
return buffer;
|
}
|
|
/**
|
* 将 ArrayBuffer 转换为十六进制字符串格式
|
* @param {ArrayBuffer} buffer
|
* @returns 小写且中间无空隔的十六进制字符串
|
*/
|
common.arrayBufferToHexString = function (buffer) {
|
return this.uint8ArrayToHexString(new Uint8Array(buffer))
|
}
|
/**
|
* 将 Uint8Array 转换为十六进制字符串格式
|
* @param {Uint8Array} array
|
* @returns 小写且中间无空隔的十六进制字符串
|
*/
|
common.uint8ArrayToHexString = function (array) {
|
let hexString = '';
|
for (let i = 0; i < array.length; i++) {
|
const byte = array[i].toString(16).padStart(2, '0');
|
hexString += byte;
|
}
|
return hexString
|
}
|
/**
|
* 设置/获取组件句柄id通用方法
|
* @param {string} name 组件名，必填
|
* @param {string} id 句柄id，非必填
|
* @param {number} pointer 句柄指针数字，非必填
|
* @returns
|
*/
|
common.handleId = function (name, id, pointer) {
|
// 组件名不能为空
|
if (name === undefined || name === null || name === "" || typeof name !== 'string') {
|
return
|
}
|
let map = dxMap.get('handleIds')
|
// 句柄id
|
if (id === undefined || id === null || id === "" || typeof id !== 'string') {
|
id = "__" + name + "_default"
|
}
|
if (pointer === undefined || pointer === null || typeof pointer !== 'number') {
|
// pointer为空则为获取
|
return map.get(id)
|
} else {
|
// pointer不为空则为设置
|
let isExist = map.get(id)
|
if (isExist) {
|
// 句柄已存在
|
return
|
}
|
map.put(id, pointer)
|
}
|
}
|
|
|
export default common
|
