OpenHarmony Flutter 原子化服务开发实战：轻量、跨端、分布式的全场景落地

引言：原子化服务 ------ 开源鸿蒙生态的 "轻量革命"

当用户无需安装 App，即可通过智慧屏快捷卡片编辑文档、通过车机桌面图标发起跨设备导航、通过手表组件同步健康数据 ------ 开源鸿蒙（OpenHarmony）的原子化服务正在重构全场景应用的形态。这种 "免安装、快启动、可组合" 的轻量应用形态，与 Flutter 的跨端高效开发特性天然契合，成为打通多设备场景的关键载体。

原子化服务并非传统 App 的 "精简版"，而是基于鸿蒙 Ability 框架的全新应用形态，核心在于 "以用户场景为中心" 的能力拆分与组合。本文以 "场景化落地" 为核心，跳出 "单一设备原子化服务" 的局限，聚焦 "Flutter 跨端原子化服务 + 鸿蒙分布式能力" 的深度融合，通过 "跨设备快捷卡片、可组合服务组件、分布式协同原子化服务" 三大创新场景，用 "原理 + 架构设计 + 核心代码" 的方式，带你掌握开源鸿蒙 Flutter 原子化服务的全流程开发，实现 "一次开发、多设备部署、分布式协同" 的全场景价值。

一、原子化服务核心原理与技术架构

1.1 核心定义与核心价值

原子化服务是开源鸿蒙基于 Ability 框架提供的轻量级应用形态，以 "AbilitySlice" 为最小功能单元，支持免安装部署、秒级启动、跨设备流转，核心价值：

轻量便捷：无需安装，通过桌面卡片、二维码、设备分享等方式快速启动，降低用户使用门槛；
跨端适配：基于 Flutter 的跨端特性，一次开发即可适配手机、平板、智慧屏、车机等多设备；
分布式协同：依托鸿蒙分布式软总线、分布式存储，实现原子化服务跨设备能力调用与数据同步；
可组合性：多个原子化服务可通过鸿蒙 "服务卡片" 组合呈现，满足复杂场景需求（如 "导航 + 音乐 + 天气" 车机组合服务）。

1.2 原子化服务与传统 App 的核心差异

特性	原子化服务	传统 App
部署方式	免安装，通过鸿蒙应用市场或分布式分享部署	需下载安装，占用设备存储
启动速度	秒级启动（预加载核心资源）	启动较慢（需初始化完整应用）
功能形态	单一核心功能（如文档编辑、导航、支付）	多功能集成（如社交 + 支付 + 内容）
跨设备能力	原生支持分布式流转，可跨设备无缝切换	需额外开发跨设备同步功能
呈现形式	服务卡片 + 全屏页面，支持组合展示	仅全屏页面，独立呈现

1.3 核心技术架构："Flutter 跨端层 + 鸿蒙原子化服务层 + 分布式能力层"

已生成代码

Flutter 跨端层：负责原子化服务的 UI 渲染、核心业务逻辑开发，通过 Flutter 的多设备适配能力，确保服务在不同设备上的体验一致性；
鸿蒙原子化服务层：提供 AbilitySlice 容器、服务卡片管理、生命周期调度等核心能力，是原子化服务的 "运行载体"；
分布式能力层：依托鸿蒙分布式技术，实现原子化服务的跨设备发现、流转、数据同步，打破设备壁垒。

二、实战 1：跨设备服务卡片 ------Flutter 驱动的轻量交互入口

2.1 核心场景：智慧屏 + 手机跨设备服务卡片协同

用户在智慧屏桌面添加 "家庭相册" 原子化服务卡片，通过卡片快速查看手机同步的照片；在手机上更新相册后，智慧屏卡片实时刷新，无需打开完整应用，实现 "轻量交互 + 分布式同步"。

2.2 核心实现步骤

步骤 1：鸿蒙原子化服务配置（config.json）

json

复制代码

{
  "app": {
    "bundleName": "com.example.atomic.album",
    "versionName": "1.0.0",
    "versionCode": 1000000,
    "minAPIVersion": 9
  },
  "module": {
    "package": "com.example.atomic.album",
    "name": ".AtomicAlbumModule",
    "mainAbility": "com.example.atomic.album.MainAbility",
    "deviceTypes": ["phone", "tv", "tablet"], // 支持多设备
    "abilities": [
      {
        "name": "com.example.atomic.album.AlbumAbility",
        "type": "service", // 原子化服务类型（service能力）
        "visible": true,
        "exported": true, // 允许跨设备调用
        "skills": [
          {
            "entities": ["entity.system.service"],
            "actions": ["action.system.homecard"] // 支持服务卡片
          }
        ],
        "card": {
          "defaultSize": "2*2", // 卡片默认尺寸（2x2网格）
          "supportSizes": ["1*1", "2*2", "2*4"], // 支持的尺寸
          "type": "static" // 静态卡片（Flutter驱动刷新）
        }
      }
    ]
  }
}

步骤 2：Flutter 服务卡片 UI 开发

dart

复制代码

// album_card.dart（Flutter服务卡片UI）
import 'package:flutter/material.dart';

class AlbumServiceCard extends StatelessWidget {
  final List<String> photoUrls; // 分布式同步的照片URL列表

  const AlbumServiceCard({super.key, required this.photoUrls});

  @override
  Widget build(BuildContext context) {
    // 根据设备类型适配卡片布局（智慧屏横向、手机纵向）
    bool isTV = MediaQuery.of(context).size.width > 600;
    return Container(
      decoration: BoxDecoration(
        borderRadius: BorderRadius.circular(16),
        color: Colors.white,
        boxShadow: [BoxShadow(color: Colors.grey.withOpacity(0.3), blurRadius: 8)],
      ),
      child: Column(
        mainAxisAlignment: MainAxisAlignment.center,
        children: [
          const Text("家庭相册", style: TextStyle(fontSize: 18, fontWeight: FontWeight.bold)),
          const SizedBox(height: 10),
          // 照片网格（根据卡片尺寸适配）
          Expanded(
            child: GridView.count(
              crossAxisCount: isTV ? 2 : 1,
              padding: const EdgeInsets.all(8),
              children: photoUrls.take(isTV ? 4 : 2).map((url) {
                return ClipRRect(
                  borderRadius: BorderRadius.circular(8),
                  child: Image.network(url, fit: BoxFit.cover),
                );
              }).toList(),
            ),
          ),
        ],
      ),
    );
  }
}

步骤 3：Flutter 与鸿蒙原生卡片通信（数据同步）

java

复制代码

// AlbumCardProvider.java（鸿蒙原生卡片数据提供器）
import ohos.aafwk.ability.Ability;
import ohos.aafwk.ability.ServiceAbility;
import ohos.aafwk.content.Intent;
import ohos.agp.components.Component;
import ohos.agp.components.LayoutScatter;
import io.flutter.embedding.android.FlutterView;
import io.flutter.embedding.engine.FlutterEngine;
import io.flutter.embedding.engine.dart.DartExecutor;
import io.flutter.plugin.common.MethodChannel;

public class AlbumAbility extends ServiceAbility {
    private FlutterEngine flutterEngine;
    private MethodChannel channel;
    private String cardData; // 卡片数据（照片URL列表JSON）

    @Override
    public void onStart(Intent intent) {
        super.onStart(intent);
        initFlutterEngine();
        // 从分布式存储获取照片数据
        loadDistributedPhotoData();
        // 刷新卡片
        refreshCard();
    }

    // 初始化FlutterEngine
    private void initFlutterEngine() {
        flutterEngine = new FlutterEngine(this);
        flutterEngine.getDartExecutor().executeDartEntrypoint(
            DartExecutor.DartEntrypoint.createDefault()
        );
        // 注册方法通道（原生→Flutter传递数据）
        channel = new MethodChannel(flutterEngine.getDartExecutor().getBinaryMessenger(), "com.example.atomic/album");
    }

    // 从分布式存储加载照片数据
    private void loadDistributedPhotoData() {
        // 模拟从分布式KV存储获取数据
        cardData = "[\"https://example.com/photo1.jpg\", \"https://example.com/photo2.jpg\"]";
        // 监听分布式数据变化，实时更新卡片
        DistributedKVStore.listenDataChange("family_album_photos", (key, value) -> {
            cardData = value;
            refreshCard();
        });
    }

    // 刷新服务卡片
    private void refreshCard() {
        channel.invokeMethod("updateCardData", cardData, result -> {
            if (result.success()) {
                // 通知鸿蒙系统刷新卡片
                notifyCardUpdate();
            }
        });
    }

    // 通知卡片更新
    private void notifyCardUpdate() {
        Intent intent = new Intent();
        intent.setParam("cardName", "AlbumCard");
        intent.setParam("cardData", cardData);
        sendCardUpdateIntent(intent);
    }

    @Override
    public void onStop() {
        super.onStop();
        flutterEngine.destroy();
    }
}

步骤 4：Flutter 接收数据并更新卡片

dart

复制代码

// main.dart（Flutter入口）
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'album_card.dart';

void main() => runApp(const MyApp());

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

  @override
  State<MyApp> createState() => _MyAppState();
}

class _MyAppState extends State<MyApp> {
  List<String> _photoUrls = [];

  @override
  void initState() {
    super.initState();
    _initMethodChannel();
  }

  // 初始化方法通道，接收原生数据
  void _initMethodChannel() {
    MethodChannel channel = MethodChannel("com.example.atomic/album");
    channel.setMethodCallHandler((call) async {
      if (call.method == "updateCardData") {
        String data = call.arguments as String;
        setState(() {
          _photoUrls = List<String>.from(jsonDecode(data));
        });
        return true;
      }
      return false;
    });
  }

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        body: AlbumServiceCard(photoUrls: _photoUrls),
      ),
    );
  }
}

三、实战 2：可组合原子化服务 ------Flutter 组件化驱动的功能拼接

3.1 核心场景：车机 "出行组合服务"

用户在车机上组合 "导航原子化服务""音乐原子化服务""天气原子化服务"，通过一个统一的 Flutter 交互面板控制所有服务：导航实时显示路线，音乐自动适配驾驶场景播放，天气预警同步展示在导航界面，实现 "多服务组合 + 场景化联动"。

3.2 核心实现步骤

步骤 1：Flutter 组件化拆分（独立原子化服务组件）

dart

复制代码

// 导航服务组件（navigation_service.dart）
class NavigationServiceWidget extends StatelessWidget {
  final String destination;
  final Function(String) onRouteUpdate;

  const NavigationServiceWidget({super.key, required this.destination, required this.onRouteUpdate});

  @override
  Widget build(BuildContext context) {
    return Container(
      padding: const EdgeInsets.all(16),
      child: Column(
        children: [
          const Text("导航服务", style: TextStyle(fontSize: 16, fontWeight: FontWeight.bold)),
          const SizedBox(height: 10),
          Text("目的地：$destination"),
          const SizedBox(height: 10),
          ElevatedButton(
            onPressed: () => onRouteUpdate("已规划路线：家 → 公司（15分钟）"),
            child: const Text("开始导航"),
          ),
        ],
      ),
    );
  }
}

// 音乐服务组件（music_service.dart）
class MusicServiceWidget extends StatelessWidget {
  final String currentSong;
  final Function() onPlayPause;

  const MusicServiceWidget({super.key, required this.currentSong, required this.onPlayPause});

  @override
  Widget build(BuildContext context) {
    return Container(
      padding: const EdgeInsets.all(16),
      child: Column(
        children: [
          const Text("音乐服务", style: TextStyle(fontSize: 16, fontWeight: FontWeight.bold)),
          const SizedBox(height: 10),
          Text("当前播放：$currentSong"),
          const SizedBox(height: 10),
          ElevatedButton(
            onPressed: onPlayPause,
            child: const Text("暂停/播放"),
          ),
        ],
      ),
    );
  }
}

// 天气服务组件（weather_service.dart）
class WeatherServiceWidget extends StatelessWidget {
  final String weatherInfo;

  const WeatherServiceWidget({super.key, required this.weatherInfo});

  @override
  Widget build(BuildContext context) {
    return Container(
      padding: const EdgeInsets.all(16),
      child: Column(
        children: [
          const Text("天气服务", style: TextStyle(fontSize: 16, fontWeight: FontWeight.bold)),
          const SizedBox(height: 10),
          Text(weatherInfo),
        ],
      ),
    );
  }
}

步骤 2：组合服务页面（Flutter 驱动的服务联动）

dart

复制代码

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

  @override
  State<CombinedTravelServicePage> createState() => _CombinedTravelServicePageState();
}

class _CombinedTravelServicePageState extends State<CombinedTravelServicePage> {
  String _routeInfo = "未规划路线";
  String _currentSong = "《驾驶伴侣》";
  String _weatherInfo = "晴 25℃ 适合出行";
  bool _isMusicPlaying = true;

  // 导航路线更新时，联动音乐服务（如高速路段切换为轻音乐）
  void _onRouteUpdate(String routeInfo) {
    setState(() {
      _routeInfo = routeInfo;
      if (routeInfo.contains("高速")) {
        _currentSong = "《轻音乐合集》";
      }
    });
  }

  // 音乐播放/暂停切换
  void _toggleMusicPlay() {
    setState(() => _isMusicPlaying = !_isMusicPlaying);
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: const Text("出行组合服务")),
      body: SingleChildScrollView(
        child: Padding(
          padding: const EdgeInsets.all(16.0),
          child: Column(
            children: [
              // 导航服务组件
              NavigationServiceWidget(
                destination: "公司",
                onRouteUpdate: _onRouteUpdate,
              ),
              const Divider(height: 20),
              // 音乐服务组件
              MusicServiceWidget(
                currentSong: _currentSong,
                onPlayPause: _toggleMusicPlay,
              ),
              const Divider(height: 20),
              // 天气服务组件
              WeatherServiceWidget(weatherInfo: _weatherInfo),
            ],
          ),
        ),
      ),
    );
  }
}

步骤 3：鸿蒙原生服务组合配置

java

复制代码

// CombinedServiceAbility.java（组合服务Ability）
import ohos.aafwk.ability.ServiceAbility;
import ohos.aafwk.content.Intent;
import io.flutter.embedding.engine.FlutterEngine;
import io.flutter.embedding.engine.dart.DartExecutor;

public class CombinedServiceAbility extends ServiceAbility {
    private FlutterEngine flutterEngine;

    @Override
    public void onStart(Intent intent) {
        super.onStart(intent);
        // 初始化FlutterEngine，加载组合服务页面
        flutterEngine = new FlutterEngine(this);
        flutterEngine.getDartExecutor().executeDartEntrypoint(
            new DartExecutor.DartEntrypoint("lib/main.dart", "combined_service_main")
        );
        // 嵌入Flutter页面到原生Ability
        FlutterView flutterView = new FlutterView(this);
        flutterView.attachToFlutterEngine(flutterEngine);
        setUIContent(flutterView);
    }

    @Override
    public void onStop() {
        super.onStop();
        flutterEngine.destroy();
    }
}

四、实战 3：分布式协同原子化服务 ------ 跨设备能力流转

4.1 核心场景：手机→平板→智慧屏文档编辑原子化服务

用户在手机上通过 "文档编辑" 原子化服务创建文档，编辑过程中通过分布式流转功能将服务 "迁移" 到平板，利用平板手写笔进行精细编辑；编辑完成后，再流转到智慧屏，通过智慧屏的大屏优势进行展示和分享，整个过程数据实时同步，服务状态无缝衔接。

4.2 核心实现步骤

步骤 1：分布式流转能力封装（Flutter 端）

dart

复制代码

// distributed_flow_util.dart（分布式流转工具类）
import 'package:flutter/services.dart';

class DistributedFlowUtil {
  static const MethodChannel _channel = MethodChannel("com.example.atomic/distributed_flow");

  // 发起跨设备流转
  static Future<bool> startFlowToDevice(String deviceId) async {
    try {
      return await _channel.invokeMethod<bool>("startFlow", {"deviceId": deviceId}) ?? false;
    } on PlatformException catch (e) {
      print("流转失败：${e.message}");
      return false;
    }
  }

  // 监听流转状态（接收其他设备的流转请求）
  static void listenFlowStatus(void Function(String deviceId, String documentData) onFlowReceived) {
    _channel.setMethodCallHandler((call) async {
      if (call.method == "onFlowReceived") {
        String deviceId = call.arguments["deviceId"];
        String documentData = call.arguments["documentData"];
        onFlowReceived(deviceId, documentData);
      }
    });
  }

  // 同步文档数据到目标设备
  static Future<bool> syncDocumentData(String deviceId, String documentData) async {
    try {
      return await _channel.invokeMethod<bool>("syncData", {
        "deviceId": deviceId,
        "documentData": documentData
      }) ?? false;
    } on PlatformException catch (e) {
      print("同步失败：${e.message}");
      return false;
    }
  }
}

步骤 2：文档编辑原子化服务页面（支持流转与同步）

dart

复制代码

class DocumentEditServicePage extends StatefulWidget {
  final String? initData; // 流转时接收的初始化数据

  const DocumentEditServicePage({super.key, this.initData});

  @override
  State<DocumentEditServicePage> createState() => _DocumentEditServicePageState();
}

class _DocumentEditServicePageState extends State<DocumentEditServicePage> {
  final TextEditingController _controller = TextEditingController();
  List<SoftBusUtil.DeviceInfo> _deviceList = [];
  bool _isScanning = false;

  @override
  void initState() {
    super.initState();
    // 初始化文档数据（如果是流转过来的服务）
    if (widget.initData != null) {
      _controller.text = widget.initData!;
    }
    // 监听流转请求
    DistributedFlowUtil.listenFlowStatus((deviceId, documentData) {
      setState(() => _controller.text = documentData);
      ScaffoldMessenger.of(context).showSnackBar(
        SnackBar(content: Text("已接收来自设备$deviceId的文档数据")),
      );
    });
  }

  // 扫描可流转设备
  Future<void> _scanDevices() async {
    setState(() => _isScanning = true);
    _deviceList = await SoftBusUtil.startDeviceDiscovery();
    setState(() => _isScanning = false);
  }

  // 流转服务到目标设备
  Future<void> _flowToDevice(SoftBusUtil.DeviceInfo device) async {
    bool success = await DistributedFlowUtil.startFlowToDevice(device.deviceId);
    if (success) {
      // 同步当前文档数据
      await DistributedFlowUtil.syncDocumentData(device.deviceId, _controller.text);
      ScaffoldMessenger.of(context).showSnackBar(
        SnackBar(content: Text("已流转到${device.deviceName}")),
      );
    } else {
      ScaffoldMessenger.of(context).showSnackBar(
        const SnackBar(content: Text("流转失败")),
      );
    }
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text("文档编辑原子化服务"),
        actions: [
          IconButton(
            icon: const Icon(Icons.share),
            onPressed: _scanDevices,
            tooltip: "跨设备流转",
          ),
        ],
      ),
      body: Column(
        children: [
          Expanded(
            child: TextField(
              controller: _controller,
              expands: true,
              maxLines: null,
              decoration: const InputDecoration(
                padding: EdgeInsets.all(16),
                hintText: "输入文档内容...",
                border: InputBorder.none,
              ),
            ),
          ),
          // 可流转设备列表
          if (_isScanning)
            const LinearProgressIndicator()
          else if (_deviceList.isNotEmpty)
            SizedBox(
              height: 80,
              child: ListView.builder(
                scrollDirection: Axis.horizontal,
                itemCount: _deviceList.length,
                itemBuilder: (context, index) {
                  SoftBusUtil.DeviceInfo device = _deviceList[index];
                  return Padding(
                    padding: const EdgeInsets.all(8.0),
                    child: Column(
                      children: [
                        IconButton(
                          icon: const Icon(Icons.device_hub, size: 30),
                          onPressed: () => _flowToDevice(device),
                        ),
                        Text(device.deviceName),
                      ],
                    ),
                  );
                },
              ),
            ),
        ],
      ),
    );
  }
}

步骤 3：鸿蒙原生流转能力实现（Java）

java

复制代码

// DistributedFlowManager.java（分布式流转管理）
import ohos.distributedschedule.interwork.DeviceInfo;
import ohos.distributedschedule.interwork.IDistributedFlow;
import ohos.distributedschedule.interwork.IDistributedFlowCallback;
import ohos.rpc.RemoteException;

public class DistributedFlowManager {
    private IDistributedFlow distributedFlow;

    public DistributedFlowManager() {
        distributedFlow = IDistributedFlow.getDistributedFlow();
    }

    // 发起流转
    public boolean startFlow(String deviceId, String documentData) {
        try {
            distributedFlow.startFlow(deviceId, "com.example.atomic.document", new IDistributedFlowCallback() {
                @Override
                public void onFlowResult(int resultCode) throws RemoteException {
                    // 流转结果回调
                }
            });
            // 同步文档数据到目标设备
            syncDocumentData(deviceId, documentData);
            return true;
        } catch (RemoteException e) {
            e.printStackTrace();
            return false;
        }
    }

    // 同步文档数据
    private void syncDocumentData(String deviceId, String data) {
        // 通过分布式软总线发送数据
        DistributedSoftBusManager.getInstance().sendData(deviceId, data);
    }

    // 接收流转请求
    public void registerFlowReceiver(OnFlowReceivedListener listener) {
        distributedFlow.setFlowReceiver((deviceId, abilityName, data) -> {
            if (abilityName.equals("com.example.atomic.document")) {
                listener.onReceived(deviceId, data);
            }
        });
    }

    public interface OnFlowReceivedListener {
        void onReceived(String deviceId, String data);
    }
}

五、原子化服务性能优化与最佳实践

5.1 性能优化核心技巧

资源轻量化：Flutter 端仅打包核心资源（图片、字体），非关键资源通过云端加载，减小服务体积；
预加载策略：针对高频使用的原子化服务，在设备启动时预加载 FlutterEngine 和核心资源，提升启动速度；
数据同步节流：分布式数据同步采用 "批量 + 延迟" 策略（如文档编辑每 2 秒同步一次），减少通信开销；
生命周期优化：服务退到后台时释放非关键资源（如图片缓存），前台激活时快速恢复，降低功耗。

5.2 最佳实践

功能拆分原则：原子化服务聚焦单一核心功能，复杂场景通过多服务组合实现，避免 "大而全"；
设备适配策略：通过 Flutter 的 MediaQuery、LayoutBuilder 等组件，针对不同设备（手机、平板、智慧屏）的屏幕尺寸、交互方式进行差异化适配；
安全防护：跨设备流转时通过鸿蒙分布式身份认证，确保服务调用的安全性；敏感数据（如文档内容）传输时加密；
服务发现优化：通过鸿蒙设备类型过滤（如车机服务仅显示车机设备），减少无效设备展示，提升用户体验。

六、常见问题（FAQ）

Q1：原子化服务启动速度慢如何优化？

A1：1. 减小 Flutter 包体积（混淆代码、压缩资源、按需加载）；2. 预加载 FlutterEngine（应用启动时初始化全局 Engine）；3. 采用 "冷启动 + 热启动" 分级策略，核心服务预加载，非核心服务按需启动。

Q2：跨设备流转时数据同步丢失怎么办？

A2：1. 流转前先同步核心数据，确认数据同步成功后再发起流转；2. 实现数据同步重试机制（重试 3 次失败后提示用户）；3. 本地缓存数据，流转失败时可从本地恢复。

Q3：原子化服务如何实现多设备适配？

A3：1. 采用 Flutter 的响应式布局（如 Flex、GridLayout），适配不同屏幕尺寸；2. 根据设备类型（通过 MethodChannel 获取）动态调整 UI 布局和交互方式（如智慧屏增加遥控器操作支持）；3. 遵循鸿蒙原子化服务的设计规范，确保服务卡片在不同设备上的展示一致性。

结语：原子化服务 ------ 开源鸿蒙全场景生态的未来

原子化服务正在改变用户与应用的交互方式，而 Flutter 的跨端优势则为原子化服务的多设备落地提供了高效解决方案。通过本文的三大实战场景，你已掌握跨设备服务卡片、可组合服务、分布式协同原子化服务的核心开发方案，能够灵活应对不同全场景需求。

在开源鸿蒙生态中，原子化服务不仅是 "轻量应用"，更是 "分布式能力的载体"------ 它让应用突破了安装、设备的限制，实现了 "按需调用、跨端流转、组合使用" 的全新体验。未来，随着开源鸿蒙生态的持续完善，原子化服务将与 AI、AR/VR 等技术深度融合，衍生出更多创新场景（如 AI 驱动的智能推荐服务、AR 增强现实服务），成为全场景智慧生活的核心入口。

https://openharmonycrossplatform.csdn.net/content