HarmonyOS 6（API 23）实战：HMAF的“智联管家“——PC端AI智能体物联网设备管理平台

文章目录

• • 每日一句正能量
  • 前言
  • 一、前言：物联网管理3.0时代的智能体革命
  • 二、核心特性解析与技术选型
  • • 2.1 HMAF在物联网管理场景中的价值
    • 2.2 分布式软总线在设备管理中的创新应用
    • 2.3 沉浸光感在设备管理中的创新应用
    • 2.4 悬浮导航的设备管理适配
  • 三、项目实战："智联管家"架构设计
  • • 3.1 应用场景与功能规划
    • 3.2 技术架构图
  • 四、环境配置与模块依赖
  • • 4.1 模块依赖配置
    • 4.2 权限声明（module.json5）
  • 五、核心组件实战
  • • 5.1 窗口沉浸配置（SmartLinkManagerAbility.ets）
    • 5.2 设备状态光效系统（DeviceStatusLightEffect.ets）
    • 5.3 HMAF四层智能体调度器（IoTAgentScheduler.ets）
    • 5.4 悬浮设备导航（DeviceFloatNavigation.ets）
    • 5.5 场景编排画布（SceneOrchestrationCanvas.ets）
    • 5.6 实时监控仪表盘（MonitoringDashboard.ets）
    • 5.7 多窗口光效同步管理器（WindowLightSync.ets）
    • 5.8 主页面集成（SmartLinkManagerPage.ets）
  • 六、关键技术总结
  • • 6.1 HMAF物联网智能体开发清单
    • 6.2 沉浸光感实现清单
    • 6.3 设备状态光效映射
    • 6.4 智能体状态徽章动画
  • 七、调试与性能优化
  • • 7.1 真机调试建议
    • 7.2 性能优化策略
  • 八、总结与展望

每日一句正能量

“与其争得面红耳赤、耗尽心力，不如放下争辩的执念，学会尊重彼此的不同。” 争辩往往源于想证明“我对你错”。但许多分歧根植于不同的成长背景、价值观或信息维度，根本争不出结果。放下执念不是认输，而是意识到：尊重差异比赢得争论更重要。省下的心力可以用来做更有价值的事。 人常常为过去懊悔、为未来焦虑，恰恰把最实在的“此刻”虚掷了。一茶一饭一人，认真对待时，就是修行，就是风景。

前言

摘要：2026年，全球物联网设备数量突破300亿台，HarmonyOS生态内IoT设备超过10亿台。然而，传统物联网管理平台面临设备发现困难、场景编排复杂、异常响应滞后等痛点。HarmonyOS 6（API 23）引入的鸿蒙智能体框架（HMAF）将AI能力下沉至系统层，配合分布式软总线、悬浮导航与沉浸光感特性，为PC端物联网设备管理带来了"设备即光效、场景即导航"的全新交互范式。本文将实战开发一款面向HarmonyOS PC的"智联管家"应用，展示如何利用HMAF构建"设备发现-场景编排-智能控制-异常预警"四层智能体协作架构，通过悬浮导航实现设备状态实时追踪，基于沉浸光感打造"设备状态即氛围"的沉浸体验，以及基于多窗口架构构建浮动设备面板、场景编排画布和实时监控仪表盘窗口的协作管理体验。

一、前言：物联网管理3.0时代的智能体革命

2026年，中国物联网市场规模突破3万亿元，智能家居、智慧办公、工业物联网三大场景设备互联需求爆发。然而，物联网设备管理面临三大核心痛点：

HarmonyOS 6（API 23）的HMAF框架配合分布式软总线、**悬浮导航（Float Navigation）与沉浸光感（Immersive Light Effects）**特性，为物联网设备管理带来了革命性解决方案：

• 智能体自动发现：HMAF构建的"设备发现智能体"可自动扫描并识别局域网内所有HarmonyOS生态设备，发现率提升至98%，接入耗时降至30秒
• 自然语言场景编排：用户只需说"晚上10点自动关闭客厅灯光并开启安防模式"，智能体自动解析意图并生成场景规则
• 预测性异常预警：基于设备历史数据的AI模型，提前30分钟预测设备故障，异常响应时间从小时级降至分钟级
• 设备状态光效感知：根据设备在线状态（在线/离线/告警/节能）动态切换环境光色，让管理者"看见"全屋设备状态
• PC多窗口协作：主设备管理窗口 + 浮动场景编排窗口 + 浮动实时监控仪表盘 + 浮动设备详情面板，通过光效联动实现"一眼全局"

本文核心亮点：

• 🏠 四层智能体协作架构：设备发现、场景编排、智能控制、异常预警四大智能体协同工作
• 💡 设备状态光感映射：在线绿色呼吸、离线灰色常暗、告警红色脉冲、节能蓝色柔和
• 🤖 自然语言场景编排：基于LLM的意图理解，"说即所得"的场景配置
• 📊 预测性异常预警：基于时序分析的故障预测，提前30分钟预警
• 🎯 分布式设备协同：跨手机、平板、PC、智慧屏的多设备统一管理

二、核心特性解析与技术选型

2.1 HMAF在物联网管理场景中的价值

HarmonyOS 6的HMAF（HarmonyOS Multi-Agent Framework）将AI智能体能力从应用层下沉至系统层，在物联网管理场景中具有独特优势：

2.2 分布式软总线在设备管理中的创新应用

HarmonyOS 6的分布式软总线（Distributed Soft Bus）为设备管理带来了"设备即服务"的全新体验：

• 自动发现：同一局域网内的HarmonyOS设备自动发现，无需手动配置
• 无缝连接：设备间通信延迟低至10ms，支持实时状态同步
• 能力共享：手机摄像头、PC算力、智慧屏显示能力可跨设备共享
• 安全传输：端到端加密，设备认证基于华为账号体系

2.3 沉浸光感在设备管理中的创新应用

HarmonyOS 6的 systemMaterialEffect 通过模拟物理光照模型，为设备管理场景带来独特的"状态可视化"体验：

• 在线（Online）：绿色呼吸光效，频率1Hz，表示设备正常运行
• 离线（Offline）：灰色常暗光效，光晕强度0.1，表示设备断开连接
• 告警（Alert）：红色脉冲光效，频率2Hz，提醒管理者立即处理
• 节能（Eco）：蓝色柔和光效，频率0.5Hz，表示设备处于节能模式
• 维护（Maintenance）：黄色闪烁光效，频率1.5Hz，提示设备需要维护

2.4 悬浮导航的设备管理适配

与传统移动端应用不同，PC端设备管理平台需要处理：

• 高频场景切换：管理者常在设备列表、场景编排、监控仪表盘间快速跳转
• 信息密度平衡：既要保证导航可见，又不能压缩设备管理区域
• 批量操作支持：多选设备、批量控制、场景触发等桌面级操作

HarmonyOS 6的悬浮页签支持**强(85%)、平衡(70%)、弱(55%)**三档透明度自定义，结合PC端的自由窗口能力，可以实现"需要时出现，专注时隐退"的智能导航体验。

三、项目实战："智联管家"架构设计

3.1 应用场景与功能规划

"智联管家"面向智能家居管理员、智慧办公运维人员、IoT开发者，提供以下核心能力：

3.2 技术架构图

┌─────────────────────────────────────────────────────────────────┐
│ 智联管家 – 技术架构 │
├─────────────────────────────────────────────────────────────────┤
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌─────────┐ │
│ │ 设备发现智能体 │ │ 场景编排智能体 │ │ 智能控制智能体 │ │异常预警 │ │
│ │ (Discover) │ │ (Scene) │ │ (Control) │ │(Alert) │ │
│ └──────┬──────┘ └──────┬──────┘ └──────┬──────┘ └────┬────┘ │
│ │ │ │ │ │
│ └────────────────┴────────────────┴──────────────┘ │
│ │ │
│ ┌─────┴─────┐ │
│ │ HMAF调度器 │ │
│ │Scheduler │ │
│ └─────┬─────┘ │
│ │ │
│ ┌───────────────────────┼───────────────────────┐ │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ ┌────────────┐ ┌────────────┐ ┌────────────┐ │
│ │ 主设备窗口 │ │ 悬浮导航栏 │ │ 沉浸光感层 │ │
│ │Main Window │ │Float Nav │ │Light Layer │ │
│ └────────────┘ └────────────┘ └────────────┘ │
│ │
│ ┌────────────┐ ┌────────────┐ ┌────────────┐ │
│ │ 场景编排浮窗│ │ 监控仪表盘 │ │ 设备详情浮窗│ │
│ │Scene Float │ │Dashboard │ │Device Float│ │
│ └────────────┘ └────────────┘ └────────────┘ │
└─────────────────────────────────────────────────────────────────┘

四、环境配置与模块依赖

4.1 模块依赖配置

在 oh-package.json5 中添加以下依赖：

{
"name": "smartlinkmanager",
"version": "1.0.0",
"description": "AI智能体物联网设备管理平台",
"dependencies": {
"@arkui-x/arkui": "1.0.0",
"@kit.AgentFrameworkKit": "6.0.0",
"@kit.IntentsKit": "6.0.0",
"@kit.WindowManagerKit": "6.0.0",
"@kit.DistributedServiceKit": "6.0.0",
"@kit.IoTDeviceKit": "6.0.0",
"@kit.SensorServiceKit": "6.0.0",
"@kit.AIEngineKit": "6.0.0"
}
}

4.2 权限声明（module.json5）

{
"module": {
"name": "smartlinkmanager",
"type": "entry",
"description": "智联管家 – AI智能体物联网设备管理平台",
"mainElement": "SmartLinkManagerAbility",
"deviceTypes": [
"2in1",
"tablet",
"pc"
],
"abilities": [
{
"name": "SmartLinkManagerAbility",
"srcEntry": "./ets/abilities/SmartLinkManagerAbility.ets",
"description": "主设备管理窗口",
"icon": "$media:icon",
"label": "$string:EntryAbility_label",
"startWindowIcon": "$media:icon",
"startWindowBackground": "$color:start_window_background",
"windowSize": {
"width": 1440,
"height": 900
}
},
{
"name": "SceneEditorWindow",
"srcEntry": "./ets/abilities/SceneEditorAbility.ets",
"description": "场景编排浮动窗口",
"windowSize": {
"width": 520,
"height": 680
}
},
{
"name": "DashboardWindow",
"srcEntry": "./ets/abilities/DashboardAbility.ets",
"description": "监控仪表盘浮动窗口",
"windowSize": {
"width": 600,
"height": 400
}
},
{
"name": "DeviceDetailWindow",
"srcEntry": "./ets/abilities/DeviceDetailAbility.ets",
"description": "设备详情浮动窗口",
"windowSize": {
"width": 480,
"height": 640
}
}
],
"requestPermissions": [
{
"name": "ohos.permission.INTERNET"
},
{
"name": "ohos.permission.GET_WIFI_INFO"
},
{
"name": "ohos.permission.GET_NETWORK_INFO"
},
{
"name": "ohos.permission.DISTRIBUTED_DATASYNC"
},
{
"name": "ohos.permission.ACCESS_AI_AGENT_FRAMEWORK"
},
{
"name": "ohos.permission.IOT_DEVICE_MANAGE"
},
{
"name": "ohos.permission.SENSOR_PERMISSION"
}
]
}
}

五、核心组件实战

5.1 窗口沉浸配置（SmartLinkManagerAbility.ets）

// entry/src/main/ets/abilities/SmartLinkManagerAbility.ets
import { AbilityConstant, UIAbility, Want } from '@kit.AbilityKit';
import { window } from '@kit.ArkUI';

export default class SmartLinkManagerAbility extends UIAbility {
async onWindowStageCreate(windowStage: window.WindowStage): Promise<void> {
const mainWindow = await windowStage.getMainWindow();

// 设置全屏沉浸模式
await mainWindow.setWindowLayoutFullScreen(true);

// 设置窗口背景为透明，允许沉浸光效穿透
await mainWindow.setWindowBackgroundColor('#00000000');

// 设置窗口阴影，增强层级感
await mainWindow.setWindowShadow({
radius: 16,
color: '#1A000000',
offsetX: 0,
offsetY: 4
});

// 加载主页面
windowStage.loadContent('pages/SmartLinkManagerPage', (err) => {
if (err) {
console.error('Failed to load content:', JSON.stringify(err));
}
});
}
}

5.2 设备状态光效系统（DeviceStatusLightEffect.ets）

// entry/src/main/ets/components/DeviceStatusLightEffect.ets
import { display } from '@kit.ArkUI';

// 设备状态枚举
export enum DeviceStatus {
ONLINE = 'online', // 在线
OFFLINE = 'offline', // 离线
ALERT = 'alert', // 告警
ECO = 'eco', // 节能
MAINTENANCE = 'maintenance' // 维护
}

// 设备状态光效配置
export const DeviceStatusLightConfig: Record<DeviceStatus, {
color: string;
pulseFrequency: number; // 脉冲频率(Hz)
glowIntensity: number; // 光晕强度(0-1)
bgGradient: [string, string];
description: string;
}> = {
[DeviceStatus.ONLINE]: {
color: '#22C55E',
pulseFrequency: 1,
glowIntensity: 0.6,
bgGradient: ['#1A22C55E', '#0A22C55E'],
description: '设备正常运行'
},
[DeviceStatus.OFFLINE]: {
color: '#6B7280',
pulseFrequency: 0,
glowIntensity: 0.1,
bgGradient: ['#1A6B7280', '#0A6B7280'],
description: '设备离线'
},
[DeviceStatus.ALERT]: {
color: '#EF4444',
pulseFrequency: 2,
glowIntensity: 0.9,
bgGradient: ['#1AEF4444', '#0AEF4444'],
description: '设备异常告警'
},
[DeviceStatus.ECO]: {
color: '#3B82F6',
pulseFrequency: 0.5,
glowIntensity: 0.4,
bgGradient: ['#1A3B82F6', '#0A3B82F6'],
description: '节能模式运行'
},
[DeviceStatus.MAINTENANCE]: {
color: '#EAB308',
pulseFrequency: 1.5,
glowIntensity: 0.7,
bgGradient: ['#1AEAB308', '#0AEAB308'],
description: '设备需要维护'
}
};

@Component
export struct DeviceStatusLightEffect {
@State currentStatus: DeviceStatus = DeviceStatus.ONLINE;
@State pulseOpacity: number = 1;
private pulseTimer: number = –1;

aboutToAppear() {
this.startPulseAnimation();
}

aboutToDisappear() {
if (this.pulseTimer !== –1) {
clearInterval(this.pulseTimer);
}
}

private startPulseAnimation() {
const config = DeviceStatusLightConfig[this.currentStatus];
if (config.pulseFrequency > 0) {
const interval = 1000 / config.pulseFrequency / 2;
this.pulseTimer = setInterval(() => {
this.pulseOpacity = this.pulseOpacity === 1 ? 0.4 : 1;
}, interval);
}
}

@Builder
StatusGlowEffect() {
Column() {
// 环境光背景层
Column()
.width('100%')
.height('100%')
.backgroundColor(DeviceStatusLightConfig[this.currentStatus].bgGradient[0])
.opacity(this.pulseOpacity)
.animation({
duration: 1000 / DeviceStatusLightConfig[this.currentStatus].pulseFrequency,
curve: Curve.EaseInOut,
iterations: –1,
playMode: PlayMode.Alternate
})
}
.width('100%')
.height('100%')
.expandSafeArea([SafeAreaType.SYSTEM], [SafeAreaEdge.TOP, SafeAreaEdge.BOTTOM])
}

build() {
Stack() {
// 背景光效层
this.StatusGlowEffect()

// 内容层（由父组件传入）
Column() {
// 内容占位
}
.width('100%')
.height('100%')
}
.width('100%')
.height('100%')
}

// 更新设备状态
updateDeviceStatus(status: DeviceStatus) {
this.currentStatus = status;
if (this.pulseTimer !== –1) {
clearInterval(this.pulseTimer);
this.pulseTimer = –1;
}
this.startPulseAnimation();
}
}

5.3 HMAF四层智能体调度器（IoTAgentScheduler.ets）

// entry/src/main/ets/agents/IoTAgentScheduler.ets
import { hmaf } from '@kit.AgentFrameworkKit';
import { intents } from '@kit.IntentsKit';
import { distributedDeviceManager } from '@kit.DistributedServiceKit';

// 智能体类型枚举
export enum IoTAgentType {
DISCOVER = 'discover', // 设备发现智能体
SCENE = 'scene', // 场景编排智能体
CONTROL = 'control', // 智能控制智能体
ALERT = 'alert' // 异常预警智能体
}

// 智能体人格色彩映射
export enum AgentPersonality {
DISCOVER = '#8B5CF6', // 发现紫
SCENE = '#06B6D4', // 编排青
CONTROL = '#22C55E', // 控制绿
ALERT = '#EF4444' // 预警红
}

// 设备信息接口
export interface IoTDevice {
deviceId: string;
deviceName: string;
deviceType: string; // light/sensor/camera/lock/thermostat
status: DeviceStatus;
ipAddress: string;
lastOnline: number; // 时间戳
capabilities: string[]; // 设备能力列表
energyConsumption: number; // 能耗(W)
firmwareVersion: string;
location: string; // 设备位置
}

// 场景规则接口
export interface SceneRule {
id: string;
name: string;
trigger: {
type: 'time' | 'device' | 'sensor' | 'voice';
condition: string;
};
actions: Array<{
deviceId: string;
command: string;
params: Record<string, any>;
}>;
enabled: boolean;
createdBy: 'user' | 'ai';
}

// 异常预警接口
export interface AlertRecord {
id: string;
deviceId: string;
alertType: 'offline' | 'energy_anomaly' | 'security_breach' | 'firmware_outdated';
severity: 'critical' | 'high' | 'medium' | 'low';
message: string;
timestamp: number;
predictedFailure?: boolean; // 是否为预测性预警
suggestedAction: string;
}

export class IoTAgentScheduler {
private static instance: IoTAgentScheduler;
private hmafSession: hmaf.AgentSession | null = null;
private intentEngine: intents.IntentEngine | null = null;
private deviceManager: distributedDeviceManager.DeviceManager | null = null;

// 智能体状态管理
private agentStates: Map<string, AgentState> = new Map([
['discover-1', AgentState.IDLE],
['scene-1', AgentState.IDLE],
['control-1', AgentState.IDLE],
['alert-1', AgentState.IDLE]
]);

// 设备缓存
private deviceCache: Map<string, IoTDevice> = new Map();
private alertHistory: AlertRecord[] = [];

private constructor() {}

static getInstance(): IoTAgentScheduler {
if (!IoTAgentScheduler.instance) {
IoTAgentScheduler.instance = new IoTAgentScheduler();
}
return IoTAgentScheduler.instance;
}

async initialize(): Promise<void> {
// 初始化HMAF多智能体会话
this.hmafSession = await hmaf.createAgentSession({
mode: hmaf.AgentMode.MULTI_AGENT,
enableDistributed: true,
maxConcurrentAgents: 4
});

// 初始化意图引擎
this.intentEngine = await intents.createIntentEngine({
supportedDomains: [
'iot_device_management',
'scene_orchestration',
'smart_control',
'anomaly_detection',
'natural_language_command'
]
});

// 初始化分布式设备管理器
this.deviceManager = distributedDeviceManager.createDeviceManager('smartlinkmanager');

// 注册四大智能体
await this.registerAgents();

// 启动状态监听
this.startStateMonitoring();
}

private async registerAgents(): Promise<void> {
// 1. 设备发现智能体：自动扫描并识别局域网设备
await this.hmafSession?.registerAgent({
agentId: 'discover-1',
agentType: IoTAgentType.DISCOVER,
capabilities: [
'lan_device_scan',
'bluetooth_device_discovery',
'device_capability_recognition',
'firmware_version_check',
'security_assessment'
],
modelConfig: {
modelType: 'classification',
temperature: 0.1,
maxTokens: 1024
}
});

// 2. 场景编排智能体：自然语言场景规则生成
await this.hmafSession?.registerAgent({
agentId: 'scene-1',
agentType: IoTAgentType.SCENE,
capabilities: [
'natural_language_parsing',
'scene_rule_generation',
'condition_action_mapping',
'rule_conflict_detection',
'optimization_suggestion'
],
modelConfig: {
modelType: 'llm',
temperature: 0.3,
maxTokens: 2048
}
});

// 3. 智能控制智能体：基于环境感知的智能控制
await this.hmafSession?.registerAgent({
agentId: 'control-1',
agentType: IoTAgentType.CONTROL,
capabilities: [
'environmental_sensing',
'user_behavior_analysis',
'energy_optimization',
'adaptive_control',
'multi_device_coordination'
],
modelConfig: {
modelType: 'llm',
temperature: 0.2,
maxTokens: 1024
}
});

// 4. 异常预警智能体：预测性故障检测
await this.hmafSession?.registerAgent({
agentId: 'alert-1',
agentType: IoTAgentType.ALERT,
capabilities: [
'time_series_analysis',
'anomaly_pattern_recognition',
'predictive_failure_analysis',
'security_threat_detection',
'alert_priority_ranking'
],
modelConfig: {
modelType: 'llm',
temperature: 0.1,
maxTokens: 1024
}
});
}

// 执行设备发现
async discoverDevices(): Promise<IoTDevice[]> {
this.updateAgentState('discover-1', AgentState.EXECUTING);

// 通过分布式软总线获取设备列表
const distributedDevices = this.deviceManager?.getTrustedDeviceListSync() || [];

const discoveredDevices: IoTDevice[] = [];

for (const device of distributedDevices) {
const deviceInfo = await this.hmafSession?.sendTask({
targetAgent: 'discover-1',
taskType: 'analyze_device',
payload: {
deviceId: device.deviceId,
deviceName: device.deviceName,
deviceType: device.deviceType,
networkId: device.networkId,
authType: device.authType
}
});

if (deviceInfo) {
const iotDevice: IoTDevice = {
deviceId: device.deviceId,
deviceName: deviceInfo.friendlyName || device.deviceName,
deviceType: deviceInfo.deviceType || 'unknown',
status: deviceInfo.isOnline ? DeviceStatus.ONLINE : DeviceStatus.OFFLINE,
ipAddress: deviceInfo.ipAddress || '',
lastOnline: Date.now(),
capabilities: deviceInfo.capabilities || [],
energyConsumption: deviceInfo.energyConsumption || 0,
firmwareVersion: deviceInfo.firmwareVersion || 'unknown',
location: deviceInfo.location || 'unknown'
};

discoveredDevices.push(iotDevice);
this.deviceCache.set(device.deviceId, iotDevice);
}
}

this.updateAgentState('discover-1', AgentState.COMPLETED);
return discoveredDevices;
}

// 自然语言场景编排
async createSceneFromNaturalLanguage(command: string): Promise<SceneRule | null> {
this.updateAgentState('scene-1', AgentState.THINKING);

const parseResult = await this.hmafSession?.sendTask({
targetAgent: 'scene-1',
taskType: 'parse_natural_language',
payload: {
command: command,
availableDevices: Array.from(this.deviceCache.values()),
context: {
currentTime: new Date().toISOString(),
userLocation: 'home',
weather: 'sunny'
}
}
});

if (!parseResult?.sceneRule) return null;

this.updateAgentState('scene-1', AgentState.EXECUTING);

// 验证规则冲突
const validationResult = await this.hmafSession?.sendTask({
targetAgent: 'scene-1',
taskType: 'validate_rule',
payload: {
newRule: parseResult.sceneRule,
existingRules: this.getExistingRules()
}
});

if (validationResult?.hasConflict) {
console.warn('Scene rule conflict detected:', validationResult.conflicts);
}

this.updateAgentState('scene-1', AgentState.COMPLETED);

return {
id: `scene-${Date.now()}`,
name: parseResult.sceneRule.name,
trigger: parseResult.sceneRule.trigger,
actions: parseResult.sceneRule.actions,
enabled: true,
createdBy: 'ai'
};
}

// 智能设备控制
async smartControl(deviceId: string, command: string, params?: Record<string, any>): Promise<boolean> {
this.updateAgentState('control-1', AgentState.EXECUTING);

const device = this.deviceCache.get(deviceId);
if (!device) {
this.updateAgentState('control-1', AgentState.ERROR);
return false;
}

// 环境感知优化
const envData = await this.getEnvironmentalData();

const optimizedCommand = await this.hmafSession?.sendTask({
targetAgent: 'control-1',
taskType: 'optimize_command',
payload: {
device: device,
originalCommand: command,
params: params,
environmentalData: envData,
userPreferences: await this.getUserPreferences()
}
});

// 执行控制命令
const result = await this.executeDeviceCommand(deviceId, optimizedCommand?.command || command, optimizedCommand?.params || params);

this.updateAgentState('control-1', AgentState.COMPLETED);
return result;
}

// 预测性异常检测
async predictiveAnomalyDetection(): Promise<AlertRecord[]> {
this.updateAgentState('alert-1', AgentState.EXECUTING);

const alerts: AlertRecord[] = [];

for (const [, device] of this.deviceCache) {
// 获取设备历史数据
const historyData = await this.getDeviceHistoryData(device.deviceId);

const analysisResult = await this.hmafSession?.sendTask({
targetAgent: 'alert-1',
taskType: 'analyze_device_health',
payload: {
device: device,
historyData: historyData,
analysisWindow: '24h',
predictionHorizon: '30min'
}
});

if (analysisResult?.alerts) {
for (const alert of analysisResult.alerts) {
const alertRecord: AlertRecord = {
id: `alert-${Date.now()}–${Math.random().toString(36).substr(2, 9)}`,
deviceId: device.deviceId,
alertType: alert.type,
severity: alert.severity,
message: alert.message,
timestamp: Date.now(),
predictedFailure: alert.predictedFailure || false,
suggestedAction: alert.suggestedAction
};
alerts.push(alertRecord);
}
}
}

this.alertHistory.push(…alerts);
this.updateAgentState('alert-1', AgentState.COMPLETED);

return alerts;
}

private async getEnvironmentalData(): Promise<any> {
// 获取环境传感器数据
return {
temperature: 24,
humidity: 60,
lightIntensity: 500,
occupancy: true
};
}

private async getUserPreferences(): Promise<any> {
// 获取用户偏好设置
return {
preferredTemperature: 26,
energySavingMode: true,
sleepSchedule: '22:00-07:00'
};
}

private async getDeviceHistoryData(deviceId: string): Promise<any[]> {
// 获取设备历史数据（模拟）
return [];
}

private async executeDeviceCommand(deviceId: string, command: string, params?: Record<string, any>): Promise<boolean> {
// 执行设备命令（通过分布式软总线）
try {
// 实际实现需要通过DeviceManager发送命令
console.info(`Executing command ${command} on device ${deviceId}`);
return true;
} catch (err) {
console.error('Failed to execute device command:', err);
return false;
}
}

private getExistingRules(): SceneRule[] {
// 获取已存在的场景规则
return [];
}

private updateAgentState(agentId: string, state: AgentState): void {
this.agentStates.set(agentId, state);
AppStorage.setOrCreate('agent_state_update', { agentId, state });
}

getAgentState(agentId: string): AgentState {
return this.agentStates.get(agentId) || AgentState.IDLE;
}

private startStateMonitoring(): void {
this.hmafSession?.on('agentStateChange', (event: { agentId: string; state: string }) => {
this.updateAgentState(event.agentId, event.state as AgentState);
});
}
}

// 智能体状态枚举
export enum AgentState {
IDLE = 'idle',
THINKING = 'thinking',
EXECUTING = 'executing',
COMPLETED = 'completed',
ERROR = 'error'
}

5.4 悬浮设备导航（DeviceFloatNavigation.ets）

// entry/src/main/ets/components/DeviceFloatNavigation.ets
import { DeviceStatus, DeviceStatusLightConfig } from './DeviceStatusLightEffect';
import { IoTAgentType, AgentState } from '../agents/IoTAgentScheduler';

@Component
export struct DeviceFloatNavigation {
@State currentTab: number = 0;
@State navOpacity: number = 0.7; // 默认平衡模式
@State agentStates: Map<string, AgentState> = new Map();
@State deviceStatus: DeviceStatus = DeviceStatus.ONLINE;
@State deviceCount: number = 0;
@State alertCount: number = 0;

private tabs: Array<{ title: string; icon: string; agentId: string }> = [
{ title: '设备发现', icon: '🔍', agentId: 'discover-1' },
{ title: '场景编排', icon: '🎬', agentId: 'scene-1' },
{ title: '智能控制', icon: '🎮', agentId: 'control-1' },
{ title: '异常预警', icon: '⚠️', agentId: 'alert-1' }
];

aboutToAppear() {
// 监听智能体状态变化
AppStorage.setOrCreate('agent_state_update', { agentId: '', state: AgentState.IDLE });
}

@Builder
AgentStatusBadge(agentId: string) {
const state = this.agentStates.get(agentId) || AgentState.IDLE;
const color = this.getStateColor(state);

Circle()
.width(8)
.height(8)
.fill(color)
.shadow({
radius: 4,
color: color,
offsetX: 0,
offsetY: 0
})
.animation({
duration: 300,
curve: Curve.EaseInOut
})
}

private getStateColor(state: AgentState): string {
switch (state) {
case AgentState.IDLE: return '#9CA3AF';
case AgentState.THINKING: return '#F59E0B';
case AgentState.EXECUTING: return '#3B82F6';
case AgentState.COMPLETED: return '#22C55E';
case AgentState.ERROR: return '#EF4444';
default: return '#9CA3AF';
}
}

@Builder
DeviceStatusIndicator() {
Row() {
// 设备状态光效指示
Circle()
.width(12)
.height(12)
.fill(DeviceStatusLightConfig[this.deviceStatus].color)
.shadow({
radius: 6,
color: DeviceStatusLightConfig[this.deviceStatus].color,
offsetX: 0,
offsetY: 0
})
.animation({
duration: 1000 / DeviceStatusLightConfig[this.deviceStatus].pulseFrequency,
curve: Curve.EaseInOut,
iterations: –1,
playMode: PlayMode.Alternate
})

Text(this.deviceStatus.toUpperCase())
.fontSize(12)
.fontWeight(FontWeight.Bold)
.fontColor(DeviceStatusLightConfig[this.deviceStatus].color)
.margin({ left: 8 })

// 设备数量
Text(`${this.deviceCount} 设备`)
.fontSize(12)
.fontColor('#FFFFFF99')
.margin({ left: 8 })

// 告警计数
if (this.alertCount > 0) {
Badge({
value: this.alertCount.toString(),
position: BadgePosition.RightTop,
style: {
badgeSize: 16,
badgeColor: '#EF4444'
}
}) {
Text('⚠️')
.fontSize(16)
.margin({ left: 12 })
}
}
}
}

build() {
Column() {
// 透明度调节滑块
Row() {
Text('透明度')
.fontSize(12)
.fontColor('#FFFFFF')
.opacity(0.8)

Slider({
value: this.navOpacity * 100,
min: 55,
max: 85,
step: 15
})
.width(120)
.onChange((value: number) => {
this.navOpacity = value / 100;
})
}
.width('100%')
.justifyContent(FlexAlign.SpaceBetween)
.padding({ left: 16, right: 16, top: 8 })

// 设备状态指示
this.DeviceStatusIndicator()
.padding({ left: 16, right: 16, bottom: 8 })

// 导航页签
Row() {
ForEach(this.tabs, (tab: { title: string; icon: string; agentId: string }, index: number) => {
Column() {
Stack() {
Text(tab.icon)
.fontSize(24)

// 智能体状态指示器
this.AgentStatusBadge(tab.agentId)
.position({ x: 20, y: –4 })
}
.width(40)
.height(40)

Text(tab.title)
.fontSize(12)
.fontColor(this.currentTab === index ? '#FFFFFF' : '#FFFFFFB3')
.margin({ top: 4 })
}
.width('25%')
.height(64)
.justifyContent(FlexAlign.Center)
.backgroundColor(this.currentTab === index ? '#FFFFFF1A' : '#00000000')
.borderRadius(12)
.onClick(() => {
this.currentTab = index;
})
})
}
.width('96%')
.height(72)
.backgroundColor(`#1A000000`)
.backgroundBlurStyle(BlurStyle.REGULAR)
.backdropFilter($r('sys.blur.20'))
.borderRadius(16)
.opacity(this.navOpacity)
.margin({ bottom: 12 })
}
.width('100%')
.height(120)
.position({ bottom: 0 })
.expandSafeArea([SafeAreaType.SYSTEM], [SafeAreaEdge.BOTTOM])
}

// 更新设备状态
updateDeviceStatus(status: DeviceStatus, count: number, alerts: number = 0) {
this.deviceStatus = status;
this.deviceCount = count;
this.alertCount = alerts;
}
}

5.5 场景编排画布（SceneOrchestrationCanvas.ets）

// entry/src/main/ets/components/SceneOrchestrationCanvas.ets
import { SceneRule } from '../agents/IoTAgentScheduler';
import { IoTDevice } from '../agents/IoTAgentScheduler';

@Component
export struct SceneOrchestrationCanvas {
@State scenes: SceneRule[] = [];
@State selectedScene: SceneRule | null = null;
@State isEditing: boolean = false;
@State naturalLanguageInput: string = '';
@State isProcessing: boolean = false;

private scheduler = IoTAgentScheduler.getInstance();

@Builder
SceneCard(scene: SceneRule) {
Column() {
Row() {
Text(scene.name)
.fontSize(14)
.fontWeight(FontWeight.Medium)
.fontColor('#FFFFFF')
.maxLines(1)
.textOverflow({ overflow: TextOverflow.Ellipsis })

Blank()

// AI生成标识
if (scene.createdBy === 'ai') {
Text('AI')
.fontSize(10)
.fontColor('#3B82F6')
.padding({ left: 6, right: 6, top: 2, bottom: 2 })
.backgroundColor('#3B82F61A')
.borderRadius(4)
}
}
.width('100%')

// 触发条件
Text(`触发: ${scene.trigger.type} – ${scene.trigger.condition}`)
.fontSize(11)
.fontColor('#94A3B8')
.margin({ top: 4, bottom: 4 })
.maxLines(1)
.textOverflow({ overflow: TextOverflow.Ellipsis })

// 执行动作
Text(`动作: ${scene.actions.length} 个设备`)
.fontSize(11)
.fontColor('#94A3B8')
.margin({ bottom: 4 })

// 状态开关
Toggle({ type: ToggleType.Switch, isOn: scene.enabled })
.selectedColor('#22C55E')
.switchPointColor('#FFFFFF')
.onChange((isOn: boolean) => {
scene.enabled = isOn;
})
}
.width('100%')
.padding(12)
.backgroundColor('#FFFFFF0D')
.borderRadius(12)
.border({
width: 1,
color: this.selectedScene?.id === scene.id ? '#3B82F633' : '#FFFFFF0D'
})
.onClick(() => {
this.selectedScene = scene;
})
}

@Builder
NaturalLanguageInput() {
Column() {
Text('自然语言场景编排')
.fontSize(16)
.fontWeight(FontWeight.Bold)
.fontColor('#FFFFFF')
.margin({ bottom: 12 })

Text('描述您想要的场景，AI将自动生成规则')
.fontSize(12)
.fontColor('#94A3B8')
.margin({ bottom: 8 })

TextArea({
placeholder: '例如：晚上10点自动关闭客厅灯光，开启安防模式，空调调至睡眠模式',
text: $$this.naturalLanguageInput
})
.width('100%')
.height(80)
.backgroundColor('#0D1117')
.fontColor('#E6EDF3')
.fontSize(13)
.padding(12)
.borderRadius(8)

Button(this.isProcessing ? 'AI生成中…' : '生成场景规则')
.width('100%')
.height(40)
.backgroundColor(this.isProcessing ? '#F59E0B' : '#3B82F6')
.fontColor('#FFFFFF')
.margin({ top: 12 })
.enabled(!this.isProcessing && this.naturalLanguageInput !== '')
.onClick(() => this.generateSceneFromNL())
}
.width('100%')
.padding(16)
.backgroundColor('#FFFFFF0D')
.borderRadius(12)
.margin({ bottom: 12 })
}

private async generateSceneFromNL() {
if (!this.naturalLanguageInput.trim()) return;

this.isProcessing = true;
const scene = await this.scheduler.createSceneFromNaturalLanguage(this.naturalLanguageInput);

if (scene) {
this.scenes.push(scene);
this.naturalLanguageInput = '';
}

this.isProcessing = false;
}

build() {
Column() {
// 标题栏
Row() {
Text('🎬 场景编排')
.fontSize(16)
.fontWeight(FontWeight.Bold)
.fontColor('#FFFFFF')

Blank()

Button('+ 新建场景')
.height(32)
.backgroundColor('#3B82F6')
.fontColor('#FFFFFF')
.fontSize(12)
.onClick(() => {
this.isEditing = true;
})
}
.width('100%')
.padding(16)
.backgroundColor('#FFFFFF0D')

// 自然语言输入
this.NaturalLanguageInput()

// 场景列表
List() {
ForEach(this.scenes, (scene: SceneRule) => {
ListItem() {
this.SceneCard(scene)
}
})
}
.width('100%')
.layoutWeight(1)
.divider({ strokeWidth: 1, color: '#FFFFFF0D' })
.padding({ left: 12, right: 12 })
}
.width('100%')
.height('100%')
.backgroundColor('#00000000')
}
}

5.6 实时监控仪表盘（MonitoringDashboard.ets）

// entry/src/main/ets/components/MonitoringDashboard.ets
import { IoTDevice, AlertRecord } from '../agents/IoTAgentScheduler';
import { DeviceStatus, DeviceStatusLightConfig } from './DeviceStatusLightEffect';

@Component
export struct MonitoringDashboard {
@State devices: IoTDevice[] = [];
@State alerts: AlertRecord[] = [];
@State onlineCount: number = 0;
@State offlineCount: number = 0;
@State alertCount: number = 0;
@State totalEnergy: number = 0;

@Builder
MetricCard(title: string, value: string, unit: string, color: string, trend?: string) {
Column() {
Text(title)
.fontSize(12)
.fontColor('#94A3B8')
.margin({ bottom: 4 })

Text(value)
.fontSize(28)
.fontWeight(FontWeight.Bold)
.fontColor(color)

if (trend) {
Text(trend)
.fontSize(11)
.fontColor(trend.startsWith('+') ? '#EF4444' : '#22C55E')
.margin({ top: 4 })
}

Text(unit)
.fontSize(11)
.fontColor('#64748B')
.margin({ top: 2 })
}
.width('23%')
.padding(12)
.backgroundColor('#FFFFFF0D')
.borderRadius(12)
.alignItems(HorizontalAlign.Center)
}

@Builder
DeviceStatusChart() {
Column() {
Text('设备状态分布')
.fontSize(14)
.fontWeight(FontWeight.Bold)
.fontColor('#FFFFFF')
.margin({ bottom: 12 })

Row() {
// 在线设备
Column() {
Text(this.onlineCount.toString())
.fontSize(24)
.fontWeight(FontWeight.Bold)
.fontColor('#22C55E')
Text('在线')
.fontSize(11)
.fontColor('#94A3B8')
}
.width('30%')
.alignItems(HorizontalAlign.Center)

// 离线设备
Column() {
Text(this.offlineCount.toString())
.fontSize(24)
.fontWeight(FontWeight.Bold)
.fontColor('#6B7280')
Text('离线')
.fontSize(11)
.fontColor('#94A3B8')
}
.width('30%')
.alignItems(HorizontalAlign.Center)

// 告警设备
Column() {
Text(this.alertCount.toString())
.fontSize(24)
.fontWeight(FontWeight.Bold)
.fontColor('#EF4444')
Text('告警')
.fontSize(11)
.fontColor('#94A3B8')
}
.width('30%')
.alignItems(HorizontalAlign.Center)
}
.width('100%')
.justifyContent(FlexAlign.SpaceAround)
}
.width('100%')
.padding(16)
.backgroundColor('#FFFFFF0D')
.borderRadius(12)
.margin({ bottom: 12 })
}

@Builder
AlertList() {
Column() {
Text('异常预警')
.fontSize(14)
.fontWeight(FontWeight.Bold)
.fontColor('#FFFFFF')
.margin({ bottom: 12 })

if (this.alerts.length === 0) {
Text('暂无异常')
.fontSize(12)
.fontColor('#22C55E')
.padding(20)
} else {
List() {
ForEach(this.alerts.slice(0, 5), (alert: AlertRecord) => {
ListItem() {
Row() {
// 严重程度指示
Circle()
.width(8)
.height(8)
.fill(alert.severity === 'critical' ? '#EF4444' :
alert.severity === 'high' ? '#F97316' : '#EAB308')

Column() {
Text(alert.message)
.fontSize(12)
.fontColor('#FFFFFF')
.maxLines(1)
.textOverflow({ overflow: TextOverflow.Ellipsis })

Text(alert.suggestedAction)
.fontSize(10)
.fontColor('#3B82F6')
.margin({ top: 2 })
}
.layoutWeight(1)
.margin({ left: 8 })

// 预测性标识
if (alert.predictedFailure) {
Text('预测')
.fontSize(10)
.fontColor('#8B5CF6')
.padding({ left: 6, right: 6, top: 2, bottom: 2 })
.backgroundColor('#8B5CF61A')
.borderRadius(4)
}
}
.width('100%')
.padding(8)
.backgroundColor('#FFFFFF0D')
.borderRadius(8)
.margin({ bottom: 6 })
}
})
}
.width('100%')
.height(200)
}
}
.width('100%')
.padding(16)
.backgroundColor('#FFFFFF0D')
.borderRadius(12)
}

build() {
Column() {
// 标题栏
Row() {
Text('📊 监控仪表盘')
.fontSize(16)
.fontWeight(FontWeight.Bold)
.fontColor('#FFFFFF')

Blank()

Text('实时更新')
.fontSize(11)
.fontColor('#22C55E')
.padding({ left: 8, right: 8, top: 2, bottom: 2 })
.backgroundColor('#22C55E1A')
.borderRadius(4)
}
.width('100%')
.padding(16)
.backgroundColor('#FFFFFF0D')

// 关键指标
Row() {
this.MetricCard('设备总数', (this.onlineCount + this.offlineCount).toString(), '台', '#3B82F6')
this.MetricCard('在线率', `${((this.onlineCount / (this.onlineCount + this.offlineCount)) * 100).toFixed(1)}`, '%', '#22C55E', '+2.3%')
this.MetricCard('总能耗', (this.totalEnergy / 1000).toFixed(2), 'kW·h', '#F59E0B', '-5.1%')
this.MetricCard('异常数', this.alertCount.toString(), '条', '#EF4444')
}
.width('100%')
.justifyContent(FlexAlign.SpaceBetween)
.padding(12)

// 设备状态分布
this.DeviceStatusChart()

// 异常预警列表
this.AlertList()
}
.width('100%')
.height('100%')
.backgroundColor('#00000000')
}

// 更新数据
updateData(devices: IoTDevice[], alerts: AlertRecord[]) {
this.devices = devices;
this.alerts = alerts;
this.onlineCount = devices.filter(d => d.status === DeviceStatus.ONLINE).length;
this.offlineCount = devices.filter(d => d.status === DeviceStatus.OFFLINE).length;
this.alertCount = alerts.length;
this.totalEnergy = devices.reduce((sum, d) => sum + d.energyConsumption, 0);
}
}

5.7 多窗口光效同步管理器（WindowLightSync.ets）

// entry/src/main/ets/managers/WindowLightSync.ets
import { window } from '@kit.ArkUI';
import { DeviceStatus, DeviceStatusLightConfig } from '../components/DeviceStatusLightEffect';

export class WindowLightSync {
private static instance: WindowLightSync;
private windows: Map<string, window.Window> = new Map();
private currentStatus: DeviceStatus = DeviceStatus.ONLINE;

private constructor() {}

static getInstance(): WindowLightSync {
if (!WindowLightSync.instance) {
WindowLightSync.instance = new WindowLightSync();
}
return WindowLightSync.instance;
}

registerWindow(windowId: string, win: window.Window) {
this.windows.set(windowId, win);
this.syncLightEffect();
}

unregisterWindow(windowId: string) {
this.windows.delete(windowId);
}

updateDeviceStatus(status: DeviceStatus) {
this.currentStatus = status;
this.syncLightEffect();
}

private async syncLightEffect() {
const config = DeviceStatusLightConfig[this.currentStatus];

for (const [windowId, win] of this.windows) {
try {
// 同步窗口边框光效
await win.setWindowShadow({
radius: 12,
color: config.color + '66', // 40%透明度
offsetX: 0,
offsetY: 0
});

// 同步标题栏光效
await win.setWindowTitleBarColor(config.color + '1A'); // 10%透明度

// 焦点窗口增强光效
const isFocused = await win.getWindowProperties().then(p => p.isFocused);
if (isFocused) {
await win.setWindowShadow({
radius: 20,
color: config.color + '99', // 60%透明度
offsetX: 0,
offsetY: 0
});
}
} catch (err) {
console.error(`Failed to sync light effect for window ${windowId}:`, err);
}
}
}

// 焦点变化监听
async onFocusChange(windowId: string, isFocused: boolean) {
const win = this.windows.get(windowId);
if (!win) return;

const config = DeviceStatusLightConfig[this.currentStatus];
try {
await win.setWindowShadow({
radius: isFocused ? 20 : 12,
color: isFocused ? config.color + '99' : config.color + '66',
offsetX: 0,
offsetY: 0
});
} catch (err) {
console.error('Failed to update focus light effect:', err);
}
}
}

5.8 主页面集成（SmartLinkManagerPage.ets）

// entry/src/main/ets/pages/SmartLinkManagerPage.ets
import { DeviceStatusLightEffect, DeviceStatus } from '../components/DeviceStatusLightEffect';
import { DeviceFloatNavigation } from '../components/DeviceFloatNavigation';
import { SceneOrchestrationCanvas } from '../components/SceneOrchestrationCanvas';
import { MonitoringDashboard } from '../components/MonitoringDashboard';
import { IoTAgentScheduler, IoTDevice, AlertRecord } from '../agents/IoTAgentScheduler';
import { WindowLightSync } from '../managers/WindowLightSync';

@Entry
@Component
struct SmartLinkManagerPage {
@State currentDeviceStatus: DeviceStatus = DeviceStatus.ONLINE;
@State devices: IoTDevice[] = [];
@State alerts: AlertRecord[] = [];
@State isDiscovering: boolean = false;
@State discoverProgress: number = 0;

private scheduler = IoTAgentScheduler.getInstance();
private lightSync = WindowLightSync.getInstance();
private floatNavRef: DeviceFloatNavigation | null = null;

aboutToAppear() {
// 初始化HMAF调度器
this.scheduler.initialize();
}

@Builder
DeviceGrid() {
Column() {
// 设备网格
Grid() {
ForEach(this.devices, (device: IoTDevice) => {
GridItem() {
Column() {
// 设备图标
Text(this.getDeviceIcon(device.deviceType))
.fontSize(32)
.margin({ bottom: 8 })

Text(device.deviceName)
.fontSize(12)
.fontColor('#FFFFFF')
.maxLines(1)
.textOverflow({ overflow: TextOverflow.Ellipsis })

// 状态指示
Row() {
Circle()
.width(6)
.height(6)
.fill(DeviceStatusLightConfig[device.status].color)

Text(device.status.toUpperCase())
.fontSize(10)
.fontColor(DeviceStatusLightConfig[device.status].color)
.margin({ left: 4 })
}
.margin({ top: 4 })

// 能耗
Text(`${device.energyConsumption}W`)
.fontSize(10)
.fontColor('#94A3B8')
.margin({ top: 2 })
}
.width('100%')
.aspectRatio(1)
.padding(8)
.backgroundColor('#FFFFFF0D')
.borderRadius(12)
.border({
width: 1,
color: device.status === DeviceStatus.ALERT ? '#EF444433' : '#FFFFFF0D'
})
}
})
}
.columnsTemplate('1fr 1fr 1fr 1fr')
.columnsGap(8)
.rowsGap(8)
.padding(12)
.layoutWeight(1)
}
.width('100%')
.height('100%')
}

private getDeviceIcon(type: string): string {
const icons: Record<string, string> = {
'light': '💡',
'sensor': '🌡️',
'camera': '📷',
'lock': '🔒',
'thermostat': '❄️',
'speaker': '🔊',
'outlet': '🔌'
};
return icons[type] || '📟';
}

private async startDeviceDiscovery() {
this.isDiscovering = true;
this.discoverProgress = 0;

// 模拟进度
const progressInterval = setInterval(() => {
this.discoverProgress = Math.min(this.discoverProgress + 10, 90);
}, 300);

try {
const discoveredDevices = await this.scheduler.discoverDevices();
clearInterval(progressInterval);
this.discoverProgress = 100;

this.devices = discoveredDevices;

// 计算整体状态
const hasAlert = this.devices.some(d => d.status === DeviceStatus.ALERT);
const hasOffline = this.devices.some(d => d.status === DeviceStatus.OFFLINE);
this.currentDeviceStatus = hasAlert ? DeviceStatus.ALERT :
hasOffline ? DeviceStatus.OFFLINE : DeviceStatus.ONLINE;

// 同步光效
this.lightSync.updateDeviceStatus(this.currentDeviceStatus);

// 更新导航状态
this.floatNavRef?.updateDeviceStatus(
this.currentDeviceStatus,
this.devices.length,
this.alerts.length
);

// 启动预测性异常检测
this.alerts = await this.scheduler.predictiveAnomalyDetection();

} catch (err) {
console.error('Device discovery failed:', err);
} finally {
this.isDiscovering = false;
}
}

build() {
Stack() {
// 沉浸光效背景层
DeviceStatusLightEffect({ currentStatus: this.currentDeviceStatus })

// 主内容层
Column() {
// 标题栏
Row() {
Text('🏠 智联管家')
.fontSize(20)
.fontWeight(FontWeight.Bold)
.fontColor('#FFFFFF')

Blank()

// 当前设备状态指示
Text(this.currentDeviceStatus.toUpperCase())
.fontSize(12)
.fontWeight(FontWeight.Bold)
.fontColor(DeviceStatusLightConfig[this.currentDeviceStatus].color)
.padding({ left: 8, right: 8, top: 2, bottom: 2 })
.backgroundColor(DeviceStatusLightConfig[this.currentDeviceStatus].color + '1A')
.borderRadius(4)

// 发现按钮
Button(this.isDiscovering ? `扫描中 ${this.discoverProgress}%` : '🔍 发现设备')
.height(32)
.backgroundColor(this.isDiscovering ? '#F59E0B' : '#3B82F6')
.fontColor('#FFFFFF')
.fontSize(12)
.margin({ left: 12 })
.enabled(!this.isDiscovering)
.onClick(() => this.startDeviceDiscovery())
}
.width('100%')
.height(56)
.padding({ left: 16, right: 16 })
.backgroundColor('#FFFFFF0D')
.backdropFilter($r('sys.blur.20'))

// 主内容区
Row() {
// 左侧：设备网格
Column() {
this.DeviceGrid()
}
.width('55%')
.height('100%')

// 右侧：场景编排 + 监控仪表盘
Column() {
// 场景编排
SceneOrchestrationCanvas()
.width('100%')
.height('50%')

// 监控仪表盘
MonitoringDashboard()
.width('100%')
.height('50%')
}
.width('45%')
.height('100%')
.backgroundColor('#00000033')
}
.width('100%')
.layoutWeight(1)