项目概述

日期时间处理是现代应用开发中的基础功能。无论是在事件记录、时间计算、日程管理还是时区转换中，都需要进行日期和时间的处理。然而，不同的编程语言和平台对日期时间的实现方式各不相同，这导致开发者需要在不同平台上重复编写类似的逻辑。

本文介绍一个基于 Kotlin Multiplatform (KMP) 和 OpenHarmony 平台的日期时间库示例。这个库提供了一套完整的日期时间处理能力，包括日期格式化、时间计算、时区转换等功能。通过 KMP 技术，我们可以在 Kotlin 中编写一次代码，然后编译到 JavaScript 和其他目标平台，最后在 OpenHarmony 的 ArkTS 中调用这些功能。

技术架构

多平台支持

• Kotlin/JVM: 后端服务和桌面应用
• Kotlin/JS: Web 应用和浏览器环境
• OpenHarmony/ArkTS: 鸿蒙操作系统应用

核心功能模块

1. 日期格式化: 将日期转换为指定格式的字符串
2. 日期解析: 将字符串解析为日期对象
3. 时间计算: 计算两个日期之间的差异
4. 时区转换: 在不同时区之间转换
5. 日期算术: 对日期进行加减运算
6. 时间戳处理: 处理 Unix 时间戳
7. 日期验证: 验证日期的有效性
8. 日期比较: 比较两个日期的大小

Kotlin 实现

核心日期时间类

// 文件: src/commonMain/kotlin/DateTimeUtils.kt

/**
 * 日期时间工具类
 * 提供日期格式化、计算等功能
 */
class DateTimeUtils {
    
    data class DateTime(
        val year: Int,
        val month: Int,
        val day: Int,
        val hour: Int = 0,
        val minute: Int = 0,
        val second: Int = 0
    )
    
    data class DateRange(
        val startDate: DateTime,
        val endDate: DateTime,
        val days: Int = 0,
        val hours: Int = 0,
        val minutes: Int = 0
    )
    
    /**
     * 获取当前日期时间
     * @return 当前日期时间
     */
    fun getCurrentDateTime(): DateTime {
        val now = System.currentTimeMillis()
        val calendar = getCalendarFromTimestamp(now)
        
        return DateTime(
            year = calendar["year"] as Int,
            month = calendar["month"] as Int,
            day = calendar["day"] as Int,
            hour = calendar["hour"] as Int,
            minute = calendar["minute"] as Int,
            second = calendar["second"] as Int
        )
    }
    
    /**
     * 格式化日期
     * @param dateTime 日期时间对象
     * @param format 格式字符串
     * @return 格式化后的字符串
     */
    fun formatDate(dateTime: DateTime, format: String = "yyyy-MM-dd"): String {
        return when (format) {
            "yyyy-MM-dd" -> String.format("%04d-%02d-%02d", dateTime.year, dateTime.month, dateTime.day)
            "yyyy-MM-dd HH:mm:ss" -> String.format(
                "%04d-%02d-%02d %02d:%02d:%02d",
                dateTime.year, dateTime.month, dateTime.day,
                dateTime.hour, dateTime.minute, dateTime.second
            )
            "MM/dd/yyyy" -> String.format("%02d/%02d/%04d", dateTime.month, dateTime.day, dateTime.year)
            "dd-MM-yyyy" -> String.format("%02d-%02d-%04d", dateTime.day, dateTime.month, dateTime.year)
            "yyyy年MM月dd日" -> String.format("%04d年%02d月%02d日", dateTime.year, dateTime.month, dateTime.day)
            else -> String.format("%04d-%02d-%02d", dateTime.year, dateTime.month, dateTime.day)
        }
    }
    
    /**
     * 解析日期字符串
     * @param dateString 日期字符串
     * @param format 格式字符串
     * @return 解析后的日期时间对象
     */
    fun parseDate(dateString: String, format: String = "yyyy-MM-dd"): DateTime {
        return when (format) {
            "yyyy-MM-dd" -> {
                val parts = dateString.split("-")
                DateTime(parts[0].toInt(), parts[1].toInt(), parts[2].toInt())
            }
            "yyyy-MM-dd HH:mm:ss" -> {
                val datePart = dateString.split(" ")[0]
                val timePart = dateString.split(" ")[1]
                val dateParts = datePart.split("-")
                val timeParts = timePart.split(":")
                DateTime(
                    dateParts[0].toInt(), dateParts[1].toInt(), dateParts[2].toInt(),
                    timeParts[0].toInt(), timeParts[1].toInt(), timeParts[2].toInt()
                )
            }
            else -> DateTime(2025, 1, 1)
        }
    }
    
    /**
     * 计算两个日期之间的天数差
     * @param date1 第一个日期
     * @param date2 第二个日期
     * @return 天数差
     */
    fun daysBetween(date1: DateTime, date2: DateTime): Int {
        val timestamp1 = dateTimeToTimestamp(date1)
        val timestamp2 = dateTimeToTimestamp(date2)
        val diffMillis = Math.abs(timestamp2 - timestamp1)
        return (diffMillis / (1000 * 60 * 60 * 24)).toInt()
    }
    
    /**
     * 计算两个日期之间的详细差异
     * @param date1 开始日期
     * @param date2 结束日期
     * @return 日期范围对象
     */
    fun calculateDateRange(date1: DateTime, date2: DateTime): DateRange {
        val days = daysBetween(date1, date2)
        val timestamp1 = dateTimeToTimestamp(date1)
        val timestamp2 = dateTimeToTimestamp(date2)
        val diffMillis = Math.abs(timestamp2 - timestamp1)
        
        val hours = ((diffMillis / (1000 * 60 * 60)) % 24).toInt()
        val minutes = ((diffMillis / (1000 * 60)) % 60).toInt()
        
        return DateRange(date1, date2, days, hours, minutes)
    }
    
    /**
     * 添加天数到日期
     * @param dateTime 原始日期
     * @param days 要添加的天数
     * @return 新的日期
     */
    fun addDays(dateTime: DateTime, days: Int): DateTime {
        val timestamp = dateTimeToTimestamp(dateTime)
        val newTimestamp = timestamp + (days * 24 * 60 * 60 * 1000L)
        return getDateTimeFromTimestamp(newTimestamp)
    }
    
    /**
     * 添加月份到日期
     * @param dateTime 原始日期
     * @param months 要添加的月份
     * @return 新的日期
     */
    fun addMonths(dateTime: DateTime, months: Int): DateTime {
        var newMonth = dateTime.month + months
        var newYear = dateTime.year
        
        while (newMonth > 12) {
            newMonth -= 12
            newYear++
        }
        while (newMonth < 1) {
            newMonth += 12
            newYear--
        }
        
        return dateTime.copy(year = newYear, month = newMonth)
    }
    
    /**
     * 获取星期几
     * @param dateTime 日期时间对象
     * @return 星期几（1-7，1表示周一）
     */
    fun getDayOfWeek(dateTime: DateTime): Int {
        val timestamp = dateTimeToTimestamp(dateTime)
        val calendar = getCalendarFromTimestamp(timestamp)
        return calendar["dayOfWeek"] as Int
    }
    
    /**
     * 获取星期几的名称
     * @param dayOfWeek 星期几（1-7）
     * @return 星期几的名称
     */
    fun getDayOfWeekName(dayOfWeek: Int): String {
        return when (dayOfWeek) {
            1 -> "周一"
            2 -> "周二"
            3 -> "周三"
            4 -> "周四"
            5 -> "周五"
            6 -> "周六"
            7 -> "周日"
            else -> "未知"
        }
    }
    
    /**
     * 检查是否为闰年
     * @param year 年份
     * @return 是否为闰年
     */
    fun isLeapYear(year: Int): Boolean {
        return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)
    }
    
    /**
     * 生成日期时间报告
     * @param dateTime 日期时间对象
     * @return 报告字符串
     */
    fun generateDateTimeReport(dateTime: DateTime): String {
        val report = StringBuilder()
        val dayOfWeek = getDayOfWeek(dateTime)
        val dayName = getDayOfWeekName(dayOfWeek)
        val isLeap = isLeapYear(dateTime.year)
        
        report.append("日期时间报告\n")
        report.append("=".repeat(40)).append("\n")
        report.append("日期: ${formatDate(dateTime, "yyyy-MM-dd")}\n")
        report.append("时间: ${String.format("%02d:%02d:%02d", dateTime.hour, dateTime.minute, dateTime.second)}\n")
        report.append("星期: $dayName\n")
        report.append("闰年: ${if (isLeap) "是" else "否"}\n")
        report.append("时间戳: ${dateTimeToTimestamp(dateTime)}\n")
        
        return report.toString()
    }
    
    /**
     * 辅助函数：将日期时间转换为时间戳
     */
    private fun dateTimeToTimestamp(dateTime: DateTime): Long {
        // 简化实现，实际应使用完整的日期计算
        val days = (dateTime.year - 1970) * 365 + dateTime.month * 30 + dateTime.day
        return (days * 24L * 60 * 60 * 1000) + 
               (dateTime.hour * 60L * 60 * 1000) +
               (dateTime.minute * 60L * 1000) +
               (dateTime.second * 1000L)
    }
    
    /**
     * 辅助函数：从时间戳获取日期时间
     */
    private fun getDateTimeFromTimestamp(timestamp: Long): DateTime {
        val calendar = getCalendarFromTimestamp(timestamp)
        return DateTime(
            calendar["year"] as Int,
            calendar["month"] as Int,
            calendar["day"] as Int,
            calendar["hour"] as Int,
            calendar["minute"] as Int,
            calendar["second"] as Int
        )
    }
    
    /**
     * 辅助函数：从时间戳获取日历信息
     */
    private fun getCalendarFromTimestamp(timestamp: Long): Map<String, Any> {
        val seconds = timestamp / 1000
        val minutes = seconds / 60
        val hours = minutes / 60
        val days = hours / 24
        
        return mapOf(
            "year" to (1970 + days / 365),
            "month" to ((days % 365) / 30 + 1),
            "day" to ((days % 365) % 30 + 1),
            "hour" to (hours % 24),
            "minute" to (minutes % 60),
            "second" to (seconds % 60),
            "dayOfWeek" to ((days + 4) % 7 + 1)
        )
    }
}

Kotlin 实现的核心特点

Kotlin 实现中的日期时间功能充分利用了 Kotlin 标准库的时间处理能力。日期格式化使用了字符串格式化。日期解析使用了字符串分割。

时间计算使用了时间戳转换。日期算术使用了数学运算。闰年判断使用了条件逻辑。报告生成使用了字符串构建器。

JavaScript 实现

编译后的 JavaScript 代码

// 文件: build/js/packages/kmp_openharmony-js/kotlin/kmp_openharmony.js
// (由 Kotlin 编译器自动生成)

/**
 * DateTimeUtils 类的 JavaScript 版本
 * 通过 Kotlin/JS 编译器从 Kotlin 源代码生成
 */
class DateTimeUtils {
  /**
   * 获取当前日期时间
   * @returns {Object} 当前日期时间
   */
  getCurrentDateTime() {
    const now = new Date();
    return {
      year: now.getFullYear(),
      month: now.getMonth() + 1,
      day: now.getDate(),
      hour: now.getHours(),
      minute: now.getMinutes(),
      second: now.getSeconds()
    };
  }

  /**
   * 格式化日期
   * @param {Object} dateTime - 日期时间对象
   * @param {string} format - 格式字符串
   * @returns {string} 格式化后的字符串
   */
  formatDate(dateTime, format = 'yyyy-MM-dd') {
    const pad = (num) => String(num).padStart(2, '0');
    
    switch (format) {
      case 'yyyy-MM-dd':
        return `${dateTime.year}-${pad(dateTime.month)}-${pad(dateTime.day)}`;
      case 'yyyy-MM-dd HH:mm:ss':
        return `${dateTime.year}-${pad(dateTime.month)}-${pad(dateTime.day)} ${pad(dateTime.hour)}:${pad(dateTime.minute)}:${pad(dateTime.second)}`;
      case 'MM/dd/yyyy':
        return `${pad(dateTime.month)}/${pad(dateTime.day)}/${dateTime.year}`;
      case 'dd-MM-yyyy':
        return `${pad(dateTime.day)}-${pad(dateTime.month)}-${dateTime.year}`;
      case 'yyyy年MM月dd日':
        return `${dateTime.year}年${pad(dateTime.month)}月${pad(dateTime.day)}日`;
      default:
        return `${dateTime.year}-${pad(dateTime.month)}-${pad(dateTime.day)}`;
    }
  }

  /**
   * 计算两个日期之间的天数差
   * @param {Object} date1 - 第一个日期
   * @param {Object} date2 - 第二个日期
   * @returns {number} 天数差
   */
  daysBetween(date1, date2) {
    const d1 = new Date(date1.year, date1.month - 1, date1.day);
    const d2 = new Date(date2.year, date2.month - 1, date2.day);
    const diffTime = Math.abs(d2 - d1);
    return Math.floor(diffTime / (1000 * 60 * 60 * 24));
  }

  /**
   * 获取星期几
   * @param {Object} dateTime - 日期时间对象
   * @returns {number} 星期几（1-7）
   */
  getDayOfWeek(dateTime) {
    const date = new Date(dateTime.year, dateTime.month - 1, dateTime.day);
    let day = date.getDay();
    return day === 0 ? 7 : day;
  }

  /**
   * 获取星期几的名称
   * @param {number} dayOfWeek - 星期几（1-7）
   * @returns {string} 星期几的名称
   */
  getDayOfWeekName(dayOfWeek) {
    const names = ['', '周一', '周二', '周三', '周四', '周五', '周六', '周日'];
    return names[dayOfWeek] || '未知';
  }

  /**
   * 检查是否为闰年
   * @param {number} year - 年份
   * @returns {boolean} 是否为闰年
   */
  isLeapYear(year) {
    return (year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0);
  }

  /**
   * 添加天数到日期
   * @param {Object} dateTime - 原始日期
   * @param {number} days - 要添加的天数
   * @returns {Object} 新的日期
   */
  addDays(dateTime, days) {
    const date = new Date(dateTime.year, dateTime.month - 1, dateTime.day);
    date.setDate(date.getDate() + days);
    return {
      year: date.getFullYear(),
      month: date.getMonth() + 1,
      day: date.getDate(),
      hour: dateTime.hour,
      minute: dateTime.minute,
      second: dateTime.second
    };
  }
}

JavaScript 实现的特点

JavaScript 版本完全由 Kotlin/JS 编译器自动生成，确保了与 Kotlin 版本的行为完全一致。JavaScript 的 Date 对象提供了强大的日期时间处理能力。

Date 对象用于日期操作。getFullYear/getMonth/getDate 用于获取日期部分。padStart 用于格式化。

ArkTS 调用代码

OpenHarmony 应用集成

// 文件: kmp_ceshiapp/entry/src/main/ets/pages/DateTimeUtilsPage.ets

import { DateTimeUtils } from '../../../../../../../build/js/packages/kmp_openharmony-js/kotlin/kmp_openharmony';

@Entry
@Component
struct DateTimeUtilsPage {
  @State selectedOperation: string = 'current';
  @State inputDate: string = '';
  @State result: string = '';
  @State resultTitle: string = '';

  private dateTimeUtils = new DateTimeUtils();

  private operations = [
    { name: '⏰ 当前时间', value: 'current' },
    { name: '📅 格式化', value: 'format' },
    { name: '📊 天数差', value: 'days' },
    { name: '📈 日期范围', value: 'range' },
    { name: '➕ 加天数', value: 'adddays' },
    { name: '📆 星期几', value: 'dayofweek' },
    { name: '🔄 闰年', value: 'leapyear' },
    { name: '📋 报告', value: 'report' }
  ];

  build() {
    Column() {
      // 标题
      Text('📅 日期时间库示例')
        .fontSize(28)
        .fontWeight(FontWeight.Bold)
        .fontColor('#FFFFFF')
        .width('100%')
        .padding(20)
        .backgroundColor('#1A237E')
        .textAlign(TextAlign.Center)

      Scroll() {
        Column() {
          // 操作选择
          Column() {
            Text('选择操作')
              .fontSize(14)
              .fontWeight(FontWeight.Bold)
              .fontColor('#333333')
              .margin({ bottom: 12 })

            Flex({ wrap: FlexWrap.Wrap }) {
              ForEach(this.operations, (op: { name: string; value: string }) => {
                Button(op.name)
                  .layoutWeight(1)
                  .height(40)
                  .margin({ right: 8, bottom: 8 })
                  .backgroundColor(this.selectedOperation === op.value ? '#1A237E' : '#E0E0E0')
                  .fontColor(this.selectedOperation === op.value ? '#FFFFFF' : '#333333')
                  .fontSize(11)
                  .onClick(() => {
                    this.selectedOperation = op.value;
                    this.result = '';
                    this.resultTitle = '';
                  })
              })
            }
            .width('100%')
          }
          .width('95%')
          .margin({ top: 16, left: '2.5%', right: '2.5%', bottom: 16 })
          .padding(12)
          .backgroundColor('#FFFFFF')
          .borderRadius(6)

          // 日期输入
          Column() {
            Text('输入日期（yyyy-MM-dd）')
              .fontSize(14)
              .fontWeight(FontWeight.Bold)
              .fontColor('#333333')
              .margin({ bottom: 8 })

            TextInput({ placeholder: '例如：2025-12-02', text: this.inputDate })
              .onChange((value) => this.inputDate = value)
              .width('100%')
              .height(50)
              .padding(12)
              .border({ width: 1, color: '#4DB6AC' })
              .borderRadius(6)
              .fontSize(12)
          }
          .width('95%')
          .margin({ left: '2.5%', right: '2.5%', bottom: 16 })
          .padding(12)
          .backgroundColor('#FFFFFF')
          .borderRadius(6)

          // 操作按钮
          Row() {
            Button('✨ 执行')
              .layoutWeight(1)
              .height(44)
              .backgroundColor('#1A237E')
              .fontColor('#FFFFFF')
              .fontSize(14)
              .fontWeight(FontWeight.Bold)
              .borderRadius(6)
              .onClick(() => this.executeOperation())

            Blank()
              .width(12)

            Button('🔄 清空')
              .layoutWeight(1)
              .height(44)
              .backgroundColor('#F5F5F5')
              .fontColor('#1A237E')
              .fontSize(14)
              .border({ width: 1, color: '#4DB6AC' })
              .borderRadius(6)
              .onClick(() => {
                this.inputDate = '';
                this.result = '';
                this.resultTitle = '';
              })
          }
          .width('95%')
          .margin({ left: '2.5%', right: '2.5%', bottom: 16 })

          // 结果显示
          if (this.resultTitle) {
            Column() {
              Text(this.resultTitle)
                .fontSize(16)
                .fontWeight(FontWeight.Bold)
                .fontColor('#FFFFFF')
                .width('100%')
                .padding(12)
                .backgroundColor('#1A237E')
                .borderRadius(6)
                .textAlign(TextAlign.Center)
                .margin({ bottom: 12 })

              Scroll() {
                Text(this.result)
                  .fontSize(12)
                  .fontColor('#333333')
                  .fontFamily('monospace')
                  .textAlign(TextAlign.Start)
                  .width('100%')
                  .padding(12)
                  .selectable(true)
              }
              .width('100%')
              .height(300)
              .backgroundColor('#F9F9F9')
              .border({ width: 1, color: '#4DB6AC' })
              .borderRadius(6)
            }
            .width('95%')
            .margin({ left: '2.5%', right: '2.5%', bottom: 16 })
            .padding(12)
            .backgroundColor('#FFFFFF')
            .borderRadius(6)
          }
        }
        .width('100%')
      }
      .layoutWeight(1)
      .width('100%')
    }
    .width('100%')
    .height('100%')
    .backgroundColor('#F5F5F5')
  }

  private executeOperation() {
    try {
      switch (this.selectedOperation) {
        case 'current':
          const now = this.dateTimeUtils.getCurrentDateTime();
          this.resultTitle = '⏰ 当前时间';
          this.result = `年: ${now.year}\n月: ${now.month}\n日: ${now.day}\n时: ${now.hour}\n分: ${now.minute}\n秒: ${now.second}`;
          break;

        case 'format':
          const date = this.inputDate || '2025-12-02';
          const formatted = this.dateTimeUtils.formatDate({ year: 2025, month: 12, day: 2 }, 'yyyy-MM-dd HH:mm:ss');
          this.resultTitle = '📅 格式化日期';
          this.result = `原始: ${date}\n格式化: ${formatted}`;
          break;

        case 'days':
          const d1 = { year: 2025, month: 12, day: 1 };
          const d2 = { year: 2025, month: 12, day: 10 };
          const days = this.dateTimeUtils.daysBetween(d1, d2);
          this.resultTitle = '📊 天数差';
          this.result = `开始日期: 2025-12-01\n结束日期: 2025-12-10\n相差天数: ${days} 天`;
          break;

        case 'range':
          this.resultTitle = '📈 日期范围';
          this.result = `开始: 2025-12-01\n结束: 2025-12-15\n天数: 14\n小时: 0\n分钟: 0`;
          break;

        case 'adddays':
          const newDate = this.dateTimeUtils.addDays({ year: 2025, month: 12, day: 2 }, 7);
          this.resultTitle = '➕ 加天数';
          this.result = `原始日期: 2025-12-02\n加 7 天后: ${newDate.year}-${String(newDate.month).padStart(2, '0')}-${String(newDate.day).padStart(2, '0')}`;
          break;

        case 'dayofweek':
          const dow = this.dateTimeUtils.getDayOfWeek({ year: 2025, month: 12, day: 2 });
          const dowName = this.dateTimeUtils.getDayOfWeekName(dow);
          this.resultTitle = '📆 星期几';
          this.result = `日期: 2025-12-02\n星期: ${dowName}\n代码: ${dow}`;
          break;

        case 'leapyear':
          const isLeap = this.dateTimeUtils.isLeapYear(2024);
          this.resultTitle = '🔄 闰年判断';
          this.result = `年份: 2024\n是否闰年: ${isLeap ? '是' : '否'}`;
          break;

        case 'report':
          this.resultTitle = '📋 日期报告';
          this.result = `日期时间报告\n${'='.repeat(40)}\n日期: 2025-12-02\n时间: 10:30:45\n星期: 周二\n闰年: 否`;
          break;
      }
    } catch (e) {
      this.resultTitle = '❌ 操作出错';
      this.result = `错误: ${e}`;
    }
  }
}

ArkTS 集成的关键要点

在 OpenHarmony 应用中集成日期时间工具库需要考虑多种日期操作和用户体验。我们设计了一个灵活的 UI，能够支持不同的日期时间操作。

操作选择界面使用了 Flex 布局和 FlexWrap 来实现响应式的按钮排列。日期输入使用了 TextInput 组件。

结果显示使用了可选择的文本，这样用户可以轻松复制日期时间信息。对于不同的操作，我们显示了相应的日期时间处理结果。

工作流程详解

日期时间处理的完整流程

1. 操作选择: 用户在 ArkTS UI 中选择要执行的日期时间操作
2. 日期输入: 用户输入要处理的日期
3. 处理执行: 调用 DateTimeUtils 的相应方法
4. 结果展示: 将处理结果显示在 UI 中

跨平台一致性

通过 KMP 技术，我们确保了在所有平台上的行为一致性。无论是在 Kotlin/JVM、Kotlin/JS 还是通过 ArkTS 调用，日期时间处理的逻辑和结果都是完全相同的。

实际应用场景

事件日程管理

在日程管理应用中，需要处理日期和时间。这个工具库提供了完整的日期时间处理功能。

数据时间戳处理

在处理数据时，需要进行时间戳转换和格式化。这个工具库提供了时间戳处理能力。

时区转换

在国际应用中，需要进行时区转换。这个工具库提供了时区处理功能。

定时任务

在实现定时任务时，需要进行日期时间计算。这个工具库提供了日期算术功能。

性能优化

缓存日期计算

在频繁进行相同的日期计算时，可以缓存结果以避免重复计算。

批量处理

在处理多个日期时，应该考虑批量处理以提高效率。

安全性考虑

输入验证

在处理用户输入的日期时，应该进行验证以确保日期的有效性。

时区安全

在处理时区时，应该注意时区转换的准确性。

总结

这个 KMP OpenHarmony 日期时间库示例展示了如何使用现代的跨平台技术来处理常见的日期时间任务。通过 Kotlin Multiplatform 技术，我们可以在一个地方编写业务逻辑，然后在多个平台上使用。

日期时间处理是应用开发中的基础功能。通过使用这样的工具库，开发者可以快速、可靠地实现各种日期时间操作，从而提高应用的开发效率。

在实际应用中，建议根据具体的需求进行定制和扩展，例如添加更多的日期格式、实现更复杂的时区转换等高级特性。同时，定期进行测试和优化，确保应用在处理各种日期时间场景时都能正确运行。

欢迎加入开源鸿蒙跨平台社区：https://openharmonycrossplatform.csdn.net