HarmonyOS APP开发：智能交互设计模式与无障碍

HwJack20

199人浏览 · 2026-06-21 14:25:09

HwJack20 · 2026-06-21 14:25:09 发布

HarmonyOS APP开发：智能交互设计模式与无障碍

核心要点：掌握智能交互的核心设计模式，理解多模态融合策略，构建无障碍优先的包容性交互系统

一、背景与动机

你有没有想过，为什么有些APP用起来就是"顺手"，而有些APP怎么用都"别扭"？

答案往往不在于功能多少，而在于交互设计。好的交互设计让用户几乎不需要思考就能完成操作，而差的交互设计让用户每一步都在犹豫——“这个按钮是干什么的？”“我刚才点了什么？”“怎么返回？”

智能交互设计更进一步——它不仅让操作"顺手"，还让操作"智能"。系统能根据用户的上下文、习惯、甚至情绪状态，主动预测用户意图，提供最合适的操作路径。比如你每天早上8点都会打开新闻APP，系统在第7天就会在7:58自动把新闻推到你的锁屏上。

但智能交互有一个更深层的目标——无障碍（Accessibility）。全球有超过10亿残障人士，对他们来说，很多我们习以为常的交互方式（触摸、打字、看屏幕）可能是不可用的。智能交互技术——语音识别、手势控制、视线追踪、情感计算——恰恰为这些用户提供了全新的交互可能。

一个真正优秀的智能交互系统，不是"能做多少花哨的事"，而是"能让多少人无障碍地使用"。这就是本篇要探讨的核心命题。

二、核心原理

2.1 智能交互设计模式体系

智能交互不是单一技术，而是一套设计模式的集合。每种模式解决一类特定的交互问题：

2.2 多模态融合策略

用户可以通过多种方式与设备交互——触摸、语音、手势、注视、体感。多模态融合的核心问题是：如何将这些不同通道的输入整合成统一的交互意图？

有三种融合策略：

策略	说明	示例
互补融合	不同通道提供不同维度的信息	语音指定目标+手势指定位置
冗余融合	多个通道提供相同信息，增强可靠性	语音+按钮同时触发
排他融合	同一时刻只有一个通道生效	驾驶模式下仅语音可用

互补融合是最常见的策略。比如"把那个文件移到这里"——语音指定操作（移动）和对象（文件），手势指定目标位置（这里）。两个通道的信息互补，才能完整理解用户意图。

2.3 渐进式披露原则

人的短期记忆容量有限（7±2个信息块），一次展示太多选项会让用户无所适从。渐进式披露原则要求：只展示当前任务需要的信息，更复杂的选项在用户需要时才出现。

智能交互的渐进式披露更进一步——系统根据用户的使用频率和熟练度，动态调整披露的层级。新手看到简化界面，老手看到完整功能。

2.4 无障碍设计原则

WCAG 2.1定义了无障碍设计的四大原则：

可感知（Perceivable）：信息可以被所有用户感知（包括视觉、听觉、触觉障碍）
可操作（Operable）：界面可以通过多种方式操作（不仅限于触摸）
可理解（Understandable）：信息和操作是可理解的（清晰的标签、一致的布局）
健壮性（Robust）：内容可以被各种辅助技术正确解析

三、代码实战

3.1 多模态交互管理器

这个示例实现了多模态交互管理器，支持触摸、语音、手势和注视四种输入通道的融合。

// MultiModalManager.ets - 多模态交互管理器
// 功能：统一管理触摸、语音、手势、注视四种输入通道，实现互补融合

export class MultiModalManager {
  // 各通道的最新输入状态
  private touchState: TouchInput = { active: false, x: 0, y: 0, action: '' }
  private voiceState: VoiceInput = { active: false, command: '', target: '', params: [] }
  private gestureState: GestureInput = { active: false, type: '', direction: '' }
  private gazeState: GazeInput = { active: false, x: 0, y: 0, isFixated: false }

  // 融合策略配置
  private fusionConfig: FusionConfig = {
    mode: 'complementary',  // 互补融合
    timeout: 2000,          // 跨通道输入超时（毫秒）
    priority: ['voice', 'gaze', 'gesture', 'touch']  // 通道优先级
  }

  // 跨通道输入缓冲区
  private inputBuffer: Array<ModalInput> = []
  // 上次输入时间
  private lastInputTime: number = 0
  // 事件回调
  private callbacks: Map<string, Array<(intent: InteractionIntent) => void>> = new Map()

  // 更新触摸输入
  updateTouch(input: TouchInput) {
    this.touchState = input
    this.processInput({ channel: 'touch', data: input, timestamp: Date.now() })
  }

  // 更新语音输入
  updateVoice(input: VoiceInput) {
    this.voiceState = input
    this.processInput({ channel: 'voice', data: input, timestamp: Date.now() })
  }

  // 更新手势输入
  updateGesture(input: GestureInput) {
    this.gestureState = input
    this.processInput({ channel: 'gesture', data: input, timestamp: Date.now() })
  }

  // 更新注视输入
  updateGaze(input: GazeInput) {
    this.gazeState = input
    this.processInput({ channel: 'gaze', data: input, timestamp: Date.now() })
  }

  // 处理输入：融合多通道信息
  private processInput(input: ModalInput) {
    const now = Date.now()

    // 清理超时的缓冲输入
    this.inputBuffer = this.inputBuffer.filter(
      item => now - item.timestamp < this.fusionConfig.timeout
    )

    // 添加新输入到缓冲区
    this.inputBuffer.push(input)
    this.lastInputTime = now

    // 尝试融合：检查是否可以组合多个通道的输入
    const intent = this.tryFusion()
    if (intent) {
      this.emitIntent(intent)
      this.inputBuffer = []  // 融合成功后清空缓冲区
    }
  }

  // 尝试融合多通道输入
  private tryFusion(): InteractionIntent | null {
    const channels = new Set(this.inputBuffer.map(i => i.channel))

    // 互补融合：语音+注视 = 对指定位置的对象执行操作
    if (channels.has('voice') && channels.has('gaze')) {
      const voiceInput = this.inputBuffer.find(i => i.channel === 'voice')?.data as VoiceInput
      const gazeInput = this.inputBuffer.find(i => i.channel === 'gaze')?.data as GazeInput

      if (voiceInput && gazeInput && voiceInput.active && gazeInput.active) {
        return {
          action: voiceInput.command,         // 操作：来自语音
          target: voiceInput.target,           // 目标：来自语音
          position: { x: gazeInput.x, y: gazeInput.y },  // 位置：来自注视
          confidence: 0.9,
          channels: ['voice', 'gaze']
        }
      }
    }

    // 互补融合：语音+手势 = 语音指定操作，手势指定方向
    if (channels.has('voice') && channels.has('gesture')) {
      const voiceInput = this.inputBuffer.find(i => i.channel === 'voice')?.data as VoiceInput
      const gestureInput = this.inputBuffer.find(i => i.channel === 'gesture')?.data as GestureInput

      if (voiceInput && gestureInput && voiceInput.active && gestureInput.active) {
        return {
          action: voiceInput.command,
          target: voiceInput.target,
          direction: gestureInput.direction,   // 方向：来自手势
          confidence: 0.85,
          channels: ['voice', 'gesture']
        }
      }
    }

    // 单通道输入：直接生成意图
    if (this.inputBuffer.length === 1) {
      const input = this.inputBuffer[0]
      switch (input.channel) {
        case 'touch':
          const touch = input.data as TouchInput
          return {
            action: touch.action,
            position: { x: touch.x, y: touch.y },
            confidence: 0.95,
            channels: ['touch']
          }
        case 'voice':
          const voice = input.data as VoiceInput
          return {
            action: voice.command,
            target: voice.target,
            params: voice.params,
            confidence: 0.8,
            channels: ['voice']
          }
        case 'gesture':
          const gesture = input.data as GestureInput
          return {
            action: gesture.type,
            direction: gesture.direction,
            confidence: 0.75,
            channels: ['gesture']
          }
        case 'gaze':
          const gaze = input.data as GazeInput
          if (gaze.isFixated) {
            return {
              action: 'select',
              position: { x: gaze.x, y: gaze.y },
              confidence: 0.7,
              channels: ['gaze']
            }
          }
          break
      }
    }

    return null  // 无法融合
  }

  // 注册意图回调
  onIntent(callback: (intent: InteractionIntent) => void) {
    if (!this.callbacks.has('intent')) {
      this.callbacks.set('intent', [])
    }
    this.callbacks.get('intent')!.push(callback)
  }

  // 触发意图
  private emitIntent(intent: InteractionIntent) {
    const callbacks = this.callbacks.get('intent')
    if (callbacks) {
      callbacks.forEach(cb => cb(intent))
    }
  }

  // 重置所有通道状态
  reset() {
    this.touchState = { active: false, x: 0, y: 0, action: '' }
    this.voiceState = { active: false, command: '', target: '', params: [] }
    this.gestureState = { active: false, type: '', direction: '' }
    this.gazeState = { active: false, x: 0, y: 0, isFixated: false }
    this.inputBuffer = []
  }
}

// 输入数据类型
interface TouchInput {
  active: boolean
  x: number
  y: number
  action: string
}

interface VoiceInput {
  active: boolean
  command: string      // 操作命令（如"打开""删除""移动"）
  target: string       // 目标对象（如"设置""照片""文件"）
  params: Array<string>  // 额外参数
}

interface GestureInput {
  active: boolean
  type: string         // 手势类型（如"swipe""pinch""rotate"）
  direction: string    // 方向（如"left""up"）
}

interface GazeInput {
  active: boolean
  x: number
  y: number
  isFixated: boolean   // 是否注视固定
}

// 模态输入
interface ModalInput {
  channel: string      // 输入通道
  data: TouchInput | VoiceInput | GestureInput | GazeInput
  timestamp: number
}

// 融合配置
interface FusionConfig {
  mode: string         // 融合模式
  timeout: number      // 跨通道超时
  priority: Array<string>  // 通道优先级
}

// 交互意图
export interface InteractionIntent {
  action: string       // 操作
  target?: string      // 目标
  position?: { x: number, y: number }  // 位置
  direction?: string   // 方向
  params?: Array<string>  // 参数
  confidence: number   // 置信度
  channels: Array<string>  // 使用的通道
}

3.2 无障碍交互组件库

这个示例实现了无障碍优先的交互组件，支持屏幕阅读器、高对比度模式、大字体模式和开关控制。

// AccessibleComponents.ets - 无障碍交互组件库
// 功能：提供无障碍优先的UI组件，支持多种辅助技术

// 无障碍按钮组件
@Component
export struct AccessibleButton {
  // 按钮标签（屏幕阅读器朗读）
  @Prop accessibilityLabel: string = ''
  // 按钮提示（辅助说明）
  @Prop accessibilityHint: string = ''
  // 按钮角色
  @Prop accessibilityRole: string = 'button'
  // 是否启用
  @Prop isEnabled: boolean = true
  // 按钮文本
  @Prop label: string = ''
  // 按钮图标
  @Prop icon: string = ''
  // 变体样式
  @Prop variant: 'primary' | 'secondary' | 'danger' | 'ghost' = 'primary'
  // 尺寸
  @Prop size: 'small' | 'medium' | 'large' = 'medium'
  // 点击回调
  private onClickAction?: () => void

  build() {
    Row() {
      if (this.icon) {
        Text(this.icon)
          .fontSize(this.getFontSize())
      }
      Text(this.label)
        .fontSize(this.getFontSize())
        .fontWeight(FontWeight.Medium)
    }
    .width(this.getWidth())
    .height(this.getHeight())
    .justifyContent(FlexAlign.Center)
    .borderRadius(this.getBorderRadius())
    .backgroundColor(this.getBackgroundColor())
    .fontColor(this.getFontColor())
    .opacity(this.isEnabled ? 1.0 : 0.5)
    // 无障碍属性
    .accessibilityText(this.accessibilityLabel || this.label)
    .accessibilityDescription(this.accessibilityHint)
    .accessibilityRole(this.accessibilityRole as AccessibilityRole)
    .accessibilityLevel('important')
    .enabled(this.isEnabled)
    // 点击与键盘操作
    .onClick(() => {
      if (this.isEnabled && this.onClickAction) {
        this.onClickAction()
      }
    })
    // 焦点样式
    .focusable(true)
    .defaultFocus(false)
  }

  // 根据变体获取背景色
  private getBackgroundColor(): string {
    const colorMap: Record<string, string> = {
      'primary': '#4F46E5',
      'secondary': '#2d2d4e',
      'danger': '#EF4444',
      'ghost': 'transparent'
    }
    return colorMap[this.variant] || '#4F46E5'
  }

  // 根据变体获取字体色
  private getFontColor(): string {
    return this.variant === 'ghost' ? '#a0a0cc' : '#ffffff'
  }

  // 根据尺寸获取字号
  private getFontSize(): number {
    const sizeMap: Record<string, number> = { 'small': 12, 'medium': 14, 'large': 18 }
    return sizeMap[this.size] || 14
  }

  // 根据尺寸获取宽度
  private getWidth(): string | number {
    const sizeMap: Record<string, string | number> = {
      'small': 80, 'medium': 120, 'large': '100%'
    }
    return sizeMap[this.size] || 120
  }

  // 根据尺寸获取高度
  private getHeight(): number {
    const sizeMap: Record<string, number> = { 'small': 36, 'medium': 44, 'large': 56 }
    return sizeMap[this.size] || 44
  }

  // 根据尺寸获取圆角
  private getBorderRadius(): number {
    const sizeMap: Record<string, number> = { 'small': 8, 'medium': 12, 'large': 16 }
    return sizeMap[this.size] || 12
  }
}

// 无障碍卡片组件
@Component
export struct AccessibleCard {
  @Prop title: string = ''
  @Prop description: string = ''
  @Prop accessibilityHint: string = ''
  @Prop isActive: boolean = false
  @Prop icon: string = ''
  private onActivate?: () => void

  build() {
    Column() {
      Row() {
        if (this.icon) {
          Text(this.icon)
            .fontSize(24)
        }
        Column() {
          Text(this.title)
            .fontSize(16)
            .fontWeight(FontWeight.Bold)
            .fontColor(this.isActive ? '#4F46E5' : '#e0e0ff')
          Text(this.description)
            .fontSize(12)
            .fontColor('#808090')
            .maxLines(2)
            .textOverflow({ overflow: TextOverflow.Ellipsis })
            .margin({ top: 4 })
        }
        .alignItems(HorizontalAlign.Start)
        .layoutWeight(1)
        .margin({ left: 12 })
      }
      .width('100%')
      .padding(16)
    }
    .width('100%')
    .borderRadius(16)
    .backgroundColor(this.isActive ? '#2a2a4e' : '#1a1a2e')
    .border({
      width: this.isActive ? 2 : 1,
      color: this.isActive ? '#4F46E5' : '#2d2d4e'
    })
    .shadow(this.isActive ? { radius: 12, color: '#4F46E540', offsetX: 0, offsetY: 4 } : undefined)
    // 无障碍属性
    .accessibilityText(`${this.title}. ${this.description}`)
    .accessibilityDescription(this.accessibilityHint)
    .accessibilityRole(this.isActive ? AccessibilityRole.Checkbox : AccessibilityRole.Button)
    .accessibilityState({ checked: this.isActive })
    .focusable(true)
    .onClick(() => {
      if (this.onActivate) {
        this.onActivate()
      }
    })
  }
}

// 无障碍开关组件
@Component
export struct AccessibleSwitch {
  @Prop label: string = ''
  @Prop isOn: boolean = false
  @Prop accessibilityHint: string = ''
  private onToggle?: (value: boolean) => void

  build() {
    Row() {
      Text(this.label)
        .fontSize(14)
        .fontColor('#e0e0ff')
        .layoutWeight(1)
      Toggle({ type: ToggleType.Switch, isOn: this.isOn })
        .selectedColor('#4F46E5')
        .switchStyle({ pointRadius: 10, trackBorderRadius: 14 })
        .onChange((isOn: boolean) => {
          if (this.onToggle) {
            this.onToggle(isOn)
          }
        })
    }
    .width('100%')
    .height(48)
    .padding({ left: 16, right: 16 })
    .alignItems(VerticalAlign.Center)
    // 无障碍属性
    .accessibilityText(`${this.label} 开关，当前${this.isOn ? '已开启' : '已关闭'}`)
    .accessibilityDescription(this.accessibilityHint)
    .accessibilityRole(AccessibilityRole.Switch)
    .accessibilityState({ checked: this.isOn })
  }
}

3.3 智能交互设置面板

这个示例将多模态管理器和无障碍组件组合起来，构建一个完整的智能交互设置面板——用户可以自定义交互方式、调整无障碍参数。

// SmartInteractionPanel.ets - 智能交互设置面板
// 功能：集成多模态交互和无障碍配置的完整面板

import { MultiModalManager, InteractionIntent } from './MultiModalManager'
import { AccessibleButton } from './AccessibleComponents'
import { AccessibleCard } from './AccessibleComponents'
import { AccessibleSwitch } from './AccessibleComponents'

@Entry
@Component
struct SmartInteractionPanel {
  // 交互模式配置
  @State interactionMode: string = 'standard'     // standard / enhanced / accessibility
  @State voiceEnabled: boolean = true             // 语音交互
  @State gestureEnabled: boolean = true           // 手势交互
  @State gazeEnabled: boolean = false             // 注视交互
  @State motionEnabled: boolean = false           // 体感交互
  @State hapticEnabled: boolean = true            // 触觉反馈

  // 无障碍配置
  @State highContrastMode: boolean = false        // 高对比度
  @State largeTextMode: boolean = false           // 大字体
  @State screenReaderEnabled: boolean = false     // 屏幕阅读器
  @State switchControlEnabled: boolean = false    // 开关控制
  @State reduceMotion: boolean = false            // 减少动画

  // 智能特性配置
  @State predictiveIntent: boolean = true         // 意图预测
  @State emotionAdaptive: boolean = false         // 情感适配
  @State contextAware: boolean = true             // 上下文感知
  @State autoCalibration: boolean = true          // 自动校准

  // 状态信息
  @State activeChannels: string = '触摸 + 语音'
  @State lastIntent: string = '无'
  @State confidence: number = 0
  @State statusMessage: string = '智能交互已就绪'

  // 多模态管理器
  private modalManager: MultiModalManager = new MultiModalManager()

  aboutToAppear() {
    this.setupIntentHandler()
    this.updateActiveChannels()
  }

  build() {
    Scroll() {
      Column() {
        // 标题区域
        Column() {
          Text('🧠 智能交互')
            .fontSize(28)
            .fontWeight(FontWeight.Bold)
            .fontColor('#e0e0ff')
          Text('自定义你的交互方式')
            .fontSize(14)
            .fontColor('#808090')
            .margin({ top: 4 })
        }
        .width('100%')
        .padding({ top: 24, bottom: 16 })
        .alignItems(HorizontalAlign.Start)

        // 交互模式选择
        Text('交互模式')
          .fontSize(16)
          .fontWeight(FontWeight.Bold)
          .fontColor('#a0a0cc')
          .margin({ top: 16 })

        Row() {
          this.ModeCard('标准模式', '触摸 + 语音', '📱', this.interactionMode === 'standard', () => {
            this.interactionMode = 'standard'
            this.applyModePreset('standard')
          })
          this.ModeCard('增强模式', '多通道融合', '🚀', this.interactionMode === 'enhanced', () => {
            this.interactionMode = 'enhanced'
            this.applyModePreset('enhanced')
          })
          this.ModeCard('无障碍模式', '全通道 + 辅助', '♿', this.interactionMode === 'accessibility', () => {
            this.interactionMode = 'accessibility'
            this.applyModePreset('accessibility')
          })
        }
        .width('100%')
        .justifyContent(FlexAlign.SpaceBetween)

        // 输入通道配置
        Text('输入通道')
          .fontSize(16)
          .fontWeight(FontWeight.Bold)
          .fontColor('#a0a0cc')
          .margin({ top: 24 })

        Column() {
          AccessibleSwitch({
            label: '语音交互',
            isOn: this.voiceEnabled,
            accessibilityHint: '启用语音命令控制',
            onToggle: (val: boolean) => {
              this.voiceEnabled = val
              this.updateActiveChannels()
            }
          })
          AccessibleSwitch({
            label: '手势交互',
            isOn: this.gestureEnabled,
            accessibilityHint: '启用手势识别控制',
            onToggle: (val: boolean) => {
              this.gestureEnabled = val
              this.updateActiveChannels()
            }
          })
          AccessibleSwitch({
            label: '注视交互',
            isOn: this.gazeEnabled,
            accessibilityHint: '启用视线追踪控制',
            onToggle: (val: boolean) => {
              this.gazeEnabled = val
              this.updateActiveChannels()
            }
          })
          AccessibleSwitch({
            label: '体感交互',
            isOn: this.motionEnabled,
            accessibilityHint: '启用设备运动控制',
            onToggle: (val: boolean) => {
              this.motionEnabled = val
              this.updateActiveChannels()
            }
          })
          AccessibleSwitch({
            label: '触觉反馈',
            isOn: this.hapticEnabled,
            accessibilityHint: '启用振动触觉反馈',
            onToggle: (val: boolean) => {
              this.hapticEnabled = val
            }
          })
        }
        .width('100%')
        .borderRadius(16)
        .backgroundColor('#16213e')
        .padding(8)

        // 无障碍配置
        Text('无障碍')
          .fontSize(16)
          .fontWeight(FontWeight.Bold)
          .fontColor('#a0a0cc')
          .margin({ top: 24 })

        Column() {
          AccessibleSwitch({
            label: '高对比度',
            isOn: this.highContrastMode,
            accessibilityHint: '增强界面色彩对比度',
            onToggle: (val: boolean) => {
              this.highContrastMode = val
            }
          })
          AccessibleSwitch({
            label: '大字体',
            isOn: this.largeTextMode,
            accessibilityHint: '增大界面文字尺寸',
            onToggle: (val: boolean) => {
              this.largeTextMode = val
            }
          })
          AccessibleSwitch({
            label: '屏幕阅读器',
            isOn: this.screenReaderEnabled,
            accessibilityHint: '朗读界面元素',
            onToggle: (val: boolean) => {
              this.screenReaderEnabled = val
            }
          })
          AccessibleSwitch({
            label: '开关控制',
            isOn: this.switchControlEnabled,
            accessibilityHint: '使用外部开关设备操作',
            onToggle: (val: boolean) => {
              this.switchControlEnabled = val
            }
          })
          AccessibleSwitch({
            label: '减少动画',
            isOn: this.reduceMotion,
            accessibilityHint: '减少界面动画效果',
            onToggle: (val: boolean) => {
              this.reduceMotion = val
            }
          })
        }
        .width('100%')
        .borderRadius(16)
        .backgroundColor('#16213e')
        .padding(8)

        // 智能特性
        Text('智能特性')
          .fontSize(16)
          .fontWeight(FontWeight.Bold)
          .fontColor('#a0a0cc')
          .margin({ top: 24 })

        Column() {
          AccessibleSwitch({
            label: '意图预测',
            isOn: this.predictiveIntent,
            accessibilityHint: '预测用户操作意图',
            onToggle: (val: boolean) => {
              this.predictiveIntent = val
            }
          })
          AccessibleSwitch({
            label: '情感适配',
            isOn: this.emotionAdaptive,
            accessibilityHint: '根据情绪状态调整界面',
            onToggle: (val: boolean) => {
              this.emotionAdaptive = val
            }
          })
          AccessibleSwitch({
            label: '上下文感知',
            isOn: this.contextAware,
            accessibilityHint: '根据场景自动调整',
            onToggle: (val: boolean) => {
              this.contextAware = val
            }
          })
          AccessibleSwitch({
            label: '自动校准',
            isOn: this.autoCalibration,
            accessibilityHint: '自动优化交互精度',
            onToggle: (val: boolean) => {
              this.autoCalibration = val
            }
          })
        }
        .width('100%')
        .borderRadius(16)
        .backgroundColor('#16213e')
        .padding(8)

        // 当前状态
        Text('当前状态')
          .fontSize(16)
          .fontWeight(FontWeight.Bold)
          .fontColor('#a0a0cc')
          .margin({ top: 24 })

        Column() {
          Row() {
            Text('活跃通道:')
              .fontSize(13)
              .fontColor('#808090')
            Text(this.activeChannels)
              .fontSize(13)
              .fontColor('#4ECDC4')
              .fontWeight(FontWeight.Medium)
          }
          .width('100%')
          .justifyContent(FlexAlign.SpaceBetween)

          Row() {
            Text('最近意图:')
              .fontSize(13)
              .fontColor('#808090')
            Text(this.lastIntent)
              .fontSize(13)
              .fontColor('#FFEAA7')
              .fontWeight(FontWeight.Medium)
          }
          .width('100%')
          .justifyContent(FlexAlign.SpaceBetween)
          .margin({ top: 8 })

          Row() {
            Text('置信度:')
              .fontSize(13)
              .fontColor('#808090')
            Text(`${(this.confidence * 100).toFixed(0)}%`)
              .fontSize(13)
              .fontColor(this.confidence > 0.8 ? '#10B981' : '#F59E0B')
              .fontWeight(FontWeight.Medium)
          }
          .width('100%')
          .justifyContent(FlexAlign.SpaceBetween)
          .margin({ top: 8 })

          Text(this.statusMessage)
            .fontSize(12)
            .fontColor('#808090')
            .margin({ top: 12 })
        }
        .width('100%')
        .borderRadius(16)
        .backgroundColor('#16213e')
        .padding(16)

        // 底部操作
        Row() {
          AccessibleButton({
            label: '重置默认',
            variant: 'ghost',
            size: 'medium',
            accessibilityLabel: '重置所有设置为默认值',
            onClickAction: () => this.resetToDefaults()
          })
          AccessibleButton({
            label: '保存配置',
            variant: 'primary',
            size: 'medium',
            accessibilityLabel: '保存当前交互配置',
            onClickAction: () => this.saveConfig()
          })
        }
        .width('100%')
        .justifyContent(FlexAlign.SpaceEvenly)
        .margin({ top: 24, bottom: 32 })
      }
      .width('100%')
      .padding({ left: 16, right: 16 })
    }
    .width('100%')
    .height('100%')
    .backgroundColor('#0f0f23')
    .scrollBar(BarState.Auto)
  }

  // 模式选择卡片
  @Builder
  ModeCard(title: string, desc: string, icon: string, isActive: boolean, action: () => void) {
    Column() {
      Text(icon)
        .fontSize(28)
      Text(title)
        .fontSize(13)
        .fontWeight(FontWeight.Bold)
        .fontColor(isActive ? '#4F46E5' : '#a0a0cc')
        .margin({ top: 8 })
      Text(desc)
        .fontSize(10)
        .fontColor('#808090')
        .margin({ top: 2 })
    }
    .width('30%')
    .height(100)
    .justifyContent(FlexAlign.Center)
    .alignItems(HorizontalAlign.Center)
    .borderRadius(12)
    .backgroundColor(isActive ? '#2a2a4e' : '#16213e')
    .border({
      width: isActive ? 2 : 1,
      color: isActive ? '#4F46E5' : '#2d2d4e'
    })
    .accessibilityText(`${title}模式. ${desc}`)
    .accessibilityRole(AccessibilityRole.Radio)
    .accessibilityState({ checked: isActive })
    .focusable(true)
    .onClick(() => action())
  }

  // 应用模式预设
  private applyModePreset(mode: string) {
    switch (mode) {
      case 'standard':
        this.voiceEnabled = true
        this.gestureEnabled = true
        this.gazeEnabled = false
        this.motionEnabled = false
        this.highContrastMode = false
        this.largeTextMode = false
        this.screenReaderEnabled = false
        this.switchControlEnabled = false
        this.statusMessage = '标准模式：触摸 + 语音交互'
        break
      case 'enhanced':
        this.voiceEnabled = true
        this.gestureEnabled = true
        this.gazeEnabled = true
        this.motionEnabled = true
        this.emotionAdaptive = true
        this.statusMessage = '增强模式：全通道交互 + 情感适配'
        break
      case 'accessibility':
        this.voiceEnabled = true
        this.gestureEnabled = true
        this.gazeEnabled = true
        this.motionEnabled = false
        this.highContrastMode = true
        this.largeTextMode = true
        this.screenReaderEnabled = true
        this.switchControlEnabled = true
        this.reduceMotion = true
        this.statusMessage = '无障碍模式：全辅助功能已启用'
        break
    }
    this.updateActiveChannels()
  }

  // 更新活跃通道显示
  private updateActiveChannels() {
    const channels: Array<string> = ['触摸']
    if (this.voiceEnabled) channels.push('语音')
    if (this.gestureEnabled) channels.push('手势')
    if (this.gazeEnabled) channels.push('注视')
    if (this.motionEnabled) channels.push('体感')
    this.activeChannels = channels.join(' + ')
  }

  // 设置意图处理器
  private setupIntentHandler() {
    this.modalManager.onIntent((intent: InteractionIntent) => {
      this.lastIntent = `${intent.action}${intent.target ? ' ' + intent.target : ''}`
      this.confidence = intent.confidence
      this.statusMessage = `检测到意图: ${this.lastIntent} (置信度: ${(intent.confidence * 100).toFixed(0)}%)`
    })
  }

  // 重置默认设置
  private resetToDefaults() {
    this.applyModePreset('standard')
    this.interactionMode = 'standard'
    this.hapticEnabled = true
    this.predictiveIntent = true
    this.emotionAdaptive = false
    this.contextAware = true
    this.autoCalibration = true
    this.statusMessage = '已重置为默认设置'
  }

  // 保存配置
  private saveConfig() {
    // 在实际应用中，这里会持久化配置到Preferences
    this.statusMessage = '✅ 配置已保存'
  }
}

四、踩坑与注意事项

4.1 多模态冲突

问题：用户在说话的同时也在做手势，两个通道的输入可能产生矛盾——语音说"向左"，手势却向右划。

解决方案：

定义通道优先级，高优先级通道覆盖低优先级
使用置信度加权融合
检测通道矛盾时提示用户确认

// 通道矛盾检测
private detectConflict(inputs: Array<ModalInput>): boolean {
  // 检查语音和手势的方向是否矛盾
  const voiceInput = inputs.find(i => i.channel === 'voice')?.data as VoiceInput
  const gestureInput = inputs.find(i => i.channel === 'gesture')?.data as GestureInput

  if (voiceInput && gestureInput) {
    const directionMap: Record<string, string> = {
      'left': 'right', 'up': 'down', 'next': 'previous'
    }
    if (directionMap[voiceInput.command] === gestureInput.direction) {
      return true  // 方向矛盾
    }
  }
  return false
}

4.2 无障碍与视觉设计的平衡

问题：高对比度模式和大字体模式会破坏原有的视觉设计，导致布局溢出。

解决方案：

使用弹性布局（Flex/Grid），而非固定尺寸
为大字体模式预留足够的布局空间
使用 maxLines + textOverflow 防止文本溢出
高对比度模式使用独立的颜色主题

// 自适应字体大小
private getAdaptiveFontSize(baseSize: number): number {
  return this.largeTextMode ? baseSize * 1.3 : baseSize
}

// 高对比度颜色
private getAdaptiveColor(normalColor: string, highContrastColor: string): string {
  return this.highContrastMode ? highContrastColor : normalColor
}

4.3 屏幕阅读器的内容组织

问题：屏幕阅读器按组件顺序朗读，如果布局混乱，朗读顺序也会混乱。

解决方案：

使用语义化组件（accessibilityRole）
合理组织组件层级，确保朗读顺序符合逻辑
使用 accessibilityGroup 将相关元素组合
隐藏装饰性元素（accessibilityVisibility('none')）

// 正确的无障碍内容组织
Column() {
  // 语义化组合
  Row() {
    Text('🎵')
      .accessibilityVisibility('none')  // 装饰性图标，不朗读
    Text('正在播放: 夜曲')
      .accessibilityText('正在播放: 夜曲')
  }
  .accessibilityGroup(true)  // 组合为一个可朗读单元
  .accessibilityRole(AccessibilityRole.Text)
}

4.4 意图预测的隐私边界

问题：意图预测需要收集用户行为数据，可能涉及隐私问题。

解决方案：

所有行为数据仅在端侧处理，不上传云端
提供明确的开关，用户可随时关闭意图预测
预测结果仅作为建议，不自动执行
定期清理历史行为数据

五、HarmonyOS 6适配

5.1 无障碍API变更

变更项	HarmonyOS 5	HarmonyOS 6
无障碍服务	`@ohos.accessibility`	`@ohos.accessibilityV2`
屏幕阅读器	系统内置	支持第三方屏幕阅读器
开关控制	需自行实现	内置 `SwitchControlService`
语音控制	需自行实现	内置 `VoiceAccess`
无障碍测试	手动测试	自动化无障碍审计工具

5.2 新增多模态融合框架

HarmonyOS 6新增了 @ohos.interaction.fusion 模块：

// HarmonyOS 6 新增：多模态融合框架
import { fusion } from '@ohos.interaction.fusion'

// 创建融合管理器
const manager = fusion.createManager({
  channels: [fusion.Channel.TOUCH, fusion.Channel.VOICE, fusion.Channel.GAZE],
  strategy: fusion.FusionStrategy.COMPLEMENTARY,
  conflictResolution: fusion.ConflictResolution.PRIORITY_BASED
})

// 订阅融合意图
manager.on('intent', (intent: fusion.FusedIntent) => {
  console.info(`融合意图: ${intent.action}, 通道: ${intent.channels}`)
})

// 启动融合
manager.start()

5.3 迁移要点

无障碍属性标准化：HarmonyOS 6统一了无障碍属性命名，accessibilityText → accessibilityLabel
自动无障碍审计：DevEco Studio新增无障碍审计工具，可自动检测无障碍问题
多模态融合内置：无需自行实现融合逻辑，使用内置框架即可
隐私沙箱：所有AI推理在隐私沙箱中运行，应用层无法获取原始传感器数据

六、总结

知识点	核心内容
设计模式	感知→决策→表达→适配，四层递进
多模态融合	互补/冗余/排他三种策略，互补最常用
渐进式披露	只展示当前需要的信息，智能调整披露层级
无障碍四原则	可感知、可操作、可理解、健壮性
通道冲突	优先级覆盖 + 置信度加权 + 矛盾检测
视觉平衡	弹性布局 + 自适应字号 + 独立颜色主题
屏幕阅读器	语义化组件 + 合理层级 + 装饰元素隐藏
隐私边界	端侧处理 + 明确开关 + 仅建议不执行
HarmonyOS 6	无障碍V2、多模态融合框架、自动审计、隐私沙箱