鸿蒙 Flutter 开发：AI 能力集成与鸿蒙原生智能服务融合实战

随着人工智能技术在终端设备的普及，鸿蒙系统凭借其全场景分布式架构，整合了端侧 AI 计算、鸿蒙智联 AI 设备联动等原生智能服务；而 Flutter 作为跨端开发框架，能够快速构建统一的 AI 交互界面。此前我们探讨了鸿蒙 Flutter 的状态管理、离线存储、多模态交互、车机适配等内容，本文将聚焦鸿蒙 Flutter 的 AI 能力集成与鸿蒙原生智能服务的深度融合，以智能语音助手、端侧图像识别、鸿蒙智联 AI 设备联动为场景，通过完整代码案例，演示如何将 Flutter 与鸿蒙原生 AI 能力（方舟推理框架、鸿蒙语音服务、AI 设备互联）结合，打造具备智能交互能力的鸿蒙 Flutter 应用。

一、鸿蒙 AI 能力与 Flutter 融合的核心逻辑

鸿蒙系统提供了三大核心 AI 能力体系，与 Flutter 的融合遵循 **“端侧算力下沉，交互体验上提”** 的原则：

1. 端侧 AI 推理层（鸿蒙原生）：基于方舟推理框架（Ark 推理）、MindSpore Lite 实现端侧模型推理（如图像识别、语音解析），利用鸿蒙设备的 NPU 算力加速，确保推理低延迟；
2. 智能服务层（鸿蒙原生）：整合鸿蒙语音服务、鸿蒙智联（HarmonyOS Connect）AI 设备联动、场景化智能推荐等系统级智能服务；
3. 交互层（Flutter）：将 AI 推理结果、智能服务响应转换为可视化 UI，提供统一的跨设备 AI 交互体验，同时接收用户的语音、触控输入并传递至原生层；
4. 通信桥梁：通过MethodChannel（同步指令）、EventChannel（异步事件）、BasicMessageChannel（大数据传输，如图像数据）实现 Flutter 与鸿蒙原生的双向通信。

二、案例：鸿蒙 Flutter 智能 AI 助手应用

本案例将实现一款集成端侧语音交互、图像识别、鸿蒙智联 AI 设备控制的智能助手应用，核心功能包括：

1. 端侧语音指令解析（无需联网，基于鸿蒙方舟推理框架运行轻量级语音模型）；
2. 相册 / 摄像头图像识别（端侧识别物体并给出智能建议）；
3. 鸿蒙智联 AI 设备联动（语音控制智能灯、智能空调等设备）。

前置条件

1. 已配置鸿蒙 DevEco Studio 4.2 + 与 Flutter 3.22 + 环境，支持鸿蒙端侧 AI 开发套件；
2. 已下载轻量级端侧 AI 模型（如语音识别模型speech_model.mindir、图像识别模型resnet18.mindir），并放置于鸿蒙原生工程的raw目录；
3. 已获取鸿蒙相关权限（麦克风、摄像头、存储、鸿蒙智联设备访问）；
4. 已配置鸿蒙智联开发者账号，完成 AI 设备（智能灯、空调）的设备接入。

三、步骤 1：鸿蒙原生层封装 AI 核心能力

鸿蒙原生层负责端侧 AI 模型推理、语音服务调用、鸿蒙智联设备通信，提供统一接口供 Flutter 调用。

1. 权限配置（module.json5）

在entry/src/main/module.json5中配置 AI 能力所需权限：

{
  "module": {
    "reqPermissions": [
      { "name": "ohos.permission.MICROPHONE", "reason": "需要语音交互", "usedScene": { "abilities": [".MainAbility"], "when": "always" } },
      { "name": "ohos.permission.CAMERA", "reason": "需要图像识别", "usedScene": { "abilities": [".MainAbility"], "when": "always" } },
      { "name": "ohos.permission.READ_USER_STORAGE", "reason": "需要读取相册图片", "usedScene": { "abilities": [".MainAbility"], "when": "always" } },
      { "name": "ohos.permission.WRITE_USER_STORAGE", "reason": "需要保存识别结果", "usedScene": { "abilities": [".MainAbility"], "when": "always" } },
      { "name": "ohos.permission.DISTRIBUTED_DEVICE_ACCESS", "reason": "需要访问鸿蒙智联设备", "usedScene": { "abilities": [".MainAbility"], "when": "always" } },
      { "name": "ohos.permission.ACCESS_AI_MODEL", "reason": "需要加载端侧AI模型", "usedScene": { "abilities": [".MainAbility"], "when": "always" } }
    ]
  }
}

2. 端侧图像识别封装（ArkTS + MindSpore Lite）

基于 MindSpore Lite 加载预训练的 ResNet18 模型，实现端侧图像识别：

// model/ImageRecognitionModel.ts
import mindspore from '@ohos.mindspore.lite';
import fs from '@ohos.file.fs';
import buffer from '@ohos.buffer';

// 图像识别结果模型
export interface RecognitionResult {
  label: string; // 识别标签（如“猫”“手机”）
  confidence: number; // 置信度（0-1）
  suggestion: string; // 智能建议
}

export class ImageRecognitionModel {
  private model: mindspore.Model | null = null;
  private labels: string[] = []; // 标签列表
  private suggestions: Record<string, string> = {
    'cat': '这是一只可爱的猫咪，是否需要推荐宠物用品？',
    'dog': '这是一只忠诚的狗狗，是否需要推荐狗粮？',
    'phone': '这是一部智能手机，是否需要清理内存？',
    'cup': '这是一个水杯，记得多喝水哦！',
    'book': '这是一本书，是否需要加入阅读清单？'
  };

  // 初始化模型（加载ResNet18模型与标签）
  async init(): Promise<void> {
    try {
      // 1. 加载端侧模型文件（raw目录下的resnet18.mindir）
      const modelFile = await fs.openRawFile('resnet18.mindir');
      const modelBuffer = await fs.read(modelFile.fd, { offset: 0, length: modelFile.stats.size });
      const modelData = buffer.from(modelBuffer);

      // 2. 初始化MindSpore Lite上下文
      const context = new mindspore.Context({
        deviceType: mindspore.DeviceType.NPU, // 使用NPU加速（无NPU则自动降级为CPU）
        npuDeviceId: 0
      });

      // 3. 加载模型
      this.model = new mindspore.Model();
      await this.model.load(modelData, context);

      // 4. 加载标签文件
      const labelFile = await fs.openRawFile('labels.txt');
      const labelBuffer = await fs.read(labelFile.fd, { offset: 0, length: labelFile.stats.size });
      this.labels = new TextDecoder().decode(labelBuffer).split('\n');

      console.log('图像识别模型初始化成功');
    } catch (e) {
      console.error(`模型初始化失败：${JSON.stringify(e)}`);
      throw new Error('图像识别能力初始化失败');
    }
  }

  // 图像识别（输入图像像素数据）
  async recognize(imageData: Uint8Array, width: number, height: number): Promise<RecognitionResult> {
    if (!this.model) throw new Error('模型未初始化');

    try {
      // 1. 图像预处理（归一化、缩放，适配ResNet18输入格式）
      const inputTensor = this.preprocessImage(imageData, width, height);

      // 2. 模型推理
      const outputs = await this.model.predict([inputTensor]);
      const outputData = outputs[0].getData() as Float32Array;

      // 3. 解析推理结果
      const maxIndex = this.argmax(outputData);
      const label = this.labels[maxIndex].trim() || 'unknown';
      const confidence = outputData[maxIndex];
      const suggestion = this.suggestions[label] || '未识别到具体物体';

      return { label, confidence, suggestion };
    } catch (e) {
      console.error(`图像识别失败：${JSON.stringify(e)}`);
      return { label: 'error', confidence: 0, suggestion: '识别失败，请重试' };
    }
  }

  // 图像预处理（简化版，实际项目需根据模型要求处理）
  private preprocessImage(imageData: Uint8Array, width: number, height: number): mindspore.Tensor {
    // 此处简化为创建默认输入张量（实际需处理图像数据）
    const inputShape = [1, 3, 224, 224]; // ResNet18输入形状：batch=1, channel=3, width=224, height=224
    const inputData = new Float32Array(1 * 3 * 224 * 224).fill(0.5); // 填充默认值
    return new mindspore.Tensor(inputData, mindspore.DataType.FLOAT32, inputShape);
  }

  // 找到数组中最大值的索引
  private argmax(array: Float32Array): number {
    let maxIndex = 0;
    let maxValue = array[0];
    for (let i = 1; i < array.length; i++) {
      if (array[i] > maxValue) {
        maxValue = array[i];
        maxIndex = i;
      }
    }
    return maxIndex;
  }

  // 释放模型资源
  destroy(): void {
    if (this.model) {
      this.model.free();
      this.model = null;
    }
  }
}

3. 鸿蒙智联 AI 设备控制封装（ArkTS）

实现与鸿蒙智联智能灯、智能空调的通信，支持语音指令控制设备状态：

// service/HarmonyAIDeviceService.ts
import deviceManager from '@ohos.distributedDeviceManager';
import rpc from '@ohos.rpc';

// AI设备类型与状态
export type DeviceType = 'light' | 'air_conditioner';
export interface DeviceStatus {
  deviceId: string;
  type: DeviceType;
  name: string;
  status: 'on' | 'off';
  brightness?: number; // 灯光亮度（0-100）
  temperature?: number; // 空调温度（16-30）
}

export class HarmonyAIDeviceService {
  private deviceManager: deviceManager.DeviceManager | null = null;
  private devices: DeviceStatus[] = [];

  // 初始化设备管理器
  async init(): Promise<void> {
    try {
      this.deviceManager = await deviceManager.createDeviceManager('com.example.ai_assistant');
      // 扫描鸿蒙智联AI设备
      this.scanDevices();
    } catch (e) {
      console.error(`设备管理器初始化失败：${JSON.stringify(e)}`);
    }
  }

  // 扫描鸿蒙智联AI设备
  private scanDevices(): void {
    this.deviceManager?.on('deviceFound', (devices) => {
      // 过滤出AI设备（智能灯、空调）
      const aiDevices = devices.filter((device) => {
        return device.deviceType === 'smart_light' || device.deviceType === 'smart_air_conditioner';
      });

      // 转换为设备状态模型
      this.devices = aiDevices.map((device) => {
        const type: DeviceType = device.deviceType === 'smart_light' ? 'light' : 'air_conditioner';
        return {
          deviceId: device.deviceId,
          type,
          name: device.deviceName,
          status: 'off',
          brightness: type === 'light' ? 50 : undefined,
          temperature: type === 'air_conditioner' ? 25 : undefined
        };
      });

      console.log(`发现${this.devices.length}台AI设备`);
    });

    // 开始扫描
    this.deviceManager?.startDeviceDiscovery({
      filter: { deviceTypes: ['smart_light', 'smart_air_conditioner'] },
      timeout: 10000
    });
  }

  // 控制设备（如打开灯、调节空调温度）
  async controlDevice(deviceId: string, command: Record<string, any>): Promise<boolean> {
    if (!this.deviceManager) return false;

    try {
      // 连接设备并发送控制指令（简化版，实际需调用设备RPC接口）
      const device = this.devices.find((d) => d.deviceId === deviceId);
      if (device) {
        // 更新本地设备状态
        if (command.status) device.status = command.status;
        if (command.brightness) device.brightness = command.brightness;
        if (command.temperature) device.temperature = command.temperature;

        // 发送RPC指令到设备
        const proxy = await this.deviceManager.getDeviceProxy(deviceId);
        await proxy.sendRequest(0, rpc.MessageParcel.create().write(command), rpc.MessageParcel.create(), new rpc.MessageOption());

        return true;
      }
      return false;
    } catch (e) {
      console.error(`设备控制失败：${JSON.stringify(e)}`);
      return false;
    }
  }

  // 获取设备列表
  getDevices(): DeviceStatus[] {
    return this.devices;
  }

  // 释放资源
  destroy(): void {
    this.deviceManager?.stopDeviceDiscovery();
    this.deviceManager = null;
  }
}

4. 原生与 Flutter 通信封装（ArkTS）

通过MethodChannel、EventChannel、BasicMessageChannel实现与 Flutter 的双向通信，处理图像数据、语音指令、设备控制：

// EntryAbility.ts
import Ability from '@ohos.app.ability.UIAbility';
import Window from '@ohos.window';
import { ImageRecognitionModel, RecognitionResult } from './model/ImageRecognitionModel';
import { HarmonyAIDeviceService, DeviceType, DeviceStatus } from './service/HarmonyAIDeviceService';
import { MethodChannel, EventChannel, BasicMessageChannel, MessageCodec } from '@ohos.flutter.engine';

export default class EntryAbility extends Ability {
  private imageRecognitionModel: ImageRecognitionModel = new ImageRecognitionModel();
  private aiDeviceService: HarmonyAIDeviceService = new HarmonyAIDeviceService();
  private imageChannel?: BasicMessageChannel; // 传输图像数据
  private deviceStatusChannel?: EventChannel; // 上报设备状态

  onCreate(want, launchParam) {
    // 初始化AI模型与设备服务
    Promise.all([
      this.imageRecognitionModel.init(),
      this.aiDeviceService.init()
    ]).then(() => {
      console.log('AI能力初始化成功');
    }).catch(err => {
      console.error(`初始化失败：${err.message}`);
    });
  }

  onWindowStageCreate(windowStage: Window.WindowStage) {
    const flutterEngine = this.context.flutterEngine;
    if (flutterEngine) {
      // 1. 图像识别BasicMessageChannel（传输图像二进制数据）
      this.imageChannel = new BasicMessageChannel(flutterEngine.dartExecutor.binaryMessenger, 'com.ai.assistant.image', MessageCodec.BINARY);
      this.imageChannel.setMessageHandler(async (message) => {
        if (message instanceof Uint8Array) {
          // 解析图像数据（包含宽度、高度、像素数据）
          const width = message[0] << 8 | message[1];
          const height = message[2] << 8 | message[3];
          const imageData = message.subarray(4);
          // 执行图像识别
          const result = await this.imageRecognitionModel.recognize(imageData, width, height);
          // 返回识别结果
          return JSON.stringify(result);
        }
        return JSON.stringify({ label: 'error', confidence: 0, suggestion: '图像数据错误' });
      });

      // 2. AI设备控制MethodChannel（Flutter→原生）
      new MethodChannel(flutterEngine.dartExecutor.binaryMessenger, 'com.ai.assistant.device')
        .setMethodCallHandler((call, result) => {
          switch (call.method) {
            case 'controlDevice':
              const deviceId = call.arguments['deviceId'] as string;
              const command = call.arguments['command'] as Record<string, any>;
              this.aiDeviceService.controlDevice(deviceId, command).then((success) => {
                result.success(success);
                // 上报设备状态变化
                this.deviceStatusChannel?.sendEvent(this.aiDeviceService.getDevices());
              }).catch(() => {
                result.error('FAIL', '设备控制失败', null);
              });
              break;
            case 'getDevices':
              result.success(this.aiDeviceService.getDevices());
              break;
            default:
              result.notImplemented();
          }
        });

      // 3. 设备状态EventChannel（原生→Flutter）
      this.deviceStatusChannel = new EventChannel(flutterEngine.dartExecutor.binaryMessenger, 'com.ai.assistant.device.status');
      this.deviceStatusChannel.setStreamHandler({
        onListen(arguments, eventSink) {
          // 初始发送设备列表
          eventSink.success(this.aiDeviceService.getDevices());
        }.bind(this),
        onCancel() {}
      });

      // 4. 语音指令MethodChannel（简化版，实际集成鸿蒙语音服务）
      new MethodChannel(flutterEngine.dartExecutor.binaryMessenger, 'com.ai.assistant.voice')
        .setMethodCallHandler((call, result) => {
          if (call.method === 'recognizeVoice') {
            // 模拟端侧语音识别（实际集成鸿蒙方舟推理框架的语音模型）
            const voiceText = call.arguments['text'] as string;
            // 解析语音指令（如“打开客厅灯”“把空调调到26度”）
            const command = this.parseVoiceCommand(voiceText);
            result.success(command);
          } else {
            result.notImplemented();
          }
        });
    }

    windowStage.loadContent('flutter://entrypoint/default').then(() => {
      windowStage.getMainWindow().then(window => {
        window.setFullScreen(true);
      });
    });
  }

  // 解析语音指令（简化版，实际使用端侧NLP模型）
  private parseVoiceCommand(text: string): Record<string, any> {
    if (text.includes('打开灯') || text.includes('开灯')) {
      return { type: 'light', action: 'on', brightness: 100 };
    } else if (text.includes('关灯')) {
      return { type: 'light', action: 'off' };
    } else if (text.includes('空调') && text.includes('度')) {
      const reg = /(\d{2})/;
      const match = text.match(reg);
      const temp = match ? parseInt(match[1]) : 25;
      return { type: 'air_conditioner', action: 'set_temp', temperature: temp };
    } else {
      return { type: 'unknown' };
    }
  }

  onDestroy() {
    // 释放资源
    this.imageRecognitionModel.destroy();
    this.aiDeviceService.destroy();
  }
}

四、步骤 2：Flutter 层实现 AI 交互界面与逻辑

Flutter 层负责采集图像 / 语音输入、展示 AI 识别结果、控制鸿蒙智联设备，打造统一的智能交互体验。

1. 封装 AI 服务（Dart）

统一封装与原生的通信逻辑，提供简洁的 AI 能力调用接口：

// lib/services/ai_service.dart
import 'dart:typed_data';
import 'package:flutter/services.dart';

// 图像识别结果模型
class RecognitionResult {
  final String label;
  final double confidence;
  final String suggestion;

  RecognitionResult({
    required this.label,
    required this.confidence,
    required this.suggestion,
  });

  factory RecognitionResult.fromJson(Map<String, dynamic> json) {
    return RecognitionResult(
      label: json['label'] as String,
      confidence: (json['confidence'] as num).toDouble(),
      suggestion: json['suggestion'] as String,
    );
  }
}

// 设备状态模型
class DeviceStatus {
  final String deviceId;
  final String type;
  final String name;
  final String status;
  final int? brightness;
  final int? temperature;

  DeviceStatus({
    required this.deviceId,
    required this.type,
    required this.name,
    required this.status,
    this.brightness,
    this.temperature,
  });

  factory DeviceStatus.fromJson(Map<String, dynamic> json) {
    return DeviceStatus(
      deviceId: json['deviceId'] as String,
      type: json['type'] as String,
      name: json['name'] as String,
      status: json['status'] as String,
      brightness: json['brightness'] as int?,
      temperature: json['temperature'] as int?,
    );
  }
}

// AI服务封装
class AIService {
  // 通信通道
  static const _imageChannel = BasicMessageChannel('com.ai.assistant.image', BinaryCodec());
  static const _deviceChannel = MethodChannel('com.ai.assistant.device');
  static const _deviceStatusChannel = EventChannel('com.ai.assistant.device.status');
  static const _voiceChannel = MethodChannel('com.ai.assistant.voice');

  // 图像识别（输入图像数据：宽度、高度、像素数据）
  Future<RecognitionResult> recognizeImage(int width, int height, Uint8List imageData) async {
    // 封装图像数据：前4字节为宽度和高度（各2字节），后续为像素数据
    final Uint8List data = Uint8List(4 + imageData.length);
    data[0] = (width >> 8) & 0xFF;
    data[1] = width & 0xFF;
    data[2] = (height >> 8) & 0xFF;
    data[3] = height & 0xFF;
    data.setRange(4, 4 + imageData.length, imageData);

    // 发送图像数据并接收识别结果
    final String resultJson = await _imageChannel.send(data) as String;
    final Map<String, dynamic> json = Map.castFrom<dynamic, dynamic, String, dynamic>(
      await SystemChannels.textCodec.decodeJSON(resultJson) as Map,
    );
    return RecognitionResult.fromJson(json);
  }

  // 语音指令识别（简化版，实际采集语音数据）
  Future<Map<String, dynamic>> recognizeVoice(String text) async {
    final dynamic result = await _voiceChannel.invokeMethod('recognizeVoice', {'text': text});
    return Map.castFrom<dynamic, dynamic, String, dynamic>(result as Map);
  }

  // 获取鸿蒙智联设备列表
  Future<List<DeviceStatus>> getDevices() async {
    final List<dynamic> result = await _deviceChannel.invokeMethod('getDevices');
    return result.map((e) => DeviceStatus.fromJson(Map.castFrom<dynamic, dynamic, String, dynamic>(e as Map))).toList();
  }

  // 控制AI设备
  Future<bool> controlDevice(String deviceId, Map<String, dynamic> command) async {
    final bool success = await _deviceChannel.invokeMethod('controlDevice', {
      'deviceId': deviceId,
      'command': command,
    });
    return success;
  }

  // 监听设备状态变化
  Stream<List<DeviceStatus>> get deviceStatusStream {
    return _deviceStatusChannel.receiveBroadcastStream().map((data) {
      final List<dynamic> list = data as List;
      return list.map((e) => DeviceStatus.fromJson(Map.castFrom<dynamic, dynamic, String, dynamic>(e as Map))).toList();
    });
  }
}

2. 实现 AI 助手交互界面（Dart）

设计包含图像识别、语音交互、设备控制的一体化界面，支持拍照识别、语音指令、设备联动：

// lib/main.dart
import 'package:flutter/material.dart';
import 'dart:typed_data';
import 'services/ai_service.dart';

void main() {
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: '鸿蒙Flutter智能AI助手',
      theme: ThemeData(
        primarySwatch: Colors.blue,
        visualDensity: VisualDensity.adaptivePlatformDensity,
      ),
      home: const AIAssistantPage(),
      debugShowCheckedModeBanner: false,
    );
  }
}

class AIAssistantPage extends StatefulWidget {
  const AIAssistantPage({super.key});

  @override
  State<AIAssistantPage> createState() => _AIAssistantPageState();
}

class _AIAssistantPageState extends State<AIAssistantPage> {
  final AIService _aiService = AIService();
  RecognitionResult? _recognitionResult;
  List<DeviceStatus> _devices = [];
  final TextEditingController _voiceTextController = TextEditingController();
  String _voiceHint = "请输入语音指令（如“打开客厅灯”）";

  @override
  void initState() {
    super.initState();
    // 初始化设备列表
    _loadDevices();
    // 监听设备状态变化
    _aiService.deviceStatusStream.listen((devices) {
      setState(() => _devices = devices);
    });
  }

  // 加载鸿蒙智联设备列表
  Future<void> _loadDevices() async {
    final devices = await _aiService.getDevices();
    setState(() => _devices = devices);
  }

  // 模拟拍照识别（实际项目集成camera插件）
  Future<void> _takePhotoAndRecognize() async {
    // 模拟图像数据（宽度224，高度224，像素数据为随机值）
    const int width = 224;
    const int height = 224;
    final Uint8List imageData = Uint8List(width * height * 3);
    // 执行图像识别
    final result = await _aiService.recognizeImage(width, height, imageData);
    setState(() => _recognitionResult = result);
  }

  // 处理语音指令
  Future<void> _handleVoiceCommand() async {
    final text = _voiceTextController.text.trim();
    if (text.isEmpty) return;

    // 语音指令识别
    final command = await _aiService.recognizeVoice(text);
    setState(() {
      switch (command['type']) {
        case 'light':
          // 控制第一个智能灯
          final light = _devices.firstWhere((d) => d.type == 'light', orElse: () => DeviceStatus(
            deviceId: '',
            type: 'light',
            name: '默认灯',
            status: 'off',
          ));
          if (light.deviceId.isNotEmpty) {
            _aiService.controlDevice(light.deviceId, {
              'status': command['action'] == 'on' ? 'on' : 'off',
              'brightness': command['brightness'] ?? light.brightness,
            });
            _voiceHint = command['action'] == 'on' ? '已打开智能灯' : '已关闭智能灯';
          } else {
            _voiceHint = '未找到智能灯设备';
          }
          break;
        case 'air_conditioner':
          // 控制第一个智能空调
          final ac = _devices.firstWhere((d) => d.type == 'air_conditioner', orElse: () => DeviceStatus(
            deviceId: '',
            type: 'air_conditioner',
            name: '默认空调',
            status: 'off',
          ));
          if (ac.deviceId.isNotEmpty) {
            _aiService.controlDevice(ac.deviceId, {
              'status': 'on',
              'temperature': command['temperature'] ?? ac.temperature,
            });
            _voiceHint = '已将空调温度设置为${command['temperature']}℃';
          } else {
            _voiceHint = '未找到智能空调设备';
          }
          break;
        default:
          _voiceHint = '未识别的指令，请重试';
      }
    });
    _voiceTextController.clear();
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('鸿蒙Flutter智能AI助手'),
        centerTitle: true,
      ),
      body: SingleChildScrollView(
        padding: const EdgeInsets.all(24.0),
        child: Column(
          crossAxisAlignment: CrossAxisAlignment.stretch,
          children: [
            // 图像识别区域
            Card(
              elevation: 4,
              child: Padding(
                padding: const EdgeInsets.all(20.0),
                child: Column(
                  children: [
                    const Text(
                      '端侧图像识别',
                      style: TextStyle(fontSize: 20, fontWeight: FontWeight.bold),
                    ),
                    const SizedBox(height: 20),
                    ElevatedButton(
                      onPressed: _takePhotoAndRecognize,
                      child: const Text('拍照识别（模拟）'),
                    ),
                    const SizedBox(height: 20),
                    if (_recognitionResult != null)
                      Column(
                        children: [
                          Text(
                            '识别结果：${_recognitionResult!.label}',
                            style: const TextStyle(fontSize: 18),
                          ),
                          const SizedBox(height: 10),
                          Text(
                            '置信度：${(_recognitionResult!.confidence * 100).toStringAsFixed(1)}%',
                            style: const TextStyle(fontSize: 16, color: Colors.grey),
                          ),
                          const SizedBox(height: 10),
                          Text(
                            '智能建议：${_recognitionResult!.suggestion}',
                            style: const TextStyle(fontSize: 16, color: Colors.blue),
                          ),
                        ],
                      ),
                  ],
                ),
              ),
            ),
            const SizedBox(height: 30),

            // 语音交互区域
            Card(
              elevation: 4,
              child: Padding(
                padding: const EdgeInsets.all(20.0),
                child: Column(
                  children: [
                    const Text(
                      '端侧语音交互',
                      style: TextStyle(fontSize: 20, fontWeight: FontWeight.bold),
                    ),
                    const SizedBox(height: 20),
                    TextField(
                      controller: _voiceTextController,
                      decoration: const InputDecoration(
                        hintText: '输入语音指令（如“打开客厅灯”）',
                        border: OutlineInputBorder(),
                      ),
                    ),
                    const SizedBox(height: 10),
                    ElevatedButton(
                      onPressed: _handleVoiceCommand,
                      child: const Text('执行指令'),
                    ),
                    const SizedBox(height: 10),
                    Text(
                      _voiceHint,
                      style: const TextStyle(fontSize: 16, color: Colors.green),
                    ),
                  ],
                ),
              ),
            ),
            const SizedBox(height: 30),

            // 鸿蒙智联设备控制区域
            Card(
              elevation: 4,
              child: Padding(
                padding: const EdgeInsets.all(20.0),
                child: Column(
                  children: [
                    const Text(
                      '鸿蒙智联AI设备控制',
                      style: TextStyle(fontSize: 20, fontWeight: FontWeight.bold),
                    ),
                    const SizedBox(height: 20),
                    if (_devices.isEmpty)
                      const Text('未发现鸿蒙智联AI设备')
                    else
                      Column(
                        children: _devices.map((device) {
                          return ListTile(
                            title: Text(device.name),
                            subtitle: Text('类型：${device.type == 'light' ? '智能灯' : '智能空调'} | 状态：${device.status}'),
                            trailing: Row(
                              mainAxisSize: MainAxisSize.min,
                              children: [
                                if (device.type == 'light')
                                  ElevatedButton(
                                    onPressed: () => _aiService.controlDevice(device.deviceId, {
                                      'status': device.status == 'on' ? 'off' : 'on',
                                      'brightness': device.brightness,
                                    }),
                                    child: Text(device.status == 'on' ? '关闭' : '打开'),
                                  ),
                                if (device.type == 'air_conditioner')
                                  ElevatedButton(
                                    onPressed: () => _aiService.controlDevice(device.deviceId, {
                                      'status': 'on',
                                      'temperature': device.temperature! + 1,
                                    }),
                                    child: const Text('升温'),
                                  ),
                              ],
                            ),
                          );
                        }).toList(),
                      ),
                  ],
                ),
              ),
            ),
          ],
        ),
      ),
    );
  }
}

五、案例说明与关键优化

1. 核心功能实现

• 端侧图像识别：Flutter 模拟采集图像数据，通过BasicMessageChannel传输至原生层，原生层利用 MindSpore Lite 加载 ResNet18 模型实现端侧推理，识别结果返回 Flutter 展示；
• 端侧语音交互：Flutter 输入语音指令文本，原生层解析指令并触发设备控制，无需联网即可完成本地语音处理；
• 鸿蒙智联设备控制：Flutter 获取设备列表并展示状态，用户可通过按钮或语音指令控制智能灯、空调，设备状态变化实时同步；
• 统一交互体验：整合图像识别、语音交互、设备控制的界面，提供一体化的 AI 助手体验。

2. 端侧 AI 优化要点

• 模型轻量化：使用量化后的轻量级 AI 模型（如 INT8 量化的 ResNet18），减少模型体积与推理时间；
• 硬件加速：优先使用鸿蒙设备的 NPU 进行模型推理，无 NPU 时自动降级为 CPU，提升推理速度；
• 数据传输优化：图像数据采用二进制格式传输，减少 JSON 序列化开销，提升传输效率；
• 资源管理：原生层在应用销毁时释放 AI 模型与设备管理器资源，避免内存泄漏。

六、扩展场景与进阶建议

1. 端侧语音唤醒：集成鸿蒙端侧语音唤醒引擎，实现 “小艺小艺” 自定义唤醒词唤醒 AI 助手；
2. 多模态 AI 交互：结合语音、图像、手势输入，实现更自然的智能交互（如拍照后语音询问 “这是什么？”）；
3. 分布式 AI 推理：利用鸿蒙分布式能力，将复杂 AI 推理任务分发至算力更强的鸿蒙设备（如智慧屏、平板），推理结果返回手机端展示；
4. AI 场景化推荐：结合用户行为数据与鸿蒙场景感知能力，实现个性化智能推荐（如到家自动打开灯、睡前自动调节空调温度）；
5. 鸿蒙 AI 开发平台集成：接入鸿蒙 AI 开发平台，使用平台提供的模型训练、部署能力，快速迭代 AI 模型。

七、总结

本文通过智能 AI 助手应用案例，完整演示了鸿蒙 Flutter 集成端侧 AI 能力、鸿蒙智联智能服务的开发流程。核心在于将鸿蒙原生的端侧 AI 推理、智能设备互联能力作为底层支撑，通过高效的通信通道与 Flutter 层的交互界面结合，既发挥了鸿蒙端侧 AI 的低延迟、高安全性优势，又利用了 Flutter 跨端开发的效率优势。

随着鸿蒙系统端侧 AI 能力的不断增强，以及 Flutter 对 AI 交互界面的良好支持，这种融合开发模式将成为鸿蒙生态智能应用开发的主流方向。开发者可基于本文思路，进一步探索 AIoT 设备控制、智能视觉交互、个性化推荐等更多场景，打造具备核心竞争力的鸿蒙智能应用

欢迎大家加入[开源鸿蒙跨平台开发者社区](https://openharmonycrossplatform.csdn.net)，一起共建开源鸿蒙跨平台生态。