鸿蒙空气质量管理应用开发指南 原创

鸿蒙空气质量管理应用开发指南

一、系统架构设计

基于HarmonyOS的分布式能力和传感器技术，我们设计了一套空气质量监测系统，主要功能包括：
传感器接入：连接各类环境传感器获取数据

数据分析：实时分析空气质量指标

多设备协同：跨设备同步空气质量数据

健康建议：根据空气质量提供健康建议

预警通知：空气质量异常时及时提醒

!https://example.com/harmony-air-quality-arch.png

二、核心代码实现
传感器服务管理

// SensorService.ets
import sensor from ‘@ohos.sensor’;

class SensorService {
private static instance: SensorService;
private pm25Sensor: sensor.Sensor | null = null;
private co2Sensor: sensor.Sensor | null = null;
private tvocSensor: sensor.Sensor | null = null;
private temperatureSensor: sensor.Sensor | null = null;
private humiditySensor: sensor.Sensor | null = null;

private constructor() {}

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

public async initSensors(): Promise<void> {

try {
  this.pm25Sensor = await sensor.getSensor(sensor.SensorType.SENSOR_TYPE_PM25);
  this.co2Sensor = await sensor.getSensor(sensor.SensorType.SENSOR_TYPE_CO2);
  this.tvocSensor = await sensor.getSensor(sensor.SensorType.SENSOR_TYPE_TVOC);
  this.temperatureSensor = await sensor.getSensor(sensor.SensorType.SENSOR_TYPE_TEMPERATURE);
  this.humiditySensor = await sensor.getSensor(sensor.SensorType.SENSOR_TYPE_HUMIDITY);

catch (error) {

  console.error('初始化传感器失败:', error);

}

public startMonitoring(callback: (data: AirQualityData) => void): void {
if (this.pm25Sensor) {
this.pm25Sensor.on(‘change’, (data) => {
callback({
pm25: data.value,
timestamp: Date.now()
});
});
if (this.co2Sensor) {

  this.co2Sensor.on('change', (data) => {
    callback({
      co2: data.value,
      timestamp: Date.now()
    });
  });

if (this.tvocSensor) {

  this.tvocSensor.on('change', (data) => {
    callback({
      tvoc: data.value,
      timestamp: Date.now()
    });
  });

if (this.temperatureSensor) {

  this.temperatureSensor.on('change', (data) => {
    callback({
      temperature: data.value,
      timestamp: Date.now()
    });
  });

if (this.humiditySensor) {

  this.humiditySensor.on('change', (data) => {
    callback({
      humidity: data.value,
      timestamp: Date.now()
    });
  });

}

public stopMonitoring(): void {
this.pm25Sensor?.off(‘change’);
this.co2Sensor?.off(‘change’);
this.tvocSensor?.off(‘change’);
this.temperatureSensor?.off(‘change’);
this.humiditySensor?.off(‘change’);
public getCurrentReadings(): Promise<AirQualityData> {

return new Promise((resolve) => {
  const data: AirQualityData = {};
  
  if (this.pm25Sensor) {
    data.pm25 = this.pm25Sensor.getValue();

if (this.co2Sensor) {

    data.co2 = this.co2Sensor.getValue();

if (this.tvocSensor) {

    data.tvoc = this.tvocSensor.getValue();

if (this.temperatureSensor) {

    data.temperature = this.temperatureSensor.getValue();

if (this.humiditySensor) {

    data.humidity = this.humiditySensor.getValue();

data.timestamp = Date.now();

  resolve(data);
});

}

export const sensorService = SensorService.getInstance();

空气质量分析服务

// AirQualityService.ets
class AirQualityService {
private static instance: AirQualityService;

private constructor() {}

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

public analyzeAirQuality(data: AirQualityData): AirQualityAnalysis {

const analysis: AirQualityAnalysis = {
  aqi: this.calculateAQI(data),
  status: 'good',
  healthImplications: [],
  recommendations: []
};

// PM2.5分析
if (data.pm25) {
  const pm25Level = this.getPM25Level(data.pm25);
  analysis.status = this.getWorseStatus(analysis.status, pm25Level.status);
  analysis.healthImplications.push(...pm25Level.healthImplications);
  analysis.recommendations.push(...pm25Level.recommendations);

// CO2分析

if (data.co2) {
  const co2Level = this.getCO2Level(data.co2);
  analysis.status = this.getWorseStatus(analysis.status, co2Level.status);
  analysis.healthImplications.push(...co2Level.healthImplications);
  analysis.recommendations.push(...co2Level.recommendations);

// TVOC分析

if (data.tvoc) {
  const tvocLevel = this.getTVOCLevel(data.tvoc);
  analysis.status = this.getWorseStatus(analysis.status, tvocLevel.status);
  analysis.healthImplications.push(...tvocLevel.healthImplications);
  analysis.recommendations.push(...tvocLevel.recommendations);

// 温湿度分析

if (data.temperature && data.humidity) {
  const comfortLevel = this.getComfortLevel(data.temperature, data.humidity);
  analysis.status = this.getWorseStatus(analysis.status, comfortLevel.status);
  analysis.healthImplications.push(...comfortLevel.healthImplications);
  analysis.recommendations.push(...comfortLevel.recommendations);

return analysis;

private calculateAQI(data: AirQualityData): number {

let aqi = 0;

if (data.pm25) {
  aqi = Math.max(aqi, this.calculatePM25AQI(data.pm25));

if (data.co2) {

  aqi = Math.max(aqi, this.calculateCO2AQI(data.co2));

if (data.tvoc) {

  aqi = Math.max(aqi, this.calculateTVOCAQI(data.tvoc));

return aqi;

private calculatePM25AQI(pm25: number): number {

if (pm25 <= 12) return pm25 * 50 / 12;
if (pm25 <= 35) return 50 + (pm25 - 12) * 50 / 23;
if (pm25 <= 55) return 100 + (pm25 - 35) * 50 / 20;
if (pm25 <= 150) return 150 + (pm25 - 55) * 100 / 95;
if (pm25 <= 250) return 250 + (pm25 - 150) * 100 / 100;
return 350 + (pm25 - 250) * 100 / 150;

private getPM25Level(pm25: number): AirQualityLevel {

if (pm25 <= 12) {
  return {
    status: 'good',
    healthImplications: ['空气质量令人满意，基本无空气污染'],
    recommendations: ['保持通风']
  };

else if (pm25 <= 35) {

  return {
    status: 'moderate',
    healthImplications: ['空气质量可接受，但某些污染物可能对极少数异常敏感人群有较弱影响'],
    recommendations: ['敏感人群应减少户外活动']
  };

else {

  return {
    status: 'unhealthy',
    healthImplications: ['易感人群症状有轻度加剧，健康人群出现刺激症状'],
    recommendations: ['减少户外活动', '关闭门窗', '使用空气净化器']
  };

}

private getWorseStatus(current: string, newStatus: string): string {
const statusOrder = [‘good’, ‘moderate’, ‘unhealthy’, ‘very_unhealthy’, ‘hazardous’];
const currentIndex = statusOrder.indexOf(current);
const newIndex = statusOrder.indexOf(newStatus);
return currentIndex >= newIndex ? current : newStatus;
}

export const airQualityService = AirQualityService.getInstance();

多设备同步服务

// AirQualitySyncService.ets
import distributedData from ‘@ohos.data.distributedData’;

class AirQualitySyncService {
private static instance: AirQualitySyncService;
private kvManager: distributedData.KVManager;
private kvStore: distributedData.KVStore;

private constructor() {
this.initKVStore();
private async initKVStore(): Promise<void> {

const config = {
  bundleName: 'com.example.airQuality',
  userInfo: { userId: 'currentUser' }
};

this.kvManager = distributedData.createKVManager(config);
this.kvStore = await this.kvManager.getKVStore('air_quality_store', {
  createIfMissing: true
});

this.kvStore.on('dataChange', (data) => {
  this.handleRemoteUpdate(data);
});

public static getInstance(): AirQualitySyncService {

if (!AirQualitySyncService.instance) {
  AirQualitySyncService.instance = new AirQualitySyncService();

return AirQualitySyncService.instance;

public async syncAirQualityData(data: AirQualityData): Promise<void> {

await this.kvStore.put(data_${data.timestamp}, JSON.stringify(data));

public async getHistoricalData(hours: number = 24): Promise<AirQualityData[]> {

const entries = await this.kvStore.getEntries('data_');
const now = Date.now();
return Array.from(entries)
  .map(([_, value]) => JSON.parse(value))
  .filter(data => now - data.timestamp <= hours  60  60 * 1000)
  .sort((a, b) => a.timestamp - b.timestamp);

public async syncAlert(alert: AirQualityAlert): Promise<void> {

await this.kvStore.put(alert_${alert.id}, JSON.stringify(alert));

public async getRecentAlerts(): Promise<AirQualityAlert[]> {

const entries = await this.kvStore.getEntries('alert_');
return Array.from(entries)
  .map(([_, value]) => JSON.parse(value))
  .sort((a, b) => b.timestamp - a.timestamp);

private handleRemoteUpdate(data: distributedData.ChangeInfo): void {

if (data.deviceId === deviceInfo.deviceId) return;

const key = data.key as string;
if (key.startsWith('data_')) {
  const data = JSON.parse(data.value);
  EventBus.emit('airQualityDataUpdated', data);

else if (key.startsWith(‘alert_’)) {

  const alert = JSON.parse(data.value);
  EventBus.emit('airQualityAlertUpdated', alert);

}

export const airQualitySyncService = AirQualitySyncService.getInstance();

三、主界面实现
实时监测界面

// AirQualityView.ets
@Component
struct AirQualityView {
@State airData: AirQualityData = {};
@State analysis: AirQualityAnalysis | null = null;
@State isMonitoring: boolean = false;

aboutToAppear() {
sensorService.initSensors();
build() {

Column() {
  Text('空气质量监测')
    .fontSize(24)
    .fontWeight(FontWeight.Bold)
    .margin({ top: 16 })
  
  if (this.analysis) {
    // AQI显示
    Row() {
      Text('AQI')
        .fontSize(18)
      
      Text(this.analysis.aqi.toString())
        .fontSize(32)
        .fontColor(this.getStatusColor(this.analysis.status))
        .margin({ left: 8 })

// 状态指示

    Text(this.getStatusText(this.analysis.status))
      .fontSize(16)
      .fontColor(this.getStatusColor(this.analysis.status))
      .margin({ top: 8 })
    
    // 详细数据
    Grid() {
      GridItem() {
        AirQualityItem({ label: 'PM2.5', value: this.airData.pm25, unit: 'μg/m³' })

GridItem() {

        AirQualityItem({ label: 'CO₂', value: this.airData.co2, unit: 'ppm' })

GridItem() {

        AirQualityItem({ label: 'TVOC', value: this.airData.tvoc, unit: 'ppb' })

GridItem() {

        AirQualityItem({ label: '温度', value: this.airData.temperature, unit: '°C' })

GridItem() {

        AirQualityItem({ label: '湿度', value: this.airData.humidity, unit: '%' })

}

    .columnsTemplate('1fr 1fr')
    .rowsGap(10)
    .columnsGap(10)
    .margin({ top: 16 })
    
    // 健康建议
    if (this.analysis.recommendations.length > 0) {
      Column() {
        Text('健康建议')
          .fontSize(18)
          .fontWeight(FontWeight.Bold)
          .margin({ top: 16 })
        
        ForEach(this.analysis.recommendations, (recommendation) => {
          Text(• ${recommendation})
            .fontSize(14)
            .margin({ top: 4 })
        })

}

// 控制按钮

  Button(this.isMonitoring ? '停止监测' : '开始监测')
    .onClick(() => this.toggleMonitoring())
    .margin({ top: 16 })
    .width('80%')

.padding(16)

private toggleMonitoring(): void {

if (this.isMonitoring) {
  sensorService.stopMonitoring();

else {

  sensorService.startMonitoring((data) => {
    this.airData = { ...this.airData, ...data };
    this.analysis = airQualityService.analyzeAirQuality(this.airData);
    
    // 同步数据
    airQualitySyncService.syncAirQualityData(this.airData);
    
    // 检查是否需要预警
    if (this.analysis.status !== 'good') {
      this.sendAlert(this.analysis);

});

this.isMonitoring = !this.isMonitoring;

private sendAlert(analysis: AirQualityAnalysis): void {

const alert: AirQualityAlert = {
  id: generateId(),
  level: analysis.status,
  message: 空气质量{this.getStatusText(analysis.status)}: {analysis.healthImplications[0]},
  timestamp: Date.now(),
  aqi: analysis.aqi
};

airQualitySyncService.syncAlert(alert);
EventBus.emit('airQualityAlert', alert);

private getStatusText(status: string): string {

const statusMap: Record<string, string> = {
  good: '优',
  moderate: '良',
  unhealthy: '轻度污染',
  very_unhealthy: '中度污染',
  hazardous: '重度污染'
};

return statusMap[status] || '未知';

private getStatusColor(status: string): string {

const colorMap: Record<string, string> = {
  good: '#4CAF50',
  moderate: '#FFC107',
  unhealthy: '#FF9800',
  very_unhealthy: '#F44336',
  hazardous: '#9C27B0'
};

return colorMap[status] || '#000000';

}

@Component
struct AirQualityItem {
private label: string;
private value: number | undefined;
private unit: string;

build() {
Column() {
Text(this.label)
.fontSize(14)
.fontColor(‘#666666’)

  if (this.value !== undefined) {
    Text({this.value.toFixed(1)} {this.unit})
      .fontSize(18)
      .margin({ top: 4 })

else {

    Text('--')
      .fontSize(18)
      .margin({ top: 4 })

}

.padding(8)
.backgroundColor('#F5F5F5')
.borderRadius(8)

}

历史数据界面

// HistoryView.ets
@Component
struct HistoryView {
@State history: AirQualityData[] = [];
@State timeRange: string = ‘24h’;
@State selectedMetric: string = ‘pm25’;

aboutToAppear() {
this.loadHistory();
EventBus.on(‘airQualityDataUpdated’, () => this.loadHistory());
build() {

Column() {
  // 时间范围选择
  Row() {
    ForEach(['24h', '7d', '30d'], (range) => {
      Button(range)
        .onClick(() => {
          this.timeRange = range;
          this.loadHistory();
        })
        .stateEffect(this.timeRange === range)
        .margin(4)
    })

.margin({ top: 16 })

  // 指标选择
  Picker({ range: this.getMetricOptions(), selected: this.getMetricIndex() })
    .onChange((index: number) => {
      this.selectedMetric = this.getMetricOptions()[index];
    })
    .margin({ top: 8 })
  
  // 图表
  if (this.history.length > 0) {
    AirQualityChart({
      data: this.history,
      metric: this.selectedMetric,
      timeRange: this.timeRange
    })
    .height(200)
    .margin({ top: 16 })

else {

    Text('暂无历史数据')
      .fontSize(16)
      .margin({ top: 32 })

// 数据列表

  if (this.history.length > 0) {
    List({ space: 10 }) {
      ForEach(this.getDisplayData(), (item) => {
        ListItem() {
          HistoryItem({ data: item, metric: this.selectedMetric })

})

.layoutWeight(1)

}

.padding(16)

private async loadHistory(): Promise<void> {

const hours = this.getHoursFromRange();
this.history = await airQualitySyncService.getHistoricalData(hours);

private getHoursFromRange(): number {

const rangeMap: Record<string, number> = {
  '24h': 24,
  '7d': 168,
  '30d': 720
};

return rangeMap[this.timeRange] || 24;

private getMetricOptions(): string[] {

return ['PM2.5', 'CO₂', 'TVOC', '温度', '湿度'];

private getMetricIndex(): number {

return this.getMetricOptions().indexOf(this.selectedMetric);

private getDisplayData(): AirQualityData[] {

// 根据时间范围筛选数据
const now = Date.now();
const hours = this.getHoursFromRange();
const filtered = this.history.filter(data => 
  now - data.timestamp <= hours  60  60 * 1000
);

// 根据时间范围决定显示密度
if (this.timeRange === '24h') {
  return filtered.slice(-20); // 显示最近20条

else if (this.timeRange === ‘7d’) {

  return filtered.filter((_, i) => i % 3 === 0); // 每3条显示1条

else {

  return filtered.filter((_, i) => i % 10 === 0); // 每10条显示1条

}

@Component

struct HistoryItem {
private data: AirQualityData;
private metric: string;

build() {
Row() {
Column() {
Text(formatTime(this.data.timestamp))
.fontSize(14)

    Text(formatDate(this.data.timestamp))
      .fontSize(12)
      .fontColor('#666666')
      .margin({ top: 4 })

.layoutWeight(1)

  Text(this.getValue())
    .fontSize(16)
    .fontColor(this.getColor())

.padding(12)

private getValue(): string {

const value = this.data[this.getMetricKey()];
if (value === undefined) return '--';

const unit = this.getUnit();
return {value.toFixed(1)} {unit};

private getMetricKey(): string {

const keyMap: Record<string, string> = {
  'PM2.5': 'pm25',
  'CO₂': 'co2',
  'TVOC': 'tvoc',
  '温度': 'temperature',
  '湿度': 'humidity'
};

return keyMap[this.metric] || 'pm25';

private getUnit(): string {

const unitMap: Record<string, string> = {
  'PM2.5': 'μg/m³',
  'CO₂': 'ppm',
  'TVOC': 'ppb',
  '温度': '°C',
  '湿度': '%'
};

return unitMap[this.metric] || '';

private getColor(): string {

const value = this.data[this.getMetricKey()];
if (value === undefined) return '#000000';

if (this.metric === 'PM2.5') {
  if (value <= 35) return '#4CAF50';
  if (value <= 75) return '#FFC107';
  return '#F44336';

if (this.metric === ‘CO₂’) {

  if (value <= 1000) return '#4CAF50';
  if (value <= 2000) return '#FFC107';
  return '#F44336';

return ‘#000000’;

}

function formatTime(timestamp: number): string {
const date = new Date(timestamp);
return {date.getHours()}:{date.getMinutes().toString().padStart(2, ‘0’)};
function formatDate(timestamp: number): string {

const date = new Date(timestamp);
return {date.getMonth() + 1}/{date.getDate()};

预警通知界面

// AlertView.ets
@Component
struct AlertView {
@State alerts: AirQualityAlert[] = [];

aboutToAppear() {
this.loadAlerts();
EventBus.on(‘airQualityAlertUpdated’, () => this.loadAlerts());
build() {

Column() {
  Text('空气质量预警')
    .fontSize(24)
    .fontWeight(FontWeight.Bold)
    .margin({ top: 16 })
  
  if (this.alerts.length === 0) {
    Text('暂无预警通知')
      .fontSize(16)
      .margin({ top: 32 })

else {

    List({ space: 10 }) {
      ForEach(this.alerts, (alert) => {
        ListItem() {
          AlertItem({ alert })

})

.layoutWeight(1)

}

.padding(16)

private async loadAlerts(): Promise<void> {

this.alerts = await airQualitySyncService.getRecentAlerts();

}

@Component
struct AlertItem {
private alert: AirQualityAlert;

build() {
Column() {
Row() {
Text(this.alert.message)
.fontSize(16)
.fontColor(this.getAlertColor())
.layoutWeight(1)

    Text(formatDateTime(this.alert.timestamp))
      .fontSize(12)
      .fontColor('#666666')

Row() {

    Text(AQI: ${this.alert.aqi})
      .fontSize(14)
    
    Text(级别: ${this.getAlertLevelText()})
      .fontSize(14)
      .margin({ left: 16 })

.margin({ top: 8 })

  Divider()
    .margin({ top: 8 })

.padding(12)

private getAlertColor(): string {

const colorMap: Record<string, string> = {
  good: '#4CAF50',
  moderate: '#FFC107',
  unhealthy: '#FF9800',
  very_unhealthy: '#F44336',
  hazardous: '#9C27B0'
};

return colorMap[this.alert.level] || '#000000';

private getAlertLevelText(): string {

const levelMap: Record<string, string> = {
  good: '优',
  moderate: '良',
  unhealthy: '轻度污染',
  very_unhealthy: '中度污染',
  hazardous: '重度污染'
};

return levelMap[this.alert.level] || '未知';

}

function formatDateTime(timestamp: number): string {
const date = new Date(timestamp);
return {date.getMonth() + 1}/{date.getDate()} {date.getHours()}:{date.getMinutes().toString().padStart(2, ‘0’)};

四、高级功能实现
多设备协同预警

// CollaborativeAlertService.ets
class CollaborativeAlertService {
private static instance: CollaborativeAlertService;

private constructor() {}

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

public async broadcastAlert(alert: AirQualityAlert): Promise<void> {

const devices = await deviceManager.getTrustedDevices();
await Promise.all(devices.map(device => 
  this.sendAlertToDevice(device.id, alert)
));

private async sendAlertToDevice(deviceId: string, alert: AirQualityAlert): Promise<void> {

const ability = await featureAbility.startAbility({
  bundleName: 'com.example.airQuality',
  abilityName: 'AirQualityAlertAbility',
  deviceId
});

await ability.call({
  method: 'receiveAlert',
  parameters: [alert]
});

public async syncAllAlertsToNewDevice(deviceId: string): Promise<void> {

const alerts = await airQualitySyncService.getRecentAlerts();
const ability = await featureAbility.startAbility({
  bundleName: 'com.example.airQuality',
  abilityName: 'AlertSyncAbility',
  deviceId
});

await ability.call({
  method: 'receiveMultipleAlerts',
  parameters: [alerts]
});

}

export const alertService = CollaborativeAlertService.getInstance();

智能家居联动

// SmartHomeService.ets
import smarthome from ‘@ohos.smarthome’;

class SmartHomeService {
private static instance: SmartHomeService;
private homeManager: smarthome.SmartHomeManager;

private constructor() {
this.homeManager = smarthome.createSmartHomeManager();
public static getInstance(): SmartHomeService {

if (!SmartHomeService.instance) {
  SmartHomeService.instance = new SmartHomeService();

return SmartHomeService.instance;

public async controlDevicesBasedOnAirQuality(data: AirQualityData): Promise<void> {

const devices = await this.homeManager.getDevices();

// 控制空气净化器
const purifier = devices.find(d => d.type === 'air_purifier');
if (purifier) {
  if (data.pm25 && data.pm25 > 35) {
    await this.homeManager.turnOnDevice(purifier.id);
    await this.homeManager.setDeviceProperty(purifier.id, 'speed', 'high');

else if (data.pm25 && data.pm25 <= 12) {

    await this.homeManager.turnOffDevice(purifier.id);

}

// 控制新风系统
const ventilator = devices.find(d => d.type === 'ventilator');
if (ventilator) {
  if (data.co2 && data.co2 > 1000) {
    await this.homeManager.turnOnDevice(ventilator.id);

else if (data.co2 && data.co2 <= 800) {

    await this.homeManager.turnOffDevice(ventilator.id);

}

// 控制加湿器
const humidifier = devices.find(d => d.type === 'humidifier');
if (humidifier && data.humidity) {
  if (data.humidity < 40) {
    await this.homeManager.turnOnDevice(humidifier.id);

else if (data.humidity > 60) {

    await this.homeManager.turnOffDevice(humidifier.id);

}

public async getConnectedDevices(): Promise<SmartHomeDevice[]> {

return this.homeManager.getDevices();

}

export const smartHomeService = SmartHomeService.getInstance();

健康建议服务

// HealthAdviceService.ets
class HealthAdviceService {
private static instance: HealthAdviceService;

private constructor() {}

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

public getHealthAdvice(data: AirQualityData, analysis: AirQualityAnalysis): HealthAdvice[] {

const advice: HealthAdvice[] = [];

// PM2.5相关建议
if (data.pm25 && data.pm25 > 35) {
  advice.push({
    type: 'pm25',
    level: 'warning',
    message: 'PM2.5浓度较高',
    suggestions: [
      '减少户外活动',
      '关闭门窗',
      '使用空气净化器'

});

// CO2相关建议

if (data.co2 && data.co2 > 1000) {
  advice.push({
    type: 'co2',
    level: 'warning',
    message: '二氧化碳浓度较高',
    suggestions: [
      '开窗通风',
      '减少室内人数',
      '增加绿植'

});

// 温湿度建议

if (data.temperature && data.humidity) {
  if (data.temperature < 18 || data.temperature > 28) {
    advice.push({
      type: 'temperature',
      level: 'notice',
      message: 室温{data.temperature}°C{data.temperature < 18 ? '偏低' : '偏高'},
      suggestions: [
        data.temperature < 18 ? '适当调高暖气' : '开启空调降温',
        '穿着合适的衣物'

});

if (data.humidity < 40 || data.humidity > 60) {

    advice.push({
      type: 'humidity',
      level: 'notice',
      message: 室内湿度{data.humidity}%{data.humidity < 40 ? '偏低' : '偏高'},
      suggestions: [
        data.humidity < 40 ? '使用加湿器' : '使用除湿机',
        data.humidity < 40 ? '多喝水保持水分' : '注意防霉'

});

}

return advice;

public getActivitySuggestion(aqi: number): ActivitySuggestion {

if (aqi <= 50) {
  return {
    outdoor: '非常适合户外活动',
    indoor: '正常通风即可',
    sensitiveGroup: '无需特别防护'
  };

else if (aqi <= 100) {

  return {
    outdoor: '适合户外活动',
    indoor: '建议适度通风',
    sensitiveGroup: '极少数异常敏感人群应减少户外活动'
  };

else {

  return {
    outdoor: '减少户外活动',
    indoor: '关闭门窗，使用空气净化器',
    sensitiveGroup: '避免户外活动'
  };

}

export const healthAdviceService = HealthAdviceService.getInstance();

五、总结

本空气质量管理应用实现了以下核心价值：
实时监测：精准获取各类空气质量指标

智能分析：综合评估空气质量并提供健康建议

多设备协同：家庭成员共享空气质量数据

智能联动：与智能家居设备联动改善室内环境

及时预警：空气质量异常时及时提醒用户

扩展方向：
增加室外空气质量数据对接

开发空气质量预测功能

集成更多健康管理功能

增加社区空气质量排名

注意事项：
需要申请ohos.permission.READ_SENSOR权限

部分功能需要连接智能家居设备

传感器数据准确性需定期校准

健康建议仅供参考，特殊情况请咨询医生

多设备协同需保持网络连接