随着人工智能和大数据技术的快速发展，AI 智能问数（如 ChatBI、Data Agent 数据智能体）正成为企业数字化转型的核心引擎。这种基于自然语言处理的高效数据查询技术方案，让用户可以通过自然语言直接提问，能够理解问题并从海量数据中提取相关信息，最终以可视化或结构化的方式呈现结果。
如今，AI 智能问数正在朝着多模态融合、智能化升级、实时化与自动化方向发展，为企业提供更智能、更高效的数据支持。伴随而来的是企业如何在实现数据民主化的同时，守住数据安全与合规的底线。当一线员工、合作伙伴都能随时探查数据时，如何防止敏感数据泄露成为企业必须直面的问题。
数据泄露是 IT 管理人员最关心的问题，敏感数据泄露（如个人信息、商业机密、财务数据）不仅会导致企业面临监管处罚与声誉损失，还可能造成巨大的人力财力损失。
在 AI 问数场景中，企业数据安全普遍面临三大挑战：权限边界模糊导致越权风险高、敏感数据缺乏细粒度保护、分析过程"黑盒化"导致审计追溯困难。
Aloudata Agent 分析决策智能体采用创新的 NL2MQL2SQL 技术路径，通过在大模型与数据仓库之间构建统一的"NoETL 明细语义层"，从根本上解决了大模型直接查询数据所带来的准确性和安全性难题。
通过 Aloudata Agent，先将用户自然语言问题转换为指标语义查询（MQL），再由指标语义引擎将 MQL 自动转化为 100% 准确的 SQL 语句，在生成 SQL 查询前会通过查询 API 鉴权，核查业务对查询指标、维度及相关数据的权限。这其中，Aloudata Agent 为 AI 问数嵌入了精细化权限管控体系：
例如，某大型零售企业在推行数据民主化过程中，通过 Aloudata Agent 能够为不同角色配置差异化的数据查询权限。如门店店长仅能查看所属门店的销售数据、库存数据，无法看到其他门店信息；片区负责人可查看管辖区域内所有门店数据，但无法查看其他区域数据等。
如此一来，企业便能够实现数据民主化与数据安全的平衡，业务人员可以自主开展数据分析，IT 管理员无需担心数据泄露风险，并将传统需要天级的日报生成流程缩短至分钟级。
在 AI 问数时代，数据安全与使用效率并非零和博弈。Aloudata Agent 通过创新的技术架构和精细化的权限管控能力，为企业提供了从"被动防御"到"主动可控"的数据安全防护方案。通过 Aloudata Agent，企业可以十分放心地拥抱 AI 问数革命，在加速数据驱动决策的同时，确保核心数据资产固若金汤。
Aloudata Agent 采用 NL2MQL2SQL 技术路径，不依赖大模型直接生成 SQL，而是通过指标语义层将自然语言转换为规范的指标查询语言（MQL），再由底层引擎生成准确的 SQL，确保数据结果 100% 正确。这种架构从根本上解决了大模型"幻觉"问题。
在语义层定义阶段即嵌入精细化到行列级的权限策略，当用户发起问数请求时，会自动识别用户身份，并依据其在语义层中的权限，动态生成仅限其访问数据范围内的查询。不同身份的用户询问同一个问题，会自动返回基于其权限过滤后的结果。
不需要。Aloudata Agent 的设计理念是继承和增强现有权限体系。它优先与企业既有的数据目录、权限中心（如 LDAP/AD、Ranger 等）集成，确保权限逻辑统一。管理员只需在 Aloudata Agent 进行细化的策略编排（如脱敏规则、风险词库），而无需从头搭建权限模型。
大家好！今天我们来深入探讨 Vue 3 中最重大的技术变革之一：为什么用 Proxy 全面替代 Object.defineProperty。这不仅仅是简单的 API 替换，而是一次响应式系统的彻底革命！
这是 defineProperty 最致命的缺陷：
登录
// Vue 2 中使用 defineProperty
const data = { name: '张三' }
Object.defineProperty(data, 'name', {
get() {
console.log('读取name')
return this._name
},
set(newVal) {
console.log('设置name')
this._name = newVal
}
})
// 问题来了！
data.age = 25 // ⚠️ 静默失败！无法被检测到！
delete data.name // ⚠️ 静默失败！无法被检测到！
// Vue 2 的补救方案：$set/$delete
this.$set(this.data, 'age', 25) // 必须使用特殊API
this.$delete(this.data, 'name') // 必须使用特殊API
现实影响：
$set/$delete
const arr = [1, 2, 3]
// Vue 2 的数组劫持方案
const arrayProto = Array.prototype
const arrayMethods = Object.create(arrayProto)
;['push', 'pop', 'shift', 'unshift', 'splice', 'sort', 'reverse']
.forEach(method => {
const original = arrayProto[method]
Object.defineProperty(arrayMethods, method, {
value: function mutator(...args) {
const result = original.apply(this, args)
notifyUpdate() // 手动触发更新
return result
}
})
})
// 但这种方式依然有问题：
arr[0] = 100 // ⚠️ 通过索引直接赋值，无法被检测！
arr.length = 0 // ⚠️ 修改length属性，无法被检测！
// defineProperty 需要递归遍历所有属性
function observe(data) {
if (typeof data !== 'object' || data === null) {
return
}
// 递归劫持每个属性
Object.keys(data).forEach(key => {
defineReactive(data, key, data[key])
// 如果是对象，继续递归
if (typeof data[key] === 'object') {
observe(data[key]) // 深度递归，性能消耗大！
}
})
}
// 初始化1000个属性的对象
const largeObj = {}
for (let i = 0; i < 1000; i++) {
largeObj[`key${i}`] = { value: i }
}
// defineProperty: 需要定义2000个getter/setter（1000个属性×2）
// Proxy: 只需要1个代理！
const data = { name: '张三', hobbies: ['篮球', '游泳'] }
const proxy = new Proxy(data, {
// 拦截所有读取操作
get(target, key, receiver) {
console.log(`读取属性：${key}`)
track(target, key) // 收集依赖
return Reflect.get(target, key, receiver)
},
// 拦截所有设置操作
set(target, key, value, receiver) {
console.log(`设置属性：${key} = ${value}`)
const result = Reflect.set(target, key, value, receiver)
trigger(target, key) // 触发更新
return result
},
// 拦截删除操作
deleteProperty(target, key) {
console.log(`删除属性：${key}`)
const result = Reflect.deleteProperty(target, key)
trigger(target, key)
return result
},
// 拦截 in 操作符
has(target, key) {
console.log(`检查属性是否存在：${key}`)
return Reflect.has(target, key)
},
// 拦截 Object.keys()
ownKeys(target) {
console.log('获取所有属性键')
track(target, 'iterate') // 收集迭代依赖
return Reflect.ownKeys(target)
}
})
// 所有操作都能被拦截！
proxy.age = 25 // ✅ 正常拦截
delete proxy.name // ✅ 正常拦截
'age' in proxy // ✅ 正常拦截
Object.keys(proxy) // ✅ 正常拦截
const arr = [1, 2, 3]
const proxyArray = new Proxy(arr, {
set(target, key, value, receiver) {
console.log(`设置数组[${key}] = ${value}`)
// 自动检测数组索引操作
const oldLength = target.length
const result = Reflect.set(target, key, value, receiver)
// 如果是索引赋值
if (key !== 'length' && Number(key) >= 0) {
trigger(target, key)
}
// 如果length变化
if (key === 'length' || oldLength !== target.length) {
trigger(target, 'length')
}
return result
}
})
// 所有数组操作都能完美监控！
proxyArray[0] = 100 // ✅ 索引赋值，正常拦截
proxyArray.push(4) // ✅ push操作，正常拦截
proxyArray.length = 0 // ✅ length修改，正常拦截
// defineProperty 无法支持这些
const map = new Map([['name', '张三']])
const set = new Set([1, 2, 3])
const weakMap = new WeakMap()
const weakSet = new WeakSet()
// Proxy 可以完美代理
const proxyMap = new Proxy(map, {
get(target, key, receiver) {
// Map的get、set、has等方法都能被拦截
const value = Reflect.get(target, key, receiver)
return typeof value === 'function'
? value.bind(target) // 保持方法上下文
: value
}
})
proxyMap.set('age', 25) // ✅ 正常拦截
proxyMap.has('name') // ✅ 正常拦截
// 测试代码
const testData = {}
for (let i = 0; i < 10000; i++) {
testData[`key${i}`] = i
}
// defineProperty 版本
console.time('defineProperty')
Object.keys(testData).forEach(key => {
Object.defineProperty(testData, key, {
get() { /* ... */ },
set() { /* ... */ }
})
})
console.timeEnd('defineProperty') // ~120ms
// Proxy 版本
console.time('Proxy')
const proxy = new Proxy(testData, {
get() { /* ... */ },
set() { /* ... */ }
})
console.timeEnd('Proxy') // ~2ms
// 结果：Proxy 快 60 倍！
// defineProperty: 每个属性都需要定义descriptor
// 1000个属性 = 1000个getter + 1000个setter函数
// Proxy: 只有一个handler对象
// 无论对象有多少属性，都只需要一个代理
// 内存节省：约50%+！
// Proxy 的惰性拦截
const deepObj = {
level1: {
level2: {
level3: {
value: 'deep value'
}
}
}
}
const proxy = new Proxy(deepObj, {
get(target, key, receiver) {
const value = Reflect.get(target, key, receiver)
// 惰性代理：只有访问到时才创建子代理
if (value && typeof value === 'object') {
return reactive(value) // 按需代理
}
return value
}
})
// 只有访问 level1.level2.level3 时才会逐层创建代理
// defineProperty 则必须在初始化时递归所有层级
// Vue 2 的复杂操作
export default {
data() {
return {
user: { name: '张三' }
}
},
methods: {
addProperty() {
// 必须使用 $set
this.$set(this.user, 'age', 25)
},
deleteProperty() {
// 必须使用 $delete
this.$delete(this.user, 'name')
}
}
}
// Vue 3 的直观操作
setup() {
const user = reactive({ name: '张三' })
const addProperty = () => {
user.age = 25 // ✅ 直接赋值！
}
const deleteProperty = () => {
delete user.name // ✅ 直接删除！
}
return { user, addProperty, deleteProperty }
}
// defineProperty 会破坏类型推断
interface User {
name: string
age?: number
}
const user: User = { name: '张三' }
Object.defineProperty(user, 'age', {
value: 25,
writable: true
})
// TypeScript: ❌ 不能将类型“number”分配给类型“undefined”
// Proxy 保持类型安全
const user = reactive<User>({ name: '张三' })
user.age = 25 // ✅ TypeScript 能正确推断
// 核心响应式模块
function reactive(target) {
// 如果已经是响应式对象，直接返回
if (target && target.__v_isReactive) {
return target
}
// 创建代理
return createReactiveObject(
target,
mutableHandlers, // 可变对象的处理器
reactiveMap // 缓存映射，避免重复代理
)
}
function createReactiveObject(target, baseHandlers, proxyMap) {
// 检查缓存
const existingProxy = proxyMap.get(target)
if (existingProxy) {
return existingProxy
}
// 创建代理
const proxy = new Proxy(target, baseHandlers)
// 标记为响应式
proxy.__v_isReactive = true
// 加入缓存
proxyMap.set(target, proxy)
return proxy
}
// 简化的依赖收集系统
const targetMap = new WeakMap() // 目标对象 → 键 → 依赖集合
function track(target, key) {
if (!activeEffect) return
let depsMap = targetMap.get(target)
if (!depsMap) {
depsMap = new Map()
targetMap.set(target, depsMap)
}
let dep = depsMap.get(key)
if (!dep) {
dep = new Set()
depsMap.set(key, dep)
}
dep.add(activeEffect) // 收集当前活动的effect
}
function trigger(target, key) {
const depsMap = targetMap.get(target)
if (!depsMap) return
const dep = depsMap.get(key)
if (dep) {
dep.forEach(effect => effect()) // 触发所有相关effect
}
}
// Proxy 的兼容性考虑
if (typeof Proxy !== 'undefined') {
// 使用 Proxy 实现
return new Proxy(target, handlers)
} else {
// 降级方案：Vue 3 提供了兼容版本
// 但强烈建议使用现代浏览器或polyfill
}
// 实际支持情况：
// - Chrome 49+ ✅
// - Firefox 18+ ✅
// - Safari 10+ ✅
// - Edge 79+ ✅
// - IE 11 ❌（需要polyfill）
const data = {
name: '张三',
getName() {
return this.name
}
}
const proxy = new Proxy(data, {
get(target, key, receiver) {
// receiver 参数很重要！
const value = Reflect.get(target, key, receiver)
// 如果是方法，确保正确的 this 指向
if (typeof value === 'function') {
return value.bind(receiver) // 绑定到代理对象
}
return value
}
})
console.log(proxy.getName()) // ✅ 正确输出"张三"
| 特性 | Object.defineProperty | Proxy |
|---|---|---|
| 属性增删 | 无法检测，需要 set/delete | 完美支持 |
| 数组监控 | 需要hack，索引赋值无效 | 完美支持 |
| 新数据类型 | 不支持 Map、Set 等 | 完美支持 |
| 性能 | 递归遍历，O(n) 初始化 | 惰性代理，O(1) 初始化 |
| 内存 | 每个属性都需要描述符 | 整个对象一个代理 |
| API透明性 | 需要特殊API | 完全透明 |
| TypeScript | 类型推断困难 | 完美支持 |
Vue 3 选择 Proxy 的根本原因：
各位前端开发者们，大家好！今天我们来聊聊Vue 3带来的性能革命——这不仅仅是“快了一点”，而是架构级的全面升级！
Vue 2的响应式系统有个“先天缺陷”——无法检测到对象属性的添加和删除。Vue 3使用Proxy API彻底解决了这个问题：
// Vue 3响应式原理简化版
function reactive(target) {
return new Proxy(target, {
get(obj, key) {
track(obj, key) // 收集依赖
return obj[key]
},
set(obj, key, value) {
obj[key] = value
trigger(obj, key) // 触发更新
return true
}
})
}
实际收益：
Vue 3编译器能识别静态节点，将它们“提升”到渲染函数之外：
// 编译前
<template>
<div>
<h1>Hello World</h1> <!-- 静态节点 -->
<p>{{ dynamicContent }}</p>
</div>
</template>
// 编译后
const _hoisted_1 = /*#__PURE__*/_createVNode("h1", null, "Hello World")
function render() {
return (_openBlock(), _createBlock("div", null, [
_hoisted_1, // 直接引用，无需重新创建
_createVNode("p", null, _toDisplayString(dynamicContent))
]))
}
Vue 3为每个虚拟节点添加“补丁标志”，告诉运行时哪些部分需要更新：
// 编译时生成的优化代码
export function render() {
return (_openBlock(), _createBlock("div", null, [
_createVNode("div", {
class: normalizeClass({ active: isActive })
}, null, 2 /* CLASS */), // 只有class可能变化
_createVNode("div", {
id: props.id,
onClick: handleClick
}, null, 9 /* PROPS, HYDRATE_EVENTS */) // id和事件可能变化
]))
}
支持的Patch Flag类型：
Vue 3自动“拍平”静态子树，大幅减少虚拟节点数量：
// 编译优化前：15个vnode
<div>
<h1>标题</h1>
<div>
<p>静态段落1</p>
<p>静态段落2</p>
<p>静态段落3</p>
</div>
<span>{{ dynamicText }}</span>
</div>
// 编译优化后：只需追踪1个动态节点
const _hoisted_1 = /* 整个静态子树被打包成一个vnode */
// Vue 2选项式API - 整个组件重新计算
export default {
computed: {
fullName() {
return this.firstName + ' ' + this.lastName
},
// 即使只改firstName，所有计算属性都要重新计算
}
}
// Vue 3组合式API - 精准更新
setup() {
const firstName = ref('张')
const lastName = ref('三')
const fullName = computed(() => {
return firstName.value + ' ' + lastName.value
})
// 只有相关的ref变化时才会重新计算
}
Vue 3的模块化架构让打包体积大幅减少：
// 只引入需要的API
import { ref, computed, watch } from 'vue'
// 而不是 import Vue from 'vue'（包含所有内容）
// 结果：生产环境打包体积减少41%！
// 测试条件：1000行 x 10列数据表
Vue 2: 初始渲染 245ms，更新 156ms
Vue 3: 初始渲染 112ms，更新 47ms
// 性能提升：渲染快2.2倍，更新快3.3倍！
// 深层嵌套组件更新
Vue 2: 需要遍历整个组件树
Vue 3: 通过静态分析跳过静态子树
// 更新速度提升最高可达6倍！
Vue 3引入了cacheHandlers事件缓存：
// 内联事件处理函数会被自动缓存
<button @click="count++">点击</button>
// 编译为：
function render() {
return _createVNode("button", {
onClick: _cache[0] || (_cache[0] = ($event) => (count.value++))
}, "点击")
}
Vue 3的SSR性能提升尤为显著：
// Vue 3的流式SSR
const { renderToStream } = require('@vue/server-renderer')
app.get('*', async (req, res) => {
const stream = renderToStream(app, req.url)
// 流式传输，TTFB（首字节时间）大幅减少
res.write('<!DOCTYPE html>')
stream.pipe(res)
})
// 对比结果：
// Vue 2 SSR: 首屏时间 220ms
// Vue 3 SSR: 首屏时间 85ms（提升2.6倍！）
// 可以在Vue 2项目中逐步使用Vue 3特性
import { createApp } from 'vue'
import { Vue2Components } from './legacy'
const app = createApp(App)
// 逐步替换，平滑迁移
// 使用Vue 3的性能标记API
import { mark, measure } from 'vue'
mark('component-start')
// 组件渲染逻辑
measure('component-render', 'component-start')
Vue 3的性能提升不是某个单一优化，而是编译器、运行时、响应式系统三位一体的全面升级：
更重要的是，这些优化都是自动的——你几乎不需要修改代码就能享受性能红利！
最后送给大家一句话： “性能不是功能，但它是所有功能的基础。” Vue 3正是这句话的最佳实践。
回想一下，你上一次用 Apple Pay 买东西（刷交通卡不算）是在什么时候？国内还是国外？
▲ 图｜USA Today
Apple Pay，以及它紧密关联的 Apple Wallet 服务，自 2016 年国区上线以来已经走过了十年的漫长道路。从时间上说，甚至没有比支付宝与微信支付当年的「移动支付大战」晚多少。
然而与支付宝与微信的一路发展壮大不同，Apple Pay 在国内的接受程度始终比较有限——
除了 Apple Wallet 是目前支持范围最广、界面最友好的「交通卡」app 之外，真正用 Apple Pay 付钱买东西的场景其实屈指可数。
被很多人忽视的是：在国内，Apple Pay 实际上是可以在绝大多数有 POS 机的地方刷卡的。只不过我们太过于习惯扫码，连带着实体卡一起把 Apple Pay 给忘了而已。
▲ 2016 年，我们用 Apple Pay 买了 6 份麦当劳
为什么入局不算晚、方式无感且先进的 Apple Pay 在国内推不开呢？原因其实和它背后关联的银行卡组织——也就是大家都熟悉的银联（UnionPay）有着千丝万缕的关系。
过去十年，Apple Wallet 一直仅支持绑定银联卡，不支持国内银行发行的国际卡。由于扫码支付的挤压，原本在国内的使用场景就比较有限，出国旅游时也不能用 Apple Pay 刷一些不支持银联的商户或者服务（比如地铁）。
▲ 巴黎奥运会期间，一些场馆的消费就只能用 Visa 卡｜Cash Essentials
这样一来，让国内 Apple Pay 本就不强的存在感雪上加霜，最后变成了「国内不常用、出国不能用」的窘况，Apple Wallet 何时支持国内发的国际卡的呼声也在近几年越来越高。
这种现状终于迎来了改变——从 2026 年 1 月 15 日起， Apple Pay 终于支持绑定国内银行发行的 Visa（维萨）信用卡了，中国卡不再仅限银联。
其中，首批支持绑定下列 8 家银行的 Visa 卡，通过 Apple Pay 进行跨境支付：
除了首批 8 家银行外，浦发银行、建设银行、民生银行、光大银行等更多银行的 Visa 卡也将在未来一段时间得到支持，基本实现了对于国内主流银行 Visa 卡的全覆盖。
好消息还不止于 Visa，国内银行发行的万事达卡（Mastercard）也将在未来几个月支持添加到国区 Apple Wallet 里面，预计同样涵盖绝大多数主流国内银行，并且支持部分银行的万事达借记卡。
▲ 图｜Financial IT
比较可惜的是，目前苹果尚未宣布国区未来对于美国运通卡（American Express）和 JCB 的支持情况。
但能够一次支持四大国际卡组织中的两个已经是一次巨大的进步，出国刷 Apple Pay 也无疑变得更实用了。
至于如何在 Apple Wallet 里面添加国内银行发行的 Visa 卡，流程和添加银联卡是完全相同的，可以在钱包 app 里快速跳转到银行 app 进行绑定。
总的来说，Apple Pay 中的「中国卡」能够结束银联的独占，引入 Visa 和万事达绝对是一件好事。
不仅出国后的使用场景变得更广泛，更是能够解决一些长久存在的、主要面对个人用户的历史性问题——
毕竟支付宝和微信虽然都对「国内银行发行的国际卡」——即没有银联 logo 的「单标卡」提供了支持，但这一类卡在国内的使用场景极少，出国又因为扫码支付普及率低而很难用上，有时候还不如实体卡方便。
而现在这些卡片支持绑定到国区 Apple Wallet 里面，也就意味着用户除了扫码之外，又多了一条便捷付款的途径。
实际上，爱范儿在参加今年 CES 期间，就遇到过一些演出场馆里，箱包寄存只能通过手机扫码支付的情况，不收现金、也不支持刷卡。
而 Apple Pay 付款就是最方便快捷的办法——这时候，能在 iPhone 上绑一张国内 Visa 卡就能解燃眉之急。
甚至如果你不怎么出国，Apple Pay 搭配国内 Visa 卡依然能够派上用场。
尝试在苹果官网买过港版设备的读者一定知道，目前苹果香港官网仅支持两种付款通道：Visa/万事达/运通信用卡，以及 Apple Pay，不支持银联卡。
这就导致以前想要从官网购买港版设备，必须得繁琐地手动输入信用卡信息，如果只有银联卡的话甚至无法预订、必须线下排队。
Apple Pay 支持中国发行的 Visa 和万事达卡之后，就能在香港官网用 Apple Pay 快捷支付了——
相信我，今年九月份抢首批 iPhone Fold 的时候，这一点点效率的提升，肯定会派上用场的。
#欢迎关注爱范儿官方微信公众号：爱范儿（微信号：ifanr），更多精彩内容第一时间为您奉上。
DTWiFiProvider 是一个跨平台的高级 WiFi 服务封装库，提供了完整的 WiFi 设备管理解决方案。该库支持 WiFi 连接管理、网络扫描、热点配置、设备配网（SmartConfig、AP 模式、BLE 辅助配网）等核心功能，适用于智能家居、物联网设备配网等场景。
设计目标：
WiFi 网络扫描
WiFi 连接管理
热点配置（AP 模式）
设备配网（核心特性）
网络状态监控（核心特性）
智能重连机制（核心特性）
网络配置管理（核心特性）
数据通信
事件回调
日志支持
错误处理
| 平台 | 最低版本要求 | 开发工具 | 语言版本 |
|---|---|---|---|
| iOS | iOS 13.0+ | Xcode 12.0+ | Swift 5.0+ |
| Android | Android 5.0+ (API 21+) | Android Studio | Kotlin/Java |
| HarmonyOS | HarmonyOS 2.0+ | DevEco Studio | ArkTS/Java |
| Flutter | Flutter 2.0+ | VS Code / Android Studio | Dart |
| Web | 现代浏览器（Chrome、Safari、Firefox、Edge） | 任意 IDE | JavaScript/TypeScript |
注意：
在 Info.plist 中添加以下权限说明：
<!-- WiFi 信息访问权限（iOS 13+） -->
<key>NSLocalNetworkUsageDescription</key>
<string>应用需要访问本地网络以连接设备</string>
<!-- 位置权限（iOS 13+，扫描 WiFi 需要） -->
<key>NSLocationWhenInUseUsageDescription</key>
<string>应用需要位置权限以扫描 WiFi 网络</string>
<!-- 网络扩展权限（创建热点需要） -->
<key>com.apple.developer.networking.wifi-info</key>
<true/>
在 Xcode 项目设置中启用以下 Capabilities：
class iOSWiFiPermissionManager {
// 检查位置权限（扫描 WiFi 需要）
func checkLocationPermission() -> PermissionStatus {
switch CLLocationManager.authorizationStatus() {
case .notDetermined:
return .notDetermined
case .restricted, .denied:
return .denied
case .authorizedWhenInUse, .authorizedAlways:
return .authorized
}
}
// 请求位置权限
func requestLocationPermission(callback: (PermissionStatus) -> Void) {
let manager = CLLocationManager()
manager.delegate = self
manager.requestWhenInUseAuthorization()
// 权限结果通过 delegate 回调返回
}
// 检查 WiFi 信息访问权限
func checkWiFiInfoPermission() -> Boolean {
// iOS 13+ 需要用户授权
return NEHotspotConfigurationManager.authorized
}
}
开始
↓
检查位置权限状态
↓
┌─────────────────┐
│ 权限状态判断 │
└────────┬────────┘
│
┌────┴────┬──────────┐
│ │ │
未确定 已授权 已拒绝
│ │ │
↓ ↓ ↓
请求权限 允许使用 引导设置
│ │ │
↓ │ │
等待用户响应 │ │
│ │ │
└─────────┴──────────┘
↓
权限授予？
│
┌────┴────┐
│ │
是 否
│ │
↓ ↓
允许使用 引导设置
在 AndroidManifest.xml 中添加以下权限：
<!-- WiFi 相关权限 -->
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
<uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
<!-- 位置权限（Android 6.0+，扫描 WiFi 需要） -->
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<!-- Android 10+ 需要 -->
<uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />
<!-- 网络权限 -->
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<!-- 创建热点权限（需要系统权限，普通应用无法获取） -->
<uses-permission android:name="android.permission.WRITE_SETTINGS" />
class AndroidWiFiPermissionManager {
// Android 6.0+ 需要的权限
private val WIFI_PERMISSIONS = [
"android.permission.ACCESS_WIFI_STATE",
"android.permission.CHANGE_WIFI_STATE",
"android.permission.ACCESS_FINE_LOCATION",
"android.permission.ACCESS_COARSE_LOCATION"
]
// 检查权限状态
func checkWiFiPermissions(): Map<String, Boolean> {
return checkPermissions(WIFI_PERMISSIONS)
}
// 请求权限
func requestWiFiPermissions(activity: Activity, callback: PermissionCallback) {
val missingPermissions = filterMissingPermissions(WIFI_PERMISSIONS)
if (missingPermissions.isEmpty()) {
callback.onAllPermissionsGranted()
} else {
ActivityCompat.requestPermissions(
activity,
missingPermissions.toTypedArray(),
REQUEST_CODE_WIFI_PERMISSIONS
)
}
}
// 处理权限请求结果
func onRequestPermissionsResult(
requestCode: Int,
permissions: Array<String>,
grantResults: IntArray
) {
if (requestCode == REQUEST_CODE_WIFI_PERMISSIONS) {
val allGranted = grantResults.all {
it == PackageManager.PERMISSION_GRANTED
}
if (allGranted) {
callback.onAllPermissionsGranted()
} else {
callback.onPermissionsDenied(permissions)
}
}
}
}
开始
↓
检查 Android 版本
↓
┌─────────────────┐
│ 版本判断 │
└────────┬────────┘
│
┌────┴────┐
│ │
Android 6.0+ Android 6.0-
│ │
↓ ↓
检查权限 检查权限
(WIFI_STATE) (WIFI_STATE)
(LOCATION) (仅WIFI_STATE)
│ │
└────┬────┘
↓
权限是否已授予？
│
┌────┴────┐
│ │
是 否
│ │
↓ ↓
允许使用 请求权限
│ │
│ ↓
│ 等待用户响应
│ │
│ ┌────┴────┐
│ │ │
│ 已授予 已拒绝
│ │ │
│ ↓ ↓
│ 允许使用 引导设置
│ │ │
└────┴─────────┘
↓
完成
在 module.json5 中添加以下权限：
{
"module": {
"requestPermissions": [
{
"name": "ohos.permission.GET_WIFI_INFO",
"reason": "应用需要访问 WiFi 信息以连接设备",
"usedScene": {
"abilities": ["MainAbility"],
"when": "inuse"
}
},
{
"name": "ohos.permission.SET_WIFI_INFO",
"reason": "应用需要配置 WiFi 以连接设备",
"usedScene": {
"abilities": ["MainAbility"],
"when": "inuse"
}
},
{
"name": "ohos.permission.LOCATION",
"reason": "应用需要位置权限以扫描 WiFi 网络",
"usedScene": {
"abilities": ["MainAbility"],
"when": "inuse"
}
}
]
}
}
class HarmonyOSWiFiPermissionManager {
// 需要的权限列表
private val WIFI_PERMISSIONS = [
"ohos.permission.GET_WIFI_INFO",
"ohos.permission.SET_WIFI_INFO",
"ohos.permission.LOCATION"
]
// 检查权限状态
func checkWiFiPermissions(context: Context): Map<String, PermissionStatus> {
val result = Map<String, PermissionStatus>()
for (permission in WIFI_PERMISSIONS) {
val status = context.verifySelfPermission(permission)
result[permission] = status
}
return result
}
// 请求权限
func requestWiFiPermissions(
context: Context,
callback: PermissionRequestCallback
) {
val missingPermissions = filterMissingPermissions(WIFI_PERMISSIONS)
if (missingPermissions.isEmpty()) {
callback.onAllPermissionsGranted()
} else {
context.requestPermissionsFromUser(
missingPermissions.toTypedArray(),
REQUEST_CODE_WIFI_PERMISSIONS
)
}
}
}
在 pubspec.yaml 中添加权限插件：
dependencies:
permission_handler: ^11.0.0
wifi_iot: ^0.3.18
network_info_plus: ^4.0.0
在 android/app/src/main/AndroidManifest.xml 中添加权限（同 Android 平台配置）
在 ios/Runner/Info.plist 中添加权限（同 iOS 平台配置）
class FlutterWiFiPermissionManager {
// 检查权限状态
Future<Map<Permission, PermissionStatus>> checkWiFiPermissions() async {
if (Platform.isAndroid) {
if (await Permission.location.isGranted &&
await Permission.accessWifiState.isGranted) {
return {Permission.location: PermissionStatus.granted,
Permission.accessWifiState: PermissionStatus.granted}
}
} else if (Platform.isIOS) {
return await Permission.location.status
}
return {}
}
// 请求权限
Future<bool> requestWiFiPermissions() async {
if (Platform.isAndroid) {
if (await Permission.location.request().isGranted &&
await Permission.accessWifiState.request().isGranted) {
return true
}
} else if (Platform.isIOS) {
return await Permission.location.request().isGranted
}
return false
}
}
Web 平台受浏览器安全限制，WiFi 相关功能有限：
class WebNetworkManager {
// 检测网络状态
func checkNetworkStatus(): NetworkStatus {
if (navigator.onLine) {
return NetworkStatus.Online
} else {
return NetworkStatus.Offline
}
}
// 监听网络状态变化
func observeNetworkStatus(callback: (NetworkStatus) -> Void) {
window.addEventListener("online", () -> {
callback(NetworkStatus.Online)
})
window.addEventListener("offline", () -> {
callback(NetworkStatus.Offline)
})
}
}
为了屏蔽不同平台的权限申请差异，设计统一的权限管理接口：
// 权限状态枚举
enum WiFiPermissionStatus {
NotDetermined, // 未确定
Authorized, // 已授权
Denied, // 已拒绝
Restricted, // 受限
Unavailable // 不可用
}
// 统一权限管理接口
interface WiFiPermissionManager {
// 检查权限状态
checkPermissionStatus(): WiFiPermissionStatus
// 请求权限
requestPermission(callback: (status: WiFiPermissionStatus) -> Void)
// 打开系统设置页面
openSettings()
// 检查 WiFi 是否可用
isWiFiAvailable(): Boolean
}
// iOS 实现
class iOSWiFiPermissionManager implements WiFiPermissionManager {
checkPermissionStatus(): WiFiPermissionStatus {
locationStatus = CLLocationManager.authorizationStatus()
wifiInfoStatus = NEHotspotConfigurationManager.authorized
return convertToUnifiedStatus(locationStatus, wifiInfoStatus)
}
requestPermission(callback: (status: WiFiPermissionStatus) -> Void) {
// iOS 权限申请实现
}
}
// Android 实现
class AndroidWiFiPermissionManager implements WiFiPermissionManager {
checkPermissionStatus(): WiFiPermissionStatus {
// Android 权限检查实现
}
requestPermission(callback: (status: WiFiPermissionStatus) -> Void) {
// Android 权限申请实现
}
}
// HarmonyOS 实现
class HarmonyOSWiFiPermissionManager implements WiFiPermissionManager {
checkPermissionStatus(): WiFiPermissionStatus {
// HarmonyOS 权限检查实现
}
requestPermission(callback: (status: WiFiPermissionStatus) -> Void) {
// HarmonyOS 权限申请实现
}
}
// Flutter 实现
class FlutterWiFiPermissionManager implements WiFiPermissionManager {
checkPermissionStatus(): WiFiPermissionStatus {
// Flutter 权限检查实现
}
requestPermission(callback: (status: WiFiPermissionStatus) -> Void) {
// Flutter 权限申请实现
}
}
// Web 实现（功能受限）
class WebWiFiPermissionManager implements WiFiPermissionManager {
checkPermissionStatus(): WiFiPermissionStatus {
// Web 平台不支持 WiFi 权限，返回 Unavailable
return WiFiPermissionStatus.Unavailable
}
requestPermission(callback: (status: WiFiPermissionStatus) -> Void) {
// Web 平台不支持
callback(WiFiPermissionStatus.Unavailable)
}
}
// 工厂类创建对应平台的权限管理器
class WiFiPermissionManagerFactory {
static createManager(platform: Platform): WiFiPermissionManager {
switch (platform) {
case iOS:
return new iOSWiFiPermissionManager()
case Android:
return new AndroidWiFiPermissionManager()
case HarmonyOS:
return new HarmonyOSWiFiPermissionManager()
case Flutter:
return new FlutterWiFiPermissionManager()
case Web:
return new WebWiFiPermissionManager()
default:
throw UnsupportedPlatformException()
}
}
}
项目采用清晰的分层架构，从业务层到底层实现，职责分明：
┌─────────────────────────────────────────┐
│ 业务层 (Business Layer) │
│ - WiFiViewModel │
│ - 封装常用操作，集成所有工具 │
└──────────────┬──────────────────────────┘
│
┌──────────────▼──────────────────────────┐
│ 服务层 (Service Layer) │
│ - WiFiServiceImpl │
│ - 多网络管理，连接重试 │
└──────────────┬──────────────────────────┘
│
┌──────────────▼──────────────────────────┐
│ 底层实现层 (Implementation Layer) │
│ - DTiOSWiFiProvider │
│ - DTAndroidWiFiProvider │
│ - DTHarmonyOSWiFiProvider │
│ - DTFlutterWiFiProvider │
│ - DTWebWiFiProvider │
│ - 基于平台原生 WiFi API │
└─────────────────────────────────────────┘
┌─────────────────────────────────────────┐
│ 工具层 (Utility Layer) │
│ - WiFiCommandBuffer (指令缓冲) │
│ - DTNetworkConfigCache (配置缓存) │
│ - DTReconnectionStateMachine (重连) │
│ - DTSmartConfigProvider (配网工具) │
│ - DTDataFormatConverter (数据格式转换) │
└─────────────────────────────────────────┘
应用场景：
DTNetworkConfigCache.getInstance() - 网络配置缓存单例设计意图：
伪代码实现：
class DTNetworkConfigCache {
private static shared: DTNetworkConfigCache = null
static func getInstance(): DTNetworkConfigCache {
if (shared == null) {
shared = new DTNetworkConfigCache()
}
return shared
}
}
单例模式流程图：
首次调用 getInstance()
↓
检查 shared 是否为 null
↓
┌─────────────────┐
│ shared == null? │
└────────┬────────┘
│
┌────┴────┐
│ │
是 否
│ │
↓ ↓
创建实例 返回已有实例
│ │
↓ │
赋值给 shared │
│ │
└─────────┘
↓
返回实例
应用场景：
ReconnectionStrategy - 重连策略SmartConfigStrategy - 配网策略
ESPTouchStrategy - ESP-Touch 协议AirKissStrategy - AirKiss 协议CustomStrategy - 自定义协议设计意图：
伪代码实现：
interface ReconnectionStrategy {
func calculateDelay(attempt: Integer): Long
}
class ImmediateStrategy implements ReconnectionStrategy {
func calculateDelay(attempt: Integer): Long {
return 0
}
}
class FixedDelayStrategy implements ReconnectionStrategy {
private delay: Long
constructor(delay: Long) {
this.delay = delay
}
func calculateDelay(attempt: Integer): Long {
return delay
}
}
class ExponentialBackoffStrategy implements ReconnectionStrategy {
private initialDelay: Long
private maxDelay: Long
constructor(initialDelay: Long, maxDelay: Long) {
this.initialDelay = initialDelay
this.maxDelay = maxDelay
}
func calculateDelay(attempt: Integer): Long {
delay = initialDelay * (2 ^ attempt)
return min(delay, maxDelay)
}
}
// 配网策略
interface SmartConfigStrategy {
func configure(ssid: String, password: String, callback: ConfigCallback)
func stop()
}
class ESPTouchStrategy implements SmartConfigStrategy {
func configure(ssid: String, password: String, callback: ConfigCallback) {
// ESP-Touch 协议实现
}
}
class AirKissStrategy implements SmartConfigStrategy {
func configure(ssid: String, password: String, callback: ConfigCallback) {
// AirKiss 协议实现
}
}
策略模式流程图：
需要执行操作（重连/配网）
↓
获取当前策略
↓
┌─────────────────┐
│ 策略类型判断 │
└────────┬────────┘
│
┌────┴────┬──────────────┬──────────────┐
│ │ │ │
立即策略 固定延迟策略 指数退避策略 自定义策略
│ │ │ │
↓ ↓ ↓ ↓
返回 0 返回固定值 计算指数延迟 调用自定义函数
│ │ │ │
│ │ │ │
└─────────┴──────────────┴──────────────┘
↓
返回结果
应用场景：
DTReconnectionStateMachine - 重连状态机DTWiFiConnectionStateMachine - WiFi 连接状态机状态流转：
idle → connecting → connected/disconnected/failed
设计意图：
伪代码实现：
enum WiFiConnectionState {
Idle,
Connecting,
Connected,
Disconnected,
Failed,
Paused
}
class DTWiFiConnectionStateMachine {
private currentState: WiFiConnectionState = WiFiConnectionState.Idle
func transitionTo(newState: WiFiConnectionState) throws {
if (isValidTransition(from: currentState, to: newState)) {
currentState = newState
notifyStateChanged(newState)
} else {
throw InvalidStateTransitionException()
}
}
}
状态机模式流程图：
初始状态: Idle
↓
connectToWiFi()
↓
┌─────────────────┐
│ 状态转换判断 │
└────────┬────────┘
│
┌────┴────┐
│ │
Idle 其他状态
│ │
↓ ↓
转换到 拒绝转换
Connecting
│
↓
┌─────────────────┐
│ 连接过程中 │
└────────┬────────┘
│
┌────┴────┬──────────┬──────────┐
│ │ │ │
连接成功 连接失败 暂停请求 超时
│ │ │ │
↓ ↓ ↓ ↓
Connected Failed Paused Failed
│ │ │ │
│ │ │ │
│ │ │ │
└─────────┴──────────┴──────────┘
↓
转换回 Idle
应用场景：
onWiFiStateChanged、onNetworkListChanged 等设计意图：
伪代码实现：
class WiFiServiceImpl {
private wifiState: Observable<WiFiState>
private networkList: Observable<List<WiFiNetwork>>
// 或者使用回调方式
var onWiFiStateChanged: Callback<WiFiState>
var onNetworkListChanged: Callback<List<WiFiNetwork>>
// 通知观察者
func notifyWiFiStateChanged(state: WiFiState) {
wifiState.emit(state)
if (onWiFiStateChanged != null) {
onWiFiStateChanged.invoke(state)
}
}
}
观察者模式流程图：
WiFi 状态发生变化
↓
WiFiServiceImpl 检测到变化
↓
┌─────────────────┐
│ 通知所有观察者 │
└────────┬────────┘
│
┌────┴────┬──────────────┐
│ │ │
Observable 回调函数1 回调函数2
│ │ │
↓ ↓ ↓
发送事件 执行回调 执行回调
│ │ │
│ │ │
└─────────┴──────────────┘
↓
观察者更新状态
应用场景：
WiFiProviderFactory - 创建不同平台的 ProviderSmartConfigFactory - 创建不同协议的配网工具设计意图：
伪代码实现：
class WiFiProviderFactory {
static func createProvider(
platform: Platform,
platformContext: PlatformContext
): WiFiProvider {
switch (platform) {
case iOS:
return new DTiOSWiFiProvider(platformContext)
case Android:
return new DTAndroidWiFiProvider(platformContext)
case HarmonyOS:
return new DTHarmonyOSWiFiProvider(platformContext)
case Flutter:
return new DTFlutterWiFiProvider(platformContext)
case Web:
return new DTWebWiFiProvider(platformContext)
default:
throw UnsupportedPlatformException()
}
}
}
工厂模式流程图：
需要创建 WiFiProvider
↓
调用 Factory.createProvider()
↓
传入平台类型和平台上下文
↓
┌─────────────────┐
│ 平台类型判断 │
└────────┬────────┘
│
┌────┴────┬──────────┬──────────┬──────────┐
│ │ │ │ │
iOS Android HarmonyOS Flutter Web
│ │ │ │ │
↓ ↓ ↓ ↓ ↓
创建 iOS 创建 Android 创建 HarmonyOS 创建 Flutter 创建 Web
Provider Provider Provider Provider Provider
│ │ │ │ │
└─────────┴──────────┴──────────┴──────────┘
↓
返回 Provider
应用场景：
WiFiProvider 统一接口，屏蔽不同平台的差异设计意图：
DTWiFiProvider 通过统一的接口抽象，屏蔽不同平台的底层实现差异：
interface WiFiProvider {
// 扫描 WiFi 网络
func scanNetworks(
callback: Callback<List<WiFiNetwork>>
)
// 停止扫描
func stopScan()
// 连接 WiFi 网络
func connect(
network: WiFiNetwork,
password: String?
): Boolean
// 断开 WiFi 连接
func disconnect()
// 获取当前连接的 WiFi
func getCurrentNetwork(): WiFiNetwork?
// 获取已保存的网络列表
func getSavedNetworks(): List<WiFiNetwork>
// 删除已保存的网络
func removeSavedNetwork(ssid: String): Boolean
// 创建热点
func createHotspot(
ssid: String,
password: String,
security: SecurityType
): Boolean
// 停止热点
func stopHotspot()
// 获取热点状态
func getHotspotStatus(): HotspotStatus?
}
// 统一的数据结构
class WiFiNetwork {
ssid: String
bssid: String?
signalStrength: Integer // RSSI (dBm)
frequency: Integer // MHz
security: SecurityType
isConnected: Boolean
isSaved: Boolean
}
enum SecurityType {
NONE, // 开放网络
WPA, // WPA
WPA2, // WPA2
WPA3, // WPA3
WEP, // WEP（已废弃）
EAP // 企业级认证
}
统一接口抽象流程图：
业务层调用 WiFi 操作
↓
通过 WiFiProvider 接口
↓
┌─────────────────┐
│ 根据平台选择实现 │
└────────┬────────┘
│
┌────┴────┬──────────┬──────────┬──────────┐
│ │ │ │ │
iOS Android HarmonyOS Flutter Web
│ │ │ │ │
↓ ↓ ↓ ↓ ↓
iOS实现 Android实现 HarmonyOS实现 Flutter实现 Web实现
│ │ │ │ │
└─────────┴──────────┴──────────┴──────────┘
↓
调用平台API
↓
返回结果
class DTiOSWiFiProvider implements WiFiProvider {
private locationManager: CLLocationManager
private wifiManager: NEHotspotConfigurationManager
func scanNetworks(callback: Callback<List<WiFiNetwork>>) {
// iOS 13+ 需要使用 NetworkExtension 框架
// 需要用户授权位置权限
if (checkLocationPermission() != Authorized) {
requestLocationPermission()
return
}
// 使用 NEHotspotHelper 扫描网络（需要 Network Extension）
// 或者使用第三方库
scanWithNetworkExtension(callback)
}
func connect(network: WiFiNetwork, password: String?): Boolean {
let config = NEHotspotConfiguration(
ssid: network.ssid,
passphrase: password,
isWEP: network.security == SecurityType.WEP
)
wifiManager.apply(config) { error in
if (error != null) {
callback.onError(error)
} else {
callback.onSuccess()
}
}
}
func getCurrentNetwork(): WiFiNetwork? {
// iOS 需要使用 NetworkExtension 或 SystemConfiguration
return getCurrentNetworkWithSystemConfiguration()
}
}
class DTAndroidWiFiProvider implements WiFiProvider {
private wifiManager: WifiManager
private context: Context
func scanNetworks(callback: Callback<List<WiFiNetwork>>) {
if (checkPermissions() != AllGranted) {
requestPermissions()
return
}
// 注册广播接收器监听扫描结果
registerScanResultReceiver(callback)
// 开始扫描
wifiManager.startScan()
}
func connect(network: WiFiNetwork, password: String?): Boolean {
// Android 10+ 需要使用 WifiNetworkSpecifier
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
return connectWithNetworkSpecifier(network, password)
} else {
return connectWithWifiConfiguration(network, password)
}
}
func getCurrentNetwork(): WiFiNetwork? {
val wifiInfo = wifiManager.connectionInfo
return WiFiNetwork(
ssid: wifiInfo.ssid,
bssid: wifiInfo.bssid,
signalStrength: wifiInfo.rssi,
frequency: wifiInfo.frequency,
security: getSecurityType(wifiInfo),
isConnected: true
)
}
}
class DTHarmonyOSWiFiProvider implements WiFiProvider {
private wifiManager: wifiManager
func scanNetworks(callback: Callback<List<WiFiNetwork>>) {
if (checkPermissions() != AllGranted) {
requestPermissions()
return
}
// 注册扫描结果回调
wifiManager.on("wifiStateChange", (state) -> {
if (state == WifiState.SCAN_RESULTS_AVAILABLE) {
val scanResults = wifiManager.getScanResults()
val networks = convertToWiFiNetworks(scanResults)
callback.onSuccess(networks)
}
})
// 开始扫描
wifiManager.startWifiScan()
}
func connect(network: WiFiNetwork, password: String?): Boolean {
val config = {
ssid: network.ssid,
preSharedKey: password,
securityType: convertSecurityType(network.security)
}
return wifiManager.connectToDevice(config)
}
}
因篇幅过大而删除缩减...
因篇幅过大而删除缩减...
DTWiFiProvider 支持多种设备配网方式：
SmartConfig 配网
AP 模式配网
BLE 辅助配网
基于实际实现的最佳实践：
设备端准备
手机端实现
协议选择策略
错误处理
因篇幅过大而删除缩减...
SmartConfig 配网流程图：
开始配网
↓
选择配网协议
↓
┌─────────────────┐
│ 协议类型判断 │
└────────┬────────┘
│
┌────┴────┬──────────┐
│ │ │
ESP-Touch AirKiss 自定义
│ │ │
↓ ↓ ↓
编码数据 编码数据 编码数据
│ │ │
↓ ↓ ↓
UDP广播 UDP广播 UDP广播
│ │ │
↓ ↓ ↓
监听响应 监听响应 监听响应
│ │ │
└─────────┴──────────┘
↓
设备响应？
│
┌────┴────┐
│ │
是 否
│ │
↓ ↓
配网成功 继续发送
│ │
│ ↓
│ 超时检查
│ │
│ ┌────┴────┐
│ │ │
│ 超时 未超时
│ │ │
│ ↓ │
│ 配网失败 │
│ │ │
└────┴─────────┘
↓
完成配网
因篇幅过大而删除缩减...
AP 模式配网流程图：
开始配网
↓
扫描设备热点
↓
┌─────────────────┐
│ 找到设备热点？ │
└────────┬────────┘
│
┌────┴────┐
│ │
是 否
│ │
↓ ↓
连接设备热点 配网失败
│
↓
┌─────────────────┐
│ 连接成功？ │
└────────┬────────┘
│
┌────┴────┐
│ │
是 否
│ │
↓ ↓
发送配置 配网失败
│
↓
┌─────────────────┐
│ 配置成功？ │
└────────┬────────┘
│
┌────┴────┐
│ │
是 否
│ │
↓ ↓
配网成功 配网失败
场景描述： 智能摄像头首次使用时，需要连接到家庭 WiFi 网络。由于摄像头没有屏幕和键盘，无法直接输入 WiFi 密码，因此采用 AP 模式配网：摄像头创建热点，手机 App 连接摄像头热点后，通过 HTTP 接口将家庭 WiFi 信息发送给摄像头。
配网流程：
1. 用户按下摄像头配网按钮
↓
2. 摄像头进入 AP 模式，创建热点（SSID: Camera-XXXX）
↓
3. 手机 App 扫描并发现摄像头热点
↓
4. 用户点击"连接摄像头"
↓
5. 手机自动断开当前 WiFi，连接摄像头热点
↓
6. 手机通过 HTTP 发送家庭 WiFi 信息到摄像头
↓
7. 摄像头保存 WiFi 信息，断开热点，连接家庭 WiFi
↓
8. 配网完成，摄像头上线
代码实现示例：
因篇幅过大而删除缩减...
注意事项：
场景描述： 智能插座（如小米智能插座、TP-Link 智能插座）通常使用 SmartConfig 配网方式。手机 App 连接到目标 WiFi 后，通过 UDP 广播将 WiFi 信息发送给插座，插座接收后自动连接 WiFi。
配网流程：
1. 用户打开 App，选择"添加设备"
↓
2. 用户输入家庭 WiFi 密码
↓
3. App 连接到目标 WiFi
↓
4. App 启动 SmartConfig（ESP-Touch 协议）
↓
5. App 通过 UDP 广播发送 WiFi 信息
↓
6. 插座接收并解析 WiFi 信息
↓
7. 插座连接家庭 WiFi
↓
8. 插座发送确认消息（包含设备 IP）
↓
9. App 接收确认，配网完成
代码实现示例：
因篇幅过大而删除缩减...
使用示例：
class SmartPlugViewModel {
private val configProvider = SmartPlugConfigProvider()
func addSmartPlug() {
// 获取用户输入的 WiFi 信息
val ssid = userInput.wifiSSID
val password = userInput.wifiPassword
// 检查是否已连接到目标 WiFi
if (getCurrentWiFi().ssid != ssid) {
// 提示用户连接 WiFi
showDialog("请先连接到 WiFi: ${ssid}")
return
}
// 开始配网
configProvider.configureSmartPlug(
targetSSID: ssid,
targetPassword: password
) { result ->
when (result) {
is Progress -> {
updateProgressBar(result.progress)
}
is DeviceFound -> {
showMessage("发现设备: ${result.deviceIP}")
}
is Success -> {
showMessage("配网成功！设备 IP: ${result.deviceIP}")
// 保存设备信息
saveDevice(result.deviceIP)
}
is Error -> {
showError("配网失败: ${result.message}")
}
}
}
}
}
场景描述： 智能门锁通常同时支持 WiFi 和蓝牙。首次配网时，通过蓝牙发送 WiFi 信息给门锁，门锁连接 WiFi 后通过云端注册。这种方式结合了蓝牙的便捷性和 WiFi 的远程控制能力。
配网流程：
1. 用户打开 App，选择"添加门锁"
↓
2. App 扫描附近的蓝牙门锁
↓
3. 用户选择要配网的门锁
↓
4. App 通过蓝牙连接门锁
↓
5. App 通过蓝牙发送 WiFi 信息（SSID + 密码）
↓
6. 门锁接收 WiFi 信息，断开蓝牙
↓
7. 门锁连接家庭 WiFi
↓
8. 门锁连接云端服务器，注册设备
↓
9. App 通过云端查询门锁状态，配网完成
代码实现示例：
因篇幅过大而删除缩减...
场景描述： 智能音箱（如小爱音箱、天猫精灵）支持多种配网方式。优先使用 SmartConfig，如果失败则自动切换到 AP 模式。这种方式提高了配网成功率。
配网流程：
1. 用户打开 App，选择"添加音箱"
↓
2. App 尝试 SmartConfig 配网（30秒）
↓
3. SmartConfig 成功？
┌────┴────┐
│ │
是 否
│ │
↓ ↓
配网完成 切换到 AP 模式
│
↓
4. 扫描音箱热点
│
↓
5. 连接音箱热点
│
↓
6. 发送 WiFi 配置
│
↓
7. 配网完成
代码实现示例：
因篇幅过大而删除缩减...
场景描述： Mesh 路由器系统（如小米 Mesh、TP-Link Deco）需要将多个路由器节点连接到同一网络。主节点通过 WiFi 连接，子节点通过有线或无线方式连接到主节点。
配网流程：
1. 配置主节点（通过 WiFi 连接）
↓
2. 主节点连接家庭 WiFi
↓
3. 启动 Mesh 网络
↓
4. 添加子节点
↓
5. 子节点扫描 Mesh 网络
↓
6. 子节点连接到主节点
↓
7. 子节点同步网络配置
↓
8. Mesh 网络建立完成
代码实现示例：
因篇幅过大而删除缩减...
场景描述： 智能家居网关需要同时管理多个子设备（如智能开关、传感器等）。网关通过 Zigbee/蓝牙等方式连接子设备，然后网关本身通过 WiFi 连接到家庭网络。
配网流程：
1. 配置网关 WiFi 连接（SmartConfig 或 AP 模式）
↓
2. 网关连接家庭 WiFi
↓
3. 启动子设备扫描
↓
4. 发现附近的子设备
↓
5. 用户选择要添加的子设备
↓
6. 网关与子设备配对
↓
7. 子设备注册到网关
↓
8. 批量配网完成
代码实现示例：
因篇幅过大而删除缩减...
| 配网方式 | 适用场景 | 优点 | 缺点 | 推荐设备类型 |
|---|---|---|---|---|
| AP 模式 | 有屏幕/按钮的设备 | 稳定可靠，兼容性好 | 需要手动切换 WiFi | 摄像头、路由器、智能电视 |
| SmartConfig | 无屏幕的简单设备 | 操作简单，用户体验好 | 对网络环境要求高 | 智能插座、智能灯泡、传感器 |
| BLE 辅助 | 支持蓝牙的设备 | 配网速度快，稳定 | 需要蓝牙支持 | 智能门锁、智能手环、智能秤 |
| 混合模式 | 高端智能设备 | 成功率高，用户体验好 | 实现复杂 | 智能音箱、智能网关 |
DTNetworkConfigCache 用于持久化存储和管理 WiFi 网络配置：
配置存储
自动连接
class NetworkConfigRecord {
ssid: String
password: String?
security: SecurityType
savedTime: Long
lastConnectionTime: Long
connectionCount: Integer = 0
priority: Integer = 0 // 优先级，数字越大优先级越高
autoConnect: Boolean = true
metadata: Map<String, String>?
}
class DTNetworkConfigCache {
private static shared: DTNetworkConfigCache = null
private configRecords: Map<String, NetworkConfigRecord> = {}
private storage: LocalStorage
static func getInstance(): DTNetworkConfigCache {
if (shared == null) {
shared = new DTNetworkConfigCache()
}
return shared
}
func saveConfig(
ssid: String,
password: String?,
security: SecurityType,
priority: Integer = 0
) {
now = currentTime()
existingRecord = configRecords[ssid]
if (existingRecord != null) {
existingRecord.password = password
existingRecord.lastConnectionTime = now
existingRecord.connectionCount++
existingRecord.priority = priority
configRecords[ssid] = existingRecord
} else {
newRecord = new NetworkConfigRecord(
ssid: ssid,
password: password,
security: security,
savedTime: now,
lastConnectionTime: now,
connectionCount: 1,
priority: priority,
autoConnect: true
)
configRecords[ssid] = newRecord
}
saveToStorage()
}
func getConfigsByPriority(): List<NetworkConfigRecord> {
return configRecords.values()
.filter { it.autoConnect }
.sortedByDescending { it.priority }
.thenByDescending { it.lastConnectionTime }
}
private func saveToStorage() {
json = JSON.serialize(configRecords)
storage.putString("network_configs", json)
}
private func loadFromStorage() {
json = storage.getString("network_configs")
if (json != null) {
configRecords = JSON.deserialize(json, Map<String, NetworkConfigRecord>)
}
}
}
网络配置缓存流程图：
连接 WiFi 成功
↓
调用 saveConfig()
↓
┌─────────────────┐
│ 检查是否已有配置 │
└────────┬────────┘
│
┌────┴────┐
│ │
是 否
│ │
↓ ↓
更新配置 创建新配置
(连接次数+1) (首次保存)
(更新时间) (记录时间)
│ │
└────┬────┘
↓
保存到内存
↓
序列化为 JSON
↓
保存到本地存储
↓
完成
DTReconnectionStateMachine 管理 WiFi 断开后的重连逻辑：
状态管理
idle - 空闲状态reconnecting - 正在重连中paused - 暂停重连failed - 重连失败succeeded - 重连成功重连策略
immediate - 立即重连fixedDelay - 固定延迟exponentialBackoff - 指数退避custom - 自定义策略class DTReconnectionStateMachine {
private strategy: ReconnectionStrategy
private maxRetries: Integer = 5
private connectionTimeout: Long = 30000
private currentState: ReconnectionState = ReconnectionState.Idle
private retryCount: Integer = 0
private reconnectionTask: Task = null
private stateObservable: Observable<ReconnectionState>
constructor(strategy: ReconnectionStrategy) {
this.strategy = strategy
this.stateObservable = new Observable()
}
func startReconnection(
network: WiFiNetwork,
connectFunction: Function<WiFiNetwork, Boolean>
) {
if (currentState != ReconnectionState.Idle) {
return
}
currentState = ReconnectionState.Reconnecting(0)
stateObservable.emit(currentState)
retryCount = 0
reconnectionTask = async {
while (retryCount < maxRetries &&
currentState is ReconnectionState.Reconnecting) {
delay = strategy.calculateDelay(retryCount)
if (delay > 0) {
sleep(delay)
}
try {
success = timeout(connectionTimeout) {
connectFunction(network)
}
if (success) {
currentState = ReconnectionState.Succeeded
stateObservable.emit(currentState)
currentState = ReconnectionState.Idle
stateObservable.emit(currentState)
return
} else {
retryCount++
currentState = ReconnectionState.Reconnecting(retryCount)
stateObservable.emit(currentState)
}
} catch (TimeoutException e) {
retryCount++
currentState = ReconnectionState.Reconnecting(retryCount)
stateObservable.emit(currentState)
}
}
if (retryCount >= maxRetries) {
currentState = ReconnectionState.Failed
stateObservable.emit(currentState)
currentState = ReconnectionState.Idle
stateObservable.emit(currentState)
}
}
}
}
重连状态机完整流程图：
初始状态: Idle
↓
startReconnection()
↓
┌─────────────────┐
│ 状态检查 │
└────────┬────────┘
│
┌────┴────┐
│ │
Idle 其他状态
│ │
↓ ↓
转换到 拒绝启动
Reconnecting
│
↓
初始化重试计数 = 0
↓
┌─────────────────┐
│ 重连循环 │
└────────┬────────┘
│
┌────┴────┐
│ │
重试次数<最大 重试次数>=最大
│ │
↓ ↓
计算延迟 转换到 Failed
│ │
↓ │
等待延迟 │
│ │
↓ │
执行连接 │
│ │
↓ │
┌───┴───┐ │
│ │ │
成功 失败 │
│ │ │
↓ ↓ │
转换到 重试计数++ │
Succeeded │ │
│ 转换到 │
│Reconnecting│
│ │ │
│ └─────┘
│ │
└─────┘
↓
转换回 Idle
DTWiFiProvider 支持多种数据通信方式：
TCP Socket 通信
UDP Socket 通信
HTTP/HTTPS 请求
WebSocket 连接
interface TCPSocket {
func connect(host: String, port: Integer, callback: ConnectCallback)
func send(data: ByteArray, callback: SendCallback)
func receive(callback: ReceiveCallback)
func close()
}
class DTTCPSocket implements TCPSocket {
private socket: Socket
private isConnected: Boolean = false
func connect(host: String, port: Integer, callback: ConnectCallback) {
async {
try {
socket = new Socket()
await socket.connect(host, port)
isConnected = true
callback.onSuccess()
} catch (Exception e) {
callback.onError(e)
}
}
}
func send(data: ByteArray, callback: SendCallback) {
if (!isConnected) {
callback.onError(NotConnectedException())
return
}
async {
try {
await socket.write(data)
callback.onSuccess()
} catch (Exception e) {
callback.onError(e)
}
}
}
func receive(callback: ReceiveCallback) {
if (!isConnected) {
callback.onError(NotConnectedException())
return
}
async {
try {
data = await socket.read()
callback.onData(data)
} catch (Exception e) {
callback.onError(e)
}
}
}
}
// 使用 platform channels 调用原生代码
class FlutterWiFiProvider {
private methodChannel: MethodChannel
Future<List<WiFiNetwork>> scanNetworks() async {
try {
List<dynamic> networks = await methodChannel.invokeMethod('scanNetworks')
return networks.map((n) -> WiFiNetwork.fromMap(n)).toList()
} catch (e) {
throw WiFiException(e.message)
}
}
Future<Boolean> connect(String ssid, String? password) async {
try {
return await methodChannel.invokeMethod('connectWiFi', {
'ssid': ssid,
'password': password
})
} catch (e) {
throw WiFiException(e.message)
}
}
}
// iOS 原生实现
@objc class WiFiPlugin: NSObject, FlutterPlugin {
func handle(_ call: FlutterMethodCall, result: @escaping FlutterResult) {
switch call.method {
case "scanNetworks":
scanNetworks(result: result)
case "connectWiFi":
let args = call.arguments as! [String: Any]
connectWiFi(ssid: args["ssid"] as! String,
password: args["password"] as? String,
result: result)
default:
result(FlutterMethodNotImplemented)
}
}
}
// Android 原生实现
class WiFiPlugin: MethodCallHandler {
override fun onMethodCall(call: MethodCall, result: Result) {
when (call.method) {
"scanNetworks" -> scanNetworks(result)
"connectWiFi" -> {
val ssid = call.argument<String>("ssid")
val password = call.argument<String>("password")
connectWiFi(ssid, password, result)
}
else -> result.notImplemented()
}
}
}
// Web 平台使用 Web API
class WebWiFiProvider {
// 网络状态检测
func checkNetworkStatus(): NetworkStatus {
return navigator.onLine ? NetworkStatus.Online : NetworkStatus.Offline
}
// HTTP 请求
func httpRequest(
url: String,
method: String,
data: Any?,
headers: Map<String, String>?
): Promise<HTTPResponse> {
return fetch(url, {
method: method,
headers: headers,
body: data != null ? JSON.stringify(data) : null
}).then(response -> response.json())
}
// WebSocket 连接
func createWebSocket(url: String): WebSocket {
return new WebSocket(url)
}
}
DTWiFiProvider 支持智能频段选择和信道规划，基于802.11物理层理论优化网络性能：
频段选择策略
信道规划算法
| 频段 | 频率范围 | 信道数量 | 覆盖范围 | 穿透能力 | 干扰程度 | 适用场景 |
|---|---|---|---|---|---|---|
| 2.4 GHz | 2400-2483.5 MHz | 3个非重叠 | 大 | 强 | 高 | 家庭、覆盖优先、IoT设备 |
| 5 GHz | 5150-5925 MHz | 20+个非重叠 | 中 | 中 | 低 | 企业、速率优先、高带宽 |
| 6 GHz | 5925-7125 MHz | 59个非重叠 | 小 | 弱 | 极低 | 高性能、低延迟、WiFi 6E/7 |
enum WiFiFrequency {
GHz_2_4, // 2.4 GHz
GHz_5, // 5 GHz
GHz_6 // 6 GHz (WiFi 6E/7)
}
class FrequencySelectionStrategy {
func selectOptimalFrequency(
requirements: NetworkRequirements
): WiFiFrequency {
// 1. 根据应用场景选择
if (requirements.priority == Coverage) {
return WiFiFrequency.GHz_2_4 // 覆盖优先
} else if (requirements.priority == Speed) {
return WiFiFrequency.GHz_5 // 速率优先
} else if (requirements.priority == Performance) {
return WiFiFrequency.GHz_6 // 性能优先
}
// 2. 根据设备能力选择
if (requirements.supports6GHz && requirements.needsHighPerformance) {
return WiFiFrequency.GHz_6
} else if (requirements.supports5GHz && requirements.needsHighSpeed) {
return WiFiFrequency.GHz_5
} else {
return WiFiFrequency.GHz_2_4
}
}
}
class ChannelPlanningManager {
// 2.4 GHz 非重叠信道
private val CHANNELS_2_4_GHZ_NON_OVERLAPPING = [1, 6, 11]
// 5 GHz 常用非重叠信道
private val CHANNELS_5_GHZ_NON_OVERLAPPING = [36, 40, 44, 48, 52, 56, 60, 64, 149, 153, 157, 161]
// 6 GHz 非重叠信道（WiFi 6E/7）
private val CHANNELS_6_GHZ_NON_OVERLAPPING = [1, 5, 9, 13, 17, 21, 25, 29, 33, 37, 41, 45, 49, 53, 57, 61, 65, 69, 73, 77, 81, 85, 89, 93, 97, 101, 105, 109, 113, 117, 121, 125, 129, 133, 137, 141, 145, 149, 153, 157, 161, 165, 169, 173, 177, 181, 185, 189, 193, 197, 201, 205, 209, 213, 217, 221, 225, 229, 233]
func planChannels(
networks: List<WiFiNetwork>,
frequency: WiFiFrequency
): Map<WiFiNetwork, Integer> {
// 1. 获取可用信道
availableChannels = getAvailableChannels(frequency)
// 2. 构建干扰图
interferenceGraph = buildInterferenceGraph(networks)
// 3. 使用图着色算法分配信道
channelAssignment = graphColoring(interferenceGraph, availableChannels)
// 4. 优化调整（考虑信号强度、负载等）
optimizedAssignment = optimizeAssignment(channelAssignment, networks)
return optimizedAssignment
}
private func buildInterferenceGraph(
networks: List<WiFiNetwork>
): Graph {
graph = new Graph()
for (network1 in networks) {
for (network2 in networks) {
if (network1 != network2) {
// 计算干扰程度
interference = calculateInterference(network1, network2)
if (interference > INTERFERENCE_THRESHOLD) {
graph.addEdge(network1, network2, interference)
}
}
}
}
return graph
}
private func calculateInterference(
network1: WiFiNetwork,
network2: WiFiNetwork
): Float {
// 1. 距离因素
distance = calculateDistance(network1.location, network2.location)
distanceFactor = 1.0 / (distance * distance)
// 2. 信号强度因素
signalFactor = (network1.signalStrength + network2.signalStrength) / 2
// 3. 信道重叠因素
channelOverlap = calculateChannelOverlap(
network1.channel,
network2.channel,
network1.bandwidth,
network2.bandwidth
)
// 综合干扰评分
interference = distanceFactor * signalFactor * channelOverlap
return interference
}
private func graphColoring(
graph: Graph,
channels: List<Integer>
): Map<WiFiNetwork, Integer> {
assignment = {}
// 按度数排序（度数大的优先分配）
sortedNetworks = graph.nodes.sortByDescending { it.degree }
for (network in sortedNetworks) {
// 查找邻居已使用的信道
usedChannels = graph.neighbors(network)
.map { assignment[it] }
.filterNotNull()
// 选择未使用的信道
availableChannel = channels.find { it not in usedChannels }
if (availableChannel != null) {
assignment[network] = availableChannel
} else {
// 如果所有信道都被使用，选择干扰最小的
bestChannel = findLeastInterferingChannel(
network,
channels,
assignment,
graph
)
assignment[network] = bestChannel
}
}
return assignment
}
}
信道规划流程图：
开始信道规划
↓
获取所有网络信息
↓
构建干扰图
↓
┌─────────────────┐
│ 频段判断 │
└────────┬────────┘
│
┌────┴────┬──────────┐
│ │ │
2.4 GHz 5 GHz 6 GHz
│ │ │
↓ ↓ ↓
选择非重叠 选择非重叠 选择非重叠
信道组 信道组 信道组
│ │ │
└─────────┴──────────┘
↓
图着色算法
↓
分配信道
↓
优化调整
↓
完成规划
智能信道选择算法：
class OptimalChannelSelector {
func selectOptimalChannel(
frequency: WiFiFrequency,
currentNetworks: List<WiFiNetwork>
): Integer {
// 1. 扫描所有可用信道
channelMetrics = {}
availableChannels = getAvailableChannels(frequency)
for (channel in availableChannels) {
// 2. 计算信道质量指标
interference = calculateInterference(channel, currentNetworks)
noise = measureNoise(channel)
utilization = calculateUtilization(channel, currentNetworks)
// 3. 综合评分
score = -interference * 0.4 - noise * 0.3 - utilization * 0.3
channelMetrics[channel] = score
}
// 4. 选择最佳信道
bestChannel = channelMetrics.maxBy { it.value }.key
return bestChannel
}
private func calculateInterference(
channel: Integer,
networks: List<WiFiNetwork>
): Float {
interference = 0.0
for (network in networks) {
if (isChannelOverlapping(channel, network.channel, network.bandwidth)) {
// 计算重叠程度
overlap = calculateOverlap(channel, network.channel, network.bandwidth)
// 考虑信号强度
signalStrength = network.signalStrength
interference += overlap * signalStrength
}
}
return interference
}
private func measureNoise(channel: Integer): Float {
// 测量信道噪声水平
// 实际实现需要调用平台API
return getNoiseLevel(channel)
}
private func calculateUtilization(
channel: Integer,
networks: List<WiFiNetwork>
): Float {
utilization = 0.0
for (network in networks) {
if (network.channel == channel) {
// 考虑网络负载
utilization += network.load * network.clientCount
}
}
return utilization
}
}
自适应功率控制设计：
class AdaptivePowerController {
private val TARGET_RSSI = -65 // dBm (目标信号强度)
private val MIN_POWER = 1 // 最小功率等级
private val MAX_POWER = 100 // 最大功率等级
private val INTERFERENCE_THRESHOLD = -80 // dBm
private val POWER_BOOST = 10 // 干扰时的功率提升
func adjustTransmitPower(
ap: AccessPoint,
clients: List<Client>
) {
// 1. 测量客户端信号强度
clientRSSIs = clients.map { it.rssi }
// 2. 计算所需最小功率
minRequiredPower = MIN_POWER
for (rssi in clientRSSIs) {
if (rssi < TARGET_RSSI) {
// 计算需要提升的功率
powerBoost = TARGET_RSSI - rssi
minRequiredPower = max(minRequiredPower, powerBoost)
}
}
// 3. 考虑干扰
interferenceLevel = measureInterference(ap)
if (interferenceLevel < INTERFERENCE_THRESHOLD) {
// 干扰较大，提高功率以对抗干扰
minRequiredPower += POWER_BOOST
}
// 4. 限制在合理范围内
optimalPower = clamp(minRequiredPower, MIN_POWER, MAX_POWER)
// 5. 应用功率设置
ap.setTransmitPower(optimalPower)
}
private func measureInterference(ap: AccessPoint): Float {
// 测量周围网络的干扰水平
nearbyNetworks = scanNearbyNetworks(ap)
maxInterference = -100.0
for (network in nearbyNetworks) {
if (network.channel == ap.channel) {
maxInterference = max(maxInterference, network.signalStrength)
}
}
return maxInterference
}
}
功率控制流程图：
开始功率调整
↓
获取所有客户端RSSI
↓
计算目标功率
↓
┌─────────────────┐
│ 检查干扰水平 │
└────────┬────────┘
│
┌────┴────┐
│ │
干扰高 干扰低
│ │
↓ ↓
提升功率 保持功率
│ │
└────┬────┘
↓
限制在合理范围
↓
应用功率设置
基于802.11 EDCA的QoS管理：
enum AccessCategory {
AC_VO, // Voice (语音) - 最高优先级
AC_VI, // Video (视频)
AC_BE, // Best Effort (尽力而为)
AC_BK // Background (背景) - 最低优先级
}
class QoSManager {
private queues: Map<AccessCategory, PriorityQueue<Frame>>
// EDCA参数配置
private val EDCA_PARAMS = {
AC_VO: {aifsn: 2, cwMin: 3, cwMax: 7},
AC_VI: {aifsn: 2, cwMin: 7, cwMax: 15},
AC_BE: {aifsn: 3, cwMin: 15, cwMax: 1023},
AC_BK: {aifsn: 7, cwMin: 15, cwMax: 1023}
}
func transmit(
frame: Frame,
ac: AccessCategory
) {
queue = queues[ac]
queue.enqueue(frame)
// 根据AC设置不同的访问参数
params = EDCA_PARAMS[ac]
aifsn = params.aifsn
cwMin = params.cwMin
cwMax = params.cwMax
// 执行EDCA退避
backoff = randomBackoff(cwMin, cwMax)
wait(AIFS(aifsn) + backoff)
// 发送帧
sendFrame(frame)
}
func scheduleTransmission() {
// 优先调度高优先级队列
for (ac in [AC_VO, AC_VI, AC_BE, AC_BK]) {
if (!queues[ac].isEmpty()) {
frame = queues[ac].dequeue()
transmit(frame, ac)
return
}
}
}
private func AIFS(aifsn: Integer): Long {
// AIFS = SIFS + AIFSN × Slot Time
sifs = 10 // μs (2.4 GHz) or 16 μs (5 GHz)
slotTime = 9 // μs
return sifs + aifsn * slotTime
}
private func randomBackoff(cwMin: Integer, cwMax: Integer): Long {
// 随机选择 [0, CW] 范围内的时隙数
cw = random(cwMin, cwMax)
slotTime = 9 // μs
return cw * slotTime
}
}
QoS管理流程图：
数据帧到达
↓
确定访问类别(AC)
↓
┌─────────────────┐
│ AC类型判断 │
└────────┬────────┘
│
┌────┴────┬──────────┬──────────┐
│ │ │ │
AC_VO AC_VI AC_BE AC_BK
(语音) (视频) (尽力而为) (背景)
│ │ │ │
↓ ↓ ↓ ↓
入队 入队 入队 入队
│ │ │ │
└─────────┴──────────┴──────────┘
↓
等待信道空闲
↓
计算AIFS
↓
执行退避
↓
发送帧
支持的加密标准：
enum SecurityType {
NONE, // 开放网络
WEP, // WEP（已废弃，不推荐使用）
WPA, // WPA（已过时，不推荐使用）
WPA2, // WPA2（广泛支持，推荐）
WPA3, // WPA3（最新，最安全，强烈推荐）
WPA2_WPA3, // WPA2/WPA3混合模式
EAP // 企业级认证（802.1X）
}
class SecurityManager {
// 推荐的安全配置优先级
private val SECURITY_PRIORITY = [
SecurityType.WPA3, // 优先级1：最新，最安全
SecurityType.WPA2, // 优先级2：广泛支持，安全
SecurityType.WPA2_WPA3, // 优先级3：兼容模式
SecurityType.WPA, // 优先级4：已过时
SecurityType.WEP, // 优先级5：已废弃，不安全
SecurityType.NONE // 优先级6：开放网络，不安全
]
func selectBestSecurity(
supportedTypes: List<SecurityType>
): SecurityType {
// 选择支持的最高优先级安全类型
for (securityType in SECURITY_PRIORITY) {
if (securityType in supportedTypes) {
return securityType
}
}
return SecurityType.NONE
}
func validatePassword(
password: String,
securityType: SecurityType
): Boolean {
// WPA3要求密码至少8个字符
if (securityType == SecurityType.WPA3) {
return password.length >= 8
}
// WPA2要求密码至少8个字符
if (securityType == SecurityType.WPA2) {
return password.length >= 8
}
// WEP要求密钥长度为5或13个字符（ASCII）或10或26个字符（十六进制）
if (securityType == SecurityType.WEP) {
return password.length == 5 || password.length == 13 ||
password.length == 10 || password.length == 26
}
return true
}
}
强密码验证：
class PasswordPolicy {
private val MIN_LENGTH = 8
private val MIN_COMPLEXITY_SCORE = 3
func validateWiFiPassword(password: String): PasswordValidationResult {
// 1. 长度检查
if (password.length < MIN_LENGTH) {
return PasswordValidationResult(
valid: false,
reason: "密码长度至少需要${MIN_LENGTH}个字符"
)
}
// 2. 复杂度检查
hasUpperCase = password.matches(/[A-Z]/)
hasLowerCase = password.matches(/[a-z]/)
hasDigit = password.matches(/[0-9]/)
hasSpecialChar = password.matches(/[!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?]/)
complexityScore = (hasUpperCase ? 1 : 0) +
(hasLowerCase ? 1 : 0) +
(hasDigit ? 1 : 0) +
(hasSpecialChar ? 1 : 0)
if (complexityScore < MIN_COMPLEXITY_SCORE) {
return PasswordValidationResult(
valid: false,
reason: "密码复杂度不足，建议包含大小写字母、数字和特殊字符"
)
}
// 3. 常见弱密码检查
if (isCommonWeakPassword(password)) {
return PasswordValidationResult(
valid: false,
reason: "密码过于简单，请使用更复杂的密码"
)
}
return PasswordValidationResult(valid: true)
}
private func isCommonWeakPassword(password: String): Boolean {
commonPasswords = ["password", "12345678", "qwerty", "admin", "welcome"]
return commonPasswords.contains(password.toLowerCase())
}
}
WPA2 4次握手实现：
class WPA2Handshake {
func perform4WayHandshake(
ap: AccessPoint,
client: Client,
passphrase: String
): HandshakeResult {
// 1. 生成PMK（Pairwise Master Key）
pmk = PBKDF2(
password: passphrase,
salt: ap.ssid,
iterations: 4096,
keyLength: 256
)
// 2. AP生成ANonce
aNonce = generateRandom(32)
// 3. AP发送Message 1
ap.send(Message1: aNonce)
// 4. Client生成SNonce和PTK
sNonce = generateRandom(32)
ptk = PRF(
key: pmk,
label: "Pairwise key expansion",
data: min(ap.mac, client.mac) + max(ap.mac, client.mac) +
min(aNonce, sNonce) + max(aNonce, sNonce)
)
// 5. Client发送Message 2
mic = HMAC_SHA1(ptk.kck, message2)
client.send(Message2: sNonce, mic: mic)
// 6. AP验证MIC并生成GTK
if (verifyMIC(message2, ptk.kck, mic)) {
gtk = generateRandom(32)
mic = HMAC_SHA1(ptk.kck, message3)
ap.send(Message3: gtk, mic: mic)
} else {
return HandshakeResult(success: false, reason: "MIC验证失败")
}
// 7. Client验证并确认
if (verifyMIC(message3, ptk.kck, mic)) {
client.installKeys(ptk, gtk)
client.send(Message4: ACK)
return HandshakeResult(success: true)
} else {
return HandshakeResult(success: false, reason: "MIC验证失败")
}
}
}
WPA3 SAE密钥交换实现：
class WPA3SAEHandshake {
// DoS防护：限制并发SAE握手数量
private maxConcurrentHandshakes: Integer = 10
private activeHandshakes: Map<String, HandshakeSession> = {}
private handshakeQueue: Queue<HandshakeRequest> = PriorityQueue()
// 支持的加密组（仅使用强组）
private val ALLOWED_GROUPS = [
CRYPTO_GROUP_19, // 256位椭圆曲线
CRYPTO_GROUP_20, // 384位椭圆曲线
CRYPTO_GROUP_21 // 521位椭圆曲线
]
func performSAEKeyExchange(
ap: AccessPoint,
client: Client,
password: String
): HandshakeResult {
// 1. DoS防护：检查并发限制
if (activeHandshakes.size >= maxConcurrentHandshakes) {
// 将请求加入队列
handshakeQueue.enqueue(HandshakeRequest(ap, client, password))
return HandshakeResult(
success: false,
reason: "系统繁忙，请稍后重试"
)
}
// 2. 创建握手会话
sessionId = generateSessionId(ap, client)
session = HandshakeSession(
id: sessionId,
ap: ap,
client: client,
startTime: currentTime()
)
activeHandshakes[sessionId] = session
try {
// 3. 生成密码元素
pwe_ap = generatePasswordElement(ap.ssid, password, "AP")
pwe_client = generatePasswordElement(ap.ssid, password, "Client")
// 4. 生成随机数
rand_ap = generateRandom()
rand_client = generateRandom()
// 5. 计算承诺
commit_ap = commit(pwe_ap, rand_ap)
commit_client = commit(pwe_client, rand_client)
// 6. 交换承诺（限制组协商，防止组降级攻击）
allowedGroups = negotiateGroups(ap.supportedGroups, client.supportedGroups)
if (allowedGroups.isEmpty() || !isStrongGroup(allowedGroups)) {
return HandshakeResult(
success: false,
reason: "不支持的安全组"
)
}
ap.send(commit_ap, allowedGroups: allowedGroups)
client.send(commit_client, allowedGroups: allowedGroups)
// 7. 交换确认
confirm_ap = confirm(commit_client, rand_ap, pwe_ap, allowedGroups[0])
confirm_client = confirm(commit_ap, rand_client, pwe_client, allowedGroups[0])
ap.send(confirm_ap)
client.send(confirm_client)
// 8. 验证并生成PMK
if (verify(confirm_ap, confirm_client)) {
pmk = kdf(rand_ap, rand_client, pwe_ap, pwe_client)
ap.installKeys(pmk)
client.installKeys(pmk)
// 清理会话
activeHandshakes.remove(sessionId)
// 处理队列中的下一个请求
processNextHandshake()
return HandshakeResult(success: true)
} else {
return HandshakeResult(
success: false,
reason: "SAE验证失败"
)
}
} catch (Exception e) {
// 错误处理
activeHandshakes.remove(sessionId)
return HandshakeResult(
success: false,
reason: "SAE握手异常: ${e.message}"
)
}
}
// DoS缓解：在非特权处理队列中执行SAE操作
private func executeSAEOnNonPrivilegedQueue(operation: Function) {
// 将计算密集型操作移到后台线程
// 防止CPU资源耗尽导致整个BSS失败
backgroundQueue.execute {
try {
operation()
} catch (Exception e) {
logError("SAE操作失败", e)
}
}
}
// 防止组降级攻击
private func negotiateGroups(
apGroups: List<Integer>,
clientGroups: List<Integer>
): List<Integer> {
// 1. 取交集
commonGroups = apGroups.intersect(clientGroups)
// 2. 仅保留允许的强组
allowedCommonGroups = commonGroups.filter { it in ALLOWED_GROUPS }
// 3. 按强度排序（选择最强的组）
sortedGroups = allowedCommonGroups.sortByDescending { getGroupStrength(it) }
return sortedGroups
}
private func isStrongGroup(groups: List<Integer>): Boolean {
return groups.any { it in ALLOWED_GROUPS }
}
// 处理队列中的下一个握手请求
private func processNextHandshake() {
if (!handshakeQueue.isEmpty() &&
activeHandshakes.size < maxConcurrentHandshakes) {
request = handshakeQueue.dequeue()
performSAEKeyExchange(request.ap, request.client, request.password)
}
}
// 密码存储安全考虑
// 注意：SAE要求AP存储明文密码以进行握手
// 实现时应确保密码存储的安全性
private func storePasswordSecurely(ssid: String, password: String) {
// 1. 使用平台提供的安全存储
secureStorage = getSecureStorage()
// 2. 加密存储（如果平台支持）
if (secureStorage.supportsEncryption) {
encryptedPassword = encrypt(password, secureStorage.key)
secureStorage.put("wifi_password_${ssid}", encryptedPassword)
} else {
// 3. 使用系统级安全存储
systemSecureStorage.put("wifi_password_${ssid}", password)
}
}
}
WPA3 SAE实现安全考虑：
DoS攻击防护
组降级攻击防护
密码存储安全
前向安全性
基于WiFi理论文档中的网关、路由器工作原理，DTWiFiProvider 支持网关和路由器的管理功能：
网关管理
路由器管理
网络地址转换（NAT）
class NATManager {
// NAT转换表 [内部IP:端口 -> 外部IP:端口]
private natEntries: Map<InternalAddress, ExternalAddress> = {}
private portPool: Set<Integer> = generatePortPool(1024, 65535)
private val NAT_TIMEOUT = 300000 // 5分钟超时
/**
* 数据包出站（内部 -> 外部）
*/
func translateOutbound(packet: IPPacket): IPPacket {
internalAddr = packet.sourceAddress + ":" + packet.sourcePort
// 查找或创建NAT条目
if (!natEntries.containsKey(internalAddr)) {
// 分配外部端口
externalPort = allocatePort()
externalAddr = getPublicIP() + ":" + externalPort
natEntries[internalAddr] = ExternalAddress(
ip: externalAddr.ip,
port: externalPort,
lastUsedTime: currentTime()
)
}
externalAddr = natEntries[internalAddr]
externalAddr.lastUsedTime = currentTime()
// 修改数据包
translatedPacket = packet.copy()
translatedPacket.sourceAddress = getPublicIP()
translatedPacket.sourcePort = externalAddr.port
// 更新校验和
translatedPacket.checksum = recalculateChecksum(translatedPacket)
return translatedPacket
}
/**
* 数据包入站（外部 -> 内部）
*/
func translateInbound(packet: IPPacket): IPPacket? {
externalAddr = packet.destinationAddress + ":" + packet.destinationPort
// 查找对应的内部地址
internalAddr = natEntries.findValue(externalAddr)
if (internalAddr == null) {
// 没有对应的NAT条目，丢弃（安全防护）
return null
}
// 修改数据包
translatedPacket = packet.copy()
translatedPacket.destinationAddress = internalAddr.ip
translatedPacket.destinationPort = internalAddr.port
// 更新校验和
translatedPacket.checksum = recalculateChecksum(translatedPacket)
return translatedPacket
}
/**
* 清理过期NAT条目
*/
func cleanupExpiredEntries() {
now = currentTime()
expiredEntries = natEntries.filter {
now - it.value.lastUsedTime > NAT_TIMEOUT
}
for (entry in expiredEntries) {
natEntries.remove(entry.key)
portPool.add(entry.value.port) // 回收端口
}
}
}
class DHCPServerManager {
// IP地址池
private ipPool: IPAddressPool = IPAddressPool(
startIP: "192.168.1.100",
endIP: "192.168.1.200"
)
// 租约表 [MAC地址 -> 租约信息]
private leases: Map<String, DHCPLease> = {}
// 默认租期：24小时
private val DEFAULT_LEASE_TIME = 86400 // 秒
/**
* 处理DHCP请求
*/
func handleDHCPRequest(request: DHCPPacket): DHCPPacket {
switch (request.messageType) {
case DHCP_DISCOVER:
return handleDiscover(request)
case DHCP_REQUEST:
return handleRequest(request)
case DHCP_RELEASE:
return handleRelease(request)
case DHCP_RENEW:
return handleRenew(request)
}
}
/**
* 处理DHCP Discover
*/
private func handleDiscover(request: DHCPPacket): DHCPPacket {
clientMAC = request.clientMAC
// 检查是否有现有租约
existingLease = leases[clientMAC]
if (existingLease != null && !existingLease.isExpired()) {
// 续租现有IP
ip = existingLease.ip
} else {
// 分配新IP
ip = ipPool.allocate()
if (ip == null) {
return DHCPPacket(type: DHCP_NAK) // 无可用IP
}
}
// 创建租约
lease = DHCPLease(
ip: ip,
clientMAC: clientMAC,
leaseTime: DEFAULT_LEASE_TIME,
startTime: currentTime()
)
leases[clientMAC] = lease
// 返回DHCP Offer
return DHCPPacket(
type: DHCP_OFFER,
clientIP: ip,
subnetMask: "255.255.255.0",
gateway: "192.168.1.1",
dnsServers: ["8.8.8.8", "8.8.4.4"],
leaseTime: DEFAULT_LEASE_TIME
)
}
/**
* 清理过期租约
*/
func cleanupExpiredLeases() {
now = currentTime()
expiredLeases = leases.filter { it.value.isExpired(now) }
for (lease in expiredLeases) {
ipPool.release(lease.value.ip)
leases.remove(lease.key)
}
}
}
class RouterManager {
private routingTable: List<RouteEntry> = []
/**
* 查找路由（最长前缀匹配）
*/
func findRoute(destinationIP: IPAddress): RouteEntry? {
bestMatch: RouteEntry? = null
longestPrefix = 0
for (entry in routingTable) {
// 检查目标IP是否匹配网络
if (isInNetwork(destinationIP, entry.network, entry.subnetMask)) {
// 选择最长前缀匹配
prefixLength = getPrefixLength(entry.subnetMask)
if (prefixLength > longestPrefix) {
longestPrefix = prefixLength
bestMatch = entry
}
}
}
return bestMatch
}
/**
* 转发数据包
*/
func forwardPacket(packet: IPPacket): Boolean {
// 1. 查找路由
route = findRoute(packet.destinationAddress)
if (route == null) {
// 无路由，丢弃或发送ICMP不可达
sendICMPUnreachable(packet.sourceAddress)
return false
}
// 2. 检查TTL
if (packet.ttl <= 1) {
sendICMPTimeExceeded(packet.sourceAddress)
return false
}
// 3. 更新TTL
packet.ttl--
packet.checksum = recalculateChecksum(packet)
// 4. 转发到下一跳
if (route.nextHop == "0.0.0.0") {
// 直连网络，直接发送
sendToInterface(packet, route.interface)
} else {
// 通过下一跳转发
sendToNextHop(packet, route.nextHop, route.interface)
}
return true
}
}
基于WiFi理论文档中的AC+AP架构原理，DTWiFiProvider 支持企业级WiFi管理：
AC（接入控制器）管理
AP（接入点）管理
CAPWAP协议支持
class CAPWAPManager {
/**
* AP发现AC
*/
func discoverAC(): AccessController? {
// 1. 发送Discovery Request（广播）
discoveryRequest = CAPWAPPacket(
type: DISCOVERY_REQUEST,
apMAC: getAPMAC(),
apIP: getAPIP()
)
broadcast(discoveryRequest, port: 5246)
// 2. 接收Discovery Response
responses = receiveDiscoveryResponses(timeout: 5)
// 3. 选择最佳AC（基于优先级、负载等）
bestAC = selectBestAC(responses)
return bestAC
}
/**
* AP加入AC
*/
func joinAC(ac: AccessController): Boolean {
// 1. 发送Join Request
joinRequest = CAPWAPPacket(
type: JOIN_REQUEST,
apMAC: getAPMAC(),
apIP: getAPIP(),
capabilities: getAPCapabilities()
)
sendToAC(joinRequest, ac)
// 2. 接收Join Response
joinResponse = receiveFromAC(timeout: 10)
if (joinResponse.type != JOIN_RESPONSE ||
joinResponse.status != SUCCESS) {
return false
}
// 3. 配置请求
configRequest = CAPWAPPacket(
type: CONFIGURATION_REQUEST,
apMAC: getAPMAC()
)
sendToAC(configRequest, ac)
// 4. 接收配置
configResponse = receiveFromAC(timeout: 10)
applyConfiguration(configResponse.config)
// 5. 建立数据隧道
establishDataTunnel(ac)
return true
}
/**
* 数据隧道（数据包封装）
*/
func encapsulateDataPacket(packet: IPPacket): CAPWAPPacket {
return CAPWAPPacket(
type: DATA,
apMAC: getAPMAC(),
payload: packet
)
}
}
class AccessControllerManager {
private aps: Map<String, AccessPoint> = {}
private configuration: NetworkConfiguration = NetworkConfiguration()
/**
* 统一配置下发
*/
func configureAllAPs(config: APConfiguration) {
for (ap in aps.values) {
ap.applyConfiguration(config)
}
}
/**
* 负载均衡（参考华为CloudCampus方案）
*/
func balanceLoad() {
// 1. 收集所有AP的负载信息
apLoads = aps.map { ap ->
APLoadInfo(
apID: ap.id,
clientCount: ap.getClientCount(),
channelUtilization: ap.getChannelUtilization(),
rssi: ap.getAverageRSSI()
)
}
// 2. 识别过载AP
overloadedAPs = apLoads.filter {
it.clientCount > MAX_CLIENTS_PER_AP ||
it.channelUtilization > UTILIZATION_THRESHOLD
}
// 3. 引导客户端到负载较低的AP
for (overloadedAP in overloadedAPs) {
nearbyAPs = findNearbyAPs(overloadedAP, radius: 50) // 50米
underloadedAPs = nearbyAPs.filter {
it.clientCount < MAX_CLIENTS_PER_AP * 0.8
}
// 引导部分客户端
clients = overloadedAP.getClients()
for (client in clients) {
if (client.rssi < -75) { // 信号较弱
targetAP = selectBestAP(client, underloadedAPs)
if (targetAP != null) {
initiateRoaming(client, targetAP)
}
}
}
}
}
/**
* 无缝漫游管理（802.11r/k/v）
*/
func manageRoaming(client: Client, fromAP: AccessPoint, toAP: AccessPoint) {
// 1. 预认证（802.11r）
if (toAP.supportsFastRoaming()) {
preAuthenticate(client, toAP)
}
// 2. 密钥缓存
if (client.hasCachedKeys()) {
toAP.installCachedKeys(client)
}
// 3. 上下文转移
clientContext = fromAP.getClientContext(client)
toAP.setClientContext(client, clientContext)
// 4. 数据包转发
setupPacketForwarding(fromAP, toAP, client)
}
}
基于WiFi理论文档中的Mesh网络原理，DTWiFiProvider 支持Mesh网络组网：
Mesh节点管理
Mesh路由协议（HWMP）
智能回传优化
class MeshRouterManager {
private neighbors: List<MeshNeighbor> = []
private routingTable: MeshRoutingTable = MeshRoutingTable()
private pathMetrics: Map<Path, Integer> = {}
/**
* 路径发现（按需路由）
*/
func discoverPath(destination: MeshNode): Path? {
// 1. 检查路由表
existingPath = routingTable.findPath(destination)
if (existingPath != null && !existingPath.isExpired()) {
return existingPath
}
// 2. 发送路径请求（PREQ）
preq = PathRequestPacket(
source: getNodeID(),
destination: destination.id,
sequenceNumber: generateSequenceNumber(),
hopCount: 0,
metric: 0
)
// 广播PREQ
broadcastPREQ(preq)
// 3. 等待路径回复（PREP）
prep = waitForPREP(destination, timeout: 5)
if (prep != null) {
// 构建路径
path = buildPathFromPREP(prep)
routingTable.addPath(destination, path)
return path
}
return null
}
/**
* 计算链路度量（ETX - Expected Transmission Count）
*/
func calculateLinkMetric(neighbor: MeshNeighbor): Float {
// ETX = 1 / (forwardDeliveryRate * reverseDeliveryRate)
forwardRate = neighbor.forwardDeliveryRate
reverseRate = neighbor.reverseDeliveryRate
if (forwardRate == 0 || reverseRate == 0) {
return INFINITY
}
etx = 1.0 / (forwardRate * reverseRate)
return etx
}
}
class IntelligentMeshBackhaul {
/**
* 智能回传路径选择
*/
func selectOptimalBackhaulPath(node: MeshNode): BackhaulPath {
// 1. 获取所有可能的回传路径
candidatePaths = findCandidatePaths(node)
// 2. 评估每条路径
pathScores = candidatePaths.map { path ->
// 2.1 路径质量评分
qualityScore = calculatePathQuality(path)
// 2.2 路径负载评分
loadScore = calculatePathLoad(path)
// 2.3 路径稳定性评分
stabilityScore = calculatePathStability(path)
// 综合评分
totalScore = qualityScore * 0.5 +
loadScore * 0.3 +
stabilityScore * 0.2
PathScore(path: path, score: totalScore)
}
// 3. 选择最佳路径
bestPath = pathScores.maxBy { it.score }.path
return bestPath
}
/**
* 动态路径切换
*/
func dynamicPathSwitching(node: MeshNode) {
currentPath = node.getCurrentBackhaulPath()
// 1. 监控当前路径质量
currentQuality = monitorPathQuality(currentPath)
// 2. 如果质量下降，寻找替代路径
if (currentQuality < QUALITY_THRESHOLD) {
alternativePath = selectOptimalBackhaulPath(node)
// 3. 如果替代路径更好，切换
if (alternativePath.quality > currentQuality * 1.2) {
switchBackhaulPath(node, alternativePath)
}
}
}
}
基于WiFi理论文档中的多频段协同原理，DTWiFiProvider 支持三频协同组网：
智能频段分配
频段负载均衡
class TriBandCoordinationManager {
/**
* 智能频段分配（参考理论文档实现）
*/
func intelligentBandAllocation(device: Client): Frequency {
// 1. 根据设备类型选择
when (device.type) {
IOT_DEVICE, LOW_POWER -> {
// IoT设备、低功耗设备：2.4GHz
return Frequency.GHz_2_4
}
HIGH_BANDWIDTH, REAL_TIME -> {
// 高带宽、实时设备：5GHz或6GHz
if (device.supports6GHz && has6GHzAvailable()) {
return Frequency.GHz_6
} else {
return Frequency.GHz_5
}
}
STANDARD -> {
// 标准设备：根据信号强度选择
rssi2_4 = measureRSSI(device, Frequency.GHz_2_4)
rssi5 = measureRSSI(device, Frequency.GHz_5)
if (rssi5 > rssi2_4 + 5) { // 5GHz信号明显更好
return Frequency.GHz_5
} else {
return Frequency.GHz_2_4
}
}
}
}
/**
* 频段负载均衡
*/
func bandLoadBalancing() {
// 1. 收集各频段负载
bandLoads = [
Frequency.GHz_2_4: getBandLoad(Frequency.GHz_2_4),
Frequency.GHz_5: getBandLoad(Frequency.GHz_5),
Frequency.GHz_6: getBandLoad(Frequency.GHz_6)
]
// 2. 识别过载频段
overloadedBand = bandLoads.maxBy { it.value }.key
underloadedBand = bandLoads.minBy { it.value }.key
// 3. 迁移部分设备
if (bandLoads[overloadedBand] - bandLoads[underloadedBand] > 30) {
migrateDevices(
from: overloadedBand,
to: underloadedBand,
count: calculateMigrationCount(bandLoads)
)
}
}
}
OFDMA资源分配：
class WiFi6OFDMAManager {
// 资源单元（RU）类型
enum ResourceUnit {
RU_26, // 26-tone RU (约2 MHz)
RU_52, // 52-tone RU (约4 MHz)
RU_106, // 106-tone RU (约8 MHz)
RU_242, // 242-tone RU (20 MHz全部)
RU_484, // 484-tone RU
RU_996 // 996-tone RU (80 MHz全部)
}
// 信道状态信息（CSI）缓存
private csiCache: Map<User, ChannelStateInfo> = {}
private csiUpdateInterval: Long = 100 // 100ms更新间隔
func allocateResources(
users: List<User>,
bandwidth: Integer // 20, 40, 80, 160 MHz
): ResourceAllocation {
// 1. 更新CSI（信道状态信息）
updateCSI(users)
// 2. 根据用户QoS需求排序
sortedUsers = users.sortByPriority()
// 3. 计算可用RU
availableRUs = calculateAvailableRUs(bandwidth)
// 4. 为每个用户分配RU（考虑CSI）
allocation = {}
for (user in sortedUsers) {
// 获取用户CSI
csi = csiCache[user]
// 根据数据量、SNR和CSI选择RU大小
requiredRU = selectRUSize(
user.dataQueue,
user.snr,
csi
)
// 选择最佳RU位置（考虑频率选择性衰落）
bestRU = findBestRU(
availableRUs,
requiredRU,
user.channelResponse,
csi
)
allocation[user] = bestRU
availableRUs.remove(bestRU)
}
return allocation
}
private func updateCSI(users: List<User>) {
now = currentTime()
for (user in users) {
lastUpdate = csiCache[user]?.lastUpdate ?: 0
if (now - lastUpdate > csiUpdateInterval) {
// 更新CSI（实际实现需要从设备获取）
csi = measureCSI(user)
csiCache[user] = csi
}
}
}
private func selectRUSize(
dataQueue: Integer,
snr: Float,
csi: ChannelStateInfo?
): ResourceUnit {
// 1. 根据数据量估算所需带宽
requiredBandwidth = estimateBandwidth(dataQueue)
// 2. 根据SNR选择调制方式
modulation = selectModulation(snr)
// 3. 根据CSI调整（考虑频率选择性衰落）
if (csi != null) {
// 如果CSI显示某些频段质量差，选择更大的RU
if (csi.hasFrequencySelectiveFading) {
requiredBandwidth *= 1.2 // 增加20%余量
}
}
// 4. 选择最接近的RU大小
return findClosestRU(requiredBandwidth)
}
// 用户调度算法（ProxySelect算法简化版）
func scheduleUsers(
users: List<User>,
bandwidth: Integer
): Schedule {
// 1. 计算每个用户的代理速率（近似零迫束形成速率）
userRates = []
for (user in users) {
proxyRate = calculateProxyRate(user)
userRates.add({user: user, rate: proxyRate})
}
// 2. 按优先级和速率排序
sortedUsers = userRates.sortByDescending {
it.user.priority * it.rate
}
// 3. 分配资源
allocation = allocateResources(sortedUsers.map { it.user }, bandwidth)
return Schedule(allocation: allocation, users: sortedUsers)
}
// 功率和调制自适应
func adaptPowerAndModulation(
user: User,
ru: ResourceUnit,
csi: ChannelStateInfo
): PowerModulationConfig {
// 1. 根据CSI调整功率
optimalPower = calculateOptimalPower(user.rssi, csi)
// 2. 根据SNR和CSI选择调制方式
modulation = selectAdaptiveModulation(user.snr, csi)
// 3. 即使CSI过时，也能通过自适应提升性能
if (csi.isOutdated) {
// 使用保守的调制方式
modulation = downgradeModulation(modulation)
}
return PowerModulationConfig(
power: optimalPower,
modulation: modulation
)
}
// 与遗留设备共存
func manageLegacyCoexistence(
wifi6Users: List<User>,
legacyUsers: List<User>
) {
// 1. WiFi 6客户端使用触发访问
for (user in wifi6Users) {
if (user.supportsOFDMA) {
scheduleWithTriggeredAccess(user)
}
}
// 2. 遗留客户端使用传统竞争方式
for (user in legacyUsers) {
scheduleWithTraditionalContention(user)
}
// 3. 动态调整MU-EDCA参数平衡访问
adjustMUEDCAParameters(wifi6Users, legacyUsers)
}
}
TWT（目标唤醒时间）支持：
class TWTManager {
func negotiateTWT(
ap: AccessPoint,
client: Client,
wakeInterval: Long // 唤醒间隔（微秒）
): TWTAgreement {
// 1. 客户端请求TWT
twtRequest = {
wakeInterval: wakeInterval,
minWakeDuration: 100, // μs
twtChannel: 1
}
// 2. AP响应
twtResponse = {
accepted: true,
twt: calculateNextTWT(currentTime(), wakeInterval),
wakeInterval: wakeInterval
}
// 3. 客户端进入睡眠
client.sleepUntil(twtResponse.twt)
// 4. TWT时间到达，客户端唤醒
client.wakeUp()
// 5. 客户端发送PS-Poll或等待AP发送数据
if (ap.hasBufferedData(client)) {
ap.sendBufferedData(client)
} else {
client.sendPSPoll()
}
return TWTAgreement(twt: twtResponse.twt, wakeInterval: wakeInterval)
}
}
6 GHz频段检测与使用：
class WiFi6EManager {
func check6GHzSupport(): Boolean {
// 检测设备是否支持6 GHz频段
return checkDeviceCapability("6GHz")
}
func scan6GHzNetworks(): List<WiFiNetwork> {
if (!check6GHzSupport()) {
return []
}
// 扫描6 GHz频段网络
networks = scanFrequencyBand(WiFiFrequency.GHz_6)
return networks
}
func connectTo6GHzNetwork(
network: WiFiNetwork,
password: String?
): Boolean {
// 连接6 GHz网络
return connectToNetwork(network, password, frequency: WiFiFrequency.GHz_6)
}
}
多链路操作（MLO）支持：
class WiFi7MLOManager {
class MLOConnection {
links: List<Link> // 多个链路（2.4/5/6 GHz）
func transmit(data: BitArray) {
// 1. 数据分割
segments = splitData(data, links.size())
// 2. 并行发送到不同链路
for (i = 0; i < links.size(); i++) {
links[i].send(segments[i])
}
}
func receive(): BitArray {
// 1. 从所有链路接收
segments = []
for (link in links) {
segment = link.receive()
segments.add(segment)
}
// 2. 数据重组
data = mergeData(segments)
return data
}
}
func createMLOConnection(
ap: AccessPoint,
frequencies: List<WiFiFrequency>
): MLOConnection {
links = []
for (frequency in frequencies) {
link = createLink(ap, frequency)
links.add(link)
}
return MLOConnection(links: links)
}
}
DTWiFiProvider/
├── Business/ # 业务层
│ └── WiFiViewModel # 业务逻辑封装
│
├── Service/ # 服务层
│ └── WiFiServiceImpl # 服务层实现
│
├── Implementation/ # 实现层
│ ├── WiFiProvider # 统一接口
│ ├── DTiOSWiFiProvider # iOS 平台实现
│ ├── DTAndroidWiFiProvider # Android 平台实现
│ ├── DTHarmonyOSWiFiProvider # HarmonyOS 平台实现
│ ├── DTFlutterWiFiProvider # Flutter 平台实现
│ └── DTWebWiFiProvider # Web 平台实现
│
└── Utility/ # 工具层
├── WiFiCommandBuffer # 指令缓冲工具
├── DTNetworkConfigCache # 网络配置缓存
├── DTReconnectionStateMachine # 重连状态机
├── DTSmartConfigProvider # SmartConfig 配网工具
├── DTAPModeConfigProvider # AP 模式配网工具
├── DTDataFormatConverter # 数据格式转换工具
├── ChannelPlanningManager # 信道规划管理器
├── FrequencySelectionStrategy # 频段选择策略
├── AdaptivePowerController # 自适应功率控制器
├── QoSManager # QoS管理器
├── SecurityManager # 安全管理器
├── WiFi6OFDMAManager # WiFi 6 OFDMA管理器
├── TWTManager # TWT管理器
├── WiFi6EManager # WiFi 6E管理器
├── WiFi7MLOManager # WiFi 7 MLO管理器
├── NATManager # NAT管理器（网关功能）
├── DHCPServerManager # DHCP服务器管理器
├── RouterManager # 路由器管理器
├── AccessControllerManager # AC管理器（企业级）
├── CAPWAPManager # CAPWAP协议管理器
├── MeshRouterManager # Mesh路由管理器
├── IntelligentMeshBackhaul # 智能Mesh回传优化
└── TriBandCoordinationManager # 三频协同管理器
各平台需要实现以下接口：
| 平台 | WiFi API | 异步框架 | 存储方案 | 响应式框架 |
|---|---|---|---|---|
| Android | WifiManager / WifiNetworkSpecifier | Coroutines | SharedPreferences / Room | Flow / LiveData |
| iOS | NetworkExtension / SystemConfiguration | DispatchQueue / Combine | UserDefaults / CoreData | Combine |
| HarmonyOS | @ohos.wifiManager | Promise / async/await | dataPreferences | Emitter |
| Flutter | wifi_iot / platform channels | Future / async/await | SharedPreferences | Stream |
| Web | Navigator API / Fetch API | Promise / async/await | LocalStorage / IndexedDB | RxJS / Stream |
DTWiFiProvider 的设计体现了以下核心思想：
| 特性 | Android | iOS | HarmonyOS | Flutter | Web |
|---|---|---|---|---|---|
| 异步处理 | Coroutines | DispatchQueue / Combine | Promise / async/await | Future / async/await | Promise / async/await |
| 观察者模式 | Flow / LiveData | Combine | Emitter | Stream | RxJS / Stream |
| 持久化 | SharedPreferences / Room | UserDefaults / CoreData | dataPreferences | SharedPreferences | LocalStorage / IndexedDB |
| WiFi 框架 | WifiManager | NetworkExtension | @ohos.wifiManager | wifi_iot | Navigator API |
| WiFi 扫描 | ✅ 支持 | ⚠️ 受限（需要 Network Extension） | ✅ 支持 | ✅ 支持 | ❌ 不支持 |
| WiFi 连接 | ✅ 支持 | ✅ 支持 | ✅ 支持 | ✅ 支持 | ❌ 不支持 |
| 热点创建 | ⚠️ 需要系统权限 | ⚠️ 需要 Network Extension | ⚠️ 需要系统权限 | ⚠️ 需要系统权限 | ❌ 不支持 |
| Socket 通信 | ✅ 支持 | ✅ 支持 | ✅ 支持 | ✅ 支持 | ✅ 支持（WebSocket） |
| HTTP 请求 | ✅ 支持 | ✅ 支持 | ✅ 支持 | ✅ 支持 | ✅ 支持 |
DTWiFiProvider 是一个功能完善、设计优雅的跨平台 WiFi 管理解决方案。通过统一接口抽象、平台适配层和丰富的工具支持，为开发者提供了便捷的 WiFi 开发体验。无论是原生开发还是跨平台开发，都能享受到一致的 API 和强大的功能支持。
v2.0 更新说明：
本次优化结合了WiFi理论文档中的网关、路由器、AC+AP架构、Mesh网络等企业级WiFi技术，新增了以下功能：
这些功能使得DTWiFiProvider不仅适用于智能家居、物联网设备配网等消费级场景，还适用于企业级WiFi网络、智慧楼宇、智慧园区等复杂组网场景。
参考案例：华为CloudCampus解决方案
技术特点：
参考案例：中兴ZTE iCampus解决方案
技术特点：
参考案例：小米全屋智能解决方案
技术特点：
参考案例：施耐德EcoStruxure Building、霍尼韦尔Building Solutions
技术特点：
设计模式应用：
Adapter Pattern（适配器模式）
Bridge Pattern（桥接模式）
Strategy Pattern（策略模式）
架构模式：
关键实现要点：
CSI（信道状态信息）管理
用户调度算法
功率和调制自适应
遗留设备共存
安全实现要点：
DoS攻击防护
组降级攻击防护
密码存储
前向安全性
实现步骤：
设备端准备
AT+CWSTARTSMART=1 // 启动SmartConfig（ESP-Touch）
手机端实现
协议选择
错误处理
信道规划：
功率控制：
QoS管理：
加密算法选择
密码策略
网络隔离
定期更新
注意：本文档为概要设计文档，具体实现细节请参考各平台的 API 文档和代码实现。实现时请参考上述最佳实践和实际案例。
