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 窗口沉浸配置（LogisticsAbility.ets）
    • 3.3 悬浮场景导航组件（FloatLogisticsNav.ets）
    • 3.4 HMAF智能体服务层（LogisticsAgentService.ets）
    • 3.5 物流总览主页面（OverviewPage.ets）
    • 3.6 浮动运力面板Ability（FleetPanelAbility.ets）
    • 3.7 浮动运力面板页面（FleetPanelPage.ets）
  • 四、关键技术总结
  • • 4.1 悬浮导航适配清单
    • 4.2 沉浸光感最佳实践
    • 4.3 HMAF智能体架构设计原则
  • 五、调试与测试建议
  • • 5.1 DevEco Studio调试配置
    • 5.2 关键测试场景
  • 六、结语

每日一句正能量

“不必刻意迎合世间的热闹，在独处时读书、沉淀、自愈。” 社交场合的热闹往往是消耗型的。独处不是孤独，而是主动选择的充电方式。读书获取新知，沉淀整理思绪，自愈修复情绪。高质量独处比低质量合群更有助于成长。

摘要

摘要：2026年，中国智慧物流市场规模突破1.5万亿元，但传统物流管理系统面临订单预测滞后、车辆调度粗放、仓储协同低效三大痛点。HarmonyOS 6（API 23）引入的鸿蒙智能体框架（HMAF）将AI能力下沉至系统层，配合悬浮导航与沉浸光感特性，为PC端智慧物流管理带来了"运力即光效、场景即导航"的全新交互范式。本文将实战开发一款面向HarmonyOS PC的"智链云枢"应用，展示如何利用HMAF构建"订单感知-路径优化-仓储协同-运力调度"四层智能体协作架构，通过悬浮导航实现物流场景实时切换，基于沉浸光感打造"运力负载即氛围"的沉浸体验，以及基于多窗口架构构建浮动运力面板、实时路径视窗和智能调度助手的协作管理体验。

一、前言：智慧物流供应链管理的范式革新

2026年，中国智慧物流市场规模突破1.5万亿元，快递业务量超过2000亿件，但传统物流管理系统仍面临三大核心痛点：

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": "SmartLogisticsEntry",
"type": "entry",
"description": "智链云枢 – 智慧物流AI智能体供应链调度管理平台",
"mainElement": "LogisticsAbility",
"abilities": [
{
"name": "LogisticsAbility",
"srcEntry": "./ets/abilities/LogisticsAbility.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": "FleetPanelAbility",
"srcEntry": "./ets/abilities/FleetPanelAbility.ets",
"description": "浮动运力面板",
"launchType": "multiton"
},
{
"name": "RouteViewAbility",
"srcEntry": "./ets/abilities/RouteViewAbility.ets",
"description": "实时路径视窗",
"launchType": "multiton"
}
],
"requestPermissions": [
{
"name": "ohos.permission.INTERNET"
},
{
"name": "ohos.permission.GET_NETWORK_INFO"
},
{
"name": "ohos.permission.DISTRIBUTED_DATASYNC"
},
{
"name": "ohos.permission.LOCATION"
}
],
"dependencies": [
{
"moduleName": "agent_framework_kit",
"bundleName": "com.huawei.hmos.agentframework"
}
]
}
}

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

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

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

// 物流场景枚举
export enum LogisticsScene {
OVERVIEW = 'overview', // 物流总览
ORDER = 'order', // 订单管理
ROUTE = 'route', // 路径优化
WAREHOUSE = 'warehouse' // 仓储协同
}

// 运力负载状态枚举（对应不同光效）
export enum CapacityLoad {
IDLE = 'idle', // 空闲 – 宁静绿
MODERATE = 'moderate', // 适中 – 活力蓝
TENSE = 'tense', // 紧张 – 警示橙
OVERLOAD = 'overload' // 超载 – 紧急红
}

export default class LogisticsAbility extends UIAbility {
private mainWindow: window.Window | null = null;
private currentScene: LogisticsScene = LogisticsScene.OVERVIEW;
private currentLoad: CapacityLoad = CapacityLoad.MODERATE;

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

// 加载主页面
windowStage.loadContent('pages/LogisticsDashboard', (err) => {
if (err.code) {
hilog.error(0x0000, 'SmartLogistics', 'Failed to load content: %{public}s', JSON.stringify(err));
return;
}
hilog.info(0x0000, 'SmartLogistics', '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('#0F172A');

// 获取安全区信息
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, 'SmartLogistics',
'Window configured: statusBar=%{public}d, navBar=%{public}d',
statusBarHeight, navBarHeight);

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

// 根据物流场景和运力负载更新系统光效
public async updateImmersiveLighting(scene: LogisticsScene, load: CapacityLoad): Promise<void> {
if (!this.mainWindow) return;

this.currentScene = scene;
this.currentLoad = load;

// 场景-光效映射表（深色主题适配物流场景）
const sceneLightEffects: Record<LogisticsScene, Record<CapacityLoad, string>> = {
[LogisticsScene.OVERVIEW]: {
[CapacityLoad.IDLE]: '#0D3328', // 深翠绿
[CapacityLoad.MODERATE]: '#0D1F33', // 深海蓝
[CapacityLoad.TENSE]: '#331F0D', // 深琥珀
[CapacityLoad.OVERLOAD]: '#330D0D' // 深绯红
},
[LogisticsScene.ORDER]: {
[CapacityLoad.IDLE]: '#0A2E1F',
[CapacityLoad.MODERATE]: '#0A1E2E',
[CapacityLoad.TENSE]: '#2E1E0A',
[CapacityLoad.OVERLOAD]: '#2E0A0A'
},
[LogisticsScene.ROUTE]: {
[CapacityLoad.IDLE]: '#082818',
[CapacityLoad.MODERATE]: '#081828',
[CapacityLoad.TENSE]: '#281808',
[CapacityLoad.OVERLOAD]: '#280808'
},
[LogisticsScene.WAREHOUSE]: {
[CapacityLoad.IDLE]: '#052215',
[CapacityLoad.MODERATE]: '#051525',
[CapacityLoad.TENSE]: '#251505',
[CapacityLoad.OVERLOAD]: '#250505'
}
};

const lightColor = sceneLightEffects[scene][load];

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

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

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

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

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

3.3 悬浮场景导航组件（FloatLogisticsNav.ets）

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

// entry/src/main/ets/components/FloatLogisticsNav.ets
import { window } from '@kit.ArkUI';
import { vibrator } from '@kit.SensorServiceKit';
import { LogisticsScene, CapacityLoad } from '../abilities/LogisticsAbility';

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

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

@Component
export struct FloatLogisticsNav {
@State currentScene: LogisticsScene = LogisticsScene.OVERVIEW;
@State navTransparency: number = TransparencyLevel.BALANCED;
@State isExpanded: boolean = false;
@State bottomAvoidHeight: number = 0;
@State capacityLoad: CapacityLoad = CapacityLoad.MODERATE;

// 智能体待处理告警数
@State agentAlerts: Record<LogisticsScene, number> = {
[LogisticsScene.OVERVIEW]: 0,
[LogisticsScene.ORDER]: 12,
[LogisticsScene.ROUTE]: 5,
[LogisticsScene.WAREHOUSE]: 3
};

// 导航项配置
private navItems: NavItem[] = [
{
icon: $r('app.media.ic_overview'),
label: '物流总览',
scene: LogisticsScene.OVERVIEW,
badge: 0,
agentStatus: 'idle'
},
{
icon: $r('app.media.ic_order'),
label: '订单管理',
scene: LogisticsScene.ORDER,
badge: 12,
agentStatus: 'alert'
},
{
icon: $r('app.media.ic_route'),
label: '路径优化',
scene: LogisticsScene.ROUTE,
badge: 5,
agentStatus: 'running'
},
{
icon: $r('app.media.ic_warehouse'),
label: '仓储协同',
scene: LogisticsScene.WAREHOUSE,
badge: 3,
agentStatus: 'running'
}
];

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

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

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 startLoadMonitor(): void {
setInterval(() => {
const loads = [CapacityLoad.IDLE, CapacityLoad.MODERATE, CapacityLoad.TENSE, CapacityLoad.OVERLOAD];
this.capacityLoad = loads[Math.floor(Math.random() * loads.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.getLoadGradientColors()
})
}
.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() : '#AAAAAA')
.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() : '#BBBBBB')
.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('#CCCCCC')
.margin({ right: 8 })

Row() {
Circle()
.width(8)
.height(8)
.fill(this.getLoadColor())
Text(this.getLoadLabel())
.fontSize(11)
.fontColor(this.getLoadColor())
.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('#CCCCCC')
.margin({ left: 8 })
}
.width('100%')
.height(36)
.padding({ left: 16, right: 16 })
}
.width('100%')
.height(50)
.backgroundColor('rgba(255,255,255,0.1)')
.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 getLoadGradientColors(): Array<[string, number]> {
switch (this.capacityLoad) {
case CapacityLoad.IDLE:
return [['rgba(16,185,129,0.15)', 0.0], ['rgba(255,255,255,0.02)', 1.0]];
case CapacityLoad.MODERATE:
return [['rgba(59,130,246,0.15)', 0.0], ['rgba(255,255,255,0.02)', 1.0]];
case CapacityLoad.TENSE:
return [['rgba(245,158,11,0.15)', 0.0], ['rgba(255,255,255,0.02)', 1.0]];
case CapacityLoad.OVERLOAD:
return [['rgba(239,68,68,0.15)', 0.0], ['rgba(255,255,255,0.02)', 1.0]];
}
}

// 获取激活态颜色
private getActiveColor(alpha?: number): string {
const baseColors: Record<CapacityLoad, string> = {
[CapacityLoad.IDLE]: '#10B981',
[CapacityLoad.MODERATE]: '#3B82F6',
[CapacityLoad.TENSE]: '#F59E0B',
[CapacityLoad.OVERLOAD]: '#EF4444'
};
const color = baseColors[this.capacityLoad];
if (alpha !== undefined) {
return color + Math.round(alpha * 255).toString(16).padStart(2, '0');
}
return color;
}

// 获取负载颜色
private getLoadColor(): string {
return this.getActiveColor();
}

// 获取负载标签
private getLoadLabel(): string {
const labels: Record<CapacityLoad, string> = {
[CapacityLoad.IDLE]: '空闲',
[CapacityLoad.MODERATE]: '适中',
[CapacityLoad.TENSE]: '紧张',
[CapacityLoad.OVERLOAD]: '超载'
};
return labels[this.capacityLoad];
}

// 切换物流场景
private switchScene(scene: LogisticsScene): void {
this.currentScene = scene;
this.triggerHapticFeedback();

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

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

private async updateWindowLightEffect(scene: LogisticsScene): Promise<void> {
try {
const mainWindow = await window.getLastWindow();
const ability = getContext(this) as unknown as LogisticsAbility;
if (ability && ability.updateImmersiveLighting) {
ability.updateImmersiveLighting(scene, this.capacityLoad);
}
} 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智能体服务层（LogisticsAgentService.ets）

代码亮点：本段代码实现了基于HMAF框架的四层智能体协作架构。通过AgentController注册订单感知、路径优化、仓储协同、运力调度四个智能体，每个智能体通过FunctionComponent暴露工具能力。核心设计包括：智能体状态机管理（idle/running/completed/error）、A2A协议跨智能体任务委托、以及基于Intents Kit的意图感知调度。

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

// 智能体类型枚举
export enum AgentType {
ORDER_PERCEPTION = 'order_perception', // 订单感知智能体
ROUTE_OPTIMIZE = 'route_optimize', // 路径优化智能体
WAREHOUSE_SYNC = 'warehouse_sync', // 仓储协同智能体
CAPACITY_DISPATCH = 'capacity_dispatch' // 运力调度智能体
}

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

// 订单数据接口
export interface OrderData {
orderId: string;
origin: string; // 发货地
destination: string; // 收货地
weight: number; // 重量(kg)
volume: number; // 体积(m³)
priority: 'urgent' | 'normal' | 'low';
deadline: number; // 截止时间戳
status: 'pending' | 'processing' | 'delivering' | 'completed';
timestamp: number;
}

// 路径优化结果接口
export interface RouteResult {
vehicleId: string;
driverName: string;
route: string[]; // 途径点
distance: number; // 总距离(km)
estimatedTime: number; // 预计时间(分钟)
fuelCost: number; // 燃油成本
loadRate: number; // 装载率 0-100
suggestions: string[];
}

// 仓储状态接口
export interface WarehouseStatus {
warehouseId: string;
warehouseName: string;
inventoryLevel: number; // 库存水平 0-100
inboundQueue: number; // 入库排队
outboundQueue: number; // 出库排队
availableSpace: number; // 可用空间(m³)
syncStatus: 'synced' | 'syncing' | 'delayed';
}

// 运力调度结果接口
export interface DispatchResult {
vehicleId: string;
vehicleType: 'truck' | 'van' | 'motorcycle';
currentLoad: number; // 当前负载 0-100
location: string;
nextTask: string;
eta: number; // 预计到达时间
}

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

// 订单数据缓存
private orderCache: Map<string, OrderData[]> = new Map();
// 路径结果缓存
private routeCache: Map<string, RouteResult> = new Map();

private constructor() {}

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

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

// 注册四个核心智能体
await this.registerOrderPerception();
await this.registerRouteOptimize();
await this.registerWarehouseSync();
await this.registerCapacityDispatch();

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

// 注册订单感知智能体
private async registerOrderPerception(): Promise<void> {
const perceptor = new FunctionController({
functionName: 'perceiveOrders',
description: '实时感知物流订单数据，包括来源、目的地、优先级、截止时间等',
parameters: {
type: 'object',
properties: {
regionId: { type: 'string', description: '区域ID' },
timeWindow: { type: 'number', description: '时间窗口（小时）' },
orderType: { type: 'string', enum: ['all', 'urgent', 'normal'], description: '订单类型' }
},
required: ['regionId']
}
});

// 实现订单感知逻辑
perceptor.onCall(async (params: Record<string, Object>) => {
this.agentStatus.set(AgentType.ORDER_PERCEPTION, AgentStatus.RUNNING);

try {
const regionId = params.regionId as string;

// 模拟从分布式设备采集订单数据（实际应接入物流IoT设备）
const orders = await this.collectFromDevices(regionId);

// 缓存数据
if (!this.orderCache.has(regionId)) {
this.orderCache.set(regionId, []);
}
this.orderCache.get(regionId)?.push(…orders);

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

// 触发路径优化（A2A协议：智能体间任务委托）
await this.delegateToRouteOptimize(regionId);

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

this.agents.set(AgentType.ORDER_PERCEPTION, perceptor);
await this.agentController?.registerFunction(perceptor);
}

// 注册路径优化智能体
private async registerRouteOptimize(): Promise<void> {
const optimizer = new FunctionController({
functionName: 'optimizeRoutes',
description: '基于订单数据和实时路况进行智能路径优化',
parameters: {
type: 'object',
properties: {
regionId: { type: 'string', description: '区域ID' },
strategy: { type: 'string', enum: ['shortest', 'fastest', 'cheapest', 'balanced'], description: '优化策略' }
},
required: ['regionId']
}
});

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

try {
const regionId = params.regionId as string;
const orders = this.orderCache.get(regionId) || [];

// 模拟AI路径优化逻辑（实际应调用云端大模型API）
const results: RouteResult[] = orders.map(order => ({
vehicleId: `veh_${regionId}_${Math.floor(Math.random() * 100)}`,
driverName: `司机${Math.floor(Math.random() * 50) + 1}`,
route: [order.origin, '中转站A', '中转站B', order.destination],
distance: Math.floor(Math.random() * 500) + 50,
estimatedTime: Math.floor(Math.random() * 300) + 60,
fuelCost: Math.floor(Math.random() * 500) + 100,
loadRate: Math.floor(Math.random() * 40) + 60,
suggestions: this.generateRouteSuggestions(order)
}));

results.forEach(r => this.routeCache.set(r.vehicleId, r));
this.agentStatus.set(AgentType.ROUTE_OPTIMIZE, AgentStatus.COMPLETED);

// 触发运力调度（A2A协议）
await this.delegateToCapacityDispatch(regionId);

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

this.agents.set(AgentType.ROUTE_OPTIMIZE, optimizer);
await this.agentController?.registerFunction(optimizer);
}

// 注册仓储协同智能体
private async registerWarehouseSync(): Promise<void> {
const syncer = new FunctionController({
functionName: 'syncWarehouses',
description: '同步各仓库库存状态，协调入库出库作业',
parameters: {
type: 'object',
properties: {
warehouseId: { type: 'string', description: '仓库ID' },
syncType: { type: 'string', enum: ['full', 'incremental'], description: '同步类型' }
},
required: ['warehouseId']
}
});

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

try {
const warehouseId = params.warehouseId as string;

// 模拟仓库状态同步
const status: WarehouseStatus = {
warehouseId,
warehouseName: `仓库${warehouseId}`,
inventoryLevel: Math.floor(Math.random() * 100),
inboundQueue: Math.floor(Math.random() * 50),
outboundQueue: Math.floor(Math.random() * 50),
availableSpace: Math.floor(Math.random() * 10000),
syncStatus: 'synced'
};

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

this.agents.set(AgentType.WAREHOUSE_SYNC, syncer);
await this.agentController?.registerFunction(syncer);
}

// 注册运力调度智能体
private async registerCapacityDispatch(): Promise<void> {
const dispatcher = new FunctionController({
functionName: 'dispatchCapacity',
description: '基于路径优化结果进行运力调度分配',
parameters: {
type: 'object',
properties: {
regionId: { type: 'string', description: '区域ID' },
vehicleType: { type: 'string', enum: ['all', 'truck', 'van', 'motorcycle'] }
},
required: ['regionId']
}
});

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

try {
const regionId = params.regionId as string;

// 模拟运力调度
const dispatches: DispatchResult[] = Array.from({ length: 10 }, (_, i) => ({
vehicleId: `veh_${regionId}_${i + 1}`,
vehicleType: ['truck', 'van', 'motorcycle'][Math.floor(Math.random() * 3)] as DispatchResult['vehicleType'],
currentLoad: Math.floor(Math.random() * 100),
location: `区域${regionId}节点${Math.floor(Math.random() * 10) + 1}`,
nextTask: `配送订单${Math.floor(Math.random() * 1000)}`,
eta: Date.now() + Math.floor(Math.random() * 3600000)
}));

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

this.agents.set(AgentType.CAPACITY_DISPATCH, dispatcher);
await this.agentController?.registerFunction(dispatcher);
}

// 从分布式设备采集订单数据
private async collectFromDevices(regionId: string): Promise<OrderData[]> {
// 获取分布式设备列表（扫描枪、PDA、车载终端等）
const devices = distributedDeviceManager.getAvailableDeviceListSync();

// 模拟采集数据
const origins = ['北京', '上海', '广州', '深圳', '杭州'];
const destinations = ['成都', '武汉', '西安', '南京', '重庆'];

const mockData: OrderData[] = Array.from({ length: 20 }, (_, i) => ({
orderId: `ord_${regionId}_${Date.now()}_${i}`,
origin: origins[Math.floor(Math.random() * origins.length)],
destination: destinations[Math.floor(Math.random() * destinations.length)],
weight: Math.floor(Math.random() * 50) + 1,
volume: Math.floor(Math.random() * 10) + 1,
priority: ['urgent', 'normal', 'low'][Math.floor(Math.random() * 3)] as OrderData['priority'],
deadline: Date.now() + Math.floor(Math.random() * 86400000),
status: 'pending',
timestamp: Date.now()
}));

return mockData;
}

// A2A协议：委托路径优化任务
private async delegateToRouteOptimize(regionId: string): Promise<void> {
const optimizer = this.agents.get(AgentType.ROUTE_OPTIMIZE);
if (optimizer) {
await optimizer.call({ regionId, strategy: 'balanced' });
}
}

// A2A协议：委托运力调度任务
private async delegateToCapacityDispatch(regionId: string): Promise<void> {
const dispatcher = this.agents.get(AgentType.CAPACITY_DISPATCH);
if (dispatcher) {
await dispatcher.call({ regionId, vehicleType: 'all' });
}
}

// 辅助方法
private generateRouteSuggestions(order: OrderData): string[] {
const suggestions: string[] = [];
if (order.priority === 'urgent') suggestions.push('建议优先配送');
if (order.weight > 30) suggestions.push('建议安排大型车辆');
if (order.deadline – Date.now() < 86400000) suggestions.push('建议加急处理');
return suggestions;
}

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

// 公共API：触发订单感知
async triggerOrderPerception(regionId: string): Promise<OrderData[]> {
const perceptor = this.agents.get(AgentType.ORDER_PERCEPTION);
if (!perceptor) throw new Error('Order perceptor not registered');

const result = await perceptor.call({ regionId });
return (result as Record<string, Object>).data as OrderData[];
}

// 公共API：获取路径结果
getRouteResult(vehicleId: string): RouteResult | undefined {
return this.routeCache.get(vehicleId);
}
}

3.5 物流总览主页面（OverviewPage.ets）

代码亮点：本页面实现了物流总览场景的核心交互，包括：实时订单热力图（通过Canvas绘制物流网络图，颜色深浅表示订单密度）、HMAF智能体状态实时面板（显示四个智能体的运行状态）、悬浮导航集成、以及基于沉浸光感的动态背景。

// entry/src/main/ets/pages/OverviewPage.ets
import { LogisticsAgentService, OrderData, AgentType, AgentStatus } from '../services/LogisticsAgentService';
import { FloatLogisticsNav, LogisticsScene } from '../components/FloatLogisticsNav';
import { CapacityLoad } from '../abilities/LogisticsAbility';

@Entry
@Component
struct OverviewPage {
@State orders: OrderData[] = [];
@State isLoading: boolean = false;
@State selectedOrder: OrderData | null = null;
@State agentStatuses: Record<AgentType, AgentStatus> = {
[AgentType.ORDER_PERCEPTION]: AgentStatus.IDLE,
[AgentType.ROUTE_OPTIMIZE]: AgentStatus.IDLE,
[AgentType.WAREHOUSE_SYNC]: AgentStatus.IDLE,
[AgentType.CAPACITY_DISPATCH]: AgentStatus.IDLE
};

private agentService: LogisticsAgentService = LogisticsAgentService.getInstance();
private regionId: string = 'region_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.collectOrderData();
} catch (error) {
console.error('Failed to initialize:', error);
}
}

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

private updateAgentStatuses(): void {
this.agentStatuses = {
[AgentType.ORDER_PERCEPTION]: this.agentService.getAgentStatus(AgentType.ORDER_PERCEPTION),
[AgentType.ROUTE_OPTIMIZE]: this.agentService.getAgentStatus(AgentType.ROUTE_OPTIMIZE),
[AgentType.WAREHOUSE_SYNC]: this.agentService.getAgentStatus(AgentType.WAREHOUSE_SYNC),
[AgentType.CAPACITY_DISPATCH]: this.agentService.getAgentStatus(AgentType.CAPACITY_DISPATCH)
};
}

private async collectOrderData(): Promise<void> {
this.isLoading = true;
try {
const data = await this.agentService.triggerOrderPerception(this.regionId);
this.orders = data;
} catch (error) {
console.error('Failed to collect data:', error);
} finally {
this.isLoading = false;
}
}

build() {
FloatLogisticsNav({
currentScene: LogisticsScene.OVERVIEW,
onSceneChange: (scene: LogisticsScene) => {
// 场景切换逻辑
console.info(`Switched to scene: ${scene}`);
}
}) {
this.overviewContentBuilder()
}
}

@Builder
overviewContentBuilder(): void {
Column() {
// 顶部标题栏（沉浸光感安全区适配）
Row() {
Column() {
Text('智链云枢 – 智慧物流供应链调度管理')
.fontSize(24)
.fontWeight(FontWeight.Bold)
.fontColor('#FFFFFF')

Text(`实时订单 | 共${this.orders.length}单 | 紧急订单: ${this.getUrgentCount()}单`)
.fontSize(14)
.fontColor('rgba(255,255,255,0.7)')
.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.05)')
.backdropFilter($r('sys.blur.10'))

// 订单热力图区域
Stack() {
if (this.isLoading) {
LoadingProgress()
.width(48)
.height(48)
.color('#3B82F6')
} else {
this.orderHeatmapBuilder()
}
}
.width('100%')
.layoutWeight(1)
.padding(16)

// 选中订单详情面板
if (this.selectedOrder) {
this.orderDetailPanel()
}
}
.width('100%')
.height('100%')
.backgroundColor('#0F172A')
}

// 订单热力图构建器
@Builder
orderHeatmapBuilder(): void {
Grid() {
ForEach(this.orders.slice(0, 12), (order: OrderData) => {
GridItem() {
Column() {
Text(order.orderId.slice(–6))
.fontSize(13)
.fontColor('#FFFFFF')
.fontWeight(FontWeight.Medium)

Text(`${order.origin} → ${order.destination}`)
.fontSize(11)
.fontColor('rgba(255,255,255,0.8)')
.margin({ top: 4 })

Text(`${order.weight}kg`)
.fontSize(11)
.fontColor('rgba(255,255,255,0.6)')
.margin({ top: 2 })
}
.width('100%')
.height('100%')
.justifyContent(FlexAlign.Center)
.backgroundColor(this.getPriorityColor(order.priority))
.borderRadius(12)
.shadow({
radius: 8,
color: 'rgba(0,0,0,0.3)',
offsetX: 0,
offsetY: 2
})
.scale({ x: this.selectedOrder?.orderId === order.orderId ? 1.05 : 1.0, y: this.selectedOrder?.orderId === order.orderId ? 1.05 : 1.0 })
.animation({
duration: 200,
curve: Curve.EaseInOut
})
}
.onClick(() => {
this.selectedOrder = this.selectedOrder?.orderId === order.orderId ? null : order;
})
})
}
.columnsTemplate('1fr 1fr 1fr 1fr')
.rowsTemplate('1fr 1fr 1fr')
.columnsGap(8)
.rowsGap(8)
.width('100%')
.height('100%')
}

// 订单详情面板
@Builder
orderDetailPanel(): void {
Column() {
Row() {
Text(`订单 ${this.selectedOrder!.orderId.slice(–6)}`)
.fontSize(18)
.fontWeight(FontWeight.Bold)
.fontColor('#FFFFFF')

Button('关闭')
.fontSize(12)
.fontColor('rgba(255,255,255,0.6)')
.backgroundColor('transparent')
.onClick(() => {
this.selectedOrder = null;
})
}
.width('100%')
.justifyContent(FlexAlign.SpaceBetween)

// 订单指标
this.infoRow('发货地', this.selectedOrder!.origin)
this.infoRow('收货地', this.selectedOrder!.destination)
this.infoRow('重量', `${this.selectedOrder!.weight}kg`)
this.infoRow('体积', `${this.selectedOrder!.volume}m³`)
this.infoRow('优先级', this.selectedOrder!.priority)

// 调度建议
Text('智能调度建议')
.fontSize(14)
.fontColor('rgba(255,255,255,0.8)')
.margin({ top: 12, bottom: 8 })
.alignSelf(ItemAlign.Start)

Row() {
ForEach(this.getDispatchSuggestions(this.selectedOrder!), (suggestion: string) => {
Text(suggestion)
.fontSize(12)
.fontColor('#F59E0B')
.backgroundColor('rgba(245,158,11,0.15)')
.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('#3B82F6')
.borderRadius(20)
.padding({ left: 16, right: 16 })
.onClick(() => {
this.triggerRouteOptimize(this.selectedOrder!.orderId);
})

Button('运力调度')
.fontSize(13)
.fontColor('#FFFFFF')
.backgroundColor('#10B981')
.borderRadius(20)
.padding({ left: 16, right: 16 })
.margin({ left: 12 })
.onClick(() => {
this.triggerCapacityDispatch(this.selectedOrder!.orderId);
})

Button('仓储同步')
.fontSize(13)
.fontColor('#FFFFFF')
.backgroundColor('#8B5CF6')
.borderRadius(20)
.padding({ left: 16, right: 16 })
.margin({ left: 12 })
.onClick(() => {
this.triggerWarehouseSync(this.selectedOrder!.orderId);
})
}
.width('100%')
.justifyContent(FlexAlign.Start)
}
.width('100%')
.height(320)
.padding(20)
.backgroundColor('rgba(255,255,255,0.08)')
.backdropFilter($r('sys.blur.20'))
.borderRadius({ topLeft: 24, topRight: 24 })
.shadow({
radius: 16,
color: 'rgba(0,0,0,0.3)',
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('rgba(255,255,255,0.6)')
.margin({ top: 2 })
}
.margin({ left: 8 })
})
}
}

// 信息行构建器
@Builder
infoRow(label: string, value: string): void {
Row() {
Text(label)
.fontSize(13)
.fontColor('rgba(255,255,255,0.6)')
.width(80)

Text(value)
.fontSize(13)
.fontColor('#FFFFFF')
.layoutWeight(1)
}
.width('100%')
.height(28)
.alignItems(VerticalAlign.Center)
}

// 根据优先级获取颜色
private getPriorityColor(priority: string): string {
switch (priority) {
case 'urgent': return 'rgba(239,68,68,0.3)';
case 'normal': return 'rgba(59,130,246,0.3)';
case 'low': return 'rgba(16,185,129,0.3)';
default: return 'rgba(107,114,128,0.3)';
}
}

// 获取紧急订单数
private getUrgentCount(): number {
return this.orders.filter(o => o.priority === 'urgent').length;
}

// 获取智能体状态颜色
private getStatusColor(status: AgentStatus, alpha?: number): string {
const colors: Record<AgentStatus, string> = {
[AgentStatus.IDLE]: '#6B7280',
[AgentStatus.RUNNING]: '#3B82F6',
[AgentStatus.COMPLETED]: '#10B981',
[AgentStatus.ERROR]: '#EF4444'
};
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.ORDER_PERCEPTION]: '感知',
[AgentType.ROUTE_OPTIMIZE]: '优化',
[AgentType.WAREHOUSE_SYNC]: '仓储',
[AgentType.CAPACITY_DISPATCH]: '调度'
};
return names[type];
}

// 获取调度建议
private getDispatchSuggestions(order: OrderData): string[] {
const suggestions: string[] = [];
if (order.priority === 'urgent') suggestions.push('优先配送');
if (order.weight > 30) suggestions.push('大型车辆');
if (order.deadline – Date.now() < 86400000) suggestions.push('加急处理');
if (suggestions.length === 0) suggestions.push('正常配送');
return suggestions;
}

// 触发路径优化
private async triggerRouteOptimize(orderId: string): Promise<void> {
const optimizer = this.agentService['agents'].get(AgentType.ROUTE_OPTIMIZE);
if (optimizer) {
await optimizer.call({ regionId: this.regionId, strategy: 'balanced' });
}
}

// 触发运力调度
private async triggerCapacityDispatch(orderId: string): Promise<void> {
const dispatcher = this.agentService['agents'].get(AgentType.CAPACITY_DISPATCH);
if (dispatcher) {
await dispatcher.call({ regionId: this.regionId, vehicleType: 'all' });
}
}

// 触发仓储同步
private async triggerWarehouseSync(orderId: string): Promise<void> {
const syncer = this.agentService['agents'].get(AgentType.WAREHOUSE_SYNC);
if (syncer) {
await syncer.call({ warehouseId: `wh_${this.regionId}_01`, syncType: 'incremental' });
}
}
}

3.6 浮动运力面板Ability（FleetPanelAbility.ets）

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

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

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

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

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

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

// 设置窗口大小和位置（PC端右侧浮动）
await this.subWindow.resize(380, 640);
await this.subWindow.moveWindowTo(1180, 80);

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

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

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

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

onDestroy(): void {
if (this.subWindow) {
this.subWindow.destroyWindow();
this.subWindow = null;
}
}
}