HarmonyOS 6（API 23）实战：基于悬浮导航、沉浸光感与HMAF的“光域智脑“——PC端AI智能体沉浸式网络安全态势感知与威胁响应指挥中心

文章目录

• • 每日一句正能量
  • 前言
  • 一、前言：网络安全运营进入"智能体驱动"时代
  • 二、核心特性解析与技术选型
  • • 2.1 HMAF在网络安全态势感知中的价值
    • 2.2 沉浸光感在安全运营中的创新应用
    • 2.3 技术选型总览
  • 三、项目实战："光域智脑"架构设计
  • • 3.1 应用场景与功能规划
    • 3.2 技术架构图
  • 四、环境配置与模块依赖
  • • 4.1 模块依赖配置
    • 4.2 权限声明（module.json5）
  • 五、核心组件实战
  • • 5.1 窗口沉浸配置（EntryAbility.ets）
    • 5.2 威胁等级光效系统（ThreatLightEffect.ets）
    • 5.3 HMAF四层安全智能体架构（SecurityAgentScheduler.ets）
    • 5.4 悬浮态势导航（SecurityFloatNavigation.ets）
    • 5.5 主态势感知大屏（SituationalAwarenessPage.ets）
    • 5.6 浮动威胁拓扑窗口（ThreatTopologyAbility.ets）
    • 5.7 多窗口光效同步管理器（WindowLightSync.ets）
  • 六、关键技术总结
  • • 6.1 HMAF网络安全开发清单
    • 6.2 沉浸光感实现清单
    • 6.3 威胁等级光效映射
    • 6.4 PC端多窗口光效协同
  • 七、调试与适配建议
  • • 7.1 网络流量解析性能优化
    • 7.2 威胁光效可访问性
    • 7.3 多窗口管理优化
  • 八、运行效果展示
  • • 8.1 正常态势 – 柔绿光效
    • 8.2 关注态势 – 淡蓝光效
    • 8.3 告警态势 – 暖黄光效
    • 8.4 高危态势 – 橙红光效
    • 8.5 紧急态势 – 警示红光效
  • 九、总结与展望

每日一句正能量

外界的声音只是参考，从不是标准答案。 可以听，可以思考，但最终要不要采纳、采纳多少，由你自己决定。很多人痛苦是因为把别人的意见当成了“正确答案”，一旦不符合就自我怀疑。其实世上没有放之四海而皆准的标准答案，你的人生试卷，你才是唯一的阅卷人。

前言

摘要：2026年，全球网络安全威胁进入"智能体对抗"时代。据Gartner统计，企业年均遭受网络攻击超1200万次，传统SOC（安全运营中心）面临告警疲劳、威胁研判滞后、响应链条断裂三大痛点。HarmonyOS 6（API 23）引入的鸿蒙智能体框架（HMAF）将AI能力下沉至系统层，配合悬浮导航与沉浸光感特性，为PC端网络安全态势感知带来了"威胁即光效、风险即导航"的全新交互范式。本文将实战开发一款面向HarmonyOS PC的"光域智脑"应用，展示如何利用HMAF构建"流量采集-威胁检测-攻击研判-自动响应"四层智能体协作架构，通过悬浮导航实现安全态势实时追踪，基于沉浸光感打造"威胁等级即氛围"的沉浸体验，以及基于多窗口架构构建浮动威胁拓扑、攻击时间线和响应剧本窗口的协作安全运营体验。

一、前言：网络安全运营进入"智能体驱动"时代

2026年，全球网络安全形势愈发严峻。中国网络安全市场规模已突破2000亿元，企业安全团队年均处理安全告警超过500万条，但传统SOC平台面临三大核心痛点：

HarmonyOS 6（API 23）的HMAF框架配合**悬浮导航（Float Navigation）与沉浸光感（Immersive Light Effects）**特性，为网络安全态势感知带来了革命性解决方案：

• 智能体协同防御：HMAF构建的"安全智能体"可实时分析网络流量、自动关联威胁情报、智能研判攻击路径，威胁检测延迟降至毫秒级，研判效率提升20倍

• 威胁等级光效感知：根据当前网络安全态势（正常/关注/告警/高危/紧急）动态切换环境光色，让安全分析师"看见"威胁分布

• 悬浮态势导航：底部悬浮导航实时显示四大智能体运行状态与威胁统计徽章，安全分析师无需切换页面即可掌握全局安全态势

• PC多窗口协作运营：主态势感知大屏 + 浮动威胁拓扑窗口 + 浮动攻击时间线窗口 + 浮动响应剧本窗口的四层架构，通过光效联动实现"一眼全局"

本文核心亮点：

• 威胁等级光效：五种安全态势拥有专属光效人格（正常柔绿、关注淡蓝、告警暖黄、高危橙红、紧急警示红），根据当前最高威胁等级动态切换全局环境光、节点脉冲和导航材质

• 悬浮态势导航：底部悬浮页签替代传统工具栏，支持态势总览/流量分析/威胁检测/响应中心切换，实时显示威胁统计徽章（紧急/高危/告警数量）

• HMAF四层安全架构：基于Agent Framework Kit构建"流量采集-威胁检测-攻击研判-自动响应"四层智能体协作体系

• 多窗口光效联动：主态势窗口 + 浮动威胁拓扑 + 浮动攻击时间线 + 浮动响应剧本的光效同步与焦点感知

• 威胁意图沉浸感知：通过Intents Kit实时理解安全分析师的查询意图，自动调整界面光效与导航形态

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

2.1 HMAF在网络安全态势感知中的价值

HarmonyOS 6的HMAF采用四层架构设计：应用智能体层、智能体框架层、AI引擎层、智能体内核层。在"光域智脑"中，这种架构能够：

• 原生智能调度：安全智能体不再是SIEM的附属插件，而是系统的基础能力，支持跨设备安全态势感知

• 意图即防御：通过Intents Kit将安全分析师自然语言意图（如"查找过去一小时内所有横向移动行为"）转化为结构化检测任务

• 分布式智能体协同：利用鸿蒙分布式软总线，实现PC主控+安全大屏+移动端告警推送的多设备协作

• 端云协同推理：端侧处理实时流量特征提取与初步筛选，云端大模型处理复杂APT攻击链路与威胁情报关联

2.2 沉浸光感在安全运营中的创新应用

HarmonyOS 6的 systemMaterialEffect 通过模拟物理光照模型，为安全状态反馈带来细腻的视觉表达。在网络安全场景中，这种材质效果能够：

• 增强威胁感知：不同威胁等级拥有专属光效标识（正常柔绿、关注淡蓝、告警暖黄、高危橙红、紧急警示红）

• 状态直觉感知：流量采集时的呼吸蓝光、威胁检测时的脉冲金光、发现攻击时的警示红光、响应完成时的确认绿光

• 提升运营专注度：动态环境光随网络威胁密度变化，平静期柔和、攻击高峰期强烈，帮助分析师快速进入"战时状态"

2.3 技术选型总览

三、项目实战："光域智脑"架构设计

3.1 应用场景与功能规划

面向HarmonyOS PC的网络安全态势感知场景，核心功能包括：

主态势感知大屏：实时展示网络拓扑、威胁节点分布、攻击链路追踪，支持缩放与拖拽

流量分析模块：实时流量监控、协议分布统计、异常流量检测，支持多维度下钻

威胁检测模块：基于AI模型的实时威胁检测、威胁情报关联、误报过滤

响应中心模块：自动响应剧本执行、防火墙联动、EDR指令下发、事件归档

浮动威胁拓扑窗口：悬浮展示当前关注的子网拓扑，节点颜色随威胁等级变化

浮动攻击时间线窗口：悬浮展示选中攻击事件的完整时间线，阶段颜色编码

浮动响应剧本窗口：悬浮展示当前执行的响应剧本，步骤状态光效反馈

3.2 技术架构图

┌─────────────────────────────────────────────────────────────┐
│ 光域智脑 – 应用层 │
├─────────────────────────────────────────────────────────────┤
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────┐ │
│ │ 主态势大屏 │ │ 悬浮态势导航 │ │ 浮动窗口组 │ │
│ │ (Canvas) │ │ (HdsTabs) │ │ (威胁拓扑/时间线/ │ │
│ │ │ │ │ │ 响应剧本) │ │
│ └─────────────┘ └─────────────┘ └─────────────────────┘ │
├─────────────────────────────────────────────────────────────┤
│ HMAF 智能体调度层 │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │流量采集Agent│ │威胁检测Agent│ │攻击研判Agent│ │自动响应Agent│ │
│ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │
├─────────────────────────────────────────────────────────────┤
│ 系统服务层 │
│ Intents Kit │ Agent Framework Kit │ Window Manager │ Light │
│ │ │ │ Effect │
└─────────────────────────────────────────────────────────────┘

四、环境配置与模块依赖

4.1 模块依赖配置

// entry/oh-package.json5
{
"dependencies": {
"@kit.AgentFrameworkKit": "^1.0.0",
"@kit.IntentsKit": "^1.0.0",
"@kit.ArkUI": "^1.0.0",
"@kit.WindowManagerKit": "^1.0.0",
"@kit.LightEffectKit": "^1.0.0",
"@kit.NetworkKit": "^1.0.0",
"@kit.SecurityKit": "^1.0.0"
}
}

4.2 权限声明（module.json5）

{
"module": {
"name": "entry",
"type": "entry",
"description": "光域智脑 – 网络安全态势感知",
"mainElement": "EntryAbility",
"requestPermissions": [
{
"name": "ohos.permission.INTERNET",
"reason": "网络流量采集与分析"
},
{
"name": "ohos.permission.GET_NETWORK_INFO",
"reason": "获取网络状态信息"
},
{
"name": "ohos.permission.ACCESS_BLUETOOTH",
"reason": "分布式设备协同"
},
{
"name": "ohos.permission.SYSTEM_FLOAT_WINDOW",
"reason": "浮动窗口展示"
},
{
"name": "ohos.permission.LIGHT_EFFECT_CONTROL",
"reason": "沉浸光效控制"
}
]
}
}

五、核心组件实战

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

代码亮点：本模块实现了PC端全屏沉浸式安全态势感知窗口。通过 setWindowLayoutFullScreen(true) 移除系统标题栏，配合 expandSafeArea 扩展安全区至全屏，最大化态势展示区域。同时注册窗口焦点变化监听，实现"焦点即光效"的感知降级——当窗口失焦时自动降低背景光效强度，减少干扰。

// entry/src/main/ets/entryability/EntryAbility.ets
import { AbilityConstant, UIAbility, Want } from '@kit.AbilityKit';
import { window } from '@kit.ArkUI';
import { LightEffectManager } from '../services/LightEffectManager';

export default class EntryAbility extends UIAbility {
private mainWindow: window.Window | null = null;
private lightManager: LightEffectManager | null = null;

async onWindowStageCreate(windowStage: window.WindowStage): Promise<void> {
// 创建主窗口
this.mainWindow = await windowStage.createSubWindow('MainSituationalAwareness');

// 全屏沉浸配置
await this.mainWindow.setWindowLayoutFullScreen(true);
await this.mainWindow.setWindowSystemBarEnable([]);

// 加载主页面
this.mainWindow.loadContent('pages/SituationalAwarenessPage', (err) => {
if (err) {
console.error('Failed to load main content:', err);
return;
}
console.info('Main situational awareness window loaded');
});

// 初始化光效管理器
this.lightManager = new LightEffectManager();
await this.lightManager.initialize();

// 注册窗口焦点监听
this.mainWindow.on('windowFocusChange', (isFocused: boolean) => {
this.lightManager?.setFocusState(isFocused);
console.info(`Window focus changed: ${isFocused}`);
});

// 扩展安全区
const mainWindow = await windowStage.getMainWindow();
mainWindow.setSpecificSystemBarEnabled('status', false);
mainWindow.setSpecificSystemBarEnabled('navigation', false);
}

onWindowStageDestroy(): void {
this.lightManager?.destroy();
this.mainWindow?.destroy();
}
}

5.2 威胁等级光效系统（ThreatLightEffect.ets）

代码亮点：本模块定义了五种安全态势的完整光效人格系统。每种态势不仅拥有专属颜色，还定义了脉冲节奏、呼吸频率和光晕强度。ThreatLevel 枚举与 ThreatLightTheme 类实现了威胁等级到光效的完整映射，支持动态切换与平滑过渡。

// entry/src/main/ets/theme/ThreatLightEffect.ets

/**
* 威胁等级枚举
*/
export enum ThreatLevel {
NORMAL = 'normal', // 正常 – 柔绿
WATCH = 'watch', // 关注 – 淡蓝
ALERT = 'alert', // 告警 – 暖黄
HIGH = 'high', // 高危 – 橙红
CRITICAL = 'critical' // 紧急 – 警示红
}

/**
* 威胁光效主题接口
*/
export interface ThreatLightTheme {
level: ThreatLevel;
primaryColor: string; // 主色
secondaryColor: string; // 辅色
pulseColor: string; // 脉冲色
glowIntensity: number; // 光晕强度 (0-1)
pulseInterval: number; // 脉冲间隔 (ms)
breathSpeed: number; // 呼吸速度 (ms)
ambientOpacity: number; // 环境光透明度
nodeBorderWidth: number; // 节点边框宽度
linkFlowSpeed: number; // 链路流光速度
}

/**
* 威胁等级光效主题配置
*/
export const ThreatLightThemes: Record<ThreatLevel, ThreatLightTheme> = {
[ThreatLevel.NORMAL]: {
level: ThreatLevel.NORMAL,
primaryColor: '#4CAF50',
secondaryColor: '#81C784',
pulseColor: '#A5D6A7',
glowIntensity: 0.3,
pulseInterval: 3000,
breathSpeed: 4000,
ambientOpacity: 0.05,
nodeBorderWidth: 1,
linkFlowSpeed: 2000
},
[ThreatLevel.WATCH]: {
level: ThreatLevel.WATCH,
primaryColor: '#42A5F5',
secondaryColor: '#90CAF9',
pulseColor: '#BBDEFB',
glowIntensity: 0.4,
pulseInterval: 2500,
breathSpeed: 3500,
ambientOpacity: 0.08,
nodeBorderWidth: 1.5,
linkFlowSpeed: 1800
},
[ThreatLevel.ALERT]: {
level: ThreatLevel.ALERT,
primaryColor: '#FFA726',
secondaryColor: '#FFCC80',
pulseColor: '#FFE0B2',
glowIntensity: 0.6,
pulseInterval: 1500,
breathSpeed: 2500,
ambientOpacity: 0.12,
nodeBorderWidth: 2,
linkFlowSpeed: 1200
},
[ThreatLevel.HIGH]: {
level: ThreatLevel.HIGH,
primaryColor: '#EF5350',
secondaryColor: '#EF9A9A',
pulseColor: '#FFCDD2',
glowIntensity: 0.8,
pulseInterval: 800,
breathSpeed: 1500,
ambientOpacity: 0.18,
nodeBorderWidth: 3,
linkFlowSpeed: 800
},
[ThreatLevel.CRITICAL]: {
level: ThreatLevel.CRITICAL,
primaryColor: '#D32F2F',
secondaryColor: '#E57373',
pulseColor: '#FFEBEE',
glowIntensity: 1.0,
pulseInterval: 400,
breathSpeed: 800,
ambientOpacity: 0.25,
nodeBorderWidth: 4,
linkFlowSpeed: 400
}
};

/**
* 威胁节点数据接口
*/
export interface ThreatNode {
id: string;
name: string;
ip: string;
threatLevel: ThreatLevel;
threatType: string;
lastSeen: number;
x: number;
y: number;
connections: string[];
}

/**
* 攻击链路数据接口
*/
export interface AttackLink {
id: string;
sourceId: string;
targetId: string;
attackType: string;
threatLevel: ThreatLevel;
timestamp: number;
isActive: boolean;
}

/**
* 光效管理器
*/
export class ThreatLightManager {
private currentTheme: ThreatLightTheme = ThreatLightThemes[ThreatLevel.NORMAL];
private listeners: Set<(theme: ThreatLightTheme) => void> = new Set();

/**
* 根据最高威胁等级切换光效
*/
public switchThreatLevel(level: ThreatLevel): void {
this.currentTheme = ThreatLightThemes[level];
this.listeners.forEach(listener => listener(this.currentTheme));
console.info(`Threat level switched to ${level}, theme updated`);
}

/**
* 根据威胁节点列表自动计算最高等级
*/
public autoSwitchFromNodes(nodes: ThreatNode[]): void {
const levelPriority = [ThreatLevel.NORMAL, ThreatLevel.WATCH, ThreatLevel.ALERT, ThreatLevel.HIGH, ThreatLevel.CRITICAL];
let maxLevel = ThreatLevel.NORMAL;

for (const node of nodes) {
const currentPriority = levelPriority.indexOf(node.threatLevel);
const maxPriority = levelPriority.indexOf(maxLevel);
if (currentPriority > maxPriority) {
maxLevel = node.threatLevel;
}
}

this.switchThreatLevel(maxLevel);
}

public getCurrentTheme(): ThreatLightTheme {
return this.currentTheme;
}

public onThemeChange(listener: (theme: ThreatLightTheme) => void): void {
this.listeners.add(listener);
}

public offThemeChange(listener: (theme: ThreatLightTheme) => void): void {
this.listeners.delete(listener);
}
}

5.3 HMAF四层安全智能体架构（SecurityAgentScheduler.ets）

代码亮点：本模块是"光域智脑"的核心大脑，实现了四层安全智能体的协作调度。SecurityAgentScheduler 通过HMAF的 AgentSession 注册四个专业安全智能体，并通过 IntentsEngine 解析安全分析师的自然语言查询意图。每个智能体拥有独立的提示词模板和能力声明，支持全链路自动化（流量采集→威胁检测→攻击研判→自动响应）。

// entry/src/main/ets/agents/SecurityAgentScheduler.ets

import {
hmaf,
AgentSession,
AgentMode,
TaskMessage,
TaskResult
} from '@kit.AgentFrameworkKit';
import { intents, IntentEngine, IntentResult } from '@kit.IntentsKit';
import { ThreatLightManager, ThreatLevel, ThreatNode, AttackLink } from '../theme/ThreatLightEffect';

/**
* 智能体类型定义
*/
export enum AgentType {
TRAFFIC_COLLECTOR = 'traffic_collector', // 流量采集Agent
THREAT_DETECTOR = 'threat_detector', // 威胁检测Agent
ATTACK_ANALYZER = 'attack_analyzer', // 攻击研判Agent
AUTO_RESPONDER = 'auto_responder' // 自动响应Agent
}

/**
* 安全运营阶段枚举
*/
export enum SecurityStage {
OVERVIEW = 'overview', // 态势总览
TRAFFIC = 'traffic', // 流量分析
THREAT = 'threat', // 威胁检测
RESPONSE = 'response' // 响应中心
}

/**
* 流量采集结果接口
*/
export interface TrafficResult {
totalPackets: number;
totalBytes: number;
protocolDistribution: Record<string, number>;
topTalkers: Array<{ ip: string; bytes: number }>;
anomalyScore: number;
timeWindow: string;
}

/**
* 威胁检测结果接口
*/
export interface ThreatResult {
detectedThreats: Array<{
id: string;
type: string;
severity: ThreatLevel;
sourceIp: string;
targetIp: string;
confidence: number;
description: string;
timestamp: number;
}>;
falsePositiveRate: number;
detectionLatency: number;
}

/**
* 攻击研判结果接口
*/
export interface AttackAnalysisResult {
attackChain: Array<{
stage: string;
timestamp: number;
description: string;
evidence: string[];
}>;
attackerProfile: {
aptGroup: string;
motivation: string;
sophistication: string;
};
impactAssessment: {
compromisedAssets: string[];
dataExfiltrationRisk: string;
lateralMovementRisk: string;
};
recommendedActions: string[];
}

/**
* 自动响应结果接口
*/
export interface ResponseResult {
executedActions: Array<{
action: string;
target: string;
status: 'success' | 'failed' | 'pending';
timestamp: number;
}>;
containmentStatus: string;
playbookId: string;
mttr: number; // 平均响应时间(分钟)
}

/**
* HMAF网络安全智能体调度器
* 核心：四层智能体协作，实现网络安全的自动检测与响应
*/
export class SecurityAgentScheduler {
private session: AgentSession | null = null;
private intentEngine: IntentEngine | null = null;
private lightManager: ThreatLightManager;

// 安全数据存储
private threatNodes: Map<string, ThreatNode> = new Map();
private attackLinks: Map<string, AttackLink> = new Map();
private trafficResult: TrafficResult | null = null;
private threatResult: ThreatResult | null = null;
private attackAnalysis: AttackAnalysisResult | null = null;
private responseResult: ResponseResult | null = null;

// 回调监听
private onTrafficCollected?: (result: TrafficResult) => void;
private onThreatsDetected?: (result: ThreatResult) => void;
private onAttackAnalyzed?: (result: AttackAnalysisResult) => void;
private onResponseExecuted?: (result: ResponseResult) => void;
private onStageChanged?: (stage: SecurityStage) => void;

constructor(lightManager: ThreatLightManager) {
this.lightManager = lightManager;
}

/**
* 初始化智能体会话
*/
public async initialize(): Promise<void> {
this.session = await hmaf.createAgentSession({
mode: AgentMode.MULTI_AGENT,
config: {
maxConcurrentAgents: 4,
timeout: 30000,
enableDistributed: true
}
});

this.intentEngine = await intents.createIntentEngine({
supportedDomains: ['security_operations', 'threat_detection', 'incident_response', 'traffic_analysis']
});

await this.registerAgents();
console.info('SecurityAgentScheduler initialized successfully');
}

/**
* 注册四层安全智能体
*/
private async registerAgents(): Promise<void> {
if (!this.session) return;

// 1. 流量采集Agent – 实时网络流量采集与预处理
await this.session.registerAgent({
agentId: AgentType.TRAFFIC_COLLECTOR,
capabilities: ['packet_capture', 'flow_analysis', 'protocol_identification', 'anomaly_detection'],
promptTemplate: `
你是网络安全流量采集专家。分析给定网络接口的实时流量数据：
– 统计总包数、总字节数、流量速率
– 识别协议分布（TCP/UDP/ICMP/HTTP/HTTPS/DNS等）
– 提取Top Talkers（流量最大的源IP和目标IP）
– 计算异常评分（0-100，基于基线偏差）
– 识别可疑流量模式（扫描、DDoS、C2通信等）

返回JSON格式: {
"totalPackets": 150000,
"totalBytes": 125000000,
"protocolDistribution": {"TCP": 65, "UDP": 20, "ICMP": 5, "HTTP": 10},
"topTalkers": [{"ip": "192.168.1.100", "bytes": 50000000}],
"anomalyScore": 35,
"timeWindow": "2026-06-27T10:00:00Z/2026-06-27T11:00:00Z"
}
`
});

// 2. 威胁检测Agent – 基于AI模型的威胁识别
await this.session.registerAgent({
agentId: AgentType.THREAT_DETECTOR,
capabilities: ['signature_detection', 'behavioral_analysis', 'threat_intelligence_matching', 'machine_learning_inference'],
promptTemplate: `
你是网络安全威胁检测专家。分析给定的网络流量特征和日志：
– 识别已知威胁签名（恶意IP、域名、文件哈希）
– 检测异常行为模式（横向移动、权限提升、数据外泄）
– 关联威胁情报（APT组织、恶意软件家族、漏洞利用）
– 评估威胁严重等级（NORMAL/WATCH/ALERT/HIGH/CRITICAL）
– 计算置信度（0-100%）

对每个威胁提供：ID、类型、严重等级、源IP、目标IP、置信度、描述、时间戳

返回JSON格式: {
"detectedThreats": [{"id": "threat_001", "type": "C2通信", "severity": "HIGH", "sourceIp": "10.0.0.5", "targetIp": "185.220.101.42", "confidence": 92, "description": "检测到与已知C2服务器的加密通信", "timestamp": 1719480000}],
"falsePositiveRate": 0.02,
"detectionLatency": 150
}
`
});

// 3. 攻击研判Agent – 攻击链路与影响评估
await this.session.registerAgent({
agentId: AgentType.ATTACK_ANALYZER,
capabilities: ['attack_chain_reconstruction', 'apt_profiling', 'impact_assessment', 'kill_chain_mapping'],
promptTemplate: `
你是网络安全攻击研判专家。基于威胁检测结果进行深度分析：
– 重构完整攻击链路（初始访问→执行→持久化→权限提升→防御规避→凭证访问→发现→横向移动→收集→外泄→影响）
– 识别APT组织画像（攻击者归属、动机、 sophistication等级）
– 评估影响范围（失陷资产、数据外泄风险、横向移动风险）
– 提供处置建议（隔离、阻断、取证、加固）

返回JSON格式: {
"attackChain": [{"stage": "初始访问", "timestamp": 1719480000, "description": "钓鱼邮件投递", "evidence": ["邮件日志", "附件哈希"]}],
"attackerProfile": {"aptGroup": "APT29", "motivation": "情报收集", "sophistication": "高"},
"impactAssessment": {"compromisedAssets": ["WS-001", "DC-001"], "dataExfiltrationRisk": "高", "lateralMovementRisk": "中"},
"recommendedActions": ["隔离失陷主机", "重置域管密码", "启用EDR增强监控"]
}
`
});

// 4. 自动响应Agent – SOAR剧本执行与联动
await this.session.registerAgent({
agentId: AgentType.AUTO_RESPONDER,
capabilities: ['playbook_execution', 'firewall_integration', 'edr_command', 'siem_alerting', 'ticket_creation'],
promptTemplate: `
你是网络安全自动响应专家。基于攻击研判结果执行响应剧本：
– 选择最优响应剧本（ containment / eradication / recovery ）
– 执行防火墙阻断（恶意IP、端口、协议）
– 下发EDR指令（隔离主机、终止进程、删除文件）
– 生成SIEM告警（高优先级事件、关联规则）
– 创建工单（分配给安全团队、设定SLA）

对每个动作提供：动作名称、目标、执行状态、时间戳

返回JSON格式: {
"executedActions": [{"action": "防火墙阻断", "target": "185.220.101.42", "status": "success", "timestamp": 1719480600}],
"containmentStatus": "已遏制",
"playbookId": "SOAR-001",
"mttr": 4.5
}
`
});
}

/**
* 处理安全分析师输入 – 意图解析 + 智能体分发
*/
public async processSecurityIntent(input: string, context?: Record<string, unknown>): Promise<void> {
if (!this.session || !this.intentEngine) {
throw new Error('Scheduler not initialized');
}

// 第一步：意图解析
const intentResult: IntentResult = await this.intentEngine.parseIntent(input);
const intent = intentResult.primaryIntent;

console.info(`Detected security intent: ${intent.domain}/${intent.action}`);

// 根据意图调整运营阶段
this.adjustStageByIntent(intent);

// 第二步：智能体任务分发
switch (intent.action) {
case 'analyze_traffic':
await this.dispatchTrafficCollection(context?.interface as string || 'eth0');
break;
case 'detect_threats':
await this.dispatchThreatDetection(context?.timeRange as string || '1h');
break;
case 'analyze_attack':
await this.dispatchAttackAnalysis(context?.threatId as string);
break;
case 'execute_response':
await this.dispatchAutoResponse(context?.playbookId as string);
break;
case 'full_investigation':
// 全链路：采集 -> 检测 -> 研判 -> 响应
await this.dispatchFullInvestigation(context);
break;
default:
await this.dispatchFullInvestigation(context);
}
}

/**
* 根据意图调整运营阶段与光效
*/
private adjustStageByIntent(intent: IntentResult['primaryIntent']): void {
const stageMap: Record<string, SecurityStage> = {
'analyze_traffic': SecurityStage.TRAFFIC,
'detect_threats': SecurityStage.THREAT,
'analyze_attack': SecurityStage.THREAT,
'execute_response': SecurityStage.RESPONSE,
'full_investigation': SecurityStage.OVERVIEW
};

const newStage = stageMap[intent.action] || SecurityStage.OVERVIEW;
this.onStageChanged?.(newStage);
}

/**
* 分发流量采集任务
*/
private async dispatchTrafficCollection(networkInterface: string): Promise<void> {
const task: TaskMessage = {
targetAgent: AgentType.TRAFFIC_COLLECTOR,
taskType: 'capture',
payload: { interface: networkInterface, duration: 60 },
priority: 1
};

const result: TaskResult = await this.session!.sendTask(task);
this.trafficResult = JSON.parse(result.data);

// 触发回调
this.onTrafficCollected?.(this.trafficResult);

// 更新全局状态
AppStorage.setOrCreate('traffic_result', this.trafficResult);
}

/**
* 分发威胁检测任务
*/
private async dispatchThreatDetection(timeRange: string): Promise<void> {
const task: TaskMessage = {
targetAgent: AgentType.THREAT_DETECTOR,
taskType: 'detect',
payload: {
timeRange,
trafficData: this.trafficResult,
threatIntelVersion: '2026.06.27'
},
priority: 2
};

const result: TaskResult = await this.session!.sendTask(task);
this.threatResult = JSON.parse(result.data);

// 触发回调
this.onThreatsDetected?.(this.threatResult);

// 更新全局状态并切换光效
AppStorage.setOrCreate('threat_result', this.threatResult);

// 根据最高威胁等级自动切换光效
if (this.threatResult && this.threatResult.detectedThreats.length > 0) {
const maxThreat = this.threatResult.detectedThreats.reduce((max, threat) => {
const priority = ['normal', 'watch', 'alert', 'high', 'critical'];
return priority.indexOf(threat.severity) > priority.indexOf(max.severity) ? threat : max;
});
this.lightManager.switchThreatLevel(maxThreat.severity as ThreatLevel);
}

// 更新威胁节点
this.updateThreatNodesFromResult(this.threatResult);
}

/**
* 分发攻击研判任务
*/
private async dispatchAttackAnalysis(threatId: string): Promise<void> {
const task: TaskMessage = {
targetAgent: AgentType.ATTACK_ANALYZER,
taskType: 'analyze',
payload: {
threatId,
threatData: this.threatResult?.detectedThreats.find(t => t.id === threatId),
networkContext: this.trafficResult
},
priority: 3
};

const result: TaskResult = await this.session!.sendTask(task);
this.attackAnalysis = JSON.parse(result.data);

// 触发回调
this.onAttackAnalyzed?.(this.attackAnalysis);

// 更新攻击链路
this.updateAttackLinksFromAnalysis(this.attackAnalysis);
}

/**
* 分发自动响应任务
*/
private async dispatchAutoResponse(playbookId: string): Promise<void> {
const task: TaskMessage = {
targetAgent: AgentType.AUTO_RESPONDER,
taskType: 'respond',
payload: {
playbookId,
attackAnalysis: this.attackAnalysis,
threatData: this.threatResult
},
priority: 4
};

const result: TaskResult = await this.session!.sendTask(task);
this.responseResult = JSON.parse(result.data);

// 触发回调
this.onResponseExecuted?.(this.responseResult);

// 响应完成后切换为关注态
if (this.responseResult?.containmentStatus === '已遏制') {
this.lightManager.switchThreatLevel(ThreatLevel.WATCH);
}
}

/**
* 全链路安全调查
*/
private async dispatchFullInvestigation(context?: Record<string, unknown>): Promise<void> {
try {
// 阶段1：流量采集
await this.dispatchTrafficCollection(context?.interface as string || 'eth0');

// 阶段2：威胁检测
await this.dispatchThreatDetection(context?.timeRange as string || '1h');

// 阶段3：攻击研判（如果检测到威胁）
if (this.threatResult && this.threatResult.detectedThreats.length > 0) {
const topThreat = this.threatResult.detectedThreats[0];
await this.dispatchAttackAnalysis(topThreat.id);

// 阶段4：自动响应（如果是高危或紧急）
if (topThreat.severity === ThreatLevel.HIGH || topThreat.severity === ThreatLevel.CRITICAL) {
await this.dispatchAutoResponse('auto_containment');
}
}
} catch (error) {
console.error('Full investigation failed:', error);
}
}

/**
* 更新威胁节点数据
*/
private updateThreatNodesFromResult(result: ThreatResult): void {
for (const threat of result.detectedThreats) {
const node: ThreatNode = {
id: threat.id,
name: threat.sourceIp,
ip: threat.sourceIp,
threatLevel: threat.severity as ThreatLevel,
threatType: threat.type,
lastSeen: threat.timestamp,
x: Math.random() * 800,
y: Math.random() * 600,
connections: [threat.targetIp]
};
this.threatNodes.set(threat.id, node);
}
}

/**
* 更新攻击链路数据
*/
private updateAttackLinksFromAnalysis(analysis: AttackAnalysisResult): void {
for (let i = 0; i < analysis.attackChain.length – 1; i++) {
const current = analysis.attackChain[i];
const next = analysis.attackChain[i + 1];
const link: AttackLink = {
id: `link_${i}`,
sourceId: current.stage,
targetId: next.stage,
attackType: current.stage,
threatLevel: ThreatLevel.HIGH,
timestamp: current.timestamp,
isActive: true
};
this.attackLinks.set(link.id, link);
}
}

// 设置回调
public setOnTrafficCollected(callback: (result: TrafficResult) => void): void {
this.onTrafficCollected = callback;
}
public setOnThreatsDetected(callback: (result: ThreatResult) => void): void {
this.onThreatsDetected = callback;
}
public setOnAttackAnalyzed(callback: (result: AttackAnalysisResult) => void): void {
this.onAttackAnalyzed = callback;
}
public setOnResponseExecuted(callback: (result: ResponseResult) => void): void {
this.onResponseExecuted = callback;
}
public setOnStageChanged(callback: (stage: SecurityStage) => void): void {
this.onStageChanged = callback;
}
}

5.4 悬浮态势导航（SecurityFloatNavigation.ets）

代码亮点：本模块实现了"安全态势即导航"的悬浮页签系统。底部悬浮导航不仅承载"态势总览/流量分析/威胁检测/响应中心"四个运营阶段切换，更实时显示威胁统计徽章（紧急/高危/告警数量）和智能体运行状态角标。采用 HdsTabs 悬浮样式配合 systemMaterialEffect 实现玻璃拟态+威胁光效的双重效果，支持透明度三档调节，最大化态势展示区域。

// entry/src/main/ets/components/SecurityFloatNavigation.ets
import { window } from '@kit.ArkUI';
import { ThreatLightManager, ThreatLevel, ThreatLightTheme } from '../theme/ThreatLightEffect';
import { SecurityStage } from '../agents/SecurityAgentScheduler';

// 导航项配置
interface SecurityNavItem {
id: string;
icon: Resource;
label: string;
page: string;
stage: SecurityStage;
}

@Component
export struct SecurityFloatNavigation {
@State currentIndex: number = 0;
@State navTransparency: number = 0.70;
@State isExpanded: boolean = false;
@State bottomAvoidHeight: number = 0;
@State currentStage: SecurityStage = SecurityStage.OVERVIEW;
@State currentTheme: ThreatLightTheme | null = null;

// 威胁统计
@State criticalCount: number = 0;
@State highCount: number = 0;
@State alertCount: number = 0;
@State watchCount: number = 0;

private lightManager: ThreatLightManager;
private navItems: SecurityNavItem[] = [
{ id: 'overview', icon: $r('app.media.ic_dashboard'), label: '态势总览', page: 'OverviewPage', stage: SecurityStage.OVERVIEW },
{ id: 'traffic', icon: $r('app.media.ic_network'), label: '流量分析', page: 'TrafficPage', stage: SecurityStage.TRAFFIC },
{ id: 'threat', icon: $r('app.media.ic_shield'), label: '威胁检测', page: 'ThreatPage', stage: SecurityStage.THREAT },
{ id: 'response', icon: $r('app.media.ic_response'), label: '响应中心', page: 'ResponsePage', stage: SecurityStage.RESPONSE }
];

constructor(lightManager: ThreatLightManager) {
this.lightManager = lightManager;
}

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

// 监听光效主题变化
this.lightManager.onThemeChange((theme) => {
this.currentTheme = theme;
});

// 监听威胁统计变化
AppStorage.setOrCreate('threat_stats', (stats: { critical: number; high: number; alert: number; watch: number }) => {
this.criticalCount = stats.critical;
this.highCount = stats.high;
this.alertCount = stats.alert;
this.watchCount = stats.watch;
});

// 初始化当前主题
this.currentTheme = this.lightManager.getCurrentTheme();
}

aboutToDisappear(): void {
this.lightManager.offThemeChange(() => {});
}

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);
}
}

private getStageColor(): string {
return this.currentTheme?.primaryColor || '#4CAF50';
}

private getThreatBadgeCount(itemId: string): number {
switch (itemId) {
case 'threat': return this.criticalCount + this.highCount;
case 'response': return this.criticalCount;
default: return 0;
}
}

private getThreatBadgeColor(): string {
if (this.criticalCount > 0) return '#D32F2F';
if (this.highCount > 0) return '#EF5350';
if (this.alertCount > 0) return '#FFA726';
return '#42A5F5';
}

build() {
Stack({ alignContent: Alignment.Bottom }) {
// 内容层
Column() {
this.contentBuilder()
}
.padding({ bottom: this.bottomAvoidHeight + 80 })

// 悬浮导航栏
Column() {
Stack() {
// 玻璃拟态背景
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.getStageColor() + '20', 0.0],
[this.getStageColor() + '05', 1.0]
]
})
}
.width('100%')
.height('100%')
.borderRadius(24)
.shadow({
radius: 20,
color: (this.currentTheme?.primaryColor || '#4CAF50') + '40',
offsetX: 0,
offsetY: –4
})

// 导航项
Row() {
ForEach(this.navItems, (item: SecurityNavItem, index: number) => {
Column() {
Stack() {
Image(item.icon)
.width(24)
.height(24)
.fillColor(this.currentIndex === index ? this.getStageColor() : '#666666')

// 威胁统计徽章
if (this.getThreatBadgeCount(item.id) > 0) {
Stack() {
Text(`${this.getThreatBadgeCount(item.id)}`)
.fontSize(10)
.fontColor('#FFFFFF')
.fontWeight(FontWeight.Bold)
}
.width(18)
.height(18)
.backgroundColor(this.getThreatBadgeColor())
.borderRadius(9)
.position({ x: 14, y: –6 })
.shadow({
radius: 6,
color: this.getThreatBadgeColor(),
offsetX: 0,
offsetY: 0
})
}

// 阶段指示器
if (item.stage === this.currentStage) {
Column()
.width(6)
.height(6)
.backgroundColor(this.getStageColor())
.borderRadius(3)
.position({ x: 20, y: 20 })
.shadow({
radius: 4,
color: this.getStageColor(),
offsetX: 0,
offsetY: 0
})
}
}
.width(40)
.height(40)

Text(item.label)
.fontSize(11)
.fontColor(this.currentIndex === index ? this.getStageColor() : '#999999')
.margin({ top: 4 })
}
.layoutWeight(1)
.onClick(() => {
this.currentIndex = index;
this.currentStage = item.stage;
AppStorage.setOrCreate('security_stage', item.stage);
this.triggerHapticFeedback();
})
})
}
.width('100%')
.height(80)
.padding({ left: 16, right: 16 })
.justifyContent(FlexAlign.SpaceAround)

// 透明度调节
if (this.isExpanded) {
Row() {
Text('透明度')
.fontSize(12)
.fontColor('#666666')
.margin({ right: 8 })

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

Text(`${Math.round(this.navTransparency * 100)}%`)
.fontSize(12)
.fontColor('#666666')
.margin({ left: 8 })
}
.width('100%')
.height(40)
.justifyContent(FlexAlign.Center)
.backgroundColor('rgba(255,255,255,0.5)')
.borderRadius({ topLeft: 12, topRight: 12 })
}
}
.width('92%')
.height(this.isExpanded ? 120 : 80)
.margin({ bottom: this.bottomAvoidHeight + 12, left: '4%', right: '4%' })
.animation({
duration: 300,
curve: Curve.Spring,
iterations: 1
})
.gesture(
LongPressGesture({ duration: 500 })
.onAction(() => {
this.isExpanded = !this.isExpanded;
})
)
}
.width('100%')
.height('100%')
}

@BuilderParam contentBuilder: () => void = this.defaultContentBuilder;

@Builder
defaultContentBuilder(): void {
Column() {
Text('态势感知区域')
.fontSize(16)
.fontColor('#999999')
}
.width('100%')
.height('100%')
.justifyContent(FlexAlign.Center)
}

private triggerHapticFeedback(): void {
try {
import('@kit.SensorServiceKit').then(sensor => {
sensor.vibrator.startVibration({
type: 'time',
duration: 50
}, { id: 0 });
});
} catch (error) {
console.error('Haptic feedback failed:', error);
}
}
}

5.5 主态势感知大屏（SituationalAwarenessPage.ets）

代码亮点：本模块是"光域智脑"的核心可视化界面，基于 Canvas 实现网络拓扑的实时渲染。威胁节点根据等级显示不同颜色与脉冲效果，攻击链路实现动态流光动画。支持手势缩放与拖拽，双击节点下钻查看详情。环境背景光随全局威胁等级动态变化。

// entry/src/main/ets/pages/SituationalAwarenessPage.ets
import { ThreatLightManager, ThreatNode, AttackLink, ThreatLevel } from '../theme/ThreatLightEffect';
import { SecurityAgentScheduler, SecurityStage } from '../agents/SecurityAgentScheduler';

@Component
struct ThreatTopologyCanvas {
@State nodes: ThreatNode[] = [];
@State links: AttackLink[] = [];
@State scale: number = 1.0;
@State offsetX: number = 0;
@State offsetY: number = 0;
@State selectedNode: ThreatNode | null = null;
@State currentTheme: ThreatLightTheme | null = null;

private lightManager: ThreatLightManager;
private scheduler: SecurityAgentScheduler;
private canvasContext: CanvasRenderingContext2D | null = null;
private animationId: number = 0;

constructor(lightManager: ThreatLightManager, scheduler: SecurityAgentScheduler) {
this.lightManager = lightManager;
this.scheduler = scheduler;
}

aboutToAppear(): void {
// 监听光效变化
this.lightManager.onThemeChange((theme) => {
this.currentTheme = theme;
this.invalidate();
});

// 监听节点数据变化
AppStorage.setOrCreate('threat_nodes', (nodes: ThreatNode[]) => {
this.nodes = nodes;
this.invalidate();
});

// 监听链路数据变化
AppStorage.setOrCreate('attack_links', (links: AttackLink[]) => {
this.links = links;
this.invalidate();
});

// 启动动画循环
this.startAnimationLoop();
}

aboutToDisappear(): void {
this.lightManager.offThemeChange(() => {});
if (this.animationId) {
cancelAnimationFrame(this.animationId);
}
}

private startAnimationLoop(): void {
const animate = () => {
this.invalidate();
this.animationId = requestAnimationFrame(animate);
};
this.animationId = requestAnimationFrame(animate);
}

private invalidate(): void {
if (this.canvasContext) {
this.drawTopology(this.canvasContext);
}
}

private drawTopology(ctx: CanvasRenderingContext2D): void {
const width = ctx.canvas.width;
const height = ctx.canvas.height;
const time = Date.now();

// 清空画布
ctx.clearRect(0, 0, width, height);

// 绘制环境背景光
if (this.currentTheme) {
const gradient = ctx.createRadialGradient(
width / 2, height / 2, 0,
width / 2, height / 2, Math.max(width, height) / 2
);
gradient.addColorStop(0, this.currentTheme.primaryColor + '10');
gradient.addColorStop(1, 'transparent');
ctx.fillStyle = gradient;
ctx.fillRect(0, 0, width, height);
}

// 保存变换状态
ctx.save();
ctx.translate(this.offsetX, this.offsetY);
ctx.scale(this.scale, this.scale);

// 绘制攻击链路
for (const link of this.links) {
if (!link.isActive) continue;

const sourceNode = this.nodes.find(n => n.id === link.sou