OpenHarmony数据验证和转换 | KMP适配
本文介绍了一个基于Kotlin Multiplatform(KMP)和OpenHarmony平台的数据验证转换工具库。该库通过KMP技术实现跨平台支持，可在Kotlin/JVM、Kotlin/JS和OpenHarmony/ArkTS等多个平台上使用。核心功能包括类型验证(整数、浮点数、布尔值等)、格式验证(邮箱、URL、电话号码等)、数据转换(字符串转整数/浮点数/布尔值)、数据清洗(去除特殊字符
·
项目概述
数据验证和转换是现代应用开发中的核心需求。无论是在表单验证、API 请求处理、数据导入导出还是数据清洗中，都需要进行各种数据验证和转换操作。然而，不同的编程语言和平台对数据验证和转换的实现方式各不相同，这导致开发者需要在不同平台上重复编写类似的逻辑。
本文介绍一个基于 Kotlin Multiplatform (KMP) 和 OpenHarmony 平台的数据验证和转换工具库。这个工具库提供了一套完整的数据处理能力，包括类型验证、格式验证、数据转换、数据清洗等功能。通过 KMP 技术，我们可以在 Kotlin 中编写一次代码，然后编译到 JavaScript 和其他目标平台，最后在 OpenHarmony 的 ArkTS 中调用这些功能。
技术架构
多平台支持
- Kotlin/JVM: 后端服务和桌面应用
- Kotlin/JS: Web 应用和浏览器环境
- OpenHarmony/ArkTS: 鸿蒙操作系统应用
核心功能模块
- 类型验证: 验证数据类型是否正确
- 格式验证: 验证数据格式是否符合要求
- 范围验证: 验证数据是否在指定范围内
- 类型转换: 在不同类型之间进行转换
- 数据清洗: 清理和规范化数据
- 数据映射: 将数据从一种格式映射到另一种格式
- 批量验证: 对多个数据进行验证
- 自定义验证: 支持自定义验证规则
Kotlin 实现
核心数据验证和转换类
// 文件: src/commonMain/kotlin/DataValidator.kt
/**
* 数据验证和转换工具类
* 提供数据验证、转换、清洗等功能
*/
class DataValidator {
/**
* 验证是否为整数
* @param value 值
* @return 是否为整数
*/
fun isInteger(value: String): Boolean {
return try {
value.toInt()
true
} catch (e: Exception) {
false
}
}
/**
* 验证是否为浮点数
* @param value 值
* @return 是否为浮点数
*/
fun isDouble(value: String): Boolean {
return try {
value.toDouble()
true
} catch (e: Exception) {
false
}
}
/**
* 验证是否为布尔值
* @param value 值
* @return 是否为布尔值
*/
fun isBoolean(value: String): Boolean {
return value.lowercase() in listOf("true", "false", "yes", "no", "1", "0")
}
/**
* 验证是否为有效的电子邮件
* @param email 电子邮件
* @return 是否有效
*/
fun isValidEmail(email: String): Boolean {
val pattern = "^[A-Za-z0-9+_.-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}$"
return Regex(pattern).matches(email)
}
/**
* 验证是否为有效的 URL
* @param url URL
* @return 是否有效
*/
fun isValidUrl(url: String): Boolean {
val pattern = "^(https?|ftp)://[\\w\\-]+(\\.[\\w\\-]+)+([\\w.,@?^=%&:/~+#-]*[\\w@?^=%&/~+#-])?$"
return Regex(pattern).matches(url)
}
/**
* 验证是否为有效的电话号码
* @param phone 电话号码
* @return 是否有效
*/
fun isValidPhone(phone: String): Boolean {
val pattern = "^\\+?[1-9]\\d{1,14}$"
return Regex(pattern).matches(phone)
}
/**
* 验证是否为有效的 IP 地址
* @param ip IP 地址
* @return 是否有效
*/
fun isValidIp(ip: String): Boolean {
val pattern = "^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$"
return Regex(pattern).matches(ip)
}
/**
* 验证字符串长度
* @param value 值
* @param minLength 最小长度
* @param maxLength 最大长度
* @return 是否有效
*/
fun isValidLength(value: String, minLength: Int, maxLength: Int): Boolean {
return value.length in minLength..maxLength
}
/**
* 验证数字范围
* @param value 值
* @param min 最小值
* @param max 最大值
* @return 是否在范围内
*/
fun isInRange(value: Int, min: Int, max: Int): Boolean {
return value in min..max
}
/**
* 验证是否为空
* @param value 值
* @return 是否为空
*/
fun isEmpty(value: String): Boolean {
return value.trim().isEmpty()
}
/**
* 验证是否仅包含字母
* @param value 值
* @return 是否仅包含字母
*/
fun isAlpha(value: String): Boolean {
return value.all { it.isLetter() }
}
/**
* 验证是否仅包含数字
* @param value 值
* @return 是否仅包含数字
*/
fun isNumeric(value: String): Boolean {
return value.all { it.isDigit() }
}
/**
* 验证是否仅包含字母和数字
* @param value 值
* @return 是否仅包含字母和数字
*/
fun isAlphanumeric(value: String): Boolean {
return value.all { it.isLetterOrDigit() }
}
/**
* 字符串转整数
* @param value 值
* @param defaultValue 默认值
* @return 转换后的整数
*/
fun toInteger(value: String, defaultValue: Int = 0): Int {
return try {
value.toInt()
} catch (e: Exception) {
defaultValue
}
}
/**
* 字符串转浮点数
* @param value 值
* @param defaultValue 默认值
* @return 转换后的浮点数
*/
fun toDouble(value: String, defaultValue: Double = 0.0): Double {
return try {
value.toDouble()
} catch (e: Exception) {
defaultValue
}
}
/**
* 字符串转布尔值
* @param value 值
* @return 转换后的布尔值
*/
fun toBoolean(value: String): Boolean {
return value.lowercase() in listOf("true", "yes", "1", "on")
}
/**
* 清洗字符串（移除前后空格和特殊字符）
* @param value 值
* @return 清洗后的字符串
*/
fun sanitize(value: String): String {
return value.trim().replace(Regex("[^a-zA-Z0-9\\s]"), "")
}
/**
* 规范化字符串（转小写）
* @param value 值
* @return 规范化后的字符串
*/
fun normalize(value: String): String {
return value.trim().lowercase()
}
/**
* 截断字符串
* @param value 值
* @param maxLength 最大长度
* @return 截断后的字符串
*/
fun truncate(value: String, maxLength: Int): String {
return if (value.length > maxLength) value.substring(0, maxLength) + "..." else value
}
/**
* 验证多个值
* @param values 值列表
* @param validator 验证函数
* @return 验证结果列表
*/
fun validateMultiple(values: List<String>, validator: (String) -> Boolean): List<Boolean> {
return values.map { validator(it) }
}
/**
* 获取验证结果摘要
* @param value 值
* @return 验证结果摘要映射
*/
fun getValidationSummary(value: String): Map<String, Any> {
return mapOf(
"isEmpty" to isEmpty(value),
"isInteger" to isInteger(value),
"isDouble" to isDouble(value),
"isBoolean" to isBoolean(value),
"isAlpha" to isAlpha(value),
"isNumeric" to isNumeric(value),
"isAlphanumeric" to isAlphanumeric(value),
"isValidEmail" to isValidEmail(value),
"isValidUrl" to isValidUrl(value),
"isValidPhone" to isValidPhone(value),
"length" to value.length
)
}
}
Kotlin 实现的核心特点
Kotlin 实现中的数据验证功能充分利用了 Kotlin 标准库的字符串处理和正则表达式能力。类型验证使用了 try-catch 块来捕获转换异常。格式验证使用了正则表达式进行模式匹配。
字符验证使用了 isLetter、isDigit 等字符属性检查。字符串清洗使用了 trim 和 replace 方法。类型转换使用了 Kotlin 的内置转换方法，并提供了默认值处理。
验证摘要功能返回一个映射，包含所有主要的验证结果，便于调用者快速了解数据的各种属性。
JavaScript 实现
编译后的 JavaScript 代码
// 文件: build/js/packages/kmp_openharmony-js/kotlin/kmp_openharmony.js
// (由 Kotlin 编译器自动生成)
/**
* DataValidator 类的 JavaScript 版本
* 通过 Kotlin/JS 编译器从 Kotlin 源代码生成
*/
class DataValidator {
/**
* 验证是否为整数
* @param {string} value - 值
* @returns {boolean} 是否为整数
*/
isInteger(value) {
return !isNaN(parseInt(value)) && isFinite(value);
}
/**
* 验证是否为浮点数
* @param {string} value - 值
* @returns {boolean} 是否为浮点数
*/
isDouble(value) {
return !isNaN(parseFloat(value)) && isFinite(value);
}
/**
* 验证是否为布尔值
* @param {string} value - 值
* @returns {boolean} 是否为布尔值
*/
isBoolean(value) {
const lower = value.toLowerCase();
return ['true', 'false', 'yes', 'no', '1', '0'].includes(lower);
}
/**
* 验证是否为有效的电子邮件
* @param {string} email - 电子邮件
* @returns {boolean} 是否有效
*/
isValidEmail(email) {
const pattern = /^[A-Za-z0-9+_.-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$/;
return pattern.test(email);
}
/**
* 验证是否为有效的 URL
* @param {string} url - URL
* @returns {boolean} 是否有效
*/
isValidUrl(url) {
const pattern = /^(https?|ftp):\/\/[\w\-]+(\\.[\w\-]+)+([\w.,@?^=%&:\/~+#-]*[\w@?^=%&\/~+#-])?$/;
return pattern.test(url);
}
/**
* 验证是否为有效的电话号码
* @param {string} phone - 电话号码
* @returns {boolean} 是否有效
*/
isValidPhone(phone) {
const pattern = /^\+?[1-9]\d{1,14}$/;
return pattern.test(phone);
}
/**
* 验证是否为有效的 IP 地址
* @param {string} ip - IP 地址
* @returns {boolean} 是否有效
*/
isValidIp(ip) {
const pattern = /^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
return pattern.test(ip);
}
/**
* 验证字符串长度
* @param {string} value - 值
* @param {number} minLength - 最小长度
* @param {number} maxLength - 最大长度
* @returns {boolean} 是否有效
*/
isValidLength(value, minLength, maxLength) {
return value.length >= minLength && value.length <= maxLength;
}
/**
* 验证数字范围
* @param {number} value - 值
* @param {number} min - 最小值
* @param {number} max - 最大值
* @returns {boolean} 是否在范围内
*/
isInRange(value, min, max) {
return value >= min && value <= max;
}
/**
* 验证是否为空
* @param {string} value - 值
* @returns {boolean} 是否为空
*/
isEmpty(value) {
return value.trim().length === 0;
}
/**
* 验证是否仅包含字母
* @param {string} value - 值
* @returns {boolean} 是否仅包含字母
*/
isAlpha(value) {
return /^[a-zA-Z]+$/.test(value);
}
/**
* 验证是否仅包含数字
* @param {string} value - 值
* @returns {boolean} 是否仅包含数字
*/
isNumeric(value) {
return /^[0-9]+$/.test(value);
}
/**
* 验证是否仅包含字母和数字
* @param {string} value - 值
* @returns {boolean} 是否仅包含字母和数字
*/
isAlphanumeric(value) {
return /^[a-zA-Z0-9]+$/.test(value);
}
/**
* 字符串转整数
* @param {string} value - 值
* @param {number} defaultValue - 默认值
* @returns {number} 转换后的整数
*/
toInteger(value, defaultValue = 0) {
const result = parseInt(value);
return isNaN(result) ? defaultValue : result;
}
/**
* 字符串转浮点数
* @param {string} value - 值
* @param {number} defaultValue - 默认值
* @returns {number} 转换后的浮点数
*/
toDouble(value, defaultValue = 0.0) {
const result = parseFloat(value);
return isNaN(result) ? defaultValue : result;
}
/**
* 字符串转布尔值
* @param {string} value - 值
* @returns {boolean} 转换后的布尔值
*/
toBoolean(value) {
const lower = value.toLowerCase();
return ['true', 'yes', '1', 'on'].includes(lower);
}
/**
* 清洗字符串
* @param {string} value - 值
* @returns {string} 清洗后的字符串
*/
sanitize(value) {
return value.trim().replace(/[^a-zA-Z0-9\s]/g, '');
}
/**
* 规范化字符串
* @param {string} value - 值
* @returns {string} 规范化后的字符串
*/
normalize(value) {
return value.trim().toLowerCase();
}
/**
* 截断字符串
* @param {string} value - 值
* @param {number} maxLength - 最大长度
* @returns {string} 截断后的字符串
*/
truncate(value, maxLength) {
return value.length > maxLength ? value.substring(0, maxLength) + '...' : value;
}
/**
* 获取验证结果摘要
* @param {string} value - 值
* @returns {Object} 验证结果摘要
*/
getValidationSummary(value) {
return {
isEmpty: this.isEmpty(value),
isInteger: this.isInteger(value),
isDouble: this.isDouble(value),
isBoolean: this.isBoolean(value),
isAlpha: this.isAlpha(value),
isNumeric: this.isNumeric(value),
isAlphanumeric: this.isAlphanumeric(value),
isValidEmail: this.isValidEmail(value),
isValidUrl: this.isValidUrl(value),
isValidPhone: this.isValidPhone(value),
length: value.length
};
}
}
JavaScript 实现的特点
JavaScript 版本完全由 Kotlin/JS 编译器自动生成，确保了与 Kotlin 版本的行为完全一致。JavaScript 的正则表达式提供了强大的模式匹配能力。
parseInt 和 parseFloat 用于类型转换。isNaN 和 isFinite 用于检查转换结果的有效性。正则表达式用于验证各种格式。
ArkTS 调用代码
OpenHarmony 应用集成
// 文件: kmp_ceshiapp/entry/src/main/ets/pages/DataValidatorPage.ets
import { DataValidator } from '../../../../../../../build/js/packages/kmp_openharmony-js/kotlin/kmp_openharmony';
@Entry
@Component
struct DataValidatorPage {
@State selectedValidation: string = 'email';
@State inputValue: string = '';
@State result: string = '';
@State resultTitle: string = '';
private validator = new DataValidator();
private validations = [
{ name: '验证邮箱', value: 'email' },
{ name: '验证 URL', value: 'url' },
{ name: '验证电话', value: 'phone' },
{ name: '验证 IP', value: 'ip' },
{ name: '验证整数', value: 'integer' },
{ name: '验证浮点数', value: 'double' },
{ name: '验证字母', value: 'alpha' },
{ name: '验证数字', value: 'numeric' },
{ name: '验证字母数字', value: 'alphanumeric' },
{ name: '完整摘要', value: 'summary' }
];
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.validations, (val: { name: string; value: string }) => {
Button(val.name)
.layoutWeight(1)
.height(40)
.margin({ right: 8, bottom: 8 })
.backgroundColor(this.selectedValidation === val.value ? '#1A237E' : '#E0E0E0')
.fontColor(this.selectedValidation === val.value ? '#FFFFFF' : '#333333')
.fontSize(11)
.onClick(() => {
this.selectedValidation = val.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('输入数据')
.fontSize(14)
.fontWeight(FontWeight.Bold)
.fontColor('#333333')
.margin({ bottom: 8 })
TextInput({ placeholder: '输入要验证的数据', text: this.inputValue })
.onChange((value) => this.inputValue = value)
.width('100%')
.height(100)
.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.executeValidation())
Blank()
.width(12)
Button('🔄 清空')
.layoutWeight(1)
.height(44)
.backgroundColor('#F5F5F5')
.fontColor('#1A237E')
.fontSize(14)
.border({ width: 1, color: '#4DB6AC' })
.borderRadius(6)
.onClick(() => {
this.inputValue = '';
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 executeValidation() {
if (!this.inputValue.trim()) {
this.resultTitle = '❌ 错误';
this.result = '请输入数据';
return;
}
try {
switch (this.selectedValidation) {
case 'email':
const isEmail = this.validator.isValidEmail(this.inputValue);
this.resultTitle = isEmail ? '✅ 有效邮箱' : '❌ 无效邮箱';
this.result = `邮箱: ${this.inputValue}\n状态: ${isEmail ? '有效' : '无效'}`;
break;
case 'url':
const isUrl = this.validator.isValidUrl(this.inputValue);
this.resultTitle = isUrl ? '✅ 有效 URL' : '❌ 无效 URL';
this.result = `URL: ${this.inputValue}\n状态: ${isUrl ? '有效' : '无效'}`;
break;
case 'phone':
const isPhone = this.validator.isValidPhone(this.inputValue);
this.resultTitle = isPhone ? '✅ 有效电话' : '❌ 无效电话';
this.result = `电话: ${this.inputValue}\n状态: ${isPhone ? '有效' : '无效'}`;
break;
case 'ip':
const isIp = this.validator.isValidIp(this.inputValue);
this.resultTitle = isIp ? '✅ 有效 IP' : '❌ 无效 IP';
this.result = `IP: ${this.inputValue}\n状态: ${isIp ? '有效' : '无效'}`;
break;
case 'integer':
const isInt = this.validator.isInteger(this.inputValue);
this.resultTitle = isInt ? '✅ 有效整数' : '❌ 无效整数';
this.result = `值: ${this.inputValue}\n状态: ${isInt ? '有效' : '无效'}`;
break;
case 'double':
const isDouble = this.validator.isDouble(this.inputValue);
this.resultTitle = isDouble ? '✅ 有效浮点数' : '❌ 无效浮点数';
this.result = `值: ${this.inputValue}\n状态: ${isDouble ? '有效' : '无效'}`;
break;
case 'alpha':
const isAlpha = this.validator.isAlpha(this.inputValue);
this.resultTitle = isAlpha ? '✅ 仅包含字母' : '❌ 包含非字母字符';
this.result = `值: ${this.inputValue}\n状态: ${isAlpha ? '有效' : '无效'}`;
break;
case 'numeric':
const isNumeric = this.validator.isNumeric(this.inputValue);
this.resultTitle = isNumeric ? '✅ 仅包含数字' : '❌ 包含非数字字符';
this.result = `值: ${this.inputValue}\n状态: ${isNumeric ? '有效' : '无效'}`;
break;
case 'alphanumeric':
const isAlphanumeric = this.validator.isAlphanumeric(this.inputValue);
this.resultTitle = isAlphanumeric ? '✅ 仅包含字母和数字' : '❌ 包含特殊字符';
this.result = `值: ${this.inputValue}\n状态: ${isAlphanumeric ? '有效' : '无效'}`;
break;
case 'summary':
const summary = this.validator.getValidationSummary(this.inputValue);
this.resultTitle = '📊 完整验证摘要';
this.result = `值: ${this.inputValue}\n长度: ${summary.length}\n是否为空: ${summary.isEmpty}\n是否为整数: ${summary.isInteger}\n是否为浮点数: ${summary.isDouble}\n是否为布尔值: ${summary.isBoolean}\n是否仅字母: ${summary.isAlpha}\n是否仅数字: ${summary.isNumeric}\n是否字母数字: ${summary.isAlphanumeric}\n是否有效邮箱: ${summary.isValidEmail}\n是否有效URL: ${summary.isValidUrl}\n是否有效电话: ${summary.isValidPhone}`;
break;
}
} catch (e) {
this.resultTitle = '❌ 验证出错';
this.result = `错误: ${e}`;
}
}
}
ArkTS 集成的关键要点
在 OpenHarmony 应用中集成数据验证工具库需要考虑多种验证类型和用户体验。我们设计了一个灵活的 UI，能够支持不同的数据验证操作。
验证类型选择界面使用了 Flex 布局和 FlexWrap 来实现响应式的按钮排列。当用户选择不同的验证类型时，结果会相应更新。
输入区域使用了较大的高度以容纳多行文本输入。结果显示使用了可选择的文本，这样用户可以轻松复制验证结果。
对于完整摘要验证，我们显示了所有主要的验证结果，便于用户全面了解数据的各种属性。
工作流程详解
数据验证的完整流程
- 验证类型选择: 用户在 ArkTS UI 中选择要执行的验证类型
- 数据输入: 用户输入要验证的数据
- 验证执行: 调用 DataValidator 的相应方法
- 结果展示: 将验证结果显示在 UI 中
跨平台一致性
通过 KMP 技术，我们确保了在所有平台上的行为一致性。无论是在 Kotlin/JVM、Kotlin/JS 还是通过 ArkTS 调用，数据验证的逻辑和结果都是完全相同的。
实际应用场景
表单验证
在 Web 表单和移动应用中，需要验证用户输入的数据。这个工具库提供了常见的验证函数。
API 请求处理
在处理 API 请求时，需要验证和转换请求数据。这个工具库提供了必要的功能。
数据导入导出
在导入导出数据时，需要验证和清洗数据。这个工具库提供了数据清洗功能。
数据分析
在数据分析中，需要验证数据的有效性。这个工具库提供了全面的验证能力。
性能优化
缓存验证结果
在频繁验证相同数据时，可以缓存验证结果以避免重复计算。
批量验证
在验证大量数据时，应该考虑使用批量验证的方式以提高效率。
安全性考虑
输入清洗
在处理用户输入时，应该进行清洗以防止注入攻击。
类型安全
在进行类型转换时，应该进行适当的错误处理以防止类型错误。
总结
这个 KMP OpenHarmony 数据验证和转换工具库展示了如何使用现代的跨平台技术来处理常见的数据验证任务。通过 Kotlin Multiplatform 技术，我们可以在一个地方编写业务逻辑，然后在多个平台上使用。
数据验证是应用开发中的基础功能。通过使用这样的工具库，开发者可以快速、可靠地处理各种数据验证操作，从而提高开发效率和代码质量。
在实际应用中，建议根据具体的需求进行定制和扩展，例如添加更多的验证规则、实现自定义验证器等高级特性。同时，定期进行安全审计和性能测试，确保应用的数据验证功能始终处于最佳状态。
欢迎加入开源鸿蒙跨平台社区：https://openharmonycrossplatform.csdn.net
社区规范：仅讨论OpenHarmony相关问题。
更多推荐
7
0- 0
已为社区贡献15条内容
所有评论(0)