Developing a Fitness & Health App on HarmonyOS Next: Heart Rate Monitoring and Health Reporting System

// pages/HeartRateMonitor.ets  
import sensor from '@ohos.sensor';  
import abilityAccessCtrl, { Permissions } from '@ohos.abilityAccessCtrl';  

// 1. Dynamically request heart rate sensor permission  
async function requestPermission(): Promise<void> {  
  try {  
    let atManager = abilityAccessCtrl.createAtManager();  
    let permission: Permissions = 'ohos.permission.HEALTH_DATA';  
    await atManager.requestPermissionsFromUser(getContext(this), [permission]);  
    console.info('Heart rate permission granted');  
  } catch (err) {  
    console.error(`Permission request failed: ${err.code}, ${err.message}`);  
  }  
}  

// 2. Initialize heart rate sensor  
let heartRateSensor: sensor.HeartRateResponse | null = null;  

function initHeartRateSensor(): void {  
  try {  
    // Get sensor instance  
    heartRateSensor = sensor.getSensor(sensor.SensorId.HEART_RATE);  
    if (!heartRateSensor) {  
      console.error('Device lacks heart rate sensor');  
      return;  
    }  

    // Set data callback  
    heartRateSensor.on('data', (data: sensor.HeartRateResponse) => {  
      if (data.heartRate) {  
        // Update UI (assumes @State heartRate: number)  
        this.heartRate = data.heartRate;  
        console.info(`Real-time heart rate: ${this.heartRate} bpm`);  
        // Sync data to cloud  
        this.uploadHeartRateData(this.heartRate);  
      }  
    });  

    // Error handling  
    heartRateSensor.on('error', (err: BusinessError) => {  
      console.error(`Sensor error: ${err.code}, ${err.message}`);  
    });  
  } catch (err) {  
    console.error(`Sensor init failed: ${err.code}, ${err.message}`);  
  }  
}  

// 3. Start/stop monitoring  
function startMonitoring(): void {  
  if (heartRateSensor) {  
    try {  
      // Set sampling rate (NORMAL ≈ 5s intervals)  
      heartRateSensor.setInterval(sensor.Interval.NORMAL);  
      heartRateSensor.start();  
    } catch (err) {  
      console.error(`Start failed: ${err.code}, ${err.message}`);  
    }  
  }  
}  

function stopMonitoring(): void {  
  if (heartRateSensor) {  
    try {  
      heartRateSensor.stop();  
    } catch (err) {  
      console.error(`Stop failed: ${err.code}, ${err.message}`);  
    }  
  }  
}  

// Initialize on page display  
aboutToAppear(): void {  
  requestPermission().then(() => {  
    initHeartRateSensor();  
  });  
}  

// Release sensor on page hide  
aboutToDisappear(): void {  
  stopMonitoring();  
}  

// utils/CloudDBManager.ets  
import cloud from '@ohos.cloud.agconnect';  
import { HeartRateData } from '../model/HeartRateData';  

// Initialize Cloud DB  
const agcCloud = cloud.agconnectCloudDb();  
const cloudDbZone = agcCloud.agconnectCloudDbZone();  

// Data model class (matches cloud object type)  
export class HeartRateData {  
  userId: string = '';  
  heartRate: number = 0;  
  timestamp: Date = new Date();  

  constructor(userId: string, heartRate: number, timestamp: Date) {  
    this.userId = userId;  
    this.heartRate = heartRate;  
    this.timestamp = timestamp;  
  }  

  static getObjectTypeName(): string {  
    return 'HeartRateData';  
  }  
}  

// Upload heart rate data  
export async function uploadHeartRateData(heartRate: number): Promise<void> {  
  try {  
    // 1. Get current user ID (requires AGC Auth)  
    const currentUser = getCurrentUser();  
    if (!currentUser) {  
      console.warn('Upload skipped: User not logged in');  
      return;  
    }  

    // 2. Create data object  
    const hrData = new HeartRateData(currentUser.uid, heartRate, new Date());  

    // 3. Upsert operation  
    const upsertResult = await cloudDbZone.upsert(HeartRateData.getObjectTypeName(), [hrData]);  
    console.info('Data uploaded!', upsertResult);  
  } catch (err) {  
    console.error(`Upload failed: ${err.code}, ${err.message}`);  
    // Add retry/local caching logic here  
  }  
}  

// functions/generateDailyReport.js  
const agconnect = require('@agconnect/common-server');  
const cloudDb = require('@agconnect/database-server').cloudDb;  

exports.main = async function (event) {  
  agconnect.instance().init();  
  const agcCloudDb = cloudDb.cloudDb();  
  const cloudDbZone = agcCloudDb.agconnectCloudDbZone();  

  const calculateStats = async (userId) => {  
    // Get yesterday's data (00:00 - 23:59)  
    const yesterday = new Date();  
    yesterday.setDate(yesterday.getDate() - 1);  
    const startTime = new Date(yesterday.setHours(0, 0, 0, 0));  
    const endTime = new Date(yesterday.setHours(23, 59, 59, 999));  

    const query = cloudDb.CloudDBZoneQuery.where(HeartRateData)  
      .equalTo('userId', userId)  
      .greaterThanOrEqualTo('timestamp', startTime)  
      .lessThanOrEqualTo('timestamp', endTime);  

    const snapshot = await cloudDbZone.executeQuery(query);  
    const hrDataList = snapshot.getSnapshotObjects();  

    if (hrDataList.length === 0) return null;  

    const values = hrDataList.map(data => data.heartRate);  
    return {  
      date: startTime.toISOString().split('T')[0], // YYYY-MM-DD  
      min: Math.min(...values),  
      max: Math.max(...values),  
      avg: Math.round(values.reduce((a, b) => a + b, 0) / values.length),  
      resting: calculateRestingHr(values), // Custom calculation  
      userId: userId  
    };  
  };  

  const saveReport = async (report) => {  
    if (!report) return;  
    const reportObj = new HealthReport(report);  
    await cloudDbZone.upsert('HealthReport', [reportObj]);  
    console.log(`Report generated for ${report.userId} (${report.date})`);  
  };  

  // Target users (fetch dynamically in production)  
  const targetUsers = ['user123', 'user456'];   
  for (const userId of targetUsers) {  
    const report = await calculateStats(userId);  
    await saveReport(report);  
  }  
  return { message: 'Daily report task completed' };  
};  

// HealthReport model (define in Cloud DB)  
class HealthReport {  
  constructor({ date, min, max, avg, resting, userId }) {  
    this.reportDate = date;  
    this.minHeartRate = min;  
    this.maxHeartRate = max;  
    this.avgHeartRate = avg;  
    this.restingHeartRate = resting;  
    this.userId = userId;  
    this.generatedAt = new Date();  
  }  
}  

// pages/Achievements.ets  
import { HealthReport } from '../model';  
import { cloudDbZone } from '../utils/CloudDBManager';  

@State dailyStats: HealthReport | null = null;  
@State stepCount: number = 0; // From step sensor  

// Fetch today's health report  
async function fetchTodayReport(): Promise<void> {  
  try {  
    const currentUser = getCurrentUser();  
    if (!currentUser) return;  

    const today = new Date().toISOString().split('T')[0];  
    const query = cloudDb.CloudDBZoneQuery.where(HealthReport)  
      .equalTo('userId', currentUser.uid)  
      .equalTo('reportDate', today);  

    const snapshot = await cloudDbZone.executeQuery(query);  
    const reports = snapshot.getSnapshotObjects();  
    if (reports.length > 0) this.dailyStats = reports[0];  
  } catch (err) {  
    console.error('Fetch report failed:', err);  
  }  
}  

// Badge logic (e.g., 7 consecutive days达标)  
checkConsistencyMedal(): void {  
  if (this.dailyStats && this.dailyStats.restingHeartRate < 60) {  
    this.consecutiveDays++;  
    if (this.consecutiveDays >= 7) {  
      console.log('Earned "Heart Steady Star" badge!');  
    }  
  } else {  
    this.consecutiveDays = 0;  
  }  
}  

// Step leaderboard (Top 10)  
@State leaderboard: { userId: string, steps: number }[] = [];  

async function fetchStepLeaderboard(): Promise<void> {  
  try {  
    const query = cloudDb.CloudDBZoneQuery.where('DailyStepSummary')  
      .equalTo('date', new Date().toISOString().split('T')[0])  
      .orderByDesc('totalSteps')  
      .limit(10);  

    const snapshot = await cloudDbZone.executeQuery(query);  
    this.leaderboard = snapshot.getSnapshotObjects();  
  } catch (err) {  
    console.error('Fetch leaderboard failed:', err);  
  }  
}  

build() {  
  Column() {  
    // Display health report  
    if (this.dailyStats) {  
      Card() {  
        Text(`Today's Report (${this.dailyStats.reportDate})`)  
          .fontSize(18)  
        Row() {  
          Text(`Avg: ${this.dailyStats.avgHeartRate}`)  
          Text(`Min: ${this.dailyStats.minHeartRate}`)  
          Text(`Max: ${this.dailyStats.maxHeartRate}`)  
          Text(`Resting: ${this.dailyStats.restingHeartRate}`)  
        }.justifyContent(FlexAlign.SpaceAround)  
      }  
    }  

    // Badge display  
    if (this.hasMedal) {  
      Image($r('app.medal.heart_steady'))  
        .width(80)  
        .height(80)  
    }  

    // Leaderboard  
    List() {  
      ForEach(this.leaderboard, (item, index) => {  
        ListItem() {  
          Row() {  
            Text(`${index + 1}. User_${item.userId.slice(0, 4)}`)  
            Text(`Steps: ${item.steps}`).fontColor(Color.Blue)  
          }  
        }  
      })  
    }  
  }  
}