鸿蒙分布式喝水提醒系统：多设备协同的健康饮水管理方案原创

进修的泡芙

发布于 2025-6-22 17:46

浏览

0收藏

鸿蒙分布式喝水提醒系统：多设备协同的健康饮水管理方案

一、系统架构设计

!https://example.com/harmonyos-hydration-arch.png

采用三层架构：
感知层：多设备用户状态感知（活动量、环境数据）

逻辑层：分布式饮水需求计算与提醒策略

展示层：跨终端统一提醒与饮水记录

二、核心模块实现
饮水需求计算模块

// HydrationCalculator.ts
import health from ‘@ohos.health’;
import environment from ‘@ohos.environment’;
import distributedData from ‘@ohos.data.distributedData’;

interface HydrationNeed {
timestamp: number;
deviceId: string;
baseRequirement: number; // 基础需求(ml)
activityAdjustment: number; // 活动调整(ml)
environmentAdjustment: number; // 环境调整(ml)
totalRecommendation: number; // 总推荐量(ml)
export class HydrationCalculator {

private healthManager?: health.HealthManager;
private envSensor?: environment.EnvironmentSensor;
private kvManager: distributedData.KVManager;

async init() {
// 初始化健康数据接口
this.healthManager = await health.createHealthManager();

// 初始化环境传感器
this.envSensor = await environment.createEnvironmentSensor({
  types: ['temperature', 'humidity']
});

// 初始化分布式数据同步
const context = getContext(this);
this.kvManager = distributedData.createKVManager({ context });

async calculateCurrentNeed(userProfile: UserProfile): Promise<HydrationNeed> {

const [activityData, envData] = await Promise.all([
  this.getActivityData(),
  this.envSensor?.getData()
]);

// 基础需求计算(30ml/kg)
const base = userProfile.weight * 30;

// 活动量调整(每1000步+100ml)
const activityAdj = Math.floor(activityData.steps / 1000) * 100;

// 环境调整(温度>25℃每度+50ml，湿度<40%+100ml)
let envAdj = 0;
if (envData.temperature > 25) {
  envAdj += (envData.temperature - 25) * 50;

if (envData.humidity < 40) {

  envAdj += 100;

const recommendation: HydrationNeed = {

  timestamp: Date.now(),
  deviceId: 'local_device',
  baseRequirement: base,
  activityAdjustment: activityAdj,
  environmentAdjustment: envAdj,
  totalRecommendation: base + activityAdj + envAdj
};

await this.syncRecommendation(recommendation);
return recommendation;

// 其他方法…

分布式提醒管理

// HydrationReminder.ts
import reminderAgent from ‘@ohos.reminderAgent’;
import deviceManager from ‘@ohos.distributedHardware.deviceManager’;

export class HydrationReminder {
private reminders: Record<string, reminderAgent.ReminderRequest> = {};

async init() {
// 加载用户偏好
this.preferences = await this.loadPreferences();
async scheduleReminders(needs: HydrationNeed[]) {

const dailyGoal = needs[0].totalRecommendation;
const interval = this.calculateOptimalInterval(dailyGoal);

// 创建全天提醒计划
const startHour = 8;
const endHour = 20;
let currentHour = startHour;

while (currentHour <= endHour) {
  const reminder: reminderAgent.ReminderRequest = {
    reminderType: reminderAgent.ReminderType.REMINDER_TYPE_TIMER,
    triggerTime: this.getNextTriggerTime(currentHour),
    actionButton: [

title: ‘已喝水’, intent: ‘drank’ },

title: ‘稍后提醒’, intent: ‘snooze’ }

    ],
    notificationContent: {
      title: '喝水时间到',
      content: 今日目标: ${dailyGoal}ml，点击记录饮水量

};

  const reminderId = await reminderAgent.publish(reminder);
  this.reminders[reminderId] = reminder;
  
  currentHour += interval;

// 同步到其他设备

await this.syncRemindersToDevices();

// 其他方法…

主页面实现（ArkUI）

// HydrationApp.ets
import { HydrationCalculator } from ‘./HydrationCalculator’;
import { HydrationReminder } from ‘./HydrationReminder’;

@Entry
@Component
struct HydrationApp {
@State dailyGoal: number = 2000;
@State consumed: number = 0;
@State nextReminder?: string;
@State devices: string[] = [];

private calculator = new HydrationCalculator();
private reminder = new HydrationReminder();
private profile: UserProfile = {
weight: 70,
activityLevel: ‘moderate’
};

async aboutToAppear() {
await this.calculator.init();
await this.reminder.init();
this.loadDailyPlan();
async loadDailyPlan() {

const needs = await this.calculator.calculateCurrentNeed(this.profile);
this.dailyGoal = needs.totalRecommendation;
await this.reminder.scheduleReminders([needs]);

async logConsumption(amount: number) {

this.consumed += amount;
await this.syncConsumption({
  timestamp: Date.now(),
  amount,
  deviceId: 'local_device'
});

// 如果达到目标，取消后续提醒
if (this.consumed >= this.dailyGoal) {
  await this.reminder.cancelAllReminders();

}

build() {
Column() {
// 饮水进度展示
WaterProgress({
goal: this.dailyGoal,
consumed: this.consumed
})

  // 快捷记录按钮
  Row() {
    Button('+100ml').onClick(() => this.logConsumption(100))
    Button('+250ml').onClick(() => this.logConsumption(250))
    Button('+500ml').onClick(() => this.logConsumption(500))

// 设备连接状态

  Text(${this.devices.length}个设备同步中)
    .fontSize(14)
    .fontColor('#666666')
  
  // 设置入口
  Button('个性化设置')
    .onClick(() => this.showSettings())

}

@Component

struct WaterProgress {
@Prop goal: number;
@Prop consumed: number;

build() {
Column() {
Text(‘今日饮水’)
.fontSize(18)

  ProgressBar({
    value: this.consumed,
    total: this.goal
  })
  .width('80%')
  .height(20)
  
  Text({this.consumed}ml / {this.goal}ml)
    .fontSize(16)
  
  Text(完成度: ${((this.consumed / this.goal) * 100).toFixed(0)}%)
    .fontSize(14)
    .fontColor(this.getCompletionColor())

}

private getCompletionColor(): Resource {
const ratio = this.consumed / this.goal;
if (ratio < 0.5) return $r(‘app.color.warning’);
if (ratio < 0.8) return $r(‘app.color.normal’);
return $r(‘app.color.excellent’);
}

三、跨设备协同关键实现
饮水记录同步

// 在HydrationCalculator中添加
private async syncConsumption(record: WaterIntakeRecord) {
const kvStore = await this.kvManager.getKVStore(‘water_intake’);
await kvStore.put(record_${record.timestamp}, record);
async getTodayIntake(): Promise<number> {

const kvStore = await this.kvManager.getKVStore(‘water_intake’);
const todayStart = new Date().setHours(0, 0, 0, 0);

const entries = await kvStore.entries(‘record_’);
return entries
.filter(([, v]) => v.timestamp >= todayStart)
.reduce((sum, [, record]) => sum + record.amount, 0);

设备间状态同步

// 新增DeviceSync.ts
export class DeviceSync {
static async syncStateToAllDevices(state: AppState) {
const devices = await deviceManager.getTrustedDeviceListSync();
await Promise.all(devices.map(device =>
this.updateDeviceState(device.deviceId, state)
));
private static async updateDeviceState(deviceId: string, state: AppState) {

try {
  await distributedData.setRemoteKVStore(deviceId, 'hydration_state', {
    dailyGoal: state.dailyGoal,
    consumed: state.consumed,
    lastUpdate: Date.now()
  });

catch (err) {

  console.error(同步状态到${deviceId}失败:, err);

}

// 其他方法…

智能提醒调整

// 在HydrationReminder中添加
async adjustRemindersBasedOnIntake() {
const currentIntake = await this.calculator.getTodayIntake();
const remaining = this.dailyGoal - currentIntake;

if (remaining <= 0) {
await this.cancelAllReminders();
return;
// 重新计算剩余时间的提醒间隔

const now = new Date();
const hoursLeft = 20 - now.getHours(); // 假设20点为结束时间
const optimalInterval = Math.max(1, Math.floor(hoursLeft / (remaining / 250)));

await this.rescheduleReminders(optimalInterval);

四、性能优化方案
本地数据缓存

const intakeCache = new Map<string, number>();

async getCachedIntake(date: string): Promise<number> {
const cacheKey = intake_${date};
if (intakeCache.has(cacheKey)) {
return intakeCache.get(cacheKey)!;
const intake = await this.getDailyIntakeFromDB(date);

intakeCache.set(cacheKey, intake);
return intake;

批量数据同步

// 在HydrationCalculator中添加
private async syncMultipleRecords(records: WaterIntakeRecord[]) {
const kvStore = await this.kvManager.getKVStore(‘water_intake’);
const batch = records.map(record => ({
key: record_${record.timestamp},
value: record
}));

await kvStore.putBatch(batch);

差异同步策略

// 在DeviceSync中添加
static async syncOnlyChanges(lastSync: number): Promise<Partial<AppState>> {
const kvStore = await distributedData.getKVStore(‘water_intake’);
const changes = await kvStore.getChangesSince(lastSync);

return {
consumed: changes.reduce((sum, r) => sum + r.amount, 0),
lastUpdate: Date.now()
};

五、应用场景扩展
智能水杯集成

class SmartCupIntegration {
async connectAndMonitor(cupDeviceId: string) {
// 连接智能水杯并实时监测饮水量
}

水分平衡分析

class HydrationBalance {
async analyzeWeeklyPattern() {
// 分析每周饮水模式
}

个性化建议引擎

class RecommendationEngine {
async generatePersonalizedTips() {
// 基于用户习惯生成饮水建议
}

团队饮水挑战

class TeamChallenge {
async createFamilyChallenge(goal: number) {
// 创建家庭饮水挑战
}

本系统充分利用HarmonyOS分布式能力，实现了：
多设备状态同步：任意设备记录实时更新所有终端

智能提醒策略：基于活动量和环境动态调整

饮水进度可视化：直观展示每日饮水进度