基于HarmonyOS Next的智能健康监测应用开发实战

基于HarmonyOS Next的智能健康监测应用开发实战

一、项目概述

随着人们健康意识的提升，健康管理类应用越来越受到欢迎。本教程将带领开发者使用DevEco Studio和ArkTS语言，开发一款基于HarmonyOS Next的智能健康监测应用。该应用将实现以下核心功能：

1. 实时心率监测与可视化
2. 每日步数统计与分析
3. 睡眠质量评估
4. 健康数据云端同步

本教程面向有一定HarmonyOS开发基础的开发者，通过完整的项目实战，帮助掌握鸿蒙健康管理类应用的开发技巧。

二、开发环境准备

在开始开发前，请确保已完成以下准备工作：

1. 安装最新版DevEco Studio（建议4.0及以上版本）
2. 配置HarmonyOS Next开发环境
3. 准备一台支持鸿蒙系统的真机设备（或使用模拟器）
4. 申请健康数据访问权限

// 检查设备健康数据权限
import abilityAccessCtrl from '@ohos.abilityAccessCtrl';

async function checkHealthPermission(): Promise<boolean> {
  try {
    const atManager = abilityAccessCtrl.createAtManager();
    const grantStatus = await atManager.checkAccessToken(
      abilityAccessCtrl.ATokenTypeEnum.TOKEN_NATIVE,
      'ohos.permission.READ_HEALTH_DATA'
    );
    return grantStatus === abilityAccessCtrl.GrantStatus.PERMISSION_GRANTED;
  } catch (err) {
    console.error(`Check permission failed, code is ${err.code}, message is ${err.message}`);
    return false;
  }
}

三、项目结构设计

我们的健康监测应用将采用以下模块化结构：

health_monitor/
├── entry/
│   ├── src/
│   │   ├── main/
│   │   │   ├── ets/
│   │   │   │   ├── components/      # 自定义组件
│   │   │   │   ├── model/          # 数据模型
│   │   │   │   ├── pages/          # 页面
│   │   │   │   ├── service/        # 服务层
│   │   │   │   └── utils/          # 工具类
│   │   │   └── resources/          # 资源文件

四、核心功能实现

4.1 心率监测模块

// src/main/ets/service/HeartRateService.ets
import { HealthData, HealthType } from '@ohos.health';
import { BusinessError } from '@ohos.base';

export class HeartRateService {
  private static instance: HeartRateService | null = null;
  private healthData: HealthData | null = null;

  private constructor() {
    this.initHealthData();
  }

  public static getInstance(): HeartRateService {
    if (!HeartRateService.instance) {
      HeartRateService.instance = new HeartRateService();
    }
    return HeartRateService.instance;
  }

  private async initHealthData(): Promise<void> {
    try {
      this.healthData = await HealthData.createInstance();
      console.info('HealthData instance created successfully');
    } catch (error) {
      console.error(`Failed to create HealthData instance, error: ${JSON.stringify(error)}`);
    }
  }

  // 获取实时心率数据
  public async getRealTimeHeartRate(callback: (value: number) => void): Promise<void> {
    if (!this.healthData) {
      console.error('HealthData is not initialized');
      return;
    }

    try {
      await this.healthData.startReading({
        dataType: HealthType.HealthDataType.HEART_RATE,
        callback: (data) => {
          if (data && data.length > 0) {
            const heartRate = data[0].value;
            callback(heartRate);
          }
        }
      });
    } catch (error) {
      const err: BusinessError = error as BusinessError;
      console.error(`Failed to read heart rate, code: ${err.code}, message: ${err.message}`);
    }
  }

  // 停止心率监测
  public async stopHeartRateMonitoring(): Promise<void> {
    if (!this.healthData) return;
    
    try {
      await this.healthData.stopReading({
        dataType: HealthType.HealthDataType.HEART_RATE
      });
      console.info('Heart rate monitoring stopped');
    } catch (error) {
      console.error(`Failed to stop heart rate monitoring: ${JSON.stringify(error)}`);
    }
  }
}

4.2 步数统计模块

// src/main/ets/service/StepCounterService.ets
import { HealthData, HealthType } from '@ohos.health';
import { BusinessError } from '@ohos.base';

export class StepCounterService {
  private static instance: StepCounterService | null = null;
  private healthData: HealthData | null = null;

  private constructor() {
    this.initHealthData();
  }

  public static getInstance(): StepCounterService {
    if (!StepCounterService.instance) {
      StepCounterService.instance = new StepCounterService();
    }
    return StepCounterService.instance;
  }

  private async initHealthData(): Promise<void> {
    try {
      this.healthData = await HealthData.createInstance();
    } catch (error) {
      console.error(`Failed to create HealthData instance: ${JSON.stringify(error)}`);
    }
  }

  // 获取今日步数
  public async getTodaySteps(): Promise<number> {
    if (!this.healthData) return 0;

    try {
      const now = new Date();
      const startOfDay = new Date(now.getFullYear(), now.getMonth(), now.getDate());
      
      const result = await this.healthData.read({
        dataType: HealthType.HealthDataType.STEP_COUNT,
        startTime: startOfDay.getTime(),
        endTime: now.getTime()
      });

      if (result && result.length > 0) {
        return result.reduce((total, data) => total + data.value, 0);
      }
      return 0;
    } catch (error) {
      const err: BusinessError = error as BusinessError;
      console.error(`Failed to read step count, code: ${err.code}, message: ${err.message}`);
      return 0;
    }
  }

  // 获取步数历史数据
  public async getStepHistory(days: number): Promise<Array<{date: string, steps: number}>> {
    if (!this.healthData || days <= 0) return [];

    try {
      const now = new Date();
      const startDate = new Date(now);
      startDate.setDate(now.getDate() - days);
      
      const result = await this.healthData.read({
        dataType: HealthType.HealthDataType.STEP_COUNT,
        startTime: startDate.getTime(),
        endTime: now.getTime(),
        timeUnit: HealthType.TimeUnit.DAY
      });

      const stepsByDay: Array<{date: string, steps: number}> = [];
      
      if (result && result.length > 0) {
        result.forEach(data => {
          const date = new Date(data.startTime);
          const dateStr = `${date.getFullYear()}-${date.getMonth()+1}-${date.getDate()}`;
          stepsByDay.push({
            date: dateStr,
            steps: data.value
          });
        });
      }

      return stepsByDay;
    } catch (error) {
      console.error(`Failed to read step history: ${JSON.stringify(error)}`);
      return [];
    }
  }
}

五、UI界面开发

5.1 主页面布局

// src/main/ets/pages/Index.ets
import { HeartRateService } from '../service/HeartRateService';
import { StepCounterService } from '../service/StepCounterService';

@Entry
@Component
struct Index {
  @State heartRate: number = 0;
  @State todaySteps: number = 0;
  @State isMonitoring: boolean = false;
  private heartRateService: HeartRateService = HeartRateService.getInstance();
  private stepService: StepCounterService = StepCounterService.getInstance();

  aboutToAppear() {
    this.loadStepData();
  }

  async loadStepData() {
    this.todaySteps = await this.stepService.getTodaySteps();
  }

  toggleHeartRateMonitoring() {
    if (this.isMonitoring) {
      this.heartRateService.stopHeartRateMonitoring();
      this.isMonitoring = false;
    } else {
      this.heartRateService.getRealTimeHeartRate((rate) => {
        this.heartRate = rate;
      });
      this.isMonitoring = true;
    }
  }

  build() {
    Column() {
      // 顶部标题
      Text('健康监测')
        .fontSize(24)
        .fontWeight(FontWeight.Bold)
        .margin({ top: 20, bottom: 30 })

      // 心率监测卡片
      HealthCard({
        title: '心率监测',
        value: this.heartRate,
        unit: 'BPM',
        icon: $r('app.media.heart_icon'),
        isActive: this.isMonitoring,
        onToggle: this.toggleHeartRateMonitoring.bind(this)
      })

      // 步数统计卡片
      HealthCard({
        title: '今日步数',
        value: this.todaySteps,
        unit: '步',
        icon: $r('app.media.steps_icon'),
        showButton: false
      })

      // 健康数据图表
      HealthChart()
        .margin({ top: 20 })
    }
    .width('100%')
    .height('100%')
    .padding(16)
    .backgroundColor('#F5F5F5')
  }
}

@Component
struct HealthCard {
  private title: string = '';
  private value: number = 0;
  private unit: string = '';
  private icon: Resource = $r('app.media.default_icon');
  private isActive: boolean = false;
  private showButton: boolean = true;
  private onToggle?: () => void;

  build() {
    Column() {
      Row() {
        Image(this.icon)
          .width(24)
          .height(24)
          .margin({ right: 8 })
        
        Text(this.title)
          .fontSize(18)
          .fontWeight(FontWeight.Medium)
      }
      .justifyContent(FlexAlign.Start)
      .width('100%')
      .margin({ bottom: 12 })

      Row() {
        Text(this.value.toString())
          .fontSize(32)
          .fontWeight(FontWeight.Bold)
        
        Text(this.unit)
          .fontSize(16)
          .margin({ left: 4, top: 8 })
      }
      .justifyContent(FlexAlign.Center)
      .width('100%')

      if (this.showButton) {
        Button(this.isActive ? '停止监测' : '开始监测')
          .width('60%')
          .margin({ top: 16 })
          .onClick(() => {
            if (this.onToggle) {
              this.onToggle();
            }
          })
      }
    }
    .padding(16)
    .backgroundColor(Color.White)
    .borderRadius(12)
    .shadow({ radius: 6, color: '#00000020', offsetX: 0, offsetY: 2 })
    .margin({ bottom: 16 })
    .width('100%')
  }
}

5.2 健康数据图表组件

// src/main/ets/components/HealthChart.ets
@Component
export struct HealthChart {
  @State stepData: Array<{date: string, steps: number}> = [];
  private stepService: StepCounterService = StepCounterService.getInstance();

  aboutToAppear() {
    this.loadStepHistory();
  }

  async loadStepHistory() {
    this.stepData = await this.stepService.getStepHistory(7);
  }

  build() {
    Column() {
      Text('最近7天步数统计')
        .fontSize(18)
        .fontWeight(FontWeight.Medium)
        .margin({ bottom: 12 })
        .width('100%')
        .textAlign(TextAlign.Start)

      if (this.stepData.length > 0) {
        Row() {
          ForEach(this.stepData, (item) => {
            Column() {
              // 柱状图
              Column()
                .width(24)
                .height(item.steps / 50) // 按比例缩放高度
                .backgroundColor('#4CAF50')
                .borderRadius(4)
                .margin({ bottom: 4 })

              // 日期标签
              Text(item.date.split('-')[2]) // 只显示日
                .fontSize(12)
            }
            .margin({ right: 12 })
            .justifyContent(FlexAlign.End)
            .height(120)
          })
        }
        .width('100%')
        .justifyContent(FlexAlign.SpaceAround)
      } else {
        Text('暂无数据')
          .fontSize(14)
          .margin({ top: 20 })
      }
    }
    .padding(16)
    .backgroundColor(Color.White)
    .borderRadius(12)
    .shadow({ radius: 6, color: '#00000020', offsetX: 0, offsetY: 2 })
    .width('100%')
  }
}

六、数据持久化与云端同步

6.1 本地数据存储

// src/main/ets/service/StorageService.ets
import { dataStorage } from '@ohos.data.storage';

export class StorageService {
  private static instance: StorageService | null = null;
  private storage: dataStorage.Storage | null = null;

  private constructor() {
    this.initStorage();
  }

  public static getInstance(): StorageService {
    if (!StorageService.instance) {
      StorageService.instance = new StorageService();
    }
    return StorageService.instance;
  }

  private async initStorage(): Promise<void> {
    try {
      this.storage = await dataStorage.getStorage('/data/storage/health_data');
      console.info('Storage initialized successfully');
    } catch (error) {
      console.error(`Failed to initialize storage: ${JSON.stringify(error)}`);
    }
  }

  // 保存健康数据
  public async saveHealthData(key: string, value: any): Promise<boolean> {
    if (!this.storage) return false;

    try {
      await this.storage.put(key, JSON.stringify(value));
      await this.storage.flush();
      return true;
    } catch (error) {
      console.error(`Failed to save data: ${JSON.stringify(error)}`);
      return false;
    }
  }

  // 读取健康数据
  public async getHealthData(key: string): Promise<any> {
    if (!this.storage) return null;

    try {
      const value = await this.storage.get(key, '');
      return value ? JSON.parse(value) : null;
    } catch (error) {
      console.error(`Failed to get data: ${JSON.stringify(error)}`);
      return null;
    }
  }
}

6.2 云端数据同步

// src/main/ets/service/CloudSyncService.ets
import { cloud } from '@ohos.cloud';
import { BusinessError } from '@ohos.base';
import { StorageService } from './StorageService';

export class CloudSyncService {
  private static instance: CloudSyncService | null = null;
  private storageService: StorageService = StorageService.getInstance();

  private constructor() {}

  public static getInstance(): CloudSyncService {
    if (!CloudSyncService.instance) {
      CloudSyncService.instance = new CloudSyncService();
    }
    return CloudSyncService.instance;
  }

  // 同步健康数据到云端
  public async syncHealthData(userId: string): Promise<boolean> {
    try {
      // 从本地存储获取数据
      const heartData = await this.storageService.getHealthData('heart_rate_data');
      const stepData = await this.storageService.getHealthData('step_data');

      if (!heartData && !stepData) {
        console.info('No health data to sync');
        return true;
      }

      // 调用云端API同步数据
      const result = await cloud.callFunction({
        name: 'syncHealthData',
        data: {
          userId: userId,
          heartRate: heartData,
          steps: stepData
        }
      });

      if (result && result.success) {
        console.info('Health data synced successfully');
        return true;
      } else {
        console.error('Failed to sync health data');
        return false;
      }
    } catch (error) {
      const err: BusinessError = error as BusinessError;
      console.error(`Sync failed, code: ${err.code}, message: ${err.message}`);
      return false;
    }
  }

  // 从云端获取健康数据
  public async fetchHealthData(userId: string): Promise<boolean> {
    try {
      const result = await cloud.callFunction({
        name: 'getHealthData',
        data: {
          userId: userId
        }
      });

      if (result && result.data) {
        // 保存到本地存储
        await this.storageService.saveHealthData('heart_rate_data', result.data.heartRate);
        await this.storageService.saveHealthData('step_data', result.data.steps);
        return true;
      }
      return false;
    } catch (error) {
      console.error(`Fetch health data failed: ${JSON.stringify(error)}`);
      return false;
    }
  }
}

七、应用测试与优化

7.1 功能测试要点

1. 心率监测测试：

   • 验证实时心率数据准确性
   • 测试开始/停止监测功能
   • 验证无权限时的错误处理

2. 步数统计测试：

   • 验证步数统计准确性
   • 测试历史数据查询功能
   • 验证跨日期数据分割

3. 数据同步测试：

   • 测试本地数据存储
   • 验证云端同步功能
   • 测试网络异常处理

7.2 性能优化建议

1. 数据采集优化：

   // 使用适当的采样频率
   this.healthData.startReading({
     dataType: HealthType.HealthDataType.HEART_RATE,
     samplingInterval: 1000, // 1秒采样一次
     callback: (data) => {
       // 处理数据
     }
   });

2. 内存管理优化：

   • 及时释放不再使用的资源
   • 使用@State和@Link管理组件状态
   • 避免不必要的全局变量

3. UI渲染优化：

   • 使用ForEach渲染列表数据
   • 对复杂计算使用Worker线程
   • 减少不必要的组件重建

八、项目扩展方向

1. 健康趋势分析：

   • 增加周/月健康数据分析
   • 提供健康评分系统
   • 生成健康报告

2. 智能提醒功能：

   • 久坐提醒
   • 心率异常提醒
   • 每日目标达成提醒

3. 社交功能：

   • 健康数据分享
   • 好友健康挑战
   • 健康社区互动

4. 设备扩展：

   • 支持更多健康设备
   • 实现多设备数据同步
   • 开发手表配套应用

九、总结

本教程详细介绍了如何使用DevEco Studio和ArkTS开发基于HarmonyOS Next的健康监测应用。通过本项目的实践，开发者可以掌握：

1. 鸿蒙健康数据API的使用方法
2. ArkTS语言的核心特性
3. 鸿蒙应用的UI开发技巧
4. 数据持久化与云端同步方案
5. 性能优化与测试方法

健康管理类应用是鸿蒙生态中的重要组成部分，随着HarmonyOS Next的不断发展，开发者可以充分利用其分布式能力和丰富的硬件生态，创造出更加智能、个性化的健康管理解决方案。