Skip to content

J
jensen
Commit 5d3ca68c authored by martin hou's avatar martin hou
Browse files
Options

feat: 调整测试页面

parent 26be443f
Hide whitespace changes
Inline Side-by-side
Showing with 993 additions and 127 deletions
src/index.tsx
View file @ 5d3ca68c
......@@ -2,18 +2,55 @@ import { useEffect, useState } from 'react';
import Jensen, { BluetoothDevice } from '..';
import './index.css';
import { Logger } from './Logger'
import { mgr } from './utils/mgr';
const firmwareVersions = [
{ model: 'hidock-p1:mini', version: '2.1.6', url: 'https://jensen.test.hidock.com/firmwares/p1-mini-2.1.6.bin', remark: 'for samsung' },
{ model: 'hidock-p1:mini', version: '2.1.0', url: 'https://jensen.test.hidock.com/firmwares/mini-2.1.0.bin', remark: '' },
{ model: 'hidock-h1', version: '5.2.9', url: 'https://jensen.test.hidock.com/firmwares/hidock-h1-5.2.9.bin', remark: '' },
{ model: 'hidock-h1e', version: '6.2.9', url: 'https://jensen.test.hidock.com/firmwares/hidock-h1e-6.2.9.bin', remark: '' },
{ model: 'hidock-p1', version: '1.3.6', url: 'https://jensen.test.hidock.com/firmwares/p1-1.3.6.bin', remark: '' },
{ model: 'hidock-p1', version: '1.2.28', url: 'https://jensen.test.hidock.com/firmwares/hidock-p1-1.2.28.bin', remark: 'for testing' },
{ model: 'hidock-p1', version: '1.2.25', url: 'https://jensen.test.hidock.com/firmwares/hidock-p1-1.2.25.bin', remark: '' }
];
const jensen = new Jensen();
export function Home() {
const [files, setFiles] = useState<Jensen.FileInfo[]>([]);
const [devices, setDevices] = useState<Jensen.BluetoothDevice[]>([]);
const [greeting, setGreeting] = useState<string|null>(null);
const [firmwares, setFirmwares] = useState<typeof firmwareVersions|null>(null);
const [logs, setLogs] = useState<string[]>([]);
const [sn, setSn] = useState<string|null>(null);
mgr.onconnectionstatechanged((state, dinfo) => {
console.log('onconnectionstatechanged', state, dinfo);
// alert(JSON.stringify(dinfo));
});
mgr.onautoconnect((dinfo) => {
// console.log('onautoconnect', dinfo);
setSn(dinfo.sn);
// alert(JSON.stringify(dinfo));
});
const getJensen = () => {
if (sn == null) return alert('Please connect to a device first'), null;
return mgr.getInstance(sn);
}
useEffect(() => {
// console.log(mgr);
mgr.tryconnect();
}, []);
useEffect(() => {
/*
jensen.connect();
jensen.onconnect = () => {
console.log('connect successfully');
jensen.addWakeupListener(function() {
console.log('Wake up from sleep?');
});
jensen.getDeviceInfo().then((info) => {
console.log('getDeviceInfo', info);
alert(info.sn + ' connected');
......@@ -21,58 +58,101 @@ export function Home() {
console.log('getDeviceInfo error', e);
});
};
*/
// jensen.onerror = (e) => {
// console.log('onerror', e);
// alert('此设备已经在其它已打开的HiNotes网页上建立连接');
// };
// 创建日志更新定时器
const logUpdateInterval = setInterval(() => {
// 从Logger.messages中获取最后500条记录
let last = Logger.messages.slice(-500).reverse();
// 将last转换为字符串数组
let logStr: string[] = last.map((item) => {
return `[${item.level === 'error' ? 'x' : '*'}] [${new Date(item.time).toLocaleString()}] (${item.module} - ${item.procedure}) ${item.message}`;
});
setLogs(logStr);
}, 1000);
// 清理函数
return () => {
clearInterval(logUpdateInterval);
};
}, []);
const getFilePart = () => {
const file = files[4];
const secondsLength = Math.ceil(file.length / file.duration) * 1000;
console.time('!!!time');
jensen.getFilePart(file.name, secondsLength * 600, (res) => {
if (res instanceof Uint8Array) {
console.timeEnd('!!!time');
}
});
};
const info = async () => {
// alert(sn);
let jensen = getJensen();
if (jensen == null) return;
// console.log('jensen -> ', jensen);
let info = await jensen?.getDeviceInfo();
// alert(JSON.stringify(info));
Logger.info('jensen', 'info', 'Device Info: ' + JSON.stringify(info));
}
let bluetoothDevices: BluetoothDevice[] = [];
const bluetoothScan = async () => {
let jensen = getJensen();
if (jensen == null) return;
setDevices([]);
setGreeting('scan started at: ' + new Date().toLocaleString());
let devices = await jensen.scanDevices();
let count = prompt('Please Input the Scan Count:', '1');
if (count === undefined || count === null) return;
let countNum = parseInt(count);
if (isNaN(countNum) || countNum <= 0) return alert('Please Input the Correct Scan Count');
let rst = await jensen.startBluetoothScan(countNum, 5);
if (rst == null || rst.result != 'success') return alert('start bluetooth scan failed');
// console.log(devices);
// setDevices(devices);
setGreeting('scanning...');
}
const stopBluetoothScan = async () => {
let jensen = getJensen();
if (jensen == null) return;
let rst = await jensen.stopBluetoothScan(5);
if (rst == null || rst.result != 'success') return alert('stop bluetooth scan failed.');
setGreeting('scan stopped');
}
const getScanResults = async () => {
let jensen = getJensen();
if (jensen == null) return;
let devices = await jensen.getScanResults(5);
if (devices == null) return alert('get scan results failed.');
setDevices(devices);
setGreeting(null)
}
const connecty = async () => {
const usb = (navigator as any).usb;
let conn = await usb.requestDevice({
filters: [{ vendorId: 0x10d6 }, { vendorId: 0x3887 }]
});
if (conn == null) return null;
// if (conn.opened) throw new Error('device_already_opened');
await conn.open();
let jensen = new Jensen(Logger, conn);
jensen.onerror = (e) => {
console.log('onerror', e);
alert('此设备已经在其它已打开的HiNotes网页上建立连接');
};
await jensen.initialize();
let dinfo = await jensen.getDeviceInfo();
if (dinfo)
console.log('dinfo', dinfo);
return null;
}
const writeBluetoothDeviceList = async () => {
let jensen = getJensen();
if (jensen == null) return;
let macs = prompt('Please Input the MACs (Separated by ","):', '00:00:00:00:00:00');
if (macs === undefined || macs === null) return;
let macsList = macs.split(',').map((item) => item.trim());
let rst = await jensen.writeBluetoothDeviceList(macsList, 5);
if (rst == null || rst.result != 'success') return alert('write bluetooth device list failed.');
setGreeting('write bluetooth device list success');
}
const connect = async () => {
await jensen.connect();
alert(jensen.getModel() + ' connected')
// await jensen.connect();
// alert(jensen.getModel() + ' connected')
let info = await mgr.connect();
if (info && info.sn)
{
setSn(info.sn);
Logger.info('jensen', 'connect', info.sn + ' connected');
}
else
{
alert('connect failed');
}
}
const disconnectBTDevice = async () => {
let jensen = getJensen();
if (jensen == null) return;
let r = await jensen.disconnectBTDevice();
console.log(r);
}
......@@ -100,52 +180,62 @@ export function Home() {
}
const doConnectBluetooth = async (mac:string) => {
// alert(mac);
let jensen = getJensen();
if (jensen == null) return;
let rst = await jensen.connectBTDevice(mac, 10);
alert('connect: ' + rst.result);
}
const getTime = async () => {
let jensen = getJensen();
if (jensen == null) return;
let time = await jensen.getTime();
alert(JSON.stringify(time));
// alert(JSON.stringify(time));
Logger.info('jensen', 'getTime', 'Time: ' + JSON.stringify(time));
}
const listFiles = async () => {
let jensen = getJensen();
if (jensen == null) return;
let fc = await jensen.getFileCount();
// alert(fc?.count);
let files = await jensen.listFiles();
files.sort((a, b) => {
return b.time.getTime() - a.time.getTime();
});
console.log(files);
setFiles(files)
}
const getBluetoothStatus = async () => {
let jensen = getJensen();
if (jensen == null) return;
let info = await jensen.getBluetoothStatus();
alert(JSON.stringify(info));
// alert(JSON.stringify(info));
Logger.info('jensen', 'getBluetoothStatus', 'Bluetooth: ' + JSON.stringify(info));
}
/*
const readFilePartial = async() => {
if (files.length == 0) return alert('你没有录音文件，或是还没有查询过文件列表');
let s0 = prompt('请输入需要读取的文件序号，从0开始：', '0');
let s1 = prompt('请输入开始位置，从0开始：', '0');
let s2 = prompt('请输入读取字节数量', '32');
if (files.length == 0) return alert('You don\'t have any recording files, or you haven\'t queried the file list');
let s0 = prompt('Please Input the File Index (Start from 0):', '0');
let s1 = prompt('Please Input the Start Position (Start from 0):', '0');
let s2 = prompt('Please Input the Read Byte Count', '32');
if (s0 && s1 && s2) console.log();
else return;
let index = parseInt(s0);
let offset = parseInt(s1);
let length = parseInt(s2);
if (isNaN(index) && isNaN(offset) || isNaN(length)) return;
if (index >= files.length) return alert('请输入正确的文件序号');
if (index >= files.length) return alert('Please Input the Correct File Index');
let file = files[index];
if (offset < 0 || offset > file.length) return alert('请输入正确的读取开始位置');
if (length <= 0) return alert('请输入正确的文件读取长度');
if (offset < 0 || offset > file.length) return alert('Please Input the Correct Read Start Position');
if (length <= 0) return alert('Please Input the Correct Read Byte Count');
let data = await jensen.readFile(file.name, offset, length);
console.log(data);
}
*/
const updateDeviceTone = async () => {
let jensen = getJensen();
if (jensen == null) return;
let resp = await jensen.requestToneUpdate('826d9bac0b535e7babe02b389327a9f2', 1050688);
if (resp.code != 0x00) return alert(resp.result);
......@@ -165,13 +255,21 @@ export function Home() {
}
const updateUAC = async () => {
// 92e66fd8cfd36f09c83fc61491899307 1024
let resp = await jensen.requestUACUpdate('92e66fd8cfd36f09c83fc61491899307', 1024);
let jensen = getJensen();
if (jensen == null) return;
const uac_firmwares = {
'hidock-h1' : { url : '/firmwares/jensen-1-uac.bin', md5 : '92e66fd8cfd36f09c83fc61491899307' },
'hidock-h1e' : { url : '/firmwares/jensen-3-uac.bin', md5 : 'c355c5bf8cc8a8da8bea6b6315ad7649' }
};
let uac = uac_firmwares[jensen.getModel() as keyof typeof uac_firmwares];
if (!uac) return alert('No UAC firmware for your device');
let resp = await jensen.requestUACUpdate(uac.md5, 1024);
if (resp.code != 0x00) return alert(resp.result);
// 下载文件并完成更新处理
let xhr = new XMLHttpRequest();
xhr.open('GET', '/UAC.bin');
xhr.open('GET', uac.url);
xhr.setRequestHeader('Content-Type', 'application/octet-stream');
xhr.responseType = 'arraybuffer';
xhr.onload = function(e)
......@@ -185,19 +283,23 @@ export function Home() {
}
const batteryStatus = async () => {
let jensen = getJensen();
if (jensen == null) return;
let status = await jensen.getBatteryStatus(5);
alert(JSON.stringify(status));
// alert(JSON.stringify(status));
Logger.info('jensen', 'batteryStatus', 'Battery: ' + JSON.stringify(status));
}
let filename = '';
let filelength = 0;
const transferFile = async () => {
if (files == null || files.length == 0) return alert('请先点击List Files');
let idx = prompt('请输入需要获取的文件序号(从0开始)：', '0');
if (files == null || files.length == 0) return alert('Please Click "List Files" first');
let idx = prompt('Please Input the File Index (Start from 0):', '0');
if (idx === undefined || idx === null) return;
let num = parseInt(idx);
if (isNaN(num) || num < 0 || num >= files.length) return alert('请输入正确的序号');
if (isNaN(num) || num < 0 || num >= files.length) return alert('Please Input the Correct Index');
let file = files[num];
// 2025Jun24-165914-Wip00.hda, 232704 @ 19392
filename = file.name;
filelength = file.length;
......@@ -205,97 +307,207 @@ export function Home() {
}
const get_file = () => {
let jensen = getJensen();
if (jensen == null) return;
let recvBytes = 0;
let stime = new Date().getTime();
jensen.getFile(filename, filelength, function(data) {
console.log('data', data.length);
// console.log('data', data.length);
recvBytes += data.length;
if (recvBytes >= filelength) {
let cost = new Date().getTime() - stime;
alert('File Transfer Complete, Cost: ' + cost + ' ms');
}
}, function(recvBytes) {
let percent = Math.floor(recvBytes / filelength * 100);
console.log('progress', percent);
// console.log('progress', percent);
});
}
const writeSN = async () => {
let nsn = prompt('请输入新的SN号', '');
if (nsn && nsn.match(/^HD(H1|1E|P1|PM)\w{9}$/gi))
{
let rst = await jensen.writeSerialNumber(nsn);
alert(rst.result);
}
/*
const test = async () => {
await jensen.reconnect();
let rst = await jensen.getDeviceInfo();
if (rst) alert(rst.sn + ' reconnected...');
else alert('Something went wrong...');
}
*/
const connectx = async () => {
const usb = (navigator as any).usb;
usb.onconnect = (evt: any) => {
console.log(evt);
}
usb.getDevices().then(async (devices: any[]) => {
for (let i = 0; i < devices.length; i++)
{
let dev = devices[i];
await dev.open();
let jensen = new Jensen(Logger, dev);
await jensen.initialize();
let rst = await jensen.getDeviceInfo();
console.log(rst);
const setWebUSBTimeout = async () => {
let jensen = getJensen();
if (jensen == null) return;
let ts = prompt('Please Input the Timeout (ms):', '10000');
if (ts === undefined || ts === null) return;
let timeout = parseInt(ts);
if (isNaN(timeout) || timeout <= 0) return alert('Please Input the Correct Timeout');
await jensen.setWebUSBTimeout(timeout, 30);
Logger.info('jensen', 'setWebUSBTimeout', 'Set Timeout Success');
}
const getWebUSBTimeout = async () => {
let jensen = getJensen();
if (jensen == null) return;
let rst = await jensen.getWebUSBTimeout(5);
// alert(JSON.stringify(rst));
Logger.info('jensen', 'getWebUSBTimeout', 'WebUSB Timeout: ' + JSON.stringify(rst));
}
const listFirmwares = async () => {
let jensen = getJensen();
if (jensen == null) return;
let model = jensen.getModel();
let versions = firmwareVersions.filter((item) => item.model == model);
setFirmwares(versions);
}
const updateFirmware = async (version: string, url: string) => {
let jensen = getJensen();
if (jensen == null) return;
// let rst = await jensen.requestFirmwareUpgrade(version, url);
// alert(JSON.stringify(rst));
if (!confirm('Ready to update firmware, DO NOT close/refresh this page, and wait for the update to complete.\n\n Confirm to continue')) return;
// 版本号类似于1.2.3，需要转换为0x010203
// 将类似于"1.2.3"的字符串转换为0x010203的数值
let versionNumber = 0;
if (version && typeof version === 'string') {
let parts = version.split('.');
if (parts.length === 3) {
versionNumber = (parseInt(parts[0]) << 16) | (parseInt(parts[1]) << 8) | (parseInt(parts[2]));
} else {
alert('invalid version number');
return;
}
});
} else {
alert('invalid version number');
return;
}
Logger.info('jensen', 'ota', 'firmware download start');
let xhr = new XMLHttpRequest();
xhr.open('GET', url);
xhr.responseType = 'arraybuffer';
xhr.onload = function(e) {
if (this.status != 200) return alert('Http Error: ' + this.status);
Logger.info('jensen', 'ota', 'firmware download complete');
Logger.info('jensen', 'ota', 'firmware upgrade start');
jensen.requestFirmwareUpgrade(versionNumber, this.response.byteLength, 30).then((info) => {
Logger.info('jensen', 'ota', 'firmware upgrade: ' + JSON.stringify(info));
if (info.result == 'accepted') {
// alert('firmware upgrade accepted');
Logger.info('jensen', 'ota', 'firmware transfer start');
jensen.uploadFirmware(Array.from(new Uint8Array(this.response)), 30).then((info) => {
if (info == null)
{
Logger.info('jensen', 'ota', 'firmware transfer timedout');
}
else
{
Logger.info('jensen', 'ota', 'firmware transfer complete: ' + JSON.stringify(info));
Logger.info('jensen', 'ota', 'please wait for the firmware upgrade to complete');
}
});
}
else
{
alert('cannot upgrade firmware: ' + info.result);
}
});
}
xhr.send();
}
const test = async () => {
await jensen.reconnect();
let rst = await jensen.getDeviceInfo();
if (rst) alert(rst.sn + ' reconnected...');
else alert('what the fuck????');
const turnPopupOn = async () => {
let jensen = getJensen();
if (jensen == null) return;
// await jensen.();
let rst = await jensen.setNotification(true, 5);
Logger.info('jensen', 'popup', 'Turn Popup On: ' + JSON.stringify(rst));
}
const turnPopupOff = async () => {
let jensen = getJensen();
if (jensen == null) return;
// await jensen.turnPopupOff();
let rst = await jensen.setNotification(false, 5);
Logger.info('jensen', 'popup', 'Turn Popup On: ' + JSON.stringify(rst));
}
const getPairedDevices = async () => {
let devices = await jensen.getPairedDevices();
alert(JSON.stringify(devices));
const getSettings = async () => {
let jensen = getJensen();
if (jensen == null) return;
let rst = await jensen.getSettings(5);
Logger.info('jensen', 'settings', 'Get Settings: ' + JSON.stringify(rst));
}
return (
<>
<div style={{ display: 'flex', flexDirection: 'row', gap: '16px', padding: '16px', alignItems: 'center', flexWrap: 'wrap' }}>
<button onClick={connecty}>连接新设备</button>
<button onClick={connect}>连接</button>
<button onClick={getFilePart}>获取文件</button>
<button onClick={writeSN}>SN写号</button>
<button onClick={getTime}>获取时间</button>
<button onClick={listFiles}>文件列表</button>
<button onClick={transferFile}>传输文件</button>
<button onClick={batteryStatus}>电池电量</button>
<button onClick={getBluetoothStatus}>蓝牙连接状态</button>
<button onClick={bluetoothScan}>蓝牙扫描</button>
<button onClick={disconnectBTDevice}>蓝牙断开</button>
<button onClick={getPairedDevices}>Paired</button>
<button onClick={readFilePartial}>Read File Partial</button>
<button onClick={updateDeviceTone}>更新提示音</button>
<button onClick={updateUAC}>更新UAC</button>
<button onClick={test}>测试重连</button>
<div className="btn-container" style={{ display: 'flex', flexDirection: 'row', gap: '16px', padding: '16px', alignItems: 'center', flexWrap: 'wrap' }}>
<button onClick={connect}>Connect</button>
<button onClick={info}>Info</button>
<button onClick={getTime}>Get Time</button>
<button onClick={listFiles}>List Files</button>
<button onClick={transferFile}>Transfer</button>
<button onClick={batteryStatus}>Battery</button>
<button onClick={getBluetoothStatus}>Bluetooth Status</button>
<button onClick={bluetoothScan}>Start Scan</button>
<button onClick={stopBluetoothScan}>Stop Scan</button>
<button onClick={getScanResults}>Scan Results</button>
<button onClick={writeBluetoothDeviceList}>Write MACs</button>
<button onClick={disconnectBTDevice}>Disconnect</button>
<button onClick={updateDeviceTone}>Update Tone</button>
<button onClick={updateUAC}>Update UAC</button>
<button onClick={setWebUSBTimeout}>Set Timeout</button>
<button onClick={getWebUSBTimeout}>Get Timeout</button>
<button onClick={listFirmwares}>Firmwares</button>
<button onClick={turnPopupOn}>Turn Popup On</button>
<button onClick={turnPopupOff}>Turn Popup Off</button>
<button onClick={getSettings}>Get Settings</button>
</div>
<div id="files" style={{ padding: '0px 0px 0px 30px', marginBottom: '20px' }}>
<h3>Files: </h3>
<ol style={{ padding: '0px 0px 0px 30px', 'listStyle': 'none' }}>
{ files.map((item, index) => {
return <li key={item.name}>{index} - {item?.name}, {item?.length} @ {Math.floor(item.duration / 1000 / 60)} mins</li>
})}
</ol>
</div>
<div style={{ padding: '0px 0px 0px 30px', width: '500px' }}>
<h3>Bluetooth Device List: </h3>
{
greeting ? <div>{greeting}</div> : <></>
}
{
devices && devices.length ? (
devices.map((item, index) => {
return (
<div style={clsBleDevice}><span style={clsBleName}>({item.mac}) {item.name}</span><button style={clsBtnConnect} onClick={() => { doConnectBluetooth(item.mac) }}>Connect</button></div>
);
})
) : (
<div>no devices...</div>
)
}
<div className="result-container">
<div className="list-container">
{
firmwares && firmwares.length ? (
<div style={{ padding: '0px 0px 0px 30px', marginBottom: '20px' }}>
<h3>Firmwares: </h3>
<ol style={{ padding: '0px 0px 0px 20px', 'listStyle': 'none', lineHeight: '20px' }}>
{
firmwares.map((item, index) => {
return <li key={item.version}>{item.version} {item.remark ? '- (' + item.remark + ')' : ''} - <a href="#" onClick={() => { updateFirmware(item.version, item.url) }}>Update</a></li>
})
}
</ol>
</div>
) : (<></>)
}
<div id="files" style={{ padding: '0px 0px 0px 30px', marginBottom: '20px' }}>
<h3>Files: </h3>
<ol style={{ padding: '0px 0px 0px 30px', 'listStyle': 'none' }}>
{ files.map((item, index) => {
return <li key={item.name}>{index} - {item?.name}, {item?.length} @ {item.duration}</li>
})}
</ol>
</div>
<div style={{ padding: '0px 0px 0px 30px', width: '500px' }}>
<h3>Bluetooth Device List: </h3>
{
greeting ? <div>{greeting}</div> : <></>
}
{
devices && devices.length ? (
devices.map((item, index) => {
return (
<div style={clsBleDevice}><span style={clsBleName}>({item.mac}) {item.name}</span><button style={clsBtnConnect} onClick={() => { doConnectBluetooth(item.mac) }}>Connect</button></div>
);
})
) : (
<div>no devices...</div>
)
}
</div>
</div>
<div className="log-container">
<textarea id="log" style={{ width: '100%', height: '100%' }} value={logs.join('\n')} readOnly />
</div>
</div>
</>
);
......
src/utils/mgr.ts 0 → 100644
View file @ 5d3ca68c
import Jensen, { DeviceInfo, ScheduleInfo } from "../../";
import { Logger } from "../Logger";
// 指令参数
export type CommandOptions = {
exclusive?: boolean; // 是否排它性的，在排它性的事务执行期间，其它所有的新事务都不再等待而是直接返回错误
expires?: number; // 超时时长
retry?: number; // 重试次数
wait?: number; // 等待前一个事务完结的最大时长
reconnect?: boolean; // 是否重连来确保事务的成功
params?: any[]; // 原方法的参数
}
// 指令代理函数
export type CommandProxy = (jensen: Jensen | null) => Promise<any> | undefined;
// 指令请求
export type CommandRequest = {
id: string;
command: CommandProxy;
options: CommandOptions;
createTime: number;
}
export type CommandPromise = {
id: string;
resolve: (value:any) => void;
reject: (error:any) => void;
timeout: number;
}
// 定时任务
export type ScheduledTask = {
interval: number;
command: CommandProxy;
onComplete?: (data: any) => void;
}
// 定时任务信息，增加了执行结果的记录
type ScheduledTaskInfo = {
interval: number;
lastExecuteTime: number;
executedCount: number;
command: CommandProxy;
onComplete?: (data: any) => void;
}
type AutoConnectEventHandler = (dinfo: DeviceInfo) => void;
type ConnectionEventHandler = (state: ConnectionStatus, dinfo: DeviceInfo | string | null) => void;
// 连接状态枚举
export type ConnectionStatus = 'connect-timeout' | 'init' | 'connected' | 'reconnected' | 'disconnected';
// exec('set-time', { exclusive: false, expires: 5, })
// setTime(false, true, new Date(), 5)
//
// 连接管理
export class ConnectionManager
{
private logger: typeof Logger;
private connections: Map<string, Jensen>;
private onautoconnectEventListener: AutoConnectEventHandler | null = null;
private onconnectionstatechangedListener: ConnectionEventHandler | null = null;
constructor (_logger: typeof Logger) {
this.logger = _logger;
this.connections = new Map<string, Jensen>();
this.registerUSBEventListener();
}
async registerUSBEventListener () {
const usb = (navigator as any).usb;
const self = this;
usb.onconnect = (evt: any) => {
try
{
let dev = evt.device;
if (dev.vendorId != 0x10d6 && dev.vendorId != 0x3887) return;
self._connect(dev);
}
catch(ex)
{
this.logger.error('jensen', 'onconnect', String(ex));
}
}
usb.ondisconnect = (evt: any) => {
try
{
let dev = evt.device;
if (dev.vendorId != 0x10d6 && dev.vendorId != 0x3887) return;
self._disconnect(dev);
}
catch(ex)
{
this.logger.error('jensen', 'ondisconnect', String(ex));
}
}
}
// 尝试连接，遍历所有的WebUSB设备，如果是HiDock设备，则直接建立连接，并且还要
async tryconnect () {
const usb = (navigator as any).usb;
const self = this;
usb.getDevices().then(async (devices: any[]) => {
for (let i = 0; i < devices.length; i++)
{
let dev = devices[i];
if (dev.opend) continue;
if (dev.vendorId != 0x10d6 && dev.vendorId != 0x3887) continue;
// console.log('auto connect', dev);
self.logger.info('jensen', 'tryconnect', 'VID: ' + dev.vendorId + ', PID: ' + dev.productId);
// 使用dev创建新的Jensen实例
try
{
self._connect(dev);
}
catch(ex)
{
self.logger.error('jensen', 'tryconnect', String(ex));
}
}
});
}
// 连接事件
private async _onstatechanged (state: ConnectionStatus, jensen: Jensen) {
}
// 当设备断开连接时触发，如果设备是之前已经连接过的，那还需要触发ondisconnect事件
private async _disconnect(dev: any) {
let self = this;
this.connections.forEach((j, k) => {
let ud = j.getUSBDevice();
if (ud == dev)
{
// console.log(k + ' disconnected...');
self.logger.info('jensen', 'ondisconnect', k + ' disconnected');
self.onconnectionstatechangedListener?.('disconnected', k);
}
});
}
// 当设备连接时触发，如果设备是之前已经连接过的，那还需要触发onconnect事件
private async _connect (dev: any) {
await dev.open();
let inst = new Jensen(Logger, dev);
this.logger.info('jensen', 'auto-connect', 'initialize');
await inst.initialize();
this.onconnectionstatechangedListener?.('init', inst.getModel());
let dinfo: DeviceInfo | null = null;
for (let i = 0; i < 30; i++)
{
try
{
dinfo = await inst.getDeviceInfo(5);
if (dinfo == null)
{
inst.reconnect();
await sleep(100);
continue;
}
break;
}
catch(e)
{
// ...
}
}
if(dinfo == null) {
console.log('dinfo is null', dev);
}
if(dinfo == null && dev.opened) {
this.onconnectionstatechangedListener?.('connect-timeout', inst.getModel());
try {
dev.close();
dev.forget();
} catch (error) {
// do nothing
}
return;
}
this.logger.info('jensen', 'auto-connect', JSON.stringify(dinfo));
if (dinfo)
{
// 如果是之前已连接的设备，那就需要触发onconnect事件
if (this.connections.has(dinfo.sn))
{
this.connections.set(
dinfo.sn,
// new CommandManager(dinfo, inst)
inst
);
this.logger.info('jensen', 'onconnect', dinfo.sn + ' reconnected');
// let jensen = this.connections.get(dinfo.sn);
// jensen?.setUSBDevice(dev);
this.onconnectionstatechangedListener?.('reconnected', dinfo);
return;
}
this.connections.set(
dinfo.sn,
// new CommandManager(dinfo, inst)
inst
);
try
{
this.onautoconnectEventListener?.(dinfo);
this.onconnectionstatechangedListener?.('connected', dinfo);
}
catch(err)
{
this.logger.error('jensen', 'autoconnect', String(err));
}
}
}
onautoconnect (eventListener: AutoConnectEventHandler) {
this.onautoconnectEventListener = eventListener;
}
// 这个方法用于管理 连接/断开连接 的回调
onconnectionstatechanged (eventHandler: ConnectionEventHandler)
{
this.onconnectionstatechangedListener = eventHandler;
}
// 获取一个Jensen实例
getInstance(tag: string) {
return this.connections.get(tag);
}
// 设置一个Jensen实例
setInstance(tag: string, jensen: Jensen, oldTag: string | null = null) {
if (oldTag) this.connections.delete(oldTag);
this.connections.set(tag, jensen);
}
// 主动连接新设备，如果没有连接成功或是未连接，则直接返回null，如果用户选择的是已连接的设备，则直接抛出异常
// 但是异常的表现形式需要另外商量沟通
async connect () {
const usb = (navigator as any).usb;
let self = this;
let conn = await usb.requestDevice({
filters: [{ vendorId: 0x10d6 }, { vendorId: 0x3887 }]
});
if (conn == null) return null;
if (conn.opened) return Logger.error('jensen', 'connect', 'device already opened');
await conn.open();
let jensen = new Jensen(self.logger, conn);
jensen.onerror = (err) => {
self.logger.error('jensen', 'connect error', String(err));
// myMessage.error(i18n.t('connection.error'), 10000);
}
await jensen.initialize();
let dinfo = await jensen.getDeviceInfo();
// @ts-ignore
jensen.onerror = null;
if (dinfo)
{
self.connections.set(
dinfo.sn,
// new CommandManager(dinfo, inst)
jensen
);
return dinfo
}
return null;
}
// 关闭连接
async close (sn: string) {
let jensen = this.getInstance(sn);
if (jensen) jensen.disconnect();
this.connections.delete(sn);
}
}
// 指令管理/代理
class CommandManager
{
// 设备信息
private serialNumber: string | null = null;
// 命令队列
private commands:CommandRequest[] = [];
// 指令Promise响应
private directives: Map<string, CommandPromise> = new Map<string, CommandPromise>();
// 定时任务
private tasks: ScheduledTaskInfo[] = [];
// 是否暂停定时任务
private suspendTimer: boolean = false;
// Jensen实例
private jensen: Jensen | null = null;
// 当前事务
private currentTask: String | null = null;
constructor(dinfo: DeviceInfo, jensen: Jensen)
{
// TODO: 要不要完全保存deviceInfo？
this.serialNumber = dinfo.sn;
this.jensen = jensen;
// 开启定时器
let self = this;
window.setInterval(function() {
self._executeTimer();
}, 1000);
}
dump () {
// TODO: 完成内部成员的状态输出，用于跟踪连接和事务状态
console.log('###############################################################');
console.log('SerialNumber', this.serialNumber);
console.log('Tasks', this.tasks);
console.log('Commands', this.commands);
console.log('SuspendTimer', this.suspendTimer);
console.log('Jensen Instance', this.jensen);
}
setup () {
// 在连接初次建立时需要做的初始化工作，是不是放在这里还没有想好
}
// onconnect事件如何触发？
// 是不是应该全局唯一触发？好像至少多少时间上就应该重新触发一次
// 或者是每次触发，然后可以被别的地方接管走
// 另外，还有一个问题，如果断开了连接再次连接上来，会话都不同了，还是要按SN做标识，否则多连接管理会出问题
// 增加一个新指令消息
// 怎么样触发新指令呢？
async getDeviceInfo(secs?: number) {
// 当前是否可以执行？
// 我是不是要分一下组？
// 我是不是要加一个模式转换的方法？
return this.jensen?.getDeviceInfo(secs);
// return this.request((jensen) => jensen?.getDeviceInfo(), { reconnect: false });
}
getSerialNumber () {
return this.serialNumber;
}
// 更改模式，要不要超时时长？在超过多长时间后要销毁或者说是恢复过去？
// 1. 当前是什么模式
// 2. 请求指令的是来自于哪个模式？
// 3. 整一个事务控制吧
// 事务开始或结束，不传参数就是事务结束了
// 对于每一个事务而言，应该要尽量确保它执行的成功的，包括重连尝试
async begin(secs: number = 5) {
// 如果应用端尝试变更事务切换不过去，那就应该一直等
// 这里是不是要弄一个可以打断的？如果事务与当前事务一致，又应该怎么办？还是要阻止吧？
// 结束事务
if (this.currentTask)
{
throw new Error("pending task: " + this.currentTask);
}
let tid = this.uuid();
this.currentTask = tid;
return tid;
}
end (id: string) {
if (this.currentTask != id) throw new Error('invalid task: ' + this.currentTask + ' --> ' + id);
this.currentTask = null;
}
// 开始/停止定时任务
// 但是如果停止的话，也只是停止下一轮的执行，要不要等待全部停止完成再说？
startTimer () {
this.suspendTimer = false;
}
stopTimer() {
this.suspendTimer = true;
}
private async _executeTimer () {
if (this.suspendTimer) return;
// 遍历所有的定时器任务
for (let i = 0; i < this.tasks.length; i++)
{
let item = this.tasks[i];
let now = new Date().getTime() / 1000;
if (now - item.lastExecuteTime < item.interval) continue;
try
{
let rst = await item.command.apply(null, [this.jensen]);
item.onComplete?.apply(null, [rst]);
/*
item.command.apply(null, [this.jensen])?.then((rst) => {
item.onComplete?.apply(null, [ rst ]);
});
*/
}
catch(ex)
{
console.error(ex);
}
finally
{
item.lastExecuteTime = now;
}
}
}
// 注册定时任务，返回值为它在列表中的索引位置，可能后面有要解除定时执行的需要，先预留一下
// 这里有个问题，我要如何完成回调呢？
async registerTimer(task: ScheduledTask) {
let len = this.tasks.length;
this.tasks.push({
interval: task.interval,
command: task.command,
lastExecuteTime: 0,
executedCount: 0
});
return len;
}
// 指令分两种，有复杂结构的返回值的或是普通boolean类型的两种
async request (func: CommandProxy, opts: CommandOptions) {
// TODO: 需要在这里注册一个Promise
let self = this;
let rid = this.uuid();
let future = new Promise((resolve, reject) => {
self.directives.set(rid, {
id: rid,
resolve: resolve,
reject: reject,
timeout: opts.expires || 5
});
});
this.commands.push({ command: func, id: rid, options: opts, createTime: new Date().getTime() });
return future;
}
// 需要怎么样持续的执行呢？
async execute(func: CommandProxy, opts: CommandOptions) {
let tid = await this.begin(opts.wait);
try
{
let args: any[] | undefined = opts.params;
let execCount = 0;
let maxTries = (opts.retry || 0) + 1;
do {
execCount += 1;
try
{
let rst: any = await func(this.jensen);
if (rst) return rst;
if (opts.reconnect)
{
// TODO: 连接重新建立
this.logger.info('jensen', 'execute', 'try reconnect');
}
}
catch(ex)
{
console.error(ex);
}
}
while (execCount < maxTries);
}
finally
{
this.end(tid);
}
}
private async tryReconnect()
{
try
{
// TODO: 需要准备一个新的reconnect方法，使用同一个WebUSB实例来close/open来实现重连，否则必然会乱掉
this.jensen?.reconnect();
}
catch(ex)
{
console.error(ex);
}
}
async getTime (timeout?: number) {
return this.jensen?.getTime(timeout);
}
async setTime (date: Date, timeout?: number) {
return this.jensen?.setTime(date, timeout);
}
async getRecordingFile () {
return this.jensen?.getRecordingFile();
}
async getFileCount (timeout?: number) {
return this.jensen?.getFileCount(timeout);
}
async listFiles (timeout?: number) {
return this.jensen?.listFiles(timeout);
}
async readFile (fname: string, offset: number, length: number) {
return this.jensen?.readFile(fname, offset, length);
}
async getFile (fileName: string, length: number, on?: (msg: Uint8Array | 'fail') => void, onprogress?: (size: number) => void) {
return this.jensen?.getFile(fileName, length, on, onprogress);
}
async getFilePart (fileName: string, length: number, on?: (msg: Uint8Array | 'fail') => void, onprogress?: (size: number) => void) {
return this.jensen?.getFilePart(fileName, length, on, onprogress);
}
async getFileBlock (fileName: string, length: number, on?: (msg: Uint8Array | 'fail') => void) {
return this.jensen?.getFileBlock(fileName, length, on);
}
async requestFirmwareUpgrade (vn: number, length: number, timeout?: number) {
return this.jensen?.requestFirmwareUpgrade(vn, length, timeout);
}
async uploadFirmware (data: number[], timeout?: number, onProgress?: (cur: number, total: number) => void) {
return this.jensen?.uploadFirmware(data, timeout, onProgress);
}
async beginBNC (timeout?: number) {
return this.jensen?.beginBNC(timeout);
}
async endBNC (timeout?: number) {
return this.jensen?.endBNC(timeout);
}
async deleteFile (fileName: string) {
return this.jensen?.deleteFile(fileName);
}
async getSettings (timeout?: number) {
return this.jensen?.getSettings(timeout);
}
async setAutoRecord (enable: boolean, timeout?: number) {
return this.jensen?.setAutoRecord(enable, timeout);
}
async setAutoPlay (enable: boolean, timeout?: number) {
return this.jensen?.setAutoPlay(enable, timeout);
}
async setNotification (enable: boolean, timeout?: number) {
return this.jensen?.setNotification(enable, timeout);
}
async setBluetoothPromptPlay (enable: boolean, timeout?: number) {
return this.jensen?.setBluetoothPromptPlay(enable, timeout);
}
async getCardInfo (timeout?: number) {
return this.jensen?.getCardInfo(timeout);
}
async formatCard (timeout?: number) {
return this.jensen?.formatCard(timeout);
}
async factoryReset (timeout?: number) {
return this.jensen?.factoryReset(timeout);
}
async restoreFactorySettings (timeout?: number) {
return this.jensen?.restoreFactorySettings(timeout);
}
async recordTestStart (type: number, timeout?: number) {
return this.jensen?.recordTestStart(type, timeout);
}
async recordTestEnd (type: number, timeout?: number) {
return this.jensen?.recordTestEnd(type, timeout);
}
async test (timeout?: number) {
return this.jensen?.test(timeout);
}
async writeSerialNumber (sn: string) {
return this.jensen?.writeSerialNumber(sn);
}
async getRealtimeSettings () {
return this.jensen?.getRealtimeSettings();
}
async startRealtime () {
return this.jensen?.startRealtime();
}
async pauseRealtime () {
return this.jensen?.pauseRealtime();
}
async stopRealtime () {
return this.jensen?.stopRealtime();
}
async getRealtime (frames: number) {
return this.jensen?.getRealtime(frames);
}
async scanDevices (timeout?: number) {
return this.jensen?.scanDevices(timeout);
}
async connectBTDevice (mac: string, timeout?: number) {
return this.jensen?.connectBTDevice(mac, timeout);
}
async disconnectBTDevice (timeout?: number) {
return this.jensen?.disconnectBTDevice(timeout);
}
async getBluetoothStatus (timeout?: number) {
return this.jensen?.getBluetoothStatus(timeout);
}
async requestToneUpdate (signature: string, size: number, timeout?: number) {
return this.jensen?.requestToneUpdate(signature, size, timeout);
}
async updateTone (data: Uint8Array, timeout?: number) {
return this.jensen?.updateTone(data, timeout);
}
async requestUACUpdate (signature: string, size: number, timeout?: number) {
return this.jensen?.requestUACUpdate(signature, size, timeout);
}
async updateUAC (data: Uint8Array, timeout?: number) {
return this.jensen?.updateUAC(data, timeout);
}
async sendScheduleInfo (info: ScheduleInfo[]) {
return this.jensen?.sendScheduleInfo(info);
}
// 生成唯一id，暂时用随机数生成，后面最好用顺序递增的整数比较好
private uuid () {
return String(Math.floor(1000_0000_0000_0000 + Math.random() * 1000_0000_0000_0000));
}
}
function sleep(ms: number) {
return new Promise(resolve => setTimeout(resolve, ms));
}
export const mgr = new ConnectionManager(Logger);
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment