项目概述

时间和日期处理是应用开发中的常见需求。无论是显示当前时间、计算时间差、还是处理不同时区的时间，这些都是应用中经常遇到的问题。在多平台开发中，不同平台对时间和日期的处理方式不同。Android 使用 Calendar 和 SimpleDateFormat，iOS 使用 NSDate 和 DateFormatter，而鸿蒙系统也有自己的时间处理 API。

KMP 提供了一个统一的时间处理接口，让我们可以在共享代码中定义时间操作，然后在各个平台上提供具体的实现。本文将详细介绍如何在 KMP 项目中实现跨平台的时间和日期处理。

第一部分：时间处理的核心概念

理解时间的复杂性

时间处理看似简单，但实际上非常复杂。首先，时间有多种表示方式：时间戳（毫秒或秒）、日期字符串（ISO 8601 格式或其他格式）、本地时间、UTC 时间等。其次，时间涉及时区问题，同一时刻在不同时区显示的时间不同。最后，时间还涉及夏令时、闰秒等特殊情况。

通过使用一个统一的时间处理接口，我们可以隐藏这些复杂性，为应用提供一个简洁的时间操作 API。

定义时间处理接口

首先，我们定义一个时间处理接口。

// commonMain/kotlin/com/example/kmp/datetime/DateTime.kt
@Serializable
data class DateTime(
    val timestamp: Long,
    val timezone: String = "UTC"
)

interface DateTimeFormatter {
    fun format(dateTime: DateTime, pattern: String): String
    fun parse(dateString: String, pattern: String): DateTime?
}

interface DateTimeCalculator {
    fun addDays(dateTime: DateTime, days: Int): DateTime
    fun addHours(dateTime: DateTime, hours: Int): DateTime
    fun getDaysBetween(start: DateTime, end: DateTime): Long
}

这些接口定义了时间处理的基本操作。

实现时间管理器

接下来，我们创建一个时间管理器。

// commonMain/kotlin/com/example/kmp/datetime/DateTimeManager.kt
object DateTimeManager {
    private var formatter: DateTimeFormatter? = null
    private var calculator: DateTimeCalculator? = null
    
    fun initialize(formatter: DateTimeFormatter, calculator: DateTimeCalculator) {
        this.formatter = formatter
        this.calculator = calculator
    }
    
    fun getFormatter(): DateTimeFormatter {
        return formatter ?: throw IllegalStateException("DateTimeFormatter not initialized")
    }
    
    fun getCalculator(): DateTimeCalculator {
        return calculator ?: throw IllegalStateException("DateTimeCalculator not initialized")
    }
}

第二部分：平台特定的时间实现

Android 平台的时间实现

在 Android 平台上，我们使用 SimpleDateFormat 和 Calendar 来处理时间。

// androidMain/kotlin/com/example/kmp/datetime/AndroidDateTimeFormatter.kt
import java.text.SimpleDateFormat
import java.util.*

actual class AndroidDateTimeFormatter : DateTimeFormatter {
    actual override fun format(dateTime: DateTime, pattern: String): String {
        val sdf = SimpleDateFormat(pattern, Locale.getDefault())
        return sdf.format(Date(dateTime.timestamp))
    }
    
    actual override fun parse(dateString: String, pattern: String): DateTime? {
        return try {
            val sdf = SimpleDateFormat(pattern, Locale.getDefault())
            val date = sdf.parse(dateString)
            DateTime(date.time)
        } catch (e: Exception) {
            null
        }
    }
}

actual class AndroidDateTimeCalculator : DateTimeCalculator {
    actual override fun addDays(dateTime: DateTime, days: Int): DateTime {
        val calendar = Calendar.getInstance()
        calendar.timeInMillis = dateTime.timestamp
        calendar.add(Calendar.DAY_OF_MONTH, days)
        return DateTime(calendar.timeInMillis)
    }
    
    actual override fun addHours(dateTime: DateTime, hours: Int): DateTime {
        val calendar = Calendar.getInstance()
        calendar.timeInMillis = dateTime.timestamp
        calendar.add(Calendar.HOUR_OF_DAY, hours)
        return DateTime(calendar.timeInMillis)
    }
    
    actual override fun getDaysBetween(start: DateTime, end: DateTime): Long {
        return (end.timestamp - start.timestamp) / (1000 * 60 * 60 * 24)
    }
}

JVM 平台的时间实现（鸿蒙）

在鸿蒙系统上，我们可以使用 Java 的时间处理库。

// jvmMain/kotlin/com/example/kmp/datetime/JvmDateTimeFormatter.kt
import java.text.SimpleDateFormat
import java.util.*

actual class JvmDateTimeFormatter : DateTimeFormatter {
    actual override fun format(dateTime: DateTime, pattern: String): String {
        val sdf = SimpleDateFormat(pattern)
        return sdf.format(Date(dateTime.timestamp))
    }
    
    actual override fun parse(dateString: String, pattern: String): DateTime? {
        return try {
            val sdf = SimpleDateFormat(pattern)
            val date = sdf.parse(dateString)
            DateTime(date.time)
        } catch (e: Exception) {
            null
        }
    }
}

actual class JvmDateTimeCalculator : DateTimeCalculator {
    actual override fun addDays(dateTime: DateTime, days: Int): DateTime {
        val calendar = Calendar.getInstance()
        calendar.timeInMillis = dateTime.timestamp
        calendar.add(Calendar.DAY_OF_MONTH, days)
        return DateTime(calendar.timeInMillis)
    }
    
    actual override fun addHours(dateTime: DateTime, hours: Int): DateTime {
        val calendar = Calendar.getInstance()
        calendar.timeInMillis = dateTime.timestamp
        calendar.add(Calendar.HOUR_OF_DAY, hours)
        return DateTime(calendar.timeInMillis)
    }
    
    actual override fun getDaysBetween(start: DateTime, end: DateTime): Long {
        return (end.timestamp - start.timestamp) / (1000 * 60 * 60 * 24)
    }
}

第三部分：编译后的代码形式

Kotlin 时间代码编译为 JavaScript

当我们将 Kotlin 的时间代码编译为 JavaScript 时，会生成以下形式的代码：

// 编译后的 JavaScript (简化版)
var DateTime = function(timestamp, timezone) {
    this.timestamp = timestamp;
    this.timezone = timezone || "UTC";
};

var DateTimeFormatter = function() {};

DateTimeFormatter.prototype.format = function(dateTime, pattern) {
    var date = new Date(dateTime.timestamp);
    return this.formatDate(date, pattern);
};

DateTimeFormatter.prototype.parse = function(dateString, pattern) {
    try {
        var date = new Date(dateString);
        return new DateTime(date.getTime());
    } catch (e) {
        return null;
    }
};

Web 平台的时间实现

在 Web 平台上，我们可以使用 JavaScript 的 Date 对象或现代的 Intl API。

// Web 平台的时间实现
var WebDateTimeFormatter = function() {};

WebDateTimeFormatter.prototype.format = function(dateTime, pattern) {
    var date = new Date(dateTime.timestamp);
    var options = this.parsePattern(pattern);
    return new Intl.DateTimeFormat('zh-CN', options).format(date);
};

WebDateTimeFormatter.prototype.parsePattern = function(pattern) {
    // 将模式转换为 Intl 选项
    return {
        year: 'numeric',
        month: '2-digit',
        day: '2-digit',
        hour: '2-digit',
        minute: '2-digit',
        second: '2-digit'
    };
};

第四部分：鸿蒙系统中的实际应用

在鸿蒙应用中使用时间处理

在鸿蒙应用中，我们可以直接使用编译后的 KMP 时间代码。

// HarmonyOS 应用代码
class HarmonyTimeService {
    init {
        DateTimeManager.initialize(
            JvmDateTimeFormatter(),
            JvmDateTimeCalculator()
        )
    }
    
    fun getCurrentTimeString(): String {
        val now = DateTime(System.currentTimeMillis())
        return DateTimeManager.getFormatter().format(now, "yyyy-MM-dd HH:mm:ss")
    }
    
    fun getNextWeek(): DateTime {
        val now = DateTime(System.currentTimeMillis())
        return DateTimeManager.getCalculator().addDays(now, 7)
    }
}

处理时区转换

在实际应用中，我们经常需要处理不同时区的时间。

// 时区转换
class TimeZoneConverter {
    fun convertToTimeZone(dateTime: DateTime, targetTimeZone: String): DateTime {
        val calendar = Calendar.getInstance(TimeZone.getTimeZone(dateTime.timezone))
        calendar.timeInMillis = dateTime.timestamp
        
        val targetCalendar = Calendar.getInstance(TimeZone.getTimeZone(targetTimeZone))
        targetCalendar.timeInMillis = calendar.timeInMillis
        
        return DateTime(targetCalendar.timeInMillis, targetTimeZone)
    }
}

第五部分：高级时间处理

实现时间间隔计算

时间间隔计算在许多应用中都很常见，例如计算剩余时间、显示相对时间等。

// 时间间隔计算
class TimeIntervalCalculator {
    fun getRelativeTimeString(dateTime: DateTime): String {
        val now = System.currentTimeMillis()
        val diff = now - dateTime.timestamp
        
        return when {
            diff < 60 * 1000 -> "刚刚"
            diff < 60 * 60 * 1000 -> "${diff / (60 * 1000)} 分钟前"
            diff < 24 * 60 * 60 * 1000 -> "${diff / (60 * 60 * 1000)} 小时前"
            diff < 7 * 24 * 60 * 60 * 1000 -> "${diff / (24 * 60 * 60 * 1000)} 天前"
            else -> "很久前"
        }
    }
}

总结

通过本文的学习，我们理解了如何在 KMP 项目中实现跨平台的时间和日期处理。关键的设计原则是使用接口来抽象时间处理的具体实现，这样应用逻辑就可以独立于具体的平台。我们展示了如何在 Android、JVM（鸿蒙）和 JavaScript（Web）平台上实现时间处理接口，以及如何在鸿蒙应用中使用这些共享代码。通过这种方式，我们可以在所有平台上使用相同的时间处理代码。
欢迎加入开源鸿蒙跨平台社区：https://openharmonycrossplatform.csdn.net