/**
|
* 网络工作模块 (netWorker.js)
|
*
|
* 功能说明：
|
* - 管理网络连接（以太网、WiFi、4G）
|
* - 支持DHCP和静态IP配置
|
* - 自动重连机制
|
* - 网络状态监控和事件通知
|
* - WiFi扫描功能
|
*
|
* 网络类型：
|
* - type=1: 以太网
|
* - type=2: WiFi
|
* - type=4: 4G
|
*
|
* 网络状态：
|
* - status=4: 已连接
|
* - 其他状态: 未连接或连接中
|
*/
|
|
import net from '../../dxmodules/dxNetwork.js'
|
import std from '../../dxmodules/dxStd.js'
|
import bus from '../../dxmodules/dxEventBus.js'
|
import config from '../../dxmodules/dxConfig.js'
|
import logger from '../../dxmodules/dxLogger.js'
|
import map from '../../dxmodules/dxMap.js'
|
import driver from '../driver.js'
|
import netUtils from '../common/utils/netUtils.js'
|
import * as os from "os"
|
|
// 网络状态跟踪变量
|
let lastConnected = false // 上次连接状态
|
let shouldReconnect = false
|
let lastReconnectTime = 0 // 上次重连时间
|
const RECONNECT_INTERVAL = 15000 // 重连间隔（毫秒）
|
const net_map = map.get("NET")
|
/**
|
* 根据配置建立网络连接
|
*
|
* 支持的连接方式：
|
* 1. 以太网 - DHCP或静态IP
|
* 2. WiFi - DHCP或静态IP
|
* 3. 4G - 自动连接
|
*/
|
function connect() {
|
try {
|
// 如果网络已经连接，不需要重连
|
if (net.isConnected()) {
|
logger.info("NET already connected, skip connect")
|
return 0
|
}
|
|
let res = 0;
|
// 获取网络配置
|
let dhcp = config.get("net.dhcp") == 2 // DHCP启用标志
|
let type = config.get("net.type") // 网络类型
|
|
// 如果未配置网络类型，使用默认的以太网
|
if (!type) {
|
logger.warn("Network type not configured, using default");
|
type = 1; // 默认使用以太网
|
}
|
|
switch (type) {
|
case 1:
|
// 以太网连接
|
if (dhcp) {
|
// 使用DHCP自动获取IP
|
res = net.connectEthWithDHCP()
|
} else {
|
// 使用静态IP配置
|
const ip = config.get("net.ip")
|
const gateway = config.get("net.gateway")
|
const netmask = config.get("net.mask")
|
const dns = config.get("net.dns")
|
logger.info(ip, gateway, netmask, dns);
|
|
// 验证静态IP配置的完整性
|
if (!ip || !gateway || !netmask) {
|
logger.error("Ethernet static IP configuration incomplete");
|
return;
|
}
|
|
// 建立以太网连接
|
res = net.connectEth({ ip, gateway, netmask, dns })
|
}
|
break;
|
|
case 2:
|
// WiFi连接
|
let ssid = config.get("net.ssid")
|
let psk = config.get("net.psk")
|
if (!ssid) {
|
psk = ""
|
}
|
logger.info(ssid, psk);
|
|
if (dhcp) {
|
// 使用DHCP自动获取IP
|
res = net.connectWifiWithDHCP(ssid, psk)
|
} else {
|
// 使用静态IP配置
|
const ip = config.get("net.ip")
|
const gateway = config.get("net.gateway")
|
const netmask = config.get("net.mask")
|
|
// 验证静态IP配置的完整性
|
if (!ip || !gateway || !netmask) {
|
logger.error("WiFi static IP configuration incomplete");
|
return;
|
}
|
|
// 建立WiFi连接
|
res = net.connectWifi(ssid, psk, { ip, gateway, netmask })
|
}
|
break;
|
|
case 4:
|
// 4G连接 - 自动配置
|
res = net.connect4G()
|
break;
|
|
default:
|
logger.warn(`Unknown network type: ${type}`);
|
break;
|
}
|
logger.info("NET connect res:", res);
|
if (res < 0) {
|
//小于0并不是表示网络连接失败，而是一个特殊的错误，可以重试一次就可以
|
const currentTime = Date.now()
|
if (currentTime - lastReconnectTime >= RECONNECT_INTERVAL) {
|
shouldReconnect = true
|
}
|
}
|
return res;
|
} catch (error) {
|
logger.error("Error in connect function:", error);
|
}
|
}
|
|
/**
|
* 网络重连函数
|
*/
|
function reconnect() {
|
logger.info("NET reconnect");
|
shouldReconnect = true
|
}
|
|
/**
|
* 注册事件监听器
|
*
|
* 监听的事件：
|
* - RECONNECT: 手动触发重连
|
* - SCAN_WIFI: 扫描WiFi网络
|
*/
|
function events() {
|
// 监听重连事件
|
bus.on(driver.net.RECONNECT, () => {
|
lastConnected = false
|
reconnect()
|
})
|
|
// 监听WiFi扫描事件
|
bus.on(driver.net.SCAN_WIFI, () => {
|
// 扫描WiFi网络并返回结果
|
// 参数：超时时间2500ms，扫描间隔200ms
|
let wifiList = net.scanWifi(2500, 200)
|
if (wifiList) {
|
let ssidList = wifiList.map(v => v.ssid)
|
let cleaned = netUtils.filterWifiList(ssidList, { maxLen: 64 });
|
bus.fire(driver.net.WIFI_LIST, cleaned)
|
}
|
})
|
}
|
|
|
|
/**
|
* 网络初始化主函数
|
*
|
* 执行步骤：
|
* 1. 初始化网络模块
|
* 2. 设置网络状态回调
|
* 3. 建立网络连接
|
* 4. 创建必要的定时器
|
*/
|
function run() {
|
// 初始化网络模块
|
net.init();
|
shouldReconnect = true
|
}
|
|
let lastConnectedIp
|
// 网络状态监听器
|
function listener() {
|
std.setInterval(() => {
|
try {
|
if (net.getNative()) {
|
net.loop(); // 执行网络循环处理
|
}
|
|
// 先检查网络连接状态
|
if (net.isConnected()) {
|
let param = driver.net.getNetParam()
|
if (!lastConnected || lastConnectedIp != param.ip) {
|
bus.fire(driver.net.CONNECTED_CHANGED, "connected")
|
lastConnected = true
|
net_map.put("NET_STATUS", "connected")
|
lastConnectedIp = param.ip
|
}
|
} else {
|
logger.info("NET not isConnected");
|
// if (lastConnected) {
|
bus.fire(driver.net.CONNECTED_CHANGED, "disconnected")
|
lastConnected = false
|
net_map.put("NET_STATUS", "disconnected")
|
// 自动触发重连
|
shouldReconnect = true
|
// }
|
}
|
|
// 然后检查是否需要重连
|
if (shouldReconnect) {
|
const currentTime = Date.now()
|
if (currentTime - lastReconnectTime >= RECONNECT_INTERVAL) {
|
logger.info("NET shouldReconnect");
|
shouldReconnect = false
|
lastReconnectTime = currentTime
|
connect()
|
} else {
|
// 重连间隔不足，取消重连
|
shouldReconnect = false
|
// logger.info("NET reconnect skipped, interval not reached")
|
}
|
}
|
} catch (error) {
|
logger.error(error)
|
}
|
}, 5000)
|
}
|
|
// 模块初始化
|
try {
|
events() // 注册事件监听器
|
run() // 初始化网络
|
listener()
|
} catch (error) {
|
logger.error(error);
|
}
|
