HarmonyOS 6（API 23）实战：HMAF的“智教云枢“——PC端AI智能体智慧教育综合管理平台

文章目录

• • 每日一句正能量
  • 摘要
  • 一、前言：智慧教育管理的范式革新
  • 二、核心特性解析
  • • 2.1 悬浮导航（Float Navigation）
    • 2.2 沉浸光感（Immersive Light Effects）
    • 2.3 HMAF（HarmonyOS Multi-agent Framework）
  • 三、实战案例：打造"智教云枢"智慧教育平台
  • • 3.1 项目配置
    • 3.2 窗口沉浸配置（EducationAbility.ets）
    • 3.3 悬浮教学导航组件（FloatTeachingNav.ets）
    • 3.4 HMAF智能体服务层（EducationAgentService.ets）
    • 3.5 课堂教学主页面（ClassroomPage.ets）
    • 3.6 浮动学情面板Ability（StudentPanelAbility.ets）
    • 3.7 浮动学情面板页面（StudentPanelPage.ets）
  • 四、关键技术总结
  • • 4.1 悬浮导航适配清单
    • 4.2 沉浸光感最佳实践
    • 4.3 HMAF智能体架构设计原则
  • 五、调试与测试建议
  • • 5.1 DevEco Studio调试配置
    • 5.2 关键测试场景
  • 六、结语

每日一句正能量

“守住本心，格局自会慢慢拓宽，内心才会多一份从容与安宁。” 外界的声音会扰乱方向。当你明确自己的核心原则（本心），不因他人评价而动摇，你的心理容量（格局）就会变大——能容纳更多不同、更多不确定性。格局一大，琐事就小了，从容与安宁自然到来。

摘要

摘要：2026年，中国教育数字化战略行动进入深水区，全国中小学智慧教育平台注册用户突破1.2亿，但传统教育管理系统面临教学资源分散、学情分析滞后、家校协同低效三大痛点。HarmonyOS 6（API 23）引入的鸿蒙智能体框架（HMAF）将AI能力下沉至系统层，配合悬浮导航与沉浸光感特性，为PC端智慧教育管理带来了"学情即光效、协作即导航"的全新交互范式。本文将实战开发一款面向HarmonyOS PC的"智教云枢"应用，展示如何利用HMAF构建"学情采集-智能诊断-资源推荐-家校协同"四层智能体协作架构，通过悬浮导航实现教学场景实时切换，基于沉浸光感打造"专注度即氛围"的沉浸体验，以及基于多窗口架构构建浮动学情面板、实时课堂视窗和作业批改助手的协作教学体验。

一、前言：智慧教育管理的范式革新

2026年，中国教育数字化战略行动已进入"智能化升级"新阶段。教育部数据显示，全国中小学智慧教育平台注册用户突破1.2亿，但传统教育管理系统仍面临三大核心痛点：

HarmonyOS 6（API 23）引入的**鸿蒙智能体框架（HarmonyOS Multi-agent Framework，HMAF）将AI能力从应用层下沉至系统层，配合悬浮导航（Float Navigation）与沉浸光感（Immersive Light Effects）**特性，为PC端智慧教育管理带来了"学情即光效、协作即导航"的全新交互范式。

本文核心亮点：

• 学情状态光效：根据班级整体学习状态（专注/分散/疲劳/活跃）动态切换环境光色与脉冲节奏
• 悬浮教学导航：底部悬浮页签替代传统侧边菜单，支持教学场景（课堂/作业/考试/家校）快速切换与透明度调节
• HMAF四层智能体协作：基于Agent Framework Kit构建"学情采集-智能诊断-资源推荐-家校协同"四层智能体协作架构
• 多窗口教学协作：主教学窗口 + 浮动学情面板 + 实时课堂视窗 + 作业批改助手窗口的光效联动
• 意图感知沉浸体验：通过Intents Kit实时理解教师教学意图，自动调整界面光效与导航形态

二、核心特性解析

2.1 悬浮导航（Float Navigation）

悬浮导航是HarmonyOS 6引入的全新底部导航交互模式，主要特点包括：

• 悬浮层级设计：导航栏悬浮于内容之上，不占用布局空间
• 智能避让机制：内容区域自动适配导航栏高度，避免遮挡
• 动态透明度：支持根据滑动状态动态调整导航栏透明度（强85%/平衡70%/弱55%三档）
• 手势融合：与系统全面屏手势无缝衔接

2.2 沉浸光感（Immersive Light Effects）

沉浸光感是HarmonyOS 6的视觉增强系统，核心能力包括：

• P3广色域支持：色彩表现更丰富鲜艳
• 安全区布局优化：组件背景默认延伸至非安全区（AI导航栏、状态栏）
• 玻璃拟态效果：支持半透明、磨砂玻璃等现代视觉效果
• 系统级光效同步：锁屏、主屏、控制面板、通知面板光效统一

2.3 HMAF（HarmonyOS Multi-agent Framework）

HMAF是HarmonyOS 6推出的系统级智能体生态框架，首批上线80+智能体。 其核心架构分为三层：

三、实战案例：打造"智教云枢"智慧教育平台

3.1 项目配置

在module.json5中声明所需权限和依赖：

{
"module": {
"name": "SmartEducationEntry",
"type": "entry",
"description": "智教云枢 – 智慧教育AI智能体管理平台",
"mainElement": "EducationAbility",
"abilities": [
{
"name": "EducationAbility",
"srcEntry": "./ets/abilities/EducationAbility.ets",
"description": "主教学窗口Ability",
"icon": "$media:icon",
"label": "$string:EntryAbility_label",
"startWindowIcon": "$media:startIcon",
"startWindowBackground": "$color:start_window_background",
"exported": true,
"skills": [
{
"entities": ["entity.system.home"],
"actions": ["action.system.home"]
}
]
},
{
"name": "StudentPanelAbility",
"srcEntry": "./ets/abilities/StudentPanelAbility.ets",
"description": "浮动学情面板",
"launchType": "multiton"
},
{
"name": "ClassroomViewAbility",
"srcEntry": "./ets/abilities/ClassroomViewAbility.ets",
"description": "实时课堂视窗",
"launchType": "multiton"
}
],
"requestPermissions": [
{
"name": "ohos.permission.INTERNET"
},
{
"name": "ohos.permission.GET_NETWORK_INFO"
},
{
"name": "ohos.permission.DISTRIBUTED_DATASYNC"
}
],
"dependencies": [
{
"moduleName": "agent_framework_kit",
"bundleName": "com.huawei.hmos.agentframework"
}
]
}
}

3.2 窗口沉浸配置（EducationAbility.ets）

代码亮点：本段代码实现了HarmonyOS 6 PC端窗口的全屏沉浸配置，通过WindowStage获取主窗口后，启用沉浸模式并设置安全区背景延伸，同时根据教学场景动态调整系统光效颜色，实现"学情即氛围"的视觉体验。

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

// 教学场景枚举
export enum TeachingScene {
CLASSROOM = 'classroom', // 课堂教学
HOMEWORK = 'homework', // 作业管理
EXAM = 'exam', // 考试分析
HOME_SCHOOL = 'homeSchool' // 家校协同
}

// 学情状态枚举（对应不同光效）
export enum LearningState {
FOCUSED = 'focused', // 专注 – 宁静蓝
SCATTERED = 'scattered', // 分散 – 警示橙
FATIGUED = 'fatigued', // 疲劳 – 柔和紫
ACTIVE = 'active' // 活跃 – 生机绿
}

export default class EducationAbility extends UIAbility {
private mainWindow: window.Window | null = null;
private currentScene: TeachingScene = TeachingScene.CLASSROOM;
private currentLearningState: LearningState = LearningState.FOCUSED;

onWindowStageCreate(windowStage: window.WindowStage): void {
hilog.info(0x0000, 'SmartEducation', 'EducationAbility onWindowStageCreate');

// 加载主页面
windowStage.loadContent('pages/EducationDashboard', (err) => {
if (err.code) {
hilog.error(0x0000, 'SmartEducation', 'Failed to load content: %{public}s', JSON.stringify(err));
return;
}
hilog.info(0x0000, 'SmartEducation', 'Content loaded successfully');
});

// 配置窗口沉浸模式（HarmonyOS 6 PC端特性）
this.configureImmersiveWindow(windowStage);
}

private async configureImmersiveWindow(windowStage: window.WindowStage): Promise<void> {
try {
this.mainWindow = await windowStage.getMainWindow();

// 启用窗口全屏沉浸模式
await this.mainWindow.setWindowLayoutFullScreen(true);

// 设置安全区背景延伸（沉浸光感核心配置）
await this.mainWindow.setWindowBackgroundColor('#F5F7FA');

// 获取安全区信息
const avoidArea = this.mainWindow.getWindowAvoidArea(window.AvoidAreaType.TYPE_SYSTEM);
const navBarHeight = avoidArea.bottomRect.height;
const statusBarHeight = avoidArea.topRect.height;

// 存储安全区高度供全局使用
AppStorage.setOrCreate('navBarHeight', navBarHeight);
AppStorage.setOrCreate('statusBarHeight', statusBarHeight);

hilog.info(0x0000, 'SmartEducation',
'Window configured: statusBar=%{public}d, navBar=%{public}d',
statusBarHeight, navBarHeight);

} catch (error) {
hilog.error(0x0000, 'SmartEducation',
'Failed to configure window: %{public}s', JSON.stringify(error));
}
}

// 根据教学场景和学情状态更新系统光效
public async updateImmersiveLighting(scene: TeachingScene, state: LearningState): Promise<void> {
if (!this.mainWindow) return;

this.currentScene = scene;
this.currentLearningState = state;

// 场景-光效映射表
const sceneLightEffects: Record<TeachingScene, Record<LearningState, string>> = {
[TeachingScene.CLASSROOM]: {
[LearningState.FOCUSED]: '#E3F2FD', // 宁静蓝
[LearningState.SCATTERED]: '#FFF3E0', // 警示橙
[LearningState.FATIGUED]: '#F3E5F5', // 柔和紫
[LearningState.ACTIVE]: '#E8F5E9' // 生机绿
},
[TeachingScene.HOMEWORK]: {
[LearningState.FOCUSED]: '#E1F5FE',
[LearningState.SCATTERED]: '#FFE0B2',
[LearningState.FATIGUED]: '#EDE7F6',
[LearningState.ACTIVE]: '#C8E6C9'
},
[TeachingScene.EXAM]: {
[LearningState.FOCUSED]: '#BBDEFB',
[LearningState.SCATTERED]: '#FFCC80',
[LearningState.FATIGUED]: '#D1C4E9',
[LearningState.ACTIVE]: '#A5D6A7'
},
[TeachingScene.HOME_SCHOOL]: {
[LearningState.FOCUSED]: '#90CAF9',
[LearningState.SCATTERED]: '#FFB74D',
[LearningState.FATIGUED]: '#B39DDB',
[LearningState.ACTIVE]: '#81C784'
}
};

const lightColor = sceneLightEffects[scene][state];

try {
// 设置窗口背景光效（HarmonyOS 6沉浸光感API）
await this.mainWindow.setWindowBackgroundColor(lightColor);

// 触发系统级光效同步（通知面板、控制面板联动）
await this.mainWindow.setSystemBarProperties({
statusBarColor: lightColor,
navigationBarColor: lightColor
});

hilog.info(0x0000, 'SmartEducation',
'Light effect updated: scene=%{public}s, state=%{public}s, color=%{public}s',
scene, state, lightColor);

} catch (error) {
hilog.error(0x0000, 'SmartEducation',
'Failed to update light effect: %{public}s', JSON.stringify(error));
}
}

onDestroy(): void {
hilog.info(0x0000, 'SmartEducation', 'EducationAbility onDestroy');
this.mainWindow = null;
}
}

3.3 悬浮教学导航组件（FloatTeachingNav.ets）

代码亮点：本组件实现了HarmonyOS 6特色的底部悬浮导航栏，支持教学场景的快速切换。核心特性包括：玻璃拟态背景（backgroundBlurStyle+backdropFilter）、三档透明度调节（强85%/平衡70%/弱55%）、长按展开透明度滑块、智能体状态实时徽章（红色圆点提示待处理事项），以及与系统安全区的智能避让。

// entry/src/main/ets/components/FloatTeachingNav.ets
import { window } from '@kit.ArkUI';
import { vibrator } from '@kit.SensorServiceKit';
import { TeachingScene, LearningState } from '../abilities/EducationAbility';

// 透明度档位枚举
export enum TransparencyLevel {
STRONG = 0.85, // 强效果：高透明度，玻璃感明显
BALANCED = 0.70, // 平衡效果：适中透明度
WEAK = 0.55 // 弱效果：低透明度，更清晰
}

// 导航项配置
interface NavItem {
icon: Resource;
label: string;
scene: TeachingScene;
badge?: number; // 待处理事项数量
agentStatus?: 'idle' | 'running' | 'alert'; // 智能体状态
}

@Component
export struct FloatTeachingNav {
@State currentScene: TeachingScene = TeachingScene.CLASSROOM;
@State navTransparency: number = TransparencyLevel.BALANCED;
@State isExpanded: boolean = false;
@State bottomAvoidHeight: number = 0;
@State learningState: LearningState = LearningState.FOCUSED;

// 智能体待处理任务数
@State agentTasks: Record<TeachingScene, number> = {
[TeachingScene.CLASSROOM]: 3,
[TeachingScene.HOMEWORK]: 12,
[TeachingScene.EXAM]: 5,
[TeachingScene.HOME_SCHOOL]: 8
};

// 导航项配置
private navItems: NavItem[] = [
{
icon: $r('app.media.ic_classroom'),
label: '课堂教学',
scene: TeachingScene.CLASSROOM,
badge: 3,
agentStatus: 'running'
},
{
icon: $r('app.media.ic_homework'),
label: '作业管理',
scene: TeachingScene.HOMEWORK,
badge: 12,
agentStatus: 'alert'
},
{
icon: $r('app.media.ic_exam'),
label: '考试分析',
scene: TeachingScene.EXAM,
badge: 5,
agentStatus: 'idle'
},
{
icon: $r('app.media.ic_home_school'),
label: '家校协同',
scene: TeachingScene.HOME_SCHOOL,
badge: 8,
agentStatus: 'running'
}
];

// 场景切换回调
onSceneChange?: (scene: TeachingScene) => void;

aboutToAppear(): void {
this.getBottomAvoidArea();
this.startLearningStateMonitor();
}

private async getBottomAvoidArea(): Promise<void> {
try {
const mainWindow = await window.getLastWindow();
const avoidArea = mainWindow.getWindowAvoidArea(window.AvoidAreaType.TYPE_NAVIGATION_INDICATOR);
this.bottomAvoidHeight = avoidArea.bottomRect.height;
} catch (error) {
console.error('Failed to get avoid area:', error);
}
}

// 模拟学情状态监控（实际应接入HMAF学情采集智能体）
private startLearningStateMonitor(): void {
setInterval(() => {
const states = [LearningState.FOCUSED, LearningState.SCATTERED, LearningState.FATIGUED, LearningState.ACTIVE];
this.learningState = states[Math.floor(Math.random() * states.length)];
}, 30000); // 每30秒模拟一次状态变化
}

build() {
Stack({ alignContent: Alignment.Bottom }) {
// 内容区域（由父组件传入）
Column() {
this.contentBuilder()
}
.padding({
top: 16,
bottom: this.bottomAvoidHeight + (this.isExpanded ? 140 : 100)
})

// 悬浮导航栏容器
Column() {
// 玻璃拟态背景层
Stack() {
// 背景模糊效果（HarmonyOS 6新特性）
Column()
.width('100%')
.height('100%')
.backgroundBlurStyle(BlurStyle.REGULAR)
.opacity(this.navTransparency)
.backdropFilter($r('sys.blur.20'))

// 渐变光效层（根据学情状态动态变化）
Column()
.width('100%')
.height('100%')
.linearGradient({
direction: GradientDirection.Top,
colors: this.getStateGradientColors()
})
}
.width('100%')
.height('100%')
.borderRadius(28)
.shadow({
radius: 24,
color: 'rgba(0,0,0,0.12)',
offsetX: 0,
offsetY: –6
})

// 导航项
Row() {
ForEach(this.navItems, (item: NavItem) => {
Column() {
Stack() {
Image(item.icon)
.width(28)
.height(28)
.fillColor(this.currentScene === item.scene ? this.getActiveColor() : '#666666')
.transition(TransitionEffect.OPACITY)

// 选中指示器光效
if (this.currentScene === item.scene) {
Column()
.width(48)
.height(48)
.backgroundColor(this.getActiveColor(0.2))
.borderRadius(24)
.blur(12)
.position({ x: –10, y: –10 })
}

// 智能体状态指示器
if (item.agentStatus === 'running') {
Column()
.width(8)
.height(8)
.backgroundColor('#4CAF50')
.borderRadius(4)
.position({ x: 20, y: –4 })
.shadow({ radius: 4, color: 'rgba(76,175,80,0.6)' })
} else if (item.agentStatus === 'alert') {
Column()
.width(8)
.height(8)
.backgroundColor('#FF5252')
.borderRadius(4)
.position({ x: 20, y: –4 })
.shadow({ radius: 4, color: 'rgba(255,82,82,0.6)' })
}
}
.width(48)
.height(48)

Text(item.label)
.fontSize(12)
.fontColor(this.currentScene === item.scene ? this.getActiveColor() : '#999999')
.margin({ top: 6 })
.fontWeight(this.currentScene === item.scene ? FontWeight.Bold : FontWeight.Normal)

// 待处理事项徽章
if (item.badge && item.badge > 0) {
Badge({
value: item.badge.toString(),
position: BadgePosition.RightTop,
style: { badgeSize: 18, badgeColor: '#FF5252' }
}) {
Column().width(0).height(0)
}
.position({ x: 16, y: –36 })
}
}
.layoutWeight(1)
.onClick(() => {
this.switchScene(item.scene);
})
})
}
.width('100%')
.height(90)
.padding({ left: 20, right: 20 })
.justifyContent(FlexAlign.SpaceAround)

// 透明度调节与学情状态指示（展开状态）
if (this.isExpanded) {
Column() {
// 学情状态指示条
Row() {
Text('班级状态')
.fontSize(11)
.fontColor('#666666')
.margin({ right: 8 })

Row() {
Circle()
.width(8)
.height(8)
.fill(this.getStateColor())
Text(this.getStateLabel())
.fontSize(11)
.fontColor(this.getStateColor())
.margin({ left: 4 })
}
.layoutWeight(1)

// 透明度滑块
Slider({
value: this.navTransparency * 100,
min: 55,
max: 85,
step: 15,
style: SliderStyle.InSet
})
.width(100)
.onChange((value: number) => {
this.navTransparency = value / 100;
})

Text(`${Math.round(this.navTransparency * 100)}%`)
.fontSize(11)
.fontColor('#666666')
.margin({ left: 8 })
}
.width('100%')
.height(36)
.padding({ left: 16, right: 16 })
}
.width('100%')
.height(50)
.backgroundColor('rgba(255,255,255,0.6)')
.borderRadius({ topLeft: 16, topRight: 16 })
}
}
.width('94%')
.height(this.isExpanded ? 140 : 90)
.margin({
bottom: this.bottomAvoidHeight + 16,
left: '3%',
right: '3%'
})
.animation({
duration: 350,
curve: Curve.Spring,
iterations: 1
})
.gesture(
LongPressGesture({ duration: 600 })
.onAction(() => {
this.isExpanded = !this.isExpanded;
this.triggerHapticFeedback();
})
)
}
.width('100%')
.height('100%')
}

// 根据学情状态获取渐变色
private getStateGradientColors(): Array<[string, number]> {
switch (this.learningState) {
case LearningState.FOCUSED:
return [['rgba(227,242,253,0.3)', 0.0], ['rgba(255,255,255,0.1)', 1.0]];
case LearningState.SCATTERED:
return [['rgba(255,243,224,0.3)', 0.0], ['rgba(255,255,255,0.1)', 1.0]];
case LearningState.FATIGUED:
return [['rgba(243,229,245,0.3)', 0.0], ['rgba(255,255,255,0.1)', 1.0]];
case LearningState.ACTIVE:
return [['rgba(232,245,233,0.3)', 0.0], ['rgba(255,255,255,0.1)', 1.0]];
}
}

// 获取激活态颜色
private getActiveColor(alpha?: number): string {
const baseColors: Record<LearningState, string> = {
[LearningState.FOCUSED]: '#2196F3',
[LearningState.SCATTERED]: '#FF9800',
[LearningState.FATIGUED]: '#9C27B0',
[LearningState.ACTIVE]: '#4CAF50'
};
const color = baseColors[this.learningState];
if (alpha !== undefined) {
return color + Math.round(alpha * 255).toString(16).padStart(2, '0');
}
return color;
}

// 获取状态颜色
private getStateColor(): string {
return this.getActiveColor();
}

// 获取状态标签
private getStateLabel(): string {
const labels: Record<LearningState, string> = {
[LearningState.FOCUSED]: '专注',
[LearningState.SCATTERED]: '分散',
[LearningState.FATIGUED]: '疲劳',
[LearningState.ACTIVE]: '活跃'
};
return labels[this.learningState];
}

// 切换教学场景
private switchScene(scene: TeachingScene): void {
this.currentScene = scene;
this.triggerHapticFeedback();

// 通知父组件场景切换
if (this.onSceneChange) {
this.onSceneChange(scene);
}

// 更新窗口光效
this.updateWindowLightEffect(scene);
}

private async updateWindowLightEffect(scene: TeachingScene): Promise<void> {
try {
const mainWindow = await window.getLastWindow();
const ability = getContext(this) as unknown as EducationAbility;
if (ability && ability.updateImmersiveLighting) {
ability.updateImmersiveLighting(scene, this.learningState);
}
} catch (error) {
console.error('Failed to update light effect:', error);
}
}

private triggerHapticFeedback(): void {
try {
vibrator.startVibration({
type: 'time',
duration: 40
}, {
id: 0
});
} catch (error) {
console.error('Haptic feedback failed:', error);
}
}

// 内容构建器（由外部传入）
@BuilderParam contentBuilder: () => void = this.defaultContentBuilder;

@Builder
defaultContentBuilder(): void {
Column() {
Text('教学内容区域')
.fontSize(16)
.fontColor('#999999')
}
.width('100%')
.height('100%')
.justifyContent(FlexAlign.Center)
}
}

3.4 HMAF智能体服务层（EducationAgentService.ets）

代码亮点：本段代码实现了基于HMAF框架的四层智能体协作架构。通过AgentController注册学情采集、智能诊断、资源推荐、家校协同四个智能体，每个智能体通过FunctionComponent暴露工具能力。核心设计包括：智能体状态机管理（idle/running/completed/error）、A2A协议跨智能体任务委托、以及基于Intents Kit的意图感知调度。

// entry/src/main/ets/services/EducationAgentService.ets
import {
AgentController,
FunctionComponent,
FunctionController,
AgentIntent
} from '@kit.AgentFrameworkKit';
import { hilog } from '@kit.PerformanceAnalysisKit';
import { distributedDeviceManager } from '@kit.DistributedServiceKit';

// 智能体类型枚举
export enum AgentType {
LEARNING_COLLECTOR = 'learning_collector', // 学情采集智能体
SMART_DIAGNOSIS = 'smart_diagnosis', // 智能诊断智能体
RESOURCE_RECOMMENDER = 'resource_recommender', // 资源推荐智能体
HOME_SCHOOL_BRIDGE = 'home_school_bridge' // 家校协同智能体
}

// 智能体状态
export enum AgentStatus {
IDLE = 'idle',
RUNNING = 'running',
COMPLETED = 'completed',
ERROR = 'error'
}

// 学情数据接口
export interface LearningData {
studentId: string;
studentName: string;
focusScore: number; // 专注度评分 0-100
participationRate: number; // 参与率 0-100
comprehensionLevel: 'high' | 'medium' | 'low';
weakPoints: string[]; // 薄弱知识点
timestamp: number;
}

// 诊断结果接口
export interface DiagnosisResult {
studentId: string;
overallLevel: 'excellent' | 'good' | 'average' | 'poor';
riskFactors: string[];
suggestions: string[];
recommendedResources: ResourceItem[];
}

// 资源项接口
export interface ResourceItem {
resourceId: string;
title: string;
type: 'video' | 'document' | 'quiz' | 'interactive';
difficulty: 'easy' | 'medium' | 'hard';
matchScore: number;
url: string;
}

// 家校消息接口
export interface HomeSchoolMessage {
messageId: string;
type: 'progress' | 'alert' | 'suggestion' | 'praise';
studentId: string;
parentId: string;
content: string;
actionRequired: boolean;
timestamp: number;
}

export class EducationAgentService {
private static instance: EducationAgentService;
private agentController: AgentController | null = null;
private agents: Map<AgentType, FunctionController> = new Map();
private agentStatus: Map<AgentType, AgentStatus> = new Map();

// 学情数据缓存
private learningDataCache: Map<string, LearningData[]> = new Map();
// 诊断结果缓存
private diagnosisCache: Map<string, DiagnosisResult> = new Map();

private constructor() {}

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

// 初始化智能体框架
async initialize(): Promise<void> {
try {
this.agentController = new AgentController({
agentName: 'SmartEducationHub',
agentDescription: '智教云枢 – 智慧教育AI智能体中枢',
agentVersion: '1.0.0'
});

// 注册四个核心智能体
await this.registerLearningCollector();
await this.registerSmartDiagnosis();
await this.registerResourceRecommender();
await this.registerHomeSchoolBridge();

hilog.info(0x0000, 'SmartEducation', 'All agents registered successfully');
} catch (error) {
hilog.error(0x0000, 'SmartEducation',
'Failed to initialize agent service: %{public}s', JSON.stringify(error));
throw error;
}
}

// 注册学情采集智能体
private async registerLearningCollector(): Promise<void> {
const collector = new FunctionController({
functionName: 'collectLearningData',
description: '实时采集学生课堂学情数据，包括专注度、参与率、理解程度等',
parameters: {
type: 'object',
properties: {
classId: { type: 'string', description: '班级ID' },
subject: { type: 'string', description: '学科' },
duration: { type: 'number', description: '采集时长（分钟）' }
},
required: ['classId', 'subject']
}
});

// 实现学情采集逻辑
collector.onCall(async (params: Record<string, Object>) => {
this.agentStatus.set(AgentType.LEARNING_COLLECTOR, AgentStatus.RUNNING);

try {
const classId = params.classId as string;
const subject = params.subject as string;

// 模拟从分布式设备采集学情数据（实际应接入课堂IoT设备）
const learningData = await this.collectFromDevices(classId, subject);

// 缓存数据
if (!this.learningDataCache.has(classId)) {
this.learningDataCache.set(classId, []);
}
this.learningDataCache.get(classId)?.push(…learningData);

this.agentStatus.set(AgentType.LEARNING_COLLECTOR, AgentStatus.COMPLETED);

// 触发智能诊断（A2A协议：智能体间任务委托）
await this.delegateToDiagnosis(classId);

return {
success: true,
data: learningData,
count: learningData.length
};
} catch (error) {
this.agentStatus.set(AgentType.LEARNING_COLLECTOR, AgentStatus.ERROR);
throw error;
}
});

this.agents.set(AgentType.LEARNING_COLLECTOR, collector);
await this.agentController?.registerFunction(collector);
}

// 注册智能诊断智能体
private async registerSmartDiagnosis(): Promise<void> {
const diagnosis = new FunctionController({
functionName: 'diagnoseLearning',
description: '基于学情数据进行智能诊断，识别薄弱知识点和学习风险',
parameters: {
type: 'object',
properties: {
classId: { type: 'string', description: '班级ID' },
analysisType: { type: 'string', enum: ['individual', 'class'], description: '分析类型' }
},
required: ['classId']
}
});

diagnosis.onCall(async (params: Record<string, Object>) => {
this.agentStatus.set(AgentType.SMART_DIAGNOSIS, AgentStatus.RUNNING);

try {
const classId = params.classId as string;
const data = this.learningDataCache.get(classId) || [];

// 模拟AI诊断逻辑（实际应调用云端大模型API）
const results: DiagnosisResult[] = data.map(item => ({
studentId: item.studentId,
overallLevel: this.calculateLevel(item.focusScore, item.participationRate),
riskFactors: item.weakPoints,
suggestions: this.generateSuggestions(item),
recommendedResources: []
}));

results.forEach(r => this.diagnosisCache.set(r.studentId, r));
this.agentStatus.set(AgentType.SMART_DIAGNOSIS, AgentStatus.COMPLETED);

// 触发资源推荐（A2A协议）
await this.delegateToRecommendation(classId);

return { success: true, results };
} catch (error) {
this.agentStatus.set(AgentType.SMART_DIAGNOSIS, AgentStatus.ERROR);
throw error;
}
});

this.agents.set(AgentType.SMART_DIAGNOSIS, diagnosis);
await this.agentController?.registerFunction(diagnosis);
}

// 注册资源推荐智能体
private async registerResourceRecommender(): Promise<void> {
const recommender = new FunctionController({
functionName: 'recommendResources',
description: '基于诊断结果为学生推荐个性化学习资源',
parameters: {
type: 'object',
properties: {
studentId: { type: 'string', description: '学生ID' },
subject: { type: 'string', description: '学科' },
limit: { type: 'number', description: '推荐数量' }
},
required: ['studentId', 'subject']
}
});

recommender.onCall(async (params: Record<string, Object>) => {
this.agentStatus.set(AgentType.RESOURCE_RECOMMENDER, AgentStatus.RUNNING);

try {
const studentId = params.studentId as string;
const subject = params.subject as string;
const limit = (params.limit as number) || 5;

const diagnosis = this.diagnosisCache.get(studentId);
if (!diagnosis) {
throw new Error('No diagnosis data found for student');
}

// 模拟资源匹配算法
const resources: ResourceItem[] = diagnosis.riskFactors.map((point, index) => ({
resourceId: `res_${studentId}_${index}`,
title: `${subject} – ${point}专项训练`,
type: ['video', 'document', 'quiz', 'interactive'][index % 4] as ResourceItem['type'],
difficulty: diagnosis.overallLevel === 'poor' ? 'easy' :
diagnosis.overallLevel === 'average' ? 'medium' : 'hard',
matchScore: 85 + Math.random() * 15,
url: `https://edu-resource.harmonyos.com/${subject}/${point}`
})).slice(0, limit);

this.agentStatus.set(AgentType.RESOURCE_RECOMMENDER, AgentStatus.COMPLETED);
return { success: true, resources };
} catch (error) {
this.agentStatus.set(AgentType.RESOURCE_RECOMMENDER, AgentStatus.ERROR);
throw error;
}
});

this.agents.set(AgentType.RESOURCE_RECOMMENDER, recommender);
await this.agentController?.registerFunction(recommender);
}

// 注册家校协同智能体
private async registerHomeSchoolBridge(): Promise<void> {
const bridge = new FunctionController({
functionName: 'sendHomeSchoolMessage',
description: '向家长发送学情报告和协同建议',
parameters: {
type: 'object',
properties: {
studentId: { type: 'string', description: '学生ID' },
messageType: { type: 'string', enum: ['progress', 'alert', 'suggestion', 'praise'] },
customContent: { type: 'string', description: '自定义内容' }
},
required: ['studentId', 'messageType']
}
});

bridge.onCall(async (params: Record<string, Object>) => {
this.agentStatus.set(AgentType.HOME_SCHOOL_BRIDGE, AgentStatus.RUNNING);

try {
const studentId = params.studentId as string;
const messageType = params.messageType as HomeSchoolMessage['type'];
const diagnosis = this.diagnosisCache.get(studentId);

const message: HomeSchoolMessage = {
messageId: `msg_${Date.now()}`,
type: messageType,
studentId,
parentId: `parent_${studentId}`,
content: params.customContent as string || this.generateDefaultMessage(diagnosis, messageType),
actionRequired: messageType === 'alert' || messageType === 'suggestion',
timestamp: Date.now()
};

// 模拟发送消息（实际应调用分布式消息服务）
await this.sendToParentDevice(message);

this.agentStatus.set(AgentType.HOME_SCHOOL_BRIDGE, AgentStatus.COMPLETED);
return { success: true, messageId: message.messageId };
} catch (error) {
this.agentStatus.set(AgentType.HOME_SCHOOL_BRIDGE, AgentStatus.ERROR);
throw error;
}
});

this.agents.set(AgentType.HOME_SCHOOL_BRIDGE, bridge);
await this.agentController?.registerFunction(bridge);
}

// 从分布式设备采集学情数据
private async collectFromDevices(classId: string, subject: string): Promise<LearningData[]> {
// 获取分布式设备列表（学生平板、智能笔、答题器等）
const devices = distributedDeviceManager.getAvailableDeviceListSync();

// 模拟采集数据
const mockData: LearningData[] = Array.from({ length: 30 }, (_, i) => ({
studentId: `stu_${classId}_${i + 1}`,
studentName: `学生${i + 1}`,
focusScore: 60 + Math.random() * 40,
participationRate: 50 + Math.random() * 50,
comprehensionLevel: ['high', 'medium', 'low'][Math.floor(Math.random() * 3)] as LearningData['comprehensionLevel'],
weakPoints: [`${subject}知识点${Math.floor(Math.random() * 10) + 1}`],
timestamp: Date.now()
}));

return mockData;
}

// A2A协议：委托诊断任务
private async delegateToDiagnosis(classId: string): Promise<void> {
const diagnosisAgent = this.agents.get(AgentType.SMART_DIAGNOSIS);
if (diagnosisAgent) {
await diagnosisAgent.call({ classId, analysisType: 'class' });
}
}

// A2A协议：委托推荐任务
private async delegateToRecommendation(classId: string): Promise<void> {
const students = this.learningDataCache.get(classId) || [];
const recommender = this.agents.get(AgentType.RESOURCE_RECOMMENDER);

for (const student of students.slice(0, 5)) { // 批量处理前5名学生
if (recommender) {
await recommender.call({
studentId: student.studentId,
subject: '数学'
});
}
}
}

// 辅助方法
private calculateLevel(focus: number, participation: number): DiagnosisResult['overallLevel'] {
const avg = (focus + participation) / 2;
if (avg >= 85) return 'excellent';
if (avg >= 70) return 'good';
if (avg >= 60) return 'average';
return 'poor';
}

private generateSuggestions(data: LearningData): string[] {
const suggestions: string[] = [];
if (data.focusScore < 70) suggestions.push('建议增加课堂互动环节');
if (data.participationRate < 60) suggestions.push('建议采用小组讨论形式');
if (data.comprehensionLevel === 'low') suggestions.push('建议进行一对一辅导');
return suggestions;
}

private generateDefaultMessage(diagnosis?: DiagnosisResult, type?: string): string {
if (!diagnosis) return '暂无学情数据';
switch (type) {
case 'progress': return `${diagnosis.studentId}本周学习进度正常，继续保持`;
case 'alert': return `${diagnosis.studentId}近期学习状态下滑，请关注`;
case 'suggestion': return `建议为${diagnosis.studentId}安排${diagnosis.suggestions[0]}`;
case 'praise': return `${diagnosis.studentId}本周表现优异，请给予鼓励`;
default: return '学情更新';
}
}

private async sendToParentDevice(message: HomeSchoolMessage): Promise<void> {
// 实际应通过分布式消息服务发送到家长端设备
hilog.info(0x0000, 'SmartEducation',
'Message sent to parent: %{public}s', JSON.stringify(message));
}

// 公共API：获取智能体状态
getAgentStatus(type: AgentType): AgentStatus {
return this.agentStatus.get(type) || AgentStatus.IDLE;
}

// 公共API：触发学情采集
async triggerLearningCollection(classId: string, subject: string): Promise<LearningData[]> {
const collector = this.agents.get(AgentType.LEARNING_COLLECTOR);
if (!collector) throw new Error('Learning collector not registered');

const result = await collector.call({ classId, subject });
return (result as Record<string, Object>).data as LearningData[];
}

// 公共API：获取诊断结果
getDiagnosisResult(studentId: string): DiagnosisResult | undefined {
return this.diagnosisCache.get(studentId);
}
}

3.5 课堂教学主页面（ClassroomPage.ets）

代码亮点：本页面实现了课堂教学场景的核心交互，包括：实时学情热力图（通过Canvas绘制学生座位图，颜色深浅表示专注度）、HMAF智能体状态实时面板（显示四个智能体的运行状态）、悬浮导航集成、以及基于沉浸光感的动态背景。

// entry/src/main/ets/pages/ClassroomPage.ets
import { EducationAgentService, LearningData, AgentType, AgentStatus } from '../services/EducationAgentService';
import { FloatTeachingNav, TeachingScene } from '../components/FloatTeachingNav';
import { LearningState } from '../abilities/EducationAbility';

@Entry
@Component
struct ClassroomPage {
@State learningData: LearningData[] = [];
@State isLoading: boolean = false;
@State selectedStudent: LearningData | null = null;
@State agentStatuses: Record<AgentType, AgentStatus> = {
[AgentType.LEARNING_COLLECTOR]: AgentStatus.IDLE,
[AgentType.SMART_DIAGNOSIS]: AgentStatus.IDLE,
[AgentType.RESOURCE_RECOMMENDER]: AgentStatus.IDLE,
[AgentType.HOME_SCHOOL_BRIDGE]: AgentStatus.IDLE
};

private agentService: EducationAgentService = EducationAgentService.getInstance();
private classId: string = 'class_2026_01';
private refreshTimer: number = –1;

aboutToAppear(): void {
this.initializeAgentService();
this.startRealTimeMonitoring();
}

aboutToDisappear(): void {
if (this.refreshTimer !== –1) {
clearInterval(this.refreshTimer);
}
}

private async initializeAgentService(): Promise<void> {
try {
await this.agentService.initialize();
// 初始化学情采集
await this.collectLearningData();
} catch (error) {
console.error('Failed to initialize:', error);
}
}

private startRealTimeMonitoring(): void {
// 每10秒刷新智能体状态
this.refreshTimer = setInterval(() => {
this.updateAgentStatuses();
}, 10000);
}

private updateAgentStatuses(): void {
this.agentStatuses = {
[AgentType.LEARNING_COLLECTOR]: this.agentService.getAgentStatus(AgentType.LEARNING_COLLECTOR),
[AgentType.SMART_DIAGNOSIS]: this.agentService.getAgentStatus(AgentType.SMART_DIAGNOSIS),
[AgentType.RESOURCE_RECOMMENDER]: this.agentService.getAgentStatus(AgentType.RESOURCE_RECOMMENDER),
[AgentType.HOME_SCHOOL_BRIDGE]: this.agentService.getAgentStatus(AgentType.HOME_SCHOOL_BRIDGE)
};
}

private async collectLearningData(): Promise<void> {
this.isLoading = true;
try {
const data = await this.agentService.triggerLearningCollection(this.classId, '数学');
this.learningData = data;
} catch (error) {
console.error('Failed to collect data:', error);
} finally {
this.isLoading = false;
}
}

build() {
FloatTeachingNav({
currentScene: TeachingScene.CLASSROOM,
onSceneChange: (scene: TeachingScene) => {
// 场景切换逻辑
console.info(`Switched to scene: ${scene}`);
}
}) {
this.classroomContentBuilder()
}
}

@Builder
classroomContentBuilder(): void {
Column() {
// 顶部标题栏（沉浸光感安全区适配）
Row() {
Column() {
Text('三年级（2）班 – 数学课堂')
.fontSize(24)
.fontWeight(FontWeight.Bold)
.fontColor('#1A1A1A')

Text(`实时学情 | 共${this.learningData.length}人 | 平均专注度: ${this.getAverageFocus()}%`)
.fontSize(14)
.fontColor('#666666')
.margin({ top: 4 })
}
.alignItems(HorizontalAlign.Start)
.layoutWeight(1)

// 智能体状态指示器
this.agentStatusIndicator()
}
.width('100%')
.height(80)
.padding({ left: 24, right: 24, top: 16 })
.backgroundColor('rgba(255,255,255,0.8)')
.backdropFilter($r('sys.blur.10'))

// 学情热力图区域
Stack() {
if (this.isLoading) {
LoadingProgress()
.width(48)
.height(48)
.color('#2196F3')
} else {
this.learningHeatmapBuilder()
}
}
.width('100%')
.layoutWeight(1)
.padding(16)

// 选中学生详情面板
if (this.selectedStudent) {
this.studentDetailPanel()
}
}
.width('100%')
.height('100%')
.backgroundColor('#F5F7FA')
}

// 学情热力图构建器
@Builder
learningHeatmapBuilder(): void {
Grid() {
ForEach(this.learningData, (student: LearningData) => {
GridItem() {
Column() {
Text(student.studentName)
.fontSize(13)
.fontColor('#FFFFFF')
.fontWeight(FontWeight.Medium)

Text(`${Math.round(student.focusScore)}%`)
.fontSize(11)
.fontColor('rgba(255,255,255,0.9)')
.margin({ top: 2 })
}
.width('100%')
.height('100%')
.justifyContent(FlexAlign.Center)
.backgroundColor(this.getFocusColor(student.focusScore))
.borderRadius(12)
.shadow({
radius: 8,
color: 'rgba(0,0,0,0.1)',
offsetX: 0,
offsetY: 2
})
.scale({ x: this.selectedStudent?.studentId === student.studentId ? 1.05 : 1.0, y: this.selectedStudent?.studentId === student.studentId ? 1.05 : 1.0 })
.animation({
duration: 200,
curve: Curve.EaseInOut
})
}
.onClick(() => {
this.selectedStudent = this.selectedStudent?.studentId === student.studentId ? null : student;
})
})
}
.columnsTemplate('1fr 1fr 1fr 1fr 1fr 1fr')
.rowsTemplate('1fr 1fr 1fr 1fr 1fr')
.columnsGap(8)
.rowsGap(8)
.width('100%')
.height('100%')
}

// 学生详情面板
@Builder
studentDetailPanel(): void {
Column() {
Row() {
Text(this.selectedStudent!.studentName)
.fontSize(18)
.fontWeight(FontWeight.Bold)
.fontColor('#1A1A1A')

Button('关闭')
.fontSize(12)
.fontColor('#666666')
.backgroundColor('transparent')
.onClick(() => {
this.selectedStudent = null;
})
}
.width('100%')
.justifyContent(FlexAlign.SpaceBetween)

// 学情指标
this.metricBar('专注度', this.selectedStudent!.focusScore, '#2196F3')
this.metricBar('参与率', this.selectedStudent!.participationRate, '#4CAF50')

// 薄弱知识点
Text('薄弱知识点')
.fontSize(14)
.fontColor('#666666')
.margin({ top: 12, bottom: 8 })
.alignSelf(ItemAlign.Start)

Row() {
ForEach(this.selectedStudent!.weakPoints, (point: string) => {
Text(point)
.fontSize(12)
.fontColor('#FF5252')
.backgroundColor('rgba(255,82,82,0.1)')
.padding({ left: 8, right: 8, top: 4, bottom: 4 })
.borderRadius(8)
.margin({ right: 8 })
})
}
.width('100%')
.margin({ bottom: 12 })

// 智能体操作按钮
Row() {
Button('智能诊断')
.fontSize(13)
.fontColor('#FFFFFF')
.backgroundColor('#2196F3')
.borderRadius(20)
.padding({ left: 16, right: 16 })
.onClick(() => {
this.triggerDiagnosis(this.selectedStudent!.studentId);
})

Button('推荐资源')
.fontSize(13)
.fontColor('#FFFFFF')
.backgroundColor('#4CAF50')
.borderRadius(20)
.padding({ left: 16, right: 16 })
.margin({ left: 12 })
.onClick(() => {
this.triggerRecommendation(this.selectedStudent!.studentId);
})

Button('通知家长')
.fontSize(13)
.fontColor('#FFFFFF')
.backgroundColor('#FF9800')
.borderRadius(20)
.padding({ left: 16, right: 16 })
.margin({ left: 12 })
.onClick(() => {
this.notifyParent(this.selectedStudent!.studentId);
})
}
.width('100%')
.justifyContent(FlexAlign.Start)
}
.width('100%')
.height(280)
.padding(20)
.backgroundColor('rgba(255,255,255,0.95)')
.backdropFilter($r('sys.blur.20'))
.borderRadius({ topLeft: 24, topRight: 24 })
.shadow({
radius: 16,
color: 'rgba(0,0,0,0.1)',
offsetX: 0,
offsetY: –4
})
.animation({
duration: 300,
curve: Curve.Spring
})
}

// 智能体状态指示器
@Builder
agentStatusIndicator(): void {
Row() {
ForEach(Object.entries(this.agentStatuses), ([type, status]: [string, AgentStatus]) => {
Column() {
Circle()
.width(8)
.height(8)
.fill(this.getStatusColor(status))
.shadow({
radius: 4,
color: this.getStatusColor(status, 0.4),
offsetX: 0,
offsetY: 0
})

Text(this.getAgentShortName(type as AgentType))
.fontSize(9)
.fontColor('#999999')
.margin({ top: 2 })
}
.margin({ left: 8 })
})
}
}

// 指标条构建器
@Builder
metricBar(label: string, value: number, color: string): void {
Row() {
Text(label)
.fontSize(13)
.fontColor('#666666')
.width(60)

Stack() {
Row()
.width('100%')
.height(8)
.backgroundColor('rgba(0,0,0,0.05)')
.borderRadius(4)

Row()
.width(`${value}%`)
.height(8)
.backgroundColor(color)
.borderRadius(4)
.animation({
duration: 1000,
curve: Curve.EaseOut
})
}
.layoutWeight(1)
.height(8)

Text(`${Math.round(value)}%`)
.fontSize(13)
.fontColor(color)
.width(40)
.textAlign(TextAlign.End)
}
.width('100%')
.height(32)
.alignItems(VerticalAlign.Center)
}

// 根据专注度获取颜色
private getFocusColor(score: number): string {
if (score >= 85) return '#4CAF50';
if (score >= 70) return '#8BC34A';
if (score >= 60) return '#FFC107';
if (score >= 40) return '#FF9800';
return '#FF5252';
}

// 获取平均专注度
private getAverageFocus(): number {
if (this.learningData.length === 0) return 0;
const sum = this.learningData.reduce((acc, cur) => acc + cur.focusScore, 0);
return Math.round(sum / this.learningData.length);
}

// 获取智能体状态颜色
private getStatusColor(status: AgentStatus, alpha?: number): string {
const colors: Record<AgentStatus, string> = {
[AgentStatus.IDLE]: '#9E9E9E',
[AgentStatus.RUNNING]: '#2196F3',
[AgentStatus.COMPLETED]: '#4CAF50',
[AgentStatus.ERROR]: '#FF5252'
};
const baseColor = colors[status];
if (alpha !== undefined) {
return baseColor + Math.round(alpha * 255).toString(16).padStart(2, '0');
}
return baseColor;
}

// 获取智能体简称
private getAgentShortName(type: AgentType): string {
const names: Record<AgentType, string> = {
[AgentType.LEARNING_COLLECTOR]: '采集',
[AgentType.SMART_DIAGNOSIS]: '诊断',
[AgentType.RESOURCE_RECOMMENDER]: '推荐',
[AgentType.HOME_SCHOOL_BRIDGE]: '家校'
};
return names[type];
}

// 触发智能诊断
private async triggerDiagnosis(studentId: string): Promise<void> {
const diagnosis = this.agentService.getDiagnosisResult(studentId);
if (diagnosis) {
console.info(`Diagnosis for ${studentId}:`, JSON.stringify(diagnosis));
}
}

// 触发资源推荐
private async triggerRecommendation(studentId: string): Promise<void> {
const recommender = this.agentService['agents'].get(AgentType.RESOURCE_RECOMMENDER);
if (recommender) {
await recommender.call({ studentId, subject: '数学' });
}
}

// 通知家长
private async notifyParent(studentId: string): Promise<void> {
const bridge = this.agentService['agents'].get(AgentType.HOME_SCHOOL_BRIDGE);
if (bridge) {
await bridge.call({ studentId, messageType: 'alert' });
}
}
}

3.6 浮动学情面板Ability（StudentPanelAbility.ets）

代码亮点：本Ability实现了HarmonyOS PC端的多窗口浮动面板，通过WindowStage.createSubWindow创建悬浮窗口，支持拖拽调整位置、实时显示学情数据、以及与主窗口的光效联动。

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

export default class StudentPanelAbility extends UIAbility {
private subWindow: window.Window | null = null;

onWindowStageCreate(windowStage: window.WindowStage): void {
hilog.info(0x0000, 'SmartEducation', 'StudentPanelAbility onWindowStageCreate');

// 创建子窗口（浮动面板）
this.createFloatingPanel(windowStage);
}

private async createFloatingPanel(windowStage: window.WindowStage): Promise<void> {
try {
// 创建子窗口
this.subWindow = await windowStage.createSubWindow('studentPanel');

// 设置窗口大小和位置（PC端右侧浮动）
await this.subWindow.resize(360, 600);
await this.subWindow.moveWindowTo(1200, 100);

// 设置窗口属性
await this.subWindow.setWindowLayoutFullScreen(true);
await this.subWindow.setWindowBackgroundColor('rgba(255,255,255,0.92)');

// 加载面板内容
await this.subWindow.setUIContent('pages/StudentPanelPage');

// 显示窗口
await this.subWindow.showWindow();

hilog.info(0x0000, 'SmartEducation', 'Floating panel created successfully');
} catch (error) {
hilog.error(0x0000, 'SmartEducation',
'Failed to create floating panel: %{public}s', JSON.stringify(error));
}
}