From: Caisking Date: Fri, 18 Apr 2025 03:54:56 +0000 (+0800) Subject: 【心率】UI X-Git-Tag: leiniao_debug_1.0.0_20250922_020716~369 X-Git-Url: http://git.snicker.com.cn/css/static/gitweb.css?a=commitdiff_plain;h=cf49c34a8e0ae13df8eba4c0e5a5f5b61c984db2;p=mirrors%2FFD230.git 【心率】UI --- diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/include/HeartChartPresenter.h b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/include/HeartChartPresenter.h new file mode 100644 index 000000000..876166b71 --- /dev/null +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/include/HeartChartPresenter.h @@ -0,0 +1,59 @@ +/*** + * @Date: 2024-07-29 15:33:59 + * @LastEditors: Caisking 3449750381@qq.com + * @LastEditTime: 2024-07-29 16:28:08 + * @FilePath: /FD230/code/sdk/application/wearable/fd230app/nativeui/heartrate/include/HeartChartPresenter.h + */ + +#ifndef HEART_Chart_PRESENTER_H +#define HEART_Chart_PRESENTER_H + +#include "Presenter.h" +#include "components/ui_list.h" +#include "components/ui_view.h" +#include "KeyInputListener.h" +#include "ModelListenerSample.h" +#include "heartrate/include/HeartChartView.h" +#include "power_display_service.h" + +#define HEART_KEEP_TIME 40000 // 40s + +namespace OHOS +{ + + class HeartChartView; + class HeartChartPresenter : public Presenter, + public ModelListenerSample, + public UIView::OnClickListener, + public UIView::OnDragListener, + public RootView::OnKeyActListener, + public ListScrollListener + { + public: + HeartChartPresenter(); + ~HeartChartPresenter() override; + static HeartChartPresenter *GetInstance(void); + + void OnStart() override; + void OnResume() override; + void OnStop() override; + void OnTickEvent() override; + void Notify() override {} + bool OnClick(UIView &view, const ClickEvent &event) override; + bool OnDrag(UIView &view, const DragEvent &event) override; + bool OnKeyAct(UIView &view, const KeyEvent &event) override; // 增加按键事件 + + void NavigateBack(void); + + private: + void ResetTickTimer(void); + uint64_t startTime{0}; + bool HeartCountEvent{false}; + bool HeartCheckState{false}; + + const power_display_svr_api_t *display_api = power_display_svr_get_api(); + uint32_t display_time; + }; +} + +#endif // HEART_Chart_PRESENTER_H \ No newline at end of file diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/include/HeartChartView.h b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/include/HeartChartView.h new file mode 100644 index 000000000..06db4bd0c --- /dev/null +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/include/HeartChartView.h @@ -0,0 +1,96 @@ +/*** + * @Date: 2024-08-15 18:38:49 + * @LastEditors: Caisking 3449750381@qq.com + * @LastEditTime: 2024-08-26 15:17:07 + * @FilePath: + * /FD230/code/sdk/application/wearable/fd230app/nativeui/heartrate/include/HeartChartView.h + */ +/*** + * @Date: 2024-08-15 18:38:49 + * @LastEditors: Caisking 3449750381@qq.com + * @LastEditTime: 2024-08-15 20:25:38 + * @FilePath: + * /FD230/code/sdk/application/wearable/fd230app/nativeui/heartrate/include/HeartChartView.h + */ + +#ifndef HEART_Chart_VIEW_H +#define HEART_Chart_VIEW_H + + +#include "UiConfig.h" +#include "View.h" +#include "components/ui_button.h" +#include "components/ui_circle_progress.h" +#include "components/ui_image_animator.h" +#include "components/ui_label.h" +#include "components/ui_label_button.h" +#include "components/ui_label_ext.h" +#include "components/ui_view_group.h" +#include "wearable_log.h" + +#include "heartrate/include/HeartChartPresenter.h" + +#include "components/ui_label_button_ext.h" +#include "components/ui_scroll_view.h" + +#include "components/ui_chart.h" +#include "components/ui_image_animator.h" +#include "power_display_service.h" + +#define STOPCHECK "stop_check" +namespace OHOS { +class HeartChartPresenter; +class HeartChartView : public View { +public: + HeartChartView(); + virtual ~HeartChartView(); + + void OnStart() override; + static HeartChartView *GetInstance(void); + UIImageAnimatorView *GetImageAnimator(void); + void HeartbeatImageAnimatorStart(); + void HeartbeatImageAnimatorStop(); + + bool HeartViewInit(); + void InitChartView(void); + void InitChartLabel(void); + void InitChartImageView(void); + + void SetDataChart(); + void SetDataTopAndBottom(); + void HeartImageAnimator(); + + void UpdateShowHeart(void); + void Update_data_Chart(int serialIndex); + void CleanAllDataView(); + void UpdateChartConfig(); + void SetLastHeart(); + UIViewGroup *GetchartGroup(); + +private: + UIImageView *maxRateIconView_{nullptr}; + UIImageView *minRateIconView_{nullptr}; + UIImageView *chartBackgroundView_{nullptr}; + UIImageView *heartIconView_{nullptr}; + + UIImageAnimatorView *imageAnimator{nullptr}; + + Point heartdata[24]; + UIChartDataSerial *heartSerial{nullptr}; + UIChartPolyline *heartchart = nullptr; + + UILabelExt *displayheart_{nullptr}; + UILabelExt *uheart_{nullptr}; + UILabelExt *lastheart_{nullptr}; + UILabelExt *minheart_{nullptr}; + UILabelExt *maxheart_{nullptr}; + + UILabelExt *maxheart_dynamic_{nullptr}; + UILabelExt *maxheart_dynamic_3_{nullptr}; + UILabelExt *maxheart_dynamic_2_{nullptr}; + UILabelExt *maxheart_dynamic_1_{nullptr}; + UILabelExt *minheart_dynamic_{nullptr}; +}; +} // namespace OHOS + +#endif // 心率主界面 \ No newline at end of file diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/include/HeartDetectionPresenter.h b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/include/HeartDetectionPresenter.h new file mode 100644 index 000000000..8c7ec9318 --- /dev/null +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/include/HeartDetectionPresenter.h @@ -0,0 +1,59 @@ +/*** + * @Date: 2024-07-29 15:33:59 + * @LastEditors: Caisking 3449750381@qq.com + * @LastEditTime: 2024-07-29 16:28:08 + * @FilePath: /FD230/code/sdk/application/wearable/fd230app/nativeui/heartrate/include/HeartDetectionPresenter.h + */ + +#ifndef HEART_DETECTION_PRESENTER_H +#define HEART_DETECTION_PRESENTER_H + +#include "Presenter.h" +#include "components/ui_list.h" +#include "components/ui_view.h" +#include "KeyInputListener.h" +#include "ModelListenerSample.h" +#include "heartrate/include/HeartDetectionView.h" +#include "power_display_service.h" + +#define HEART_KEEP_TIME 40000 // 40s + +namespace OHOS +{ + + class HeartDetectionView; + class HeartDetectionPresenter : public Presenter, + public ModelListenerSample, + public UIView::OnClickListener, + public UIView::OnDragListener, + public RootView::OnKeyActListener, + public ListScrollListener + { + public: + HeartDetectionPresenter(); + ~HeartDetectionPresenter() override; + static HeartDetectionPresenter *GetInstance(void); + + void OnStart() override; + void OnResume() override; + void OnStop() override; + void OnTickEvent() override; + void Notify() override {} + bool OnClick(UIView &view, const ClickEvent &event) override; + bool OnDrag(UIView &view, const DragEvent &event) override; + bool OnKeyAct(UIView &view, const KeyEvent &event) override; // 增加按键事件 + + void NavigateBack(void); + + private: + void ResetTickTimer(void); + uint64_t startTime{0}; + bool HeartCountEvent{false}; + bool HeartCheckState{false}; + + const power_display_svr_api_t *display_api = power_display_svr_get_api(); + uint32_t display_time; + }; +} + +#endif // HEART_DETECTION_PRESENTER_H \ No newline at end of file diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/include/HeartDetectionView.h b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/include/HeartDetectionView.h new file mode 100644 index 000000000..2cc29217d --- /dev/null +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/include/HeartDetectionView.h @@ -0,0 +1,53 @@ + + +#ifndef HEART_Detection_VIEW_H +#define HEART_Detection_VIEW_H + +#include "View.h" + +#include "wearable_log.h" +#include "UiConfig.h" +#include "components/ui_label.h" +#include "components/ui_label_ext.h" +#include "components/ui_button.h" +#include "components/ui_label_button.h" +#include "components/ui_image_animator.h" +#include "components/ui_circle_progress.h" +#include "components/ui_view_group.h" + +#include "heartrate/include/HeartDetectionPresenter.h" + +#include "components/ui_scroll_view.h" +#include "components/ui_label_button_ext.h" + +#include "power_display_service.h" + +#define STOPCHECK "stop_check" +namespace OHOS +{ + class HeartDetectionPresenter; + class HeartDetectionView : public View + { + public: + HeartDetectionView(); + virtual ~HeartDetectionView(); + + void OnStart() override; + static HeartDetectionView *GetInstance(void); + + bool HeartDetectionViewInit(); + UIImageAnimatorView *GetImageAnimator(void); + void UpShowHeartText(void); + + private: + UIImageAnimatorView *imageAnimator{nullptr}; + UILabelExt *titleLabel{nullptr}; + UILabel *HeartText{nullptr}; + UIScrollView *HeartDetectionScrollView{nullptr}; + UILabelButtonExt *testButton{nullptr}; + + uint32_t heart_; + }; +} + +#endif // 心率主界面 \ No newline at end of file diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/include/HeartModel.h b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/include/HeartModel.h index 3891ec79a..00809cf43 100644 --- a/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/include/HeartModel.h +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/include/HeartModel.h @@ -1,11 +1,11 @@ #ifndef HEART_MODEL_H #define HEART_MODEL_H -#include +#include "MainClockView.h" #include "broadcast_feature.h" #include "broadcast_service.h" #include "samgr_lite.h" -#include "MainClockView.h" +#include #ifdef __cplusplus extern "C" { @@ -18,39 +18,39 @@ void HearDatatUnsubscribeTopic(Topic topic); #define HEART_ALL_POINTS 360 typedef struct { - uint16_t x; - uint16_t y; - bool flag; + uint16_t x; + uint16_t y; + bool flag; } Point; typedef struct { - /** X coordinate */ - uint16_t x; - /** Y coordinate */ - uint16_t y; + /** X coordinate */ + uint16_t x; + /** Y coordinate */ + uint16_t y; } HeartPoint; typedef struct { - uint16_t perSec; - uint16_t rest; - uint16_t minX; - uint16_t minValue; - uint16_t maxX; - uint16_t maxValue; - uint16_t index; - Point value[HEART_ALL_POINTS]; + uint16_t perSec; + uint16_t rest; + uint16_t minX; + uint16_t minValue; + uint16_t maxX; + uint16_t maxValue; + uint16_t index; + Point value[HEART_ALL_POINTS]; } HeartInfo; #pragma pack(4) typedef struct { - uint16_t perSec; - uint16_t rest; - uint16_t minX; - uint16_t minValue; - uint16_t maxX; - uint16_t maxValue; - uint16_t index; - HeartPoint value[HEART_ALL_POINTS]; + uint16_t perSec; + uint16_t rest; + uint16_t minX; + uint16_t minValue; + uint16_t maxX; + uint16_t maxValue; + uint16_t index; + HeartPoint value[HEART_ALL_POINTS]; } HeartDatas; #pragma pack() @@ -69,52 +69,137 @@ namespace OHOS { #define NUM_7 7 #define NUM_16 16 #define NUM_99 99 - +// 心率检测状态 +enum class HeartState { + End = 0, + Start, +}; +enum class HeartCheck { + RESTSTSTE = 0, // 未检测状态 + PASSIVITY, // 被动检测心率 + CARDCHECK, // 卡片检测 + INITIATIVE, // 主动检测心率 + EXERCISE, // 运动心率 +}; +enum class HeartResult { + NOT_TESTED = 0, // 未检测 + SUCCESS, // 检测成功 + NOT_WORN, // 未佩戴检测 + TIMEOUT, // 检测超时 + HIGH_RESULT, // 检测结果过高 + LOW_RESULT, // 检测结果过低 + INVALID_DATA // 无效数据 +}; +// 控制心率检测 typedef struct { - uint32_t heartRatePerSec; - Point heartRateAvg[HEART_AVE_NUM]; - uint32_t heartRateRest; - Point heartRateMax; - Point heartRateMin; + uint32_t heartRatePerSec; + Point heartRateAvg[HEART_AVE_NUM]; + uint32_t heartRateRest; + Point heartRateMax; + Point heartRateMin; } HealthAllDatas; class HeartModel { public: - HeartModel(); - ~HeartModel(); - static HeartModel *GetInstance(void); - void ObtainingHeartRateData(void); - void PushHealthDatas(HealthMsg healthMsg); - Point* GetAveHeartRate(void); - uint16_t GetAveHeartRateCount(void); - void SetAveHeartRateCount(uint16_t value); - Point* GetMaximumHeartRate(void); - void Init(void); - void HeartRatePros(HeartDatas *heartInfo); - void RefreshHeartRateScreen(uint16_t perSec, uint16_t rest, uint16_t maxRate, uint16_t minRate); - void ClearHeartData(void); - void HandleMaxHeart(uint16_t coord, uint16_t value); - void HandleMinHeart(uint16_t coord, uint16_t value); - void SetHeartRatePerSec(uint32_t sec); - void SetWearStatus(bool status); - bool GetWearStatus(void); - uint16_t GetHeartRateMax(void); - uint16_t GetHeartRateMin(void); + HeartModel(); + ~HeartModel(); + static HeartModel *GetInstance(void); + void ObtainingHeartRateData(void); + void PushHealthDatas(HealthMsg healthMsg); + Point *GetAveHeartRate(void); + uint16_t GetAveHeartRateCount(void); + void SetAveHeartRateCount(uint16_t value); + Point *GetMaximumHeartRate(void); + void Init(void); + void HeartRatePros(HeartDatas *heartInfo); + void RefreshHeartRateScreen(); + void ClearHeartData(void); + void HandleMaxHeart(uint16_t coord, uint16_t value); + void HandleMinHeart(uint16_t coord, uint16_t value); + void SetHeartRatePerSec(uint32_t sec); + uint16_t GetHeartRateMax(void); + uint16_t GetHeartRateMin(void); + /* -------------------------------------------------------------------------- + */ + void UpHeartdata(uint16_t heart); + uint16_t GetHeartdata(); + uint16_t GetShowHeartdata(); + uint16_t GetShowMaxHeartdata(); + uint16_t GetShowMinHeartdata(); + + uint16_t GetIndex(); + void SetIndex(uint16_t index); + + uint32_t GetCheckTime(void); + void SetCheckTime(uint32_t time); + void SetWearStatus(); + void SetResult(HeartResult result); + HeartResult GetResult(); + + void Heart_Start(HeartCheck check); + void Heart_Stop(void); + void Heart_Save(void); + void Heart_Result(void); + + void Heart_Control(HeartState state, HeartCheck check); + void ClearDisplayData(); + void Heart_Update_View(void); + void CleanAllData(void); + + std::string GetCheckString(); + uint16_t *GetArrayData(); + void SetArrayData(); + + void handleHeartResult(); + void logAndChangeSlice(HeartResult result); + void handleLowHeartRate(); + void handleHighHeartRate(); + + void heart_start_screen60s_timer(uint32_t interval = 30 * 1000); + void heart_stop_screen60s_timer(); + void reset_heart_screen60s_timer_time(); private: - HealthAllDatas healthDatas; - uint16_t pretime{0}; - uint16_t entryTimes{0}; - uint16_t aveCount{0}; - uint16_t preMaxValue{0}; - uint16_t preMaxX{NUM_1}; - uint16_t preMinValue{HEART_RATE_LIMIT_UPPER}; - uint16_t preMinX{NUM_1}; - uint16_t countMax{0}; - uint16_t countMin{0}; - bool wearStatus{false}; + HealthAllDatas healthDatas; + uint16_t pretime{0}; + uint16_t entryTimes{0}; + uint16_t aveCount{0}; + uint16_t preMaxValue{0}; + uint16_t preMaxX{NUM_1}; + uint16_t preMinValue{HEART_RATE_LIMIT_UPPER}; + uint16_t preMinX{NUM_1}; + uint16_t countMax{0}; + uint16_t countMin{0}; + bool wearStatus{true}; + uint16_t index_ = 0; + + uint16_t displayheart = 0; // 显示心率 + uint16_t currentheart = 0; // 保存心率 + uint16_t displayheart_max = 0; // 显示最大心率 + uint16_t displayheart_min = 0; // 显示最小心率 + + uint32 timestamp_ms; // 检测时间(存(时、分),大于24小时,改为1天前,小于1分钟为刚刚) + + bool initstatus = true; + bool heartstate = false; + bool sensorstate{false}; + + uint16_t wear_; + uint16_t valid_counter_ = 0; // 有效数计数器 + uint16_t disvalid_counter_ = 0; // 无效数计数器 + uint16_t unwear_counter_ = 0; // 佩戴错误计数器 + uint16_t display_counter_ = 0; //显示计数器 + + HeartResult heartresult_ = HeartResult::NOT_TESTED; // 检测结果 + HeartCheck checkstate = HeartCheck::RESTSTSTE; // 目前检测状态 + + uint16_t dynamic_heartrate[5]; //动态心率配置项 + + uint8_t heartRemindState{0}; + uint16_t thresholdValue{160}; + uint16_t thresholdState{1}; }; -} +} // namespace OHOS #ifdef __cplusplus } diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/include/HeartNoteView.h b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/include/HeartNoteView.h new file mode 100644 index 000000000..21383392c --- /dev/null +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/include/HeartNoteView.h @@ -0,0 +1,63 @@ +/*** + * @Date: 2024-04-15 10:55:58 + * @LastEditors: Caisking 3449750381@qq.com + * @LastEditTime: 2024-07-30 11:46:23 + * @FilePath: /FD230/code/sdk/application/wearable/fd230app/nativeui/bloodoxygen/include/HeartNoteView.h + */ +/*** + * @Date: 2024-04-15 10:55:58 + * @LastEditors: Caisking 3449750381@qq.com + * @LastEditTime: 2024-05-07 18:51:13 + * @FilePath: /XTS_FD230/FD230/code/sdk/application/wearable/fd230app/nativeui/bloodoxygen/include/HeartNoteView.h + */ +/* + * Copyright (c) CompanyNameMagicTag 2021-2021. All rights reserved. + * Description: bloodResult view + * Author: + * Create: 2021-08-01 + */ + +#ifndef HEART_NOTE_VIEW_H +#define HEART_NOTE_VIEW_H + +#include "View.h" + +#include "wearable_log.h" +#include "UiConfig.h" +#include "components/ui_label.h" +#include "components/ui_label_ext.h" +#include "components/ui_button.h" +#include "components/ui_label_button.h" +#include "components/ui_image_animator.h" +#include "components/ui_circle_progress.h" +#include "components/ui_view_group.h" + +#include "components/ui_scroll_view.h" +#include "components/ui_label_button_ext.h" +namespace OHOS { + +#define CLICK_HEART_STOP "click_heart_stop" +#define CLICK_HEART_RESTART "click_heart_restart" + + class HeartNoteView + { + public: + HeartNoteView(); + virtual ~HeartNoteView(); + UIScrollView *CreateHeartNoteView(void); + + private: + bool CrearAllView(); + // 提醒图标 + UIImageView *noteimage = nullptr; + // 按键 + UILabelButtonExt *StButton = nullptr; + UILabelButtonExt *ReButton = nullptr; + // 提醒label + UILabelExt *titleLabel = nullptr; + UILabelExt *noteLabel = nullptr; + UIScrollView *heartNoteView = nullptr; + }; +} + +#endif // 血氧主界面 \ No newline at end of file diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/include/HeartRateCardView.h b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/include/HeartRateCardView.h new file mode 100644 index 000000000..cdab034f6 --- /dev/null +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/include/HeartRateCardView.h @@ -0,0 +1,29 @@ +#ifndef HEART_RATECARD_VIEW_H +#define HEART_RATECARD_VIEW_H + +#include "components/root_view.h" +#include "components/ui_card_page.h" +#include "heartrate/include/HeartChartView.h" +#include "wearable_log.h" +namespace OHOS { + +class HeartRateCardView : public UICardPage { +public: + HeartRateCardView(); + virtual ~HeartRateCardView(); + static HeartRateCardView *GetInstance(void); + + bool InitView(void); + void PreLoad(void) override; + void UnLoad(void) override; + UIViewGroup *GetHeartRateCardView(); + +private: + HeartChartView *heartRateCardView{nullptr}; + UIViewGroup *heartRateGroupView{nullptr}; + void ClearAll(void); + bool viewiInitStatus{false}; +}; + +} // namespace OHOS +#endif \ No newline at end of file diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/include/HeartRateView.h b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/include/HeartRateView.h index 1d94d89e5..8117440d2 100644 --- a/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/include/HeartRateView.h +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/include/HeartRateView.h @@ -9,6 +9,7 @@ #define HEART_RATE_VIEW_H #include "View.h" + #include "components/ui_image_animator.h" #include "components/ui_chart.h" #include "wearable_log.h" @@ -16,7 +17,8 @@ #include "components/ui_card_page.h" #include "HeartModel.h" -namespace OHOS { +namespace OHOS +{ #define HEART_AVE_NUM 360 #define HEART_RATE_LIMIT_UPPER 200 #define HEART_RATE_LIMIT_LOWER 0 @@ -31,74 +33,88 @@ namespace OHOS { #define NUM_16 16 #define NUM_99 99 -class HeartRateView : public UICardPage { -public: - HeartRateView(); - ~HeartRateView() override; - static HeartRateView *GetInstance(void); + class HeartRateView : public UICardPage + { + public: + HeartRateView(); + ~HeartRateView() override; + static HeartRateView *GetInstance(void); + + bool InitView(void); + void PreLoad(void) override; + void UnLoad(void) override; + int32_t SetHeartRateData(Point *rateData, uint32 rateDataSize); // 设置心率数据,用于画心率曲线 + void RefreshElectrocardiogram(void); // 刷新心率曲线 + void ClearElectrocardiogram(void); // 清空心率曲线 + void RefreshHeartRatePerSec(uint16_t value); // 刷新每秒心率 + void RefreshHeartRateMax(uint16_t max); // 刷新心率最大值 + void RefreshHeartRateMin(uint16_t min); // 刷新心率最小值 + void RefreshRestHeartRate(uint16_t value); // 刷新静息心率 + void HeartbeatImageAnimatorStart(void); // 心形动画启动 + void HeartbeatImageAnimatorStop(void); // 心形动画停止 + void InitRefreshInterface(void); + void InitChartTest(void); + void Init_data_Chart(); + void Update_data_Chart(int serialIndex); + void UpdataChart(); + void CleanAllDataView(); - bool InitView(void); - void PreLoad(void) override; - void UnLoad(void) override; - int32_t SetHeartRateData(Point *rateData, uint32 rateDataSize); // 设置心率数据,用于画心率曲线 - void RefreshElectrocardiogram(void); // 刷新心率曲线 - void ClearElectrocardiogram(void); // 清空心率曲线 - void RefreshHeartRatePerSec(uint16_t value); // 刷新每秒心率 - void RefreshHeartRateMax(uint16_t max); // 刷新心率最大值 - void RefreshHeartRateMin(uint16_t min); // 刷新心率最小值 - void RefreshRestHeartRate(uint16_t value); // 刷新静息心率 - void HeartbeatImageAnimatorStart(void); // 心形动画启动 - void HeartbeatImageAnimatorStop(void); // 心形动画停止 - void InitRefreshInterface(void); + private: + typedef struct + { + uint8_t fontSize; + int16 x; + int16 y; + int16 width; + int16 height; + } LabelInfo; -private: - typedef struct { - uint8_t fontSize; - int16 x; - int16 y; - int16 width; - int16 height; - } LabelInfo; + int32_t InitHeartRateData(void); + void SetLabel(UILabel *label, LabelInfo labelInfo); + void HeartRateLabelDisplay(void); + void HeartRateCoordinate(void); + void HeartRateElectrocardiogram(void); + void InsertTopAndBottomRateImage(void); + void UpdataTopAndBottomRate(void); + void ElectrocardiogramOnePoint(Point *rateData, uint16_t index); + void ElectrocardiogramMultiPoint(Point *rateData, uint16_t rateDataNume); + int32_t HeartRateDataProc(void); + void HeartbeatImageAnimator(void); + void SetDataTopAndBottom(); - int32_t InitHeartRateData(void); - void SetLabel(UILabel *label, LabelInfo labelInfo); - void HeartRateLabelDisplay(void); - void HeartRateCoordinate(void); - void HeartRateElectrocardiogram(void); - void InsertTopAndBottomRateImage(void); - void UpdataTopAndBottomRate(void); - void ElectrocardiogramOnePoint(Point *rateData, uint16_t index); - void ElectrocardiogramMultiPoint(Point *rateData, uint16_t rateDataNume); - int32_t HeartRateDataProc(void); - void HeartbeatImageAnimator(void); + private: + Point heartRateData[HEART_AVE_NUM]; + Point rateDataTmp[HEART_AVE_NUM]; -private: - Point heartRateData[HEART_AVE_NUM]; - Point rateDataTmp[HEART_AVE_NUM]; + void PreLoadHeartRateImageRes(void); + void UnLoadHeartRateImageRes(void); + bool viewiInitStatus{false}; + bool resLoadStatus{false}; + UIChartPolyline *chart{nullptr}; + uint16_t dataNume; // 心率曲线记录数据总个数 + uint16_t currIndex; // 当前已显示心率曲线心率个数 + UIChartDataSerial *dataSerial[HEART_AVE_NUM]{nullptr}; + UIChartDataSerial *dataTopAndbottom{nullptr}; + UIImageView *imageViewTop{nullptr}; + UIImageView *imageViewBottom{nullptr}; + uint16_t serialIndex; + UIImageAnimatorView *imageAnimator{nullptr}; + UIImageView *imageViewCoordinate{nullptr}; - bool viewiInitStatus{false}; - bool resLoadStatus{false}; - UIChartPolyline *chart{nullptr}; - uint16_t dataNume; // 心率曲线记录数据总个数 - uint16_t currIndex; // 当前已显示心率曲线心率个数 - UIChartDataSerial *dataSerial[HEART_AVE_NUM]{nullptr}; - UIChartDataSerial *dataTopAndbottom{nullptr}; - UIImageView *imageViewTop{nullptr}; - UIImageView *imageViewBottom{nullptr}; - uint16_t serialIndex; - UIImageAnimatorView *imageAnimator{nullptr}; - UIImageView *imageViewCoordinate{nullptr}; + UILabel *topRate{nullptr}; + UILabel *bottomRate{nullptr}; + UILabel *ratePerSec{nullptr}; + UILabel *ratePerSecText{nullptr}; + UILabel *restRate{nullptr}; + UILabel *restRateText1{nullptr}; + UILabel *restRateText2{nullptr}; - UILabel *topRate{nullptr}; - UILabel *bottomRate{nullptr}; - UILabel *ratePerSec{nullptr}; - UILabel *ratePerSecText{nullptr}; - UILabel *restRate{nullptr}; - UILabel *restRateText1{nullptr}; - UILabel *restRateText2{nullptr}; + uint16_t maxRate; + uint16_t minRate; - uint16_t maxRate; - uint16_t minRate; -}; + Point heartdata[24]; + UIChartDataSerial *heartSerial{nullptr}; + UIChartPolyline *heartchart = nullptr; + }; } // namespace OHOS #endif // HEART_RATE_VIEW_H diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/include/HeartResultPresenter.h b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/include/HeartResultPresenter.h new file mode 100644 index 000000000..f3cf85598 --- /dev/null +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/include/HeartResultPresenter.h @@ -0,0 +1,53 @@ +/*** + * @Date: 2024-07-31 10:27:08 + * @LastEditors: Caisking 3449750381@qq.com + * @LastEditTime: 2024-07-31 10:31:42 + * @FilePath: /FD230/code/sdk/application/wearable/fd230app/nativeui/heartrate/include/HeartResultPresenter.h + */ + + +#ifndef HEART_RESULT_PRESENTER_H +#define HEART_RESULT_PRESENTER_H + +#include "Presenter.h" +#include "ModelListenerSample.h" +#include "components/ui_circle_progress.h" +#include "ohos_types.h" +#include "KeyInputListener.h" +#include "common/key_code.h" + +// #include "battery_hal.h" + +#include "heartrate/include/HeartResultView.h" + +namespace OHOS +{ + static constexpr const char *CLICK_HEART = "clickheart"; // 心率检测 + + class HeartResultView; + class HeartResultPresenter : public Presenter, + public UIView::OnClickListener, + public RootView::OnKeyActListener, + public UIView::OnDragListener + { + public: + HeartResultPresenter(); + virtual ~HeartResultPresenter(); + static HeartResultPresenter *GetInstance(void); + + void OnStart() override; + void OnPause() override; + void OnResume() override; + void OnStop() override; + + bool OnDrag(UIView &view, const DragEvent &event) override; + bool OnDragEnd(UIView &view, const DragEvent &event) override; + bool OnClick(UIView &view, const ClickEvent &event) override; + bool OnKeyAct(UIView &view, const KeyEvent &event) override; // 增加按键事件 + + uint32_t GetCurrentTime(); + int GetTDOA(uint32_t new_time, uint32_t old_time); + }; +} + +#endif diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/include/HeartResultView.h b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/include/HeartResultView.h new file mode 100644 index 000000000..62b37382a --- /dev/null +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/include/HeartResultView.h @@ -0,0 +1,49 @@ + +#ifndef HEART_Result_VIEW_H +#define HEART_Result_VIEW_H + +#include "View.h" + +#include "wearable_log.h" +#include "UiConfig.h" +#include "components/ui_label.h" +#include "components/ui_label_ext.h" +#include "components/ui_button.h" +#include "components/ui_label_button.h" +#include "components/ui_image_animator.h" +#include "components/ui_circle_progress.h" +#include "components/ui_view_group.h" +#include "heartrate/include/HeartResultPresenter.h" + +#include "components/ui_scroll_view.h" +#include "components/ui_label_button_ext.h" +namespace OHOS +{ + class HeartResultPresenter; + class HeartResultView : public View + { + public: + HeartResultView(); + virtual ~HeartResultView(); + static HeartResultView *GetInstance(void); + + void OnStart() override; + + bool HeartResultViewInit(); + void UpHeartText(void); + + void DeInit(); + bool AddButton(); + bool InitLable(); + bool Initbackground(); + + private: + UIImageView *background = nullptr; + UILabelExt *titleLabel = nullptr; + UILabelExt *timeLabel = nullptr; + UILabel *heartLabel = nullptr; + UILabelButtonExt *checkButton{nullptr}; + }; +} + +#endif // 心率主界面 \ No newline at end of file diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/src/HeartChartPresenter.cpp b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/src/HeartChartPresenter.cpp new file mode 100644 index 000000000..b6346b59d --- /dev/null +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/src/HeartChartPresenter.cpp @@ -0,0 +1,141 @@ +/*** + * @Date: 2024-08-15 18:39:25 + * @LastEditors: Caisking 3449750381@qq.com + * @LastEditTime: 2024-09-03 21:04:56 + * @FilePath: /FD230/code/sdk/application/wearable/fd230app/nativeui/heartrate/src/HeartChartPresenter.cpp + */ +/* + * Copyright (c) CompanyNameMagicTag 2021-2021. All rights reserved. + * Description: HeartChartPresenter.cpp + * Author: + * Create: 2021-11-23 + */ + +#include "heartrate/include/HeartChartView.h" +#include "heartrate/include/HeartChartPresenter.h" + +#include "AppViewIDs.h" +#include "NativeAbility.h" +#include "common/key_code.h" +#include "KeyInputListener.h" +#include "custom_utils.h" + +// #include "displaybrightness/include/DisplayBrightnessModel.h" + +#include "heartrate/include/HeartModel.h" +#include "MainModel.h" +#include "gfx_utils/mem_check.h" + +#include "NativeRegisterManager.h" + +namespace OHOS +{ + + REGIST_MENU_PRO(VIEW_HEART_CHART, HeartChartView, HeartChartPresenter, + PNG_APPLIST_HEART_IMAGE_BIG, PNG_APPLIST_HEART_IMAGE,PNG_APPLIST_HEART_IMAGE, "心率", STR_HEART_RATE); + + // 当前Presenter属性实例化的内存指针 + static HeartChartPresenter *g_pHeartChartPresenter = nullptr; + HeartChartPresenter::HeartChartPresenter() + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HeartChartPresenter::HeartChartPresenter"); + g_pHeartChartPresenter = this; +#ifdef MEM_CHECK + MemCheck::GetInstance()->EnableLeakCheck(true); +#endif + } + + HeartChartPresenter::~HeartChartPresenter() + { + g_pHeartChartPresenter = nullptr; +#ifdef MEM_CHECK + MemCheck::GetInstance()->EnableLeakCheck(false); +#endif + } + HeartChartPresenter *HeartChartPresenter::GetInstance() + { + return g_pHeartChartPresenter; + } + void HeartChartPresenter::NavigateBack() + { + NativeAbility::GetInstance().Back(TransitionType::TRANSITION_BACK_TO_HEXAGONS); + } + void HeartChartPresenter::OnStart() + { + Presenter::OnStart(); + if (!HeartCheckState) + { + HeartModel::GetInstance()->Heart_Start(HeartCheck::INITIATIVE); + HeartCheckState = true; + } + } + void HeartChartPresenter::OnResume(void) + { + } + + void HeartChartPresenter::OnStop(void) + { + if (HeartCheckState) + { + HeartModel::GetInstance()->Heart_Stop(); + HeartModel::GetInstance()->Heart_Control(HeartState::End, HeartCheck::INITIATIVE); // 主动检测心率关闭 + HeartCheckState = false; + } + } + + bool HeartChartPresenter::OnDrag(UIView &view, const DragEvent &event) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HeartChartPresenter::OnDrag"); + UNUSED(view); + if ((event.GetDragDirection() == DragEvent::DIRECTION_LEFT_TO_RIGHT) && (event.GetDeltaX() > X_DRAG_OFFSET) && + (event.GetDeltaX() > (DOUBLES * MATH_ABS(event.GetDeltaY())))) + { + NavigateBack(); + } + return false; + } + + bool HeartChartPresenter::OnClick(UIView &view, const ClickEvent &event) + { + if (strcmp(view.GetViewId(), STOPCHECK) == 0) + { + NavigateBack(); + } + return true; + } + + void HeartChartPresenter::OnTickEvent() + { + // 更新显示心率数据 + if(HeartChartView::GetInstance() == nullptr) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HeartChartView::GetInstance()==nullptr"); + return; + } + + uint64_t current_time = osKernelGetTick2ms(); + if ((startTime != 0) && (current_time - startTime >= HEART_KEEP_TIME)) + { + // 超时处理 + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "检测结果: 超时处理 HEART_KEEP_TIME: %lld", current_time - startTime); + HeartModel::GetInstance()->SetResult(HeartResult::TIMEOUT); + HeartModel::GetInstance()->Heart_Stop(); + return; + } + + HeartChartView::GetInstance()->UpdateShowHeart(); + } + + // 增加按键事件 + bool HeartChartPresenter::OnKeyAct(UIView &view, const KeyEvent &event) + { + unsigned short keyID = event.GetKeyId(); + unsigned short keyState = event.GetState(); + // 如果是power键,且是亮屏状态,按键释放就返回上一级 + if (keyID == static_cast(ZliteKeyCode::ZLITE_KEY_POWER) && keyState == 1 && uapi_get_screen_state() == 0) + { + NavigateBack(); + } + return true; + } +} diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/src/HeartChartView.cpp b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/src/HeartChartView.cpp new file mode 100644 index 000000000..aabb4cea9 --- /dev/null +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/src/HeartChartView.cpp @@ -0,0 +1,634 @@ +/*** + * @Date: 2024-08-15 18:39:02 + * @LastEditors: Caisking 3449750381@qq.com + * @LastEditTime: 2024-09-05 14:36:17 + * @FilePath: + * /FD230/code/sdk/application/wearable/fd230app/nativeui/heartrate/src/HeartChartView.cpp + */ +/*** + * @Date: 2024-04-15 10:55:58 + * @LastEditors: Caisking 3449750381@qq.com + * @LastEditTime: 2024-07-29 15:35:06 + * @FilePath: + * /FD230/code/sdk/application/wearable/fd230app/nativeui/heartrate/src/HeartChartView.cpp + */ +#include "HeartChartView.h" +#include "HeartModel.h" +#include "UiConfig.h" +#include "heart_blood/health_service/health_service.h" +#include "power_display_service.h" +#include "ui_image_animator.h" +#include "ui_resource_string.h" +#include "uicomponents/UIComponents.h" +#include "wearable_log.h" +namespace OHOS { +static HeartChartView *g_pHeartCheckView = nullptr; + +// 动态刷新设置 +static constexpr uint16_t IMAGE_SIZE = 180; +static constexpr uint16_t IMAGE_POSITION_Y = 134; +static constexpr uint16_t IMAGE_POSITION_X = 150; +static constexpr uint16_t Chart_IMAGE_ANIMATORVIEW_SIZE = 20; +static constexpr uint16_t Chart_IMAGE_ANIMATORVIEW_SPEED = 40; +// 图片路径 +static constexpr const char *BACKGROUND_IMAGE_PATH = + "/user/res/heart_chart/background.bin"; +static constexpr const char *BUTTOM_ICON_PATH = + "/user/res/heart_chart/buttomicon.bin"; +static constexpr const char *TOP_ICON_PATH = + "/user/res/heart_chart/topicon.bin"; +static constexpr const char *HEART_ICON_PATH = + "/user/res/heart_chart/hearticon.bin"; +// 心形心跳 +static constexpr int HEARTBEAT_IMAGE_WIDTH = 54; +static constexpr int HEARTBEAT_IMAGE_HEIGHT = 50; +static constexpr int HEARTBEAT_IMAGE_X = 111; +static constexpr int HEARTBEAT_IMAGE_Y = 57; +static constexpr int HEARTBEAT_IMAGE_NUM = 21; +static constexpr int HEARTBEAT_DELAY = 50; +// 心跳image +static ImageAnimatorInfo g_heartImageInfo[HEARTBEAT_IMAGE_NUM] = { + {PNG_A004_070_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_071_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_072_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_073_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_074_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_075_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_076_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_077_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_078_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_079_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_080_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_081_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_082_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_083_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_084_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_085_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_086_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_087_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_088_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_089_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_090_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, +}; + +HeartChartView::HeartChartView() { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HeartBandoffView::HeartBandoffView"); + g_pHeartCheckView = this; +} +HeartChartView::~HeartChartView() { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HeartChartView::~HeartChartView"); + + if (displayheart_) { + delete displayheart_; + displayheart_ = nullptr; + } + if (maxheart_) { + delete maxheart_; + maxheart_ = nullptr; + } + if (minheart_) { + delete minheart_; + minheart_ = nullptr; + } + if (uheart_) { + delete uheart_; + uheart_ = nullptr; + } + if (lastheart_) { + delete lastheart_; + lastheart_ = nullptr; + } + if (maxheart_dynamic_) { + delete maxheart_dynamic_; + maxheart_dynamic_ = nullptr; + } + if (maxheart_dynamic_3_) { + delete maxheart_dynamic_3_; + maxheart_dynamic_3_ = nullptr; + } + if (maxheart_dynamic_2_) { + delete maxheart_dynamic_2_; + maxheart_dynamic_2_ = nullptr; + } + if (maxheart_dynamic_1_) { + delete maxheart_dynamic_1_; + maxheart_dynamic_1_ = nullptr; + } + if (minheart_dynamic_) { + delete minheart_dynamic_; + minheart_dynamic_ = nullptr; + } + + if (maxRateIconView_) { + delete maxRateIconView_; + maxRateIconView_ = nullptr; + } + if (minRateIconView_) { + delete minRateIconView_; + minRateIconView_ = nullptr; + } + if (chartBackgroundView_) { + delete chartBackgroundView_; + chartBackgroundView_ = nullptr; + } + if (heartIconView_) { + delete heartIconView_; + heartIconView_ = nullptr; + } + + if (imageAnimator) { + imageAnimator->Stop(); + delete imageAnimator; + imageAnimator = nullptr; + } + + if (heartSerial) { + heartchart->ClearDataSerial(); + delete heartSerial; + heartSerial = nullptr; + } + + if (heartchart) { + delete heartchart; + heartchart = nullptr; + } + + g_pHeartCheckView = nullptr; +} +HeartChartView *HeartChartView::GetInstance(void) { return g_pHeartCheckView; } + +/* 更新显示数据 */ +void HeartChartView::UpdateShowHeart() { + + if (displayheart_ == nullptr) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, + "HeartChartView::UpdateShowHeart is error"); + return; + } + + // 获取当前心率 + uint16_t heart_ = HeartModel::GetInstance()->GetShowHeartdata(); + std::string heartrateStr = + (heart_ == 0) ? "--" : (heart_ < 50 ? "--" : std::to_string(heart_)); + // 更新当前心率显示 + if (displayheart_ != nullptr) { + displayheart_->SetText(heartrateStr.c_str()); + } +} +void HeartChartView::Update_data_Chart(int serialIndex) { + if (heartchart == nullptr) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Update_data_Chart fail %d", + serialIndex); + return; + } + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"开始更新曲线"); + /*清除原数据*/ + heartSerial->ClearData(); + + /*更新所有项*/ + for (int serialIndex = 0; serialIndex < 24; serialIndex++) { + heartdata[serialIndex].x = serialIndex; + heartdata[serialIndex].y = + HealthService::GetInstance()->GetHourlyHeartRate(serialIndex); + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"x:%d,y:%d\n", heartdata[serialIndex].x,heartdata[serialIndex].y); + } + /*重新添加*/ + heartSerial->AddPoints(heartdata, 24); + heartSerial->SetLineColor(Color::Red()); + heartSerial->SetFillColor(Color::Red()); + heartSerial->EnableGradient(true); + + // heartSerial->Refresh(); + + heartchart->AddDataSerial(heartSerial); + + // heartchart->RefreshChart(); + + RootView::GetInstance()->Invalidate(); + + //更新为刚刚检测 + SetLastHeart(); + + //更新最大最小值 + SetDataTopAndBottom(); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"更新更新曲线完成"); +} +void HeartChartView::CleanAllDataView() { + if (heartchart == nullptr || maxheart_ == nullptr || minheart_ == nullptr) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, " CleanAllDataView fail"); + return; + } + for (int serialIndex = 0; serialIndex < 24; serialIndex++) { + heartdata[serialIndex].x = serialIndex; + heartdata[serialIndex].y = + HealthService::GetInstance()->GetHourlyHeartRate(serialIndex); + } + + /*清空原数据*/ + heartSerial->ClearData(); + heartSerial->AddPoints(heartdata, 24); + heartSerial->SetLineColor(Color::Red()); + heartSerial->SetFillColor(Color::Red()); + heartSerial->EnableGradient(true); + + heartchart->AddDataSerial(heartSerial); + // heartchart->RefreshChart(); + + /*更新最大最小值*/ + SetDataTopAndBottom(); +} +/*设置最大最小数据*/ +void HeartChartView::SetDataTopAndBottom() { + int MaxHeart = HeartModel::GetInstance()->GetShowMaxHeartdata(); + int MinHeart = HeartModel::GetInstance()->GetShowMinHeartdata(); + + if (maxheart_ != nullptr) { + maxheart_->SetText(MaxHeart > 0 ? (std::to_string(MaxHeart)).c_str() + : "--"); + } + + if (minheart_ != nullptr) { + minheart_->SetText(MinHeart > 0 ? (std::to_string(MinHeart)).c_str() + : "--"); + } + + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "MaxHeart: %d, MinHeart: %d", MaxHeart, + MinHeart); +} +/*设置曲线图数据*/ +void HeartChartView::SetDataChart() { + if (heartchart == nullptr) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "Init_data_Chart new chart fail"); + return; + } + heartSerial = new UIChartDataSerial(); + heartSerial->SetMaxDataCount(24); +#if HEART_DATA_TEST + Point temp[] = {{0, 150}, {1, 250}, {2, 170}, {3, 0}, {4, 140}, + {5, 190}, {6, 100}, {7, 40}, {8, 10}, {9, 100}, + {10, 60}, {11, 20}, {12, 150}, {13, 250}, {14, 170}, + {15, 140}, {16, 78}, {17, 80}, {18, 100}, {19, 20}, + {20, 100}, {21, 100}, {22, 100}, {23, 100}}; + std::copy(std::begin(temp), std::end(temp), heartdata); +#else + for (int serialIndex = 0; serialIndex < 24; serialIndex++) { + heartdata[serialIndex].x = serialIndex; + heartdata[serialIndex].y = + HealthService::GetInstance()->GetHourlyHeartRate(serialIndex); + } +#endif + heartSerial->AddPoints(heartdata, 24); + heartSerial->SetLineColor(Color::Red()); + heartSerial->SetFillColor(Color::Red()); + heartSerial->EnableGradient(true); + + heartchart->AddDataSerial(heartSerial); + heartchart->Invalidate(); +} +/*设置心率动画*/ +void HeartChartView::HeartImageAnimator() { + imageAnimator = new UIImageAnimatorView(); + if (imageAnimator == nullptr) { + WEARABLE_LOGD( + WEARABLE_LOG_MODULE_APP, + "HeartRateView::[HeartbeatImageAnimator] new imageAnimator fail"); + return; + } + imageAnimator->SetPosition(HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y, + HEARTBEAT_IMAGE_WIDTH, HEARTBEAT_IMAGE_HEIGHT); + imageAnimator->SetImageAnimatorSrc(g_heartImageInfo, HEARTBEAT_IMAGE_NUM, + HEARTBEAT_DELAY); + imageAnimator->SetRepeat(true); + AddViewToRootContainer(imageAnimator); + // imageAnimator->Start(); +} +/*初始化心率曲线*/ +void HeartChartView::InitChartView(void) { + if (heartchart == nullptr) { + heartchart = new UIChartPolyline(); + } + heartchart->SetPosition(80, 199); + heartchart->Resize(313, 122); + heartchart->SetViewId("uiChart1"); + heartchart->SetStyle(STYLE_BACKGROUND_OPA, 0x00); + + UIXAxis &heartXAxis = heartchart->GetXAxis(); + heartXAxis.SetMarkNum(24); + heartXAxis.SetDataRange(0, 24); + heartXAxis.SetLineColor(Color::GetColorFromRGBA(0x33, 0x33, 0x33, 0xff)); + + UIYAxis &heartYAxis = heartchart->GetYAxis(); + heartYAxis.SetMarkNum(4); + heartYAxis.SetDataRange(0, 220); + heartYAxis.SetLineColor(Color::GetColorFromRGBA(0x33, 0x33, 0x33, 0xff)); + + heartchart->SetGradientOpacity(78, 64); + + // Add to rootView + AddViewToRootContainer(heartchart); +} + +//初始化label +/* +需要显示一个动态心率的效果 +有5个label代表 曲线图的yè½´ + 最大心率+10 + 最大心率+10-(最小心率-10)*3/4 + 最大心率+10-(最小心率-10)*2/4 + 最大心率+10-(最小心率-10)*1/4 + 最小心率-10 +*/ +void HeartChartView::InitChartLabel() { + //当前心率值 + InitLabel(displayheart_, 133, 32, 200, 100, "label", "--", GILROY_BOLD_FONT, + 65); + // 单位 + InitRollLabel(uheart_, 283, 52, 100, 60, "label", STR_TIMES_PER_MIN, + DEFAULT_VECTOR_FONT_FILENAME, 30); + uheart_->SetTextColor(Color::GetColorFromRGBA(0x99, 0x99, 0x99, 0xff)); + //上一次检测信息 + InitLabel(lastheart_, 53, 130, 360, 35, "label", "--", + DEFAULT_VECTOR_FONT_FILENAME_EN, 30); + lastheart_->SetLineBreakMode(UILabel::LINE_BREAK_OSCILLATION); + lastheart_->SetRollSpeed(23); + //最小心率 不居中 + InitLabelAdapt(minheart_, 293, 380, 200, 35, "label", "--", + DEFAULT_VECTOR_FONT_FILENAME_EN, 35); + //最大心率 不居中 + InitLabelAdapt(maxheart_, 158, 380, 200, 35, "label", "--", + DEFAULT_VECTOR_FONT_FILENAME_EN, 35); + + //动态心率最大 + InitLabel(maxheart_dynamic_, 30, 190, 50, 20, "label", "220", + DEFAULT_VECTOR_FONT_FILENAME_EN, 20); + maxheart_dynamic_->SetTextColor( + Color::GetColorFromRGBA(0x33, 0x33, 0x33, 0xff)); + //动态心率3/4 + InitLabel(maxheart_dynamic_3_, 30, 218, 50, 20, "label", "160", + DEFAULT_VECTOR_FONT_FILENAME_EN, 20); + maxheart_dynamic_3_->SetTextColor( + Color::GetColorFromRGBA(0x33, 0x33, 0x33, 0xff)); + //动态心率2/4 + InitLabel(maxheart_dynamic_2_, 30, 247, 50, 20, "label", "110", + DEFAULT_VECTOR_FONT_FILENAME_EN, 20); + maxheart_dynamic_2_->SetTextColor( + Color::GetColorFromRGBA(0x33, 0x33, 0x33, 0xff)); + //动态心率1/4 + InitLabel(maxheart_dynamic_1_, 30, 277, 50, 20, "label", "50", + DEFAULT_VECTOR_FONT_FILENAME_EN, 20); + maxheart_dynamic_1_->SetTextColor( + Color::GetColorFromRGBA(0x33, 0x33, 0x33, 0xff)); + //动态心率最小 + InitLabel(minheart_dynamic_, 30, 306, 50, 20, "label", "0", + DEFAULT_VECTOR_FONT_FILENAME_EN, 20); + minheart_dynamic_->SetTextColor( + Color::GetColorFromRGBA(0x33, 0x33, 0x33, 0xff)); + + AddViewToRootContainer(displayheart_); + AddViewToRootContainer(uheart_); + AddViewToRootContainer(lastheart_); + AddViewToRootContainer(minheart_); + AddViewToRootContainer(maxheart_); + AddViewToRootContainer(maxheart_dynamic_); + AddViewToRootContainer(maxheart_dynamic_3_); + AddViewToRootContainer(maxheart_dynamic_2_); + AddViewToRootContainer(maxheart_dynamic_1_); + AddViewToRootContainer(minheart_dynamic_); +} + +void HeartChartView::InitChartImageView() { + + if (minRateIconView_ == nullptr) { + minRateIconView_ = new UIImageView(); + } + minRateIconView_->SetPosition(266, 394); + minRateIconView_->Resize(100, 100); + minRateIconView_->SetViewId("minRateIcon"); + minRateIconView_->SetSrc(BUTTOM_ICON_PATH); + if (maxRateIconView_ == nullptr) { + maxRateIconView_ = new UIImageView(); + } + maxRateIconView_->SetPosition(129, 394); + maxRateIconView_->Resize(100, 100); + maxRateIconView_->SetViewId("maxRateIcon"); + maxRateIconView_->SetSrc(TOP_ICON_PATH); + + if (chartBackgroundView_ == nullptr) { + chartBackgroundView_ = new UIImageView(); + } + chartBackgroundView_->SetPosition(30, 160); + chartBackgroundView_->Resize(100, 100); + chartBackgroundView_->SetViewId("chartBackground"); + chartBackgroundView_->SetSrc(BACKGROUND_IMAGE_PATH); + + AddViewToRootContainer(chartBackgroundView_); + AddViewToRootContainer(minRateIconView_); + AddViewToRootContainer(maxRateIconView_); + + if (heartIconView_ == nullptr) { + heartIconView_ = new UIImageView(); + } + heartIconView_->SetPosition(111, 57); + heartIconView_->Resize(100, 100); + heartIconView_->SetViewId("heartIcon"); + heartIconView_->SetSrc(HEART_ICON_PATH); + + AddViewToRootContainer(heartIconView_); + heartIconView_->SetVisible(true); +#if 0 + if (lineView_ == nullptr) { + lineView_ = new UIImageView(); + } + lineView_->SetPosition(230, 385); + lineView_->Resize(1, 26); + lineView_->SetViewId("lineView"); + lineView_->SetStyle(STYLE_BACKGROUND_COLOR, 0xff666666); + lineView_->SetStyle(STYLE_BACKGROUND_OPA, 0xff); + + AddViewToRootContainer(lineView_); + lineView_->SetVisible(true); +#endif +} + +//更新图表配置 +void HeartChartView::UpdateChartConfig() { + if (minheart_dynamic_ == nullptr || maxheart_dynamic_1_ == nullptr || + maxheart_dynamic_2_ == nullptr || maxheart_dynamic_3_ == nullptr || + heartchart == nullptr) { + return; + } + + // 获取动态心率数据 + HeartModel::GetInstance()->SetArrayData(); + uint16_t *dynamicArray = HeartModel::GetInstance()->GetArrayData(); + + //更新label + if (dynamicArray) { + minheart_dynamic_->SetText(std::to_string(dynamicArray[0]).c_str()); + maxheart_dynamic_1_->SetText(std::to_string(dynamicArray[1]).c_str()); + maxheart_dynamic_2_->SetText(std::to_string(dynamicArray[2]).c_str()); + maxheart_dynamic_3_->SetText(std::to_string(dynamicArray[3]).c_str()); + maxheart_dynamic_->SetText(std::to_string(dynamicArray[4]).c_str()); + } + //更新chart + UIYAxis &heartYAxis = heartchart->GetYAxis(); + heartYAxis.SetMarkNum(4); + heartYAxis.SetDataRange(dynamicArray[0], dynamicArray[4]); + heartYAxis.SetLineColor(Color::GetColorFromRGBA(0x33, 0x33, 0x33, 0xff)); + heartchart->Invalidate(); +} +//更新上一次检测信息 +void HeartChartView::SetLastHeart() { + if (lastheart_ == nullptr) + return; + std::string lastStr = HeartModel::GetInstance()->GetCheckString(); + lastheart_->SetText(lastStr.c_str()); +} + +void HeartChartView::HeartbeatImageAnimatorStart() { + if (imageAnimator != nullptr) { + imageAnimator->Start(); + } +} + +void HeartChartView::HeartbeatImageAnimatorStop() { + if (imageAnimator != nullptr) { + imageAnimator->Stop(); + } +} +/*初始化检测界面*/ +bool HeartChartView::HeartViewInit() { + + //图片 + InitChartImageView(); + //标签 + InitChartLabel(); + + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HeartChartViewInit is ok"); + return true; +} +UIViewGroup *HeartChartView::GetchartGroup() { + + if (!HeartViewInit()) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "HeartChartView::InitHeartView fail"); + } + HeartImageAnimator(); //暂时屏蔽 + InitChartView(); + // UpdateChartConfig(); 屏蔽动态适配 + SetDataChart(); + SetLastHeart(); + SetDataTopAndBottom(); + HeartbeatImageAnimatorStart(); + + return GetRootContainer(); +} +void HeartChartView::OnStart() { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HeartChartView::OnStart"); + View::OnStart(); + + + if (!HeartViewInit()) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, + "HeartChartView::InitHeartView fail"); + } + + HeartImageAnimator(); + InitChartView(); + // UpdateChartConfig(); 屏蔽动态适配 + SetDataChart(); + SetLastHeart(); + SetDataTopAndBottom(); + HeartbeatImageAnimatorStart(); + + // 增加按键监听 + RootView::OnKeyActListener *keyactListener = + (RootView::OnKeyActListener *)OHOS::HeartChartPresenter::GetInstance(); + RootView::GetInstance()->SetOnKeyActListener(keyactListener); +} + +} // namespace OHOS diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/src/HeartDetectionPresenter.cpp b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/src/HeartDetectionPresenter.cpp new file mode 100644 index 000000000..75033b01c --- /dev/null +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/src/HeartDetectionPresenter.cpp @@ -0,0 +1,126 @@ +/* + * Copyright (c) CompanyNameMagicTag 2021-2021. All rights reserved. + * Description: HeartDetectionPresenter.cpp + * Author: + * Create: 2021-11-23 + */ + +#include "heartrate/include/HeartDetectionView.h" +#include "heartrate/include/HeartDetectionPresenter.h" + +#include "AppViewIDs.h" +#include "NativeAbility.h" +#include "common/key_code.h" +#include "KeyInputListener.h" +#include "custom_utils.h" + +// #include "displaybrightness/include/DisplayBrightnessModel.h" + +#include "heartrate/include/HeartModel.h" +#include "MainModel.h" +#include "NativeRegisterManager.h" +namespace OHOS +{ + + REGIST_SLICE(VIEW_HEART_CHECK, HeartDetectionView, HeartDetectionPresenter); + + // 当前Presenter属性实例化的内存指针 + static HeartDetectionPresenter *g_pHeartDetectionPresenter = nullptr; + + HeartDetectionPresenter::HeartDetectionPresenter() + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HeartDetectionPresenter::HeartDetectionPresenter"); + g_pHeartDetectionPresenter = this; + // display_time = DisplayBrightnessModel::GetInstance()->GetScreenDurationTime(); //需要配置公共接口 + display_time = 5*1000; + display_api->set_screen_auto_off_timeout(300 * 1000); // 设置常亮 + ResetTickTimer(); + } + + HeartDetectionPresenter::~HeartDetectionPresenter() + { + display_api->set_screen_auto_off_timeout(display_time); // 恢复 + g_pHeartDetectionPresenter = nullptr; + } + HeartDetectionPresenter *HeartDetectionPresenter::GetInstance() + { + return g_pHeartDetectionPresenter; + } + void HeartDetectionPresenter::NavigateBack() + { + NativeAbility::GetInstance().Back(TransitionType::TRANSITION_BACK_TO_HEXAGONS); + } + void HeartDetectionPresenter::OnStart() + { + Presenter::OnStart(); + if (!HeartCheckState) + { + HeartModel::GetInstance()->Heart_Start(HeartCheck::INITIATIVE); + HeartCheckState = true; + } + } + void HeartDetectionPresenter::OnResume(void) + { + } + + void HeartDetectionPresenter::OnStop(void) + { + if (HeartCheckState) + { + HeartModel::GetInstance()->Heart_Stop(); + HeartCheckState = false; + } + } + + bool HeartDetectionPresenter::OnDrag(UIView &view, const DragEvent &event) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HeartDetectionPresenter::OnDrag"); + UNUSED(view); + if ((event.GetDragDirection() == DragEvent::DIRECTION_LEFT_TO_RIGHT) && (event.GetDeltaX() > X_DRAG_OFFSET) && + (event.GetDeltaX() > (DOUBLES * MATH_ABS(event.GetDeltaY())))) + { + NavigateBack(); + } + return false; + } + + bool HeartDetectionPresenter::OnClick(UIView &view, const ClickEvent &event) + { + if (strcmp(view.GetViewId(), STOPCHECK) == 0) + { + NavigateBack(); + } + return true; + } + + void HeartDetectionPresenter::OnTickEvent() + { + // 更新显示心率数据 + HeartDetectionView::GetInstance()->UpShowHeartText(); + uint64_t current_time = osKernelGetTick2ms(); + // printf("current_time diff: %d\r\n", (current_time - startTime)); + if ((startTime != 0) && (current_time - startTime > HEART_KEEP_TIME)) + { + // 超时处理 + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "检测结果: 超时处理 HEART_KEEP_TIME: %lld", current_time - startTime); + HeartModel::GetInstance()->SetResult(HeartResult::TIMEOUT); + HeartModel::GetInstance()->Heart_Stop(); + } + } + void HeartDetectionPresenter::ResetTickTimer(void) + { + startTime = osKernelGetTick2ms(); + } + // 增加按键事件 + bool HeartDetectionPresenter::OnKeyAct(UIView &view, const KeyEvent &event) + { + unsigned short keyID = event.GetKeyId(); + unsigned short keyState = event.GetState(); + // 如果是power键,且是亮屏状态,按键释放就返回上一级 + if (keyID == static_cast(ZliteKeyCode::ZLITE_KEY_POWER) && keyState == 1 && uapi_get_screen_state() == 0) + { + NavigateBack(); + } + return true; + } +} diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/src/HeartDetectionView.cpp b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/src/HeartDetectionView.cpp new file mode 100644 index 000000000..073da09d6 --- /dev/null +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/src/HeartDetectionView.cpp @@ -0,0 +1,152 @@ +/*** + * @Date: 2024-04-15 10:55:58 + * @LastEditors: Caisking 3449750381@qq.com + * @LastEditTime: 2024-07-29 15:35:06 + * @FilePath: /FD230/code/sdk/application/wearable/fd230app/nativeui/heartrate/src/HeartDetectionView.cpp + */ +#include "UiConfig.h" +#include "wearable_log.h" +#include "HeartDetectionView.h" +#include "HeartModel.h" +#include "ui_image_animator.h" +#include "HeartDetectionView.h" +#include "ui_resource_string.h" +#include "power_display_service.h" +#include "uicomponents/UIComponents.h" +namespace OHOS +{ + // 动态刷新设置 + static constexpr uint16_t IMAGE_SIZE = 180; + static constexpr uint16_t IMAGE_POSITION_Y = 134; + static constexpr uint16_t IMAGE_POSITION_X = 150; + static constexpr uint16_t DETECTION_IMAGE_ANIMATORVIEW_SIZE = 20; + static constexpr uint16_t DETECTION_IMAGE_ANIMATORVIEW_SPEED = 40; + + static ImageAnimatorInfo g_imageAnimatorInfo_heart[20] = { + {PNG_CHECK_TIME_IMAGE_0, {IMAGE_POSITION_X, IMAGE_POSITION_Y}, IMAGE_SIZE, IMAGE_SIZE, IMG_SRC_FILE_PATH}, + {PNG_CHECK_TIME_IMAGE_1, {IMAGE_POSITION_X, IMAGE_POSITION_Y}, IMAGE_SIZE, IMAGE_SIZE, IMG_SRC_FILE_PATH}, + {PNG_CHECK_TIME_IMAGE_2, {IMAGE_POSITION_X, IMAGE_POSITION_Y}, IMAGE_SIZE, IMAGE_SIZE, IMG_SRC_FILE_PATH}, + {PNG_CHECK_TIME_IMAGE_3, {IMAGE_POSITION_X, IMAGE_POSITION_Y}, IMAGE_SIZE, IMAGE_SIZE, IMG_SRC_FILE_PATH}, + {PNG_CHECK_TIME_IMAGE_4, {IMAGE_POSITION_X, IMAGE_POSITION_Y}, IMAGE_SIZE, IMAGE_SIZE, IMG_SRC_FILE_PATH}, + {PNG_CHECK_TIME_IMAGE_5, {IMAGE_POSITION_X, IMAGE_POSITION_Y}, IMAGE_SIZE, IMAGE_SIZE, IMG_SRC_FILE_PATH}, + {PNG_CHECK_TIME_IMAGE_6, {IMAGE_POSITION_X, IMAGE_POSITION_Y}, IMAGE_SIZE, IMAGE_SIZE, IMG_SRC_FILE_PATH}, + {PNG_CHECK_TIME_IMAGE_7, {IMAGE_POSITION_X, IMAGE_POSITION_Y}, IMAGE_SIZE, IMAGE_SIZE, IMG_SRC_FILE_PATH}, + {PNG_CHECK_TIME_IMAGE_8, {IMAGE_POSITION_X, IMAGE_POSITION_Y}, IMAGE_SIZE, IMAGE_SIZE, IMG_SRC_FILE_PATH}, + {PNG_CHECK_TIME_IMAGE_9, {IMAGE_POSITION_X, IMAGE_POSITION_Y}, IMAGE_SIZE, IMAGE_SIZE, IMG_SRC_FILE_PATH}, + {PNG_CHECK_TIME_IMAGE_10, {IMAGE_POSITION_X, IMAGE_POSITION_Y}, IMAGE_SIZE, IMAGE_SIZE, IMG_SRC_FILE_PATH}, + {PNG_CHECK_TIME_IMAGE_11, {IMAGE_POSITION_X, IMAGE_POSITION_Y}, IMAGE_SIZE, IMAGE_SIZE, IMG_SRC_FILE_PATH}, + {PNG_CHECK_TIME_IMAGE_12, {IMAGE_POSITION_X, IMAGE_POSITION_Y}, IMAGE_SIZE, IMAGE_SIZE, IMG_SRC_FILE_PATH}, + {PNG_CHECK_TIME_IMAGE_13, {IMAGE_POSITION_X, IMAGE_POSITION_Y}, IMAGE_SIZE, IMAGE_SIZE, IMG_SRC_FILE_PATH}, + {PNG_CHECK_TIME_IMAGE_14, {IMAGE_POSITION_X, IMAGE_POSITION_Y}, IMAGE_SIZE, IMAGE_SIZE, IMG_SRC_FILE_PATH}, + {PNG_CHECK_TIME_IMAGE_15, {IMAGE_POSITION_X, IMAGE_POSITION_Y}, IMAGE_SIZE, IMAGE_SIZE, IMG_SRC_FILE_PATH}, + {PNG_CHECK_TIME_IMAGE_16, {IMAGE_POSITION_X, IMAGE_POSITION_Y}, IMAGE_SIZE, IMAGE_SIZE, IMG_SRC_FILE_PATH}, + {PNG_CHECK_TIME_IMAGE_17, {IMAGE_POSITION_X, IMAGE_POSITION_Y}, IMAGE_SIZE, IMAGE_SIZE, IMG_SRC_FILE_PATH}, + {PNG_CHECK_TIME_IMAGE_18, {IMAGE_POSITION_X, IMAGE_POSITION_Y}, IMAGE_SIZE, IMAGE_SIZE, IMG_SRC_FILE_PATH}, + {PNG_CHECK_TIME_IMAGE_19, {IMAGE_POSITION_X, IMAGE_POSITION_Y}, IMAGE_SIZE, IMAGE_SIZE, IMG_SRC_FILE_PATH}, + }; + + static HeartDetectionView *g_pHeartCheckView = nullptr; + HeartDetectionView::HeartDetectionView() + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HeartBandoffView::HeartBandoffView"); + g_pHeartCheckView = this; + } + HeartDetectionView::~HeartDetectionView() + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HeartDetectionView::~HeartDetectionView"); + + delete titleLabel; + titleLabel = nullptr; + + delete testButton; + testButton = nullptr; + + imageAnimator->Stop(); + delete imageAnimator; + imageAnimator = nullptr; + + delete HeartText; + HeartText = nullptr; + + g_pHeartCheckView = this; + } + HeartDetectionView *HeartDetectionView::GetInstance(void) + { + return g_pHeartCheckView; + } + UIImageAnimatorView *HeartDetectionView::GetImageAnimator() + { + return imageAnimator; + } + + /*更新显示数据*/ + void HeartDetectionView::UpShowHeartText() + { + uint16_t heart_ = HeartModel::GetInstance()->GetShowHeartdata(); + std::string heartrateStr = std::to_string(heart_); + if (HeartText != nullptr) + HeartText->SetText(heartrateStr.c_str()); + } + /*初始化检测界面*/ + bool HeartDetectionView::HeartDetectionViewInit() + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartDetectionViewInit is begin"); + /*初始化title*/ + InitLabelExt(titleLabel, 83, 50, 300, 35, "title", STR_CHECKON, DEFAULT_VECTOR_FONT_FILENAME, 30); + AddViewToRootContainer(titleLabel); + + /* -------------------------------------------------------------------------- */ + imageAnimator = new UIImageAnimatorView(); + if (imageAnimator == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartBandoffView::new UIImageAnimatorView fail"); + return false; + } + imageAnimator->SetImageAnimatorSrc(g_imageAnimatorInfo_heart, DETECTION_IMAGE_ANIMATORVIEW_SIZE, DETECTION_IMAGE_ANIMATORVIEW_SPEED); + imageAnimator->SetRepeat(true); + AddViewToRootContainer(imageAnimator); + + /* -------------------------------------------------------------------------- */ + /*初始化心率值label*/ + InitUILabel(HeartText, 83, 83, 300, 300, "hearttext", "--", GILROY_BOLD_FONT, 140); + AddViewToRootContainer(HeartText); + + /* -------------------------------------------------------------------------- */ + InitButtonExt(testButton, 118, 336, 230, 80, STOPCHECK, STR_CHECKSTOP, 30); + AddViewToRootContainer(testButton); + + /* -------------------------------------------------------------------------- */ + UIView::OnClickListener *clickLeftListener = (UIView::OnClickListener *)OHOS::HeartDetectionPresenter::GetInstance(); + if (clickLeftListener == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartDetectionView::new clickLeftListener fail"); + return false; + } + testButton->SetOnClickListener(clickLeftListener); + /* -------------------------------------------------------------------------- */ + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartDetectionViewInit is ok"); + return true; + } + void HeartDetectionView::OnStart() + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartDetectionView::OnStart"); + + if (!HeartDetectionViewInit()) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartDetectionView::InitHeartView fail"); + } + + + + GetRootContainer()->SetDraggable(true); + GetRootContainer()->SetTouchable(true); + GetRootContainer()->SetOnDragListener(presenter_); + // GetRootContainer()->SetOnKeyActListener(presenter_); + + if (imageAnimator != nullptr) + { + imageAnimator->Start(); + } + } + +} diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/src/HeartModel.cpp b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/src/HeartModel.cpp index d7bdba3fc..7a343c687 100644 --- a/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/src/HeartModel.cpp +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/src/HeartModel.cpp @@ -1,351 +1,1015 @@ -#include "HeartModel.h" -#include "wearable_log.h" -#include "graphic_service.h" +#include "heartrate/include/HeartModel.h" #include "IndoorWalkPreparedView.h" #include "IndoorWalkPresenter.h" #include "MainViewSample.h" -#include "HeartRateView.h" +#include "graphic_service.h" +#include "wearable_log.h" + +#include "DialModelHeartRate.h" +#include "heartrate/include/HeartChartView.h" +#include "heartrate/include/HeartDetectionPresenter.h" +#include "heartrate/include/HeartRateView.h" +#include "heartrate/include/HeartResultPresenter.h" + +#include "ConfigModel.h" +#include "DialModelHeartRate.h" +#include "custom_runtime.h" +#include "custom_utils.h" + +#include "heart_blood/health_service/health_service.h" + +#ifdef PPG_HX3695 +#include "ppg_service.h" +#endif + +#include "settings/include/SettingModel.h" +#include "uiservice/include/ui_service.h" +#include "wearable_log.h" +#include + + +// #include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// #include "battery_hal.h" + +#include "languagecode/LanguageInit.h" +#include "ui_service.h" + +#ifdef PPG_HX3695 +#include "hx3695.h" +#endif + + +#include #ifdef __cplusplus extern "C" { #endif -/* 佩戴检测结果 */ +#define MAX_UNWEAR_COUNT 2 +#define MAX_VALID_HRS_COUNT 10 //最大有效数 +#define MAX_DISVALID_HRS_COUNT 15 //最大无效数 +#define MIN_DISPLAY_HEART 50 //最新心率 +#define DISPLAY_COUNT 0 +#define HEARTTEST 1 //[0 开启测试 1 关闭] + +/*佩戴检测结果*/ enum { - SENSOR_WEAR_ON = 0, - SENSOR_WEAR_OFF, - SENSOR_WEAR_UNKNOW, - SENSOR_WEAR_MAX + SENSOR_WEAR_ON = 0, + SENSOR_WEAR_OFF, + SENSOR_WEAR_UNKNOW, + SENSOR_WEAR_MAX }; using namespace OHOS; #define LEN 32 -static void Notify(void *args, const Topic topic, Request* request); +static void Notify(void *args, const Topic topic, Request *request); Subscriber heartSubscirber = { .identity = nullptr, .args = nullptr, .Notify = Notify, }; +static void ProcessHeartRateUpdate(Request *request); +static void RefreshHeartData(); +void save_heart_maxmin(); +void HeartDataSubscribeTopic(Topic topic) { + BroadcastApi *broadcastApi = nullptr; + IUnknown *api = SAMGR_GetInstance()->GetFeatureApi(BROADCAST_SERVICE_NAME, + BROADCAST_FEATURE_NAME); + if (api == nullptr) { + return; + } + int result = + api->QueryInterface(api, DEFAULT_VERSION, (void **)&broadcastApi); + if (result != 0 || broadcastApi == nullptr) { + return; + } + int ret = broadcastApi->SubscribeTopic((IUnknown *)broadcastApi, topic, + &heartSubscirber); + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HeartSubscribeTopic ret=%d,topic=%u", + ret, topic); + broadcastApi->Release((IUnknown *)broadcastApi); +} -void HeartDataSubscribeTopic(Topic topic) -{ - BroadcastApi *broadcastApi = nullptr; - IUnknown *api = SAMGR_GetInstance()->GetFeatureApi(BROADCAST_SERVICE_NAME, BROADCAST_FEATURE_NAME); - if (api == nullptr) { - return; - } - int result = api->QueryInterface(api, DEFAULT_VERSION, (void **)&broadcastApi); - if (result != 0 || broadcastApi == nullptr) { - return; - } - int ret = broadcastApi->SubscribeTopic((IUnknown *)broadcastApi, topic, &heartSubscirber); - WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HeartSubscribeTopic ret = %d, topic = %u", ret, topic); - broadcastApi->Release((IUnknown *)broadcastApi); +void HearDatatUnsubscribeTopic(Topic topic) { + BroadcastApi *broadcastApi = nullptr; + IUnknown *api = SAMGR_GetInstance()->GetFeatureApi(BROADCAST_SERVICE_NAME, + BROADCAST_FEATURE_NAME); + if (api == nullptr) { + return; + } + int result = + api->QueryInterface(api, DEFAULT_VERSION, (void **)&broadcastApi); + if (result != 0 || broadcastApi == nullptr) { + return; + } + broadcastApi->UnsubscribeTopic((IUnknown *)broadcastApi, topic, + &heartSubscirber); + broadcastApi->Release((IUnknown *)broadcastApi); } -void HearDatatUnsubscribeTopic(Topic topic) -{ - BroadcastApi *broadcastApi = nullptr; - IUnknown *api = SAMGR_GetInstance()->GetFeatureApi(BROADCAST_SERVICE_NAME, BROADCAST_FEATURE_NAME); - if (api == nullptr) { - return; - } - int result = api->QueryInterface(api, DEFAULT_VERSION, (void **)&broadcastApi); - if (result != 0 || broadcastApi == nullptr) { - return; - } - broadcastApi->UnsubscribeTopic((IUnknown *)broadcastApi, topic, &heartSubscirber); - broadcastApi->Release((IUnknown *)broadcastApi); +static void Notify(void *args, const Topic topic, Request *request) { + UNUSED(args); + UNUSED(topic); + + // 训练过程中不需要判断数据准确性,不需要存储心率数据 + if (uapi_dev_runtime_get_train_status() == 1 || + uapi_dev_runtime_get_respiratory_training_status() || request == NULL) { + return; + } + if (request->msgId == TOPIC_EVENT_HEARTRATE_UPDATA) { + GraphicService::GetInstance()->PostGraphicEvent(std::bind( + &HeartModel::RefreshHeartRateScreen, HeartModel::GetInstance())); + } } -static void Notify(void *args, const Topic topic, Request* request) -{ - UNUSED(args); - UNUSED(topic); - if (request == nullptr) { - return; - } - if (request->msgId == TOPIC_EVENT_HEARTRATE_UPDATA) { - HeartDatas *heartInfo = (HeartDatas*)malloc(sizeof(HeartDatas)); - if (heartInfo == nullptr) { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[Notify] malloc fail"); - } +static void ProcessHeartRateUpdate(Request *request) { + uint16_t preheart = *reinterpret_cast(request->data); + + // 直接处理心率数据,不进行筛选 + uint16_t index_ = HeartModel::GetInstance()->GetIndex(); + HeartDatas *heartInfo = (HeartDatas *)malloc(sizeof(HeartDatas)); + if (heartInfo == NULL) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[Notify] malloc fail"); + return; + } + + heartInfo->index = index_; + heartInfo->maxX = index_; + heartInfo->minX = index_; + heartInfo->perSec = preheart; + heartInfo->rest = preheart; + /*最大最小值不为0*/ + heartInfo->maxValue = preheart; + heartInfo->minValue = preheart; + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "heartRateData=%d%d", heartInfo->index, + preheart); + OHOS::HeartModel::GetInstance()->HeartRatePros(heartInfo); + + free(heartInfo); // 释放内存 + heartInfo = nullptr; +} - int rets = memcpy_s(heartInfo, sizeof(HeartDatas), (HeartInfo*)request->data, request->len); - if (rets != EOK) { - free(heartInfo); - heartInfo = nullptr; - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "memcpy_s heartRateData fail! ret = %d", rets); - return; - } +static void RefreshHeartData() { + OHOS::HeartModel::GetInstance()->ClearHeartData(); + GraphicService::GetInstance()->PostGraphicEvent(std::bind( + &OHOS::HeartModel::Heart_Update_View, OHOS::HeartModel::GetInstance())); +} + +#ifdef __cplusplus +} +#endif + +namespace OHOS { +void HeartModel::ClearHeartData(void) { + pretime = 0; + entryTimes = 0; + aveCount = 0; + preMaxValue = 0; + preMaxX = NUM_1; + preMinValue = HEART_RATE_LIMIT_UPPER; + preMinX = NUM_1; + countMax = 0; + countMin = 0; + healthDatas.heartRateMax.x = (uint16_t)0XFFFF; + healthDatas.heartRateMax.y = 0; + healthDatas.heartRateMin.x = (uint16_t)0XFFFF; + healthDatas.heartRateMin.y = (uint16_t)0XFFFF; + for (int i = 0; i < HEART_AVE_NUM; i++) { + healthDatas.heartRateAvg[i].x = (uint16_t)0XFFFF; + healthDatas.heartRateAvg[i].y = (uint16_t)0XFFFF; + } + if (HeartRateView::GetInstance() != nullptr) { + HeartRateView::GetInstance()->ClearElectrocardiogram(); + } + SetAveHeartRateCount(0); + // GraphicService::GetInstance()->PostGraphicEvent( + // std::bind(&HeartModel::RefreshHeartRateScreen, + // HeartModel::GetInstance(), + // healthDatas.heartRatePerSec,healthDatas.heartRateRest, + // healthDatas.heartRateMax.y,healthDatas.heartRateMin.y)); +} + +HeartModel::HeartModel() { + /*初始化读取文件*/ + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartModel::HeartModel()"); + /*初始化历史文件*/ + HealthService::GetInstance()->LoadDailyHeartRate(); + /*读取上一次心率数据*/ + HeartRateData data; + HealthService::GetInstance()->ReadHeartRateData(data); + currentheart = data.Heart; + timestamp_ms = data.timestamp; + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "currentheart %d timestamp_ms %d", + currentheart, timestamp_ms); + // 更新表盘心率数据 + DialModelHeartRate::GetInstance()->UpdateHeartRate(currentheart); + + //读取最大最小值 + HealthService::GetInstance()->LoadHeartMaxMin(displayheart_max, + displayheart_min); + // 配置动态数组 + SetArrayData(); +} + +HeartModel::~HeartModel() { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HeartModel::~HeartModel()"); + HearDatatUnsubscribeTopic(TOPIC_EVENT_HEARTRATE_UPDATA); + HearDatatUnsubscribeTopic(TOPIC_EVENT_NEXTDAY_UPDATE); + HearDatatUnsubscribeTopic(TOPIC_EVENT_UTCTIME_UPDATE); + HearDatatUnsubscribeTopic(TOPIC_EVENT_WEARSTATE_UPDATE); +} - OHOS::HeartModel::GetInstance()->HeartRatePros(heartInfo); +HeartModel *HeartModel::GetInstance(void) { + static HeartModel heartModel; + return &heartModel; +} +uint16_t HeartModel::GetIndex() { return index_; } +void HeartModel::SetIndex(uint16_t index) { index_ = index; } + +void HeartModel::Init(void) { + HeartDataSubscribeTopic(TOPIC_EVENT_HEARTRATE_UPDATA); + HeartDataSubscribeTopic(TOPIC_EVENT_NEXTDAY_UPDATE); + HeartDataSubscribeTopic(TOPIC_EVENT_UTCTIME_UPDATE); + HeartDataSubscribeTopic(TOPIC_EVENT_WEARSTATE_UPDATE); +} - free(heartInfo); - heartInfo = nullptr; +Point *HeartModel::GetAveHeartRate(void) { return healthDatas.heartRateAvg; } + +void HeartModel::HandleMaxHeart(uint16 coord, uint16 value) { + healthDatas.heartRateMax.x = coord; + healthDatas.heartRateMax.y = value; + // 插入最大心率 countMax 数据个数 + if (preMaxValue != healthDatas.heartRateMax.y && aveCount < HEART_AVE_NUM) { + if (preMaxX == healthDatas.heartRateMax.x && countMax < HEART_AVE_NUM) { + healthDatas.heartRateAvg[countMax].y = healthDatas.heartRateMax.y; + } else if (aveCount > NUM_2 && (healthDatas.heartRateMax.x == + healthDatas.heartRateAvg[aveCount - 1].x)) { + healthDatas.heartRateAvg[aveCount - 1].y = healthDatas.heartRateMax.y; + } else { + healthDatas.heartRateAvg[aveCount] = healthDatas.heartRateMax; + countMax = aveCount; + aveCount++; } - if (request->msgId == TOPIC_EVENT_NEXTDAY_UPDATE) { - OHOS::HeartModel::GetInstance()->ClearHeartData(); + if (healthDatas.heartRateMax.x != 0) { + if (healthDatas.heartRateAvg[0].x == 0 && + healthDatas.heartRateAvg[1].x == 0) { + for (int i = 1; i < (aveCount - 1); i++) { + healthDatas.heartRateAvg[i] = healthDatas.heartRateAvg[i + 1]; + } + aveCount--; + countMax--; + } } - if (request->msgId == TOPIC_EVENT_UTCTIME_UPDATE) { - OHOS::HeartModel::GetInstance()->ClearHeartData(); + } + preMaxValue = healthDatas.heartRateMax.y; + preMaxX = healthDatas.heartRateMax.x; +} + +void HeartModel::HandleMinHeart(uint16 coord, uint16 value) { + // 最小心率 + healthDatas.heartRateMin.x = coord; + healthDatas.heartRateMin.y = value; + // 插入最小心率 + // avecount 当下有效数据个数,在MaxHeart中也用到,看起来似乎有问题??? + // preMinValue 上一个心率最小值 + // preMinX 上一个最小值对应的坐标 + // 当上一个值与当前值不等,且没有超过总数限制,则进行数据处理 + if (preMinValue != healthDatas.heartRateMin.y && aveCount < HEART_AVE_NUM) { + + if (preMinX == healthDatas.heartRateMin.x && countMin < HEART_AVE_NUM) { + // 上一个最小坐标和当前值一致,且数据没超过限制,则直接赋值给有效数据 + // countMin 即可 + healthDatas.heartRateAvg[countMin].y = healthDatas.heartRateMin.y; + } else if (aveCount > NUM_2 && (healthDatas.heartRateMin.x == + healthDatas.heartRateAvg[aveCount - 1].x)) { + // 有效数据大于2,且当前x值与原始数据最后一个x一致,最后一个数据赋值 + healthDatas.heartRateAvg[aveCount - 1].y = healthDatas.heartRateMin.y; + } else { + healthDatas.heartRateAvg[aveCount] = healthDatas.heartRateMin; + countMin = aveCount; + aveCount++; } - if (request->msgId == TOPIC_EVENT_WEARSTATE_UPDATE) { - uint32 wearStatus = *((uint32*)request->data); - if (wearStatus == SENSOR_WEAR_OFF) { - OHOS::HeartModel::GetInstance()->SetWearStatus(false); - OHOS::HeartModel::GetInstance()->SetHeartRatePerSec(0); - if (OHOS::MainClockView::GetInstance() != nullptr) { - OHOS::MainClockView::GetInstance()->RefreshHeartRate(0); - } - } else { - OHOS::HeartModel::GetInstance()->SetWearStatus(true); + + // 最初的值一直是0 ,则只显示1个 ,不会在后面增加数据。 + if (healthDatas.heartRateMin.x != 0) { + if (healthDatas.heartRateAvg[0].x == 0 && + healthDatas.heartRateAvg[1].x == 0) { + for (int i = 0; i < (aveCount - 1); i++) { + healthDatas.heartRateAvg[i] = healthDatas.heartRateAvg[i + 1]; } + aveCount--; + countMin--; + } } + } + preMinValue = healthDatas.heartRateMin.y; + preMinX = healthDatas.heartRateMin.x; } -#ifdef __cplusplus +void HeartModel::HeartRatePros(HeartDatas *heartInfo) { + uint16_t perSecHeartRate = 0; + uint16_t restHeartRate = 0; + + // 每秒心率 + perSecHeartRate = heartInfo->perSec; + if (perSecHeartRate >= HEART_RATE_LIMIT_LOWER && + perSecHeartRate <= HEART_RATE_LIMIT_UPPER) { + healthDatas.heartRatePerSec = perSecHeartRate; + } + + // GraphicService::GetInstance()->PostGraphicEvent( + // std::bind(&HeartModel::RefreshHeartRateScreen, + // HeartModel::GetInstance(), + // healthDatas.heartRatePerSec,healthDatas.heartRateRest, + // healthDatas.heartRateMax.y,healthDatas.heartRateMin.y)); } -#endif -namespace OHOS { -void HeartModel::ClearHeartData(void) -{ - pretime = 0; - entryTimes = 0; - aveCount = 0; - preMaxValue = 0; - preMaxX = NUM_1; - preMinValue = HEART_RATE_LIMIT_UPPER; - preMinX = NUM_1; - countMax = 0; - countMin = 0; - healthDatas.heartRateMax.x = (uint16_t)0XFFFF; - healthDatas.heartRateMax.y = 0; - healthDatas.heartRateMin.x = (uint16_t)0XFFFF; - healthDatas.heartRateMin.y = (uint16_t)0XFFFF; - for (int i = 0; i < HEART_AVE_NUM; i++) { - healthDatas.heartRateAvg[i].x = (uint16_t)0XFFFF; - healthDatas.heartRateAvg[i].y = (uint16_t)0XFFFF; - } - if (HeartRateView::GetInstance() != nullptr) { - HeartRateView::GetInstance()->ClearElectrocardiogram(); +uint16_t HeartModel::GetAveHeartRateCount(void) { return aveCount; } + +uint16_t HeartModel::GetHeartRateMax(void) { + return healthDatas.heartRateMax.y; +} + +uint16_t HeartModel::GetHeartRateMin(void) { + return healthDatas.heartRateMin.y; +} + +void HeartModel::SetHeartRatePerSec(uint32 sec) { + healthDatas.heartRatePerSec = sec; + if (HeartRateView::GetInstance() == nullptr) { + return; + } + HeartRateView::GetInstance()->RefreshHeartRatePerSec( + healthDatas.heartRatePerSec); +} + +void HeartModel::SetAveHeartRateCount(uint16_t value) { aveCount = value; } + +void HeartModel::RefreshHeartRateScreen() { + if (MainViewSample::GetInstance() != nullptr && + HeartChartView::GetInstance() != nullptr) { + if (MainViewSample::GetInstance()->GetHorCurrentCard() == HEART_RATE) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, + "HeartChartView::GetInstance() start"); + HeartChartView::GetInstance()->UpdateShowHeart(); + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, + "HeartChartView::GetInstance() end"); } - SetAveHeartRateCount(0); - GraphicService::GetInstance()->PostGraphicEvent(std::bind(&HeartModel::RefreshHeartRateScreen, HeartModel::GetInstance(), - healthDatas.heartRatePerSec, healthDatas.heartRateRest, healthDatas.heartRateMax.y, healthDatas.heartRateMin.y)); -} - -HeartModel::HeartModel() -{ - WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HeartModel::HeartModel()"); -} - -HeartModel::~HeartModel() -{ - WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HeartModel::~HeartModel()"); - HearDatatUnsubscribeTopic(TOPIC_EVENT_HEARTRATE_UPDATA); - HearDatatUnsubscribeTopic(TOPIC_EVENT_NEXTDAY_UPDATE); - HearDatatUnsubscribeTopic(TOPIC_EVENT_UTCTIME_UPDATE); - HearDatatUnsubscribeTopic(TOPIC_EVENT_WEARSTATE_UPDATE); -} - -HeartModel *HeartModel::GetInstance(void) -{ - static HeartModel heartModel; - return &heartModel; -} - -void HeartModel::Init(void) -{ - HeartDataSubscribeTopic(TOPIC_EVENT_HEARTRATE_UPDATA); - HeartDataSubscribeTopic(TOPIC_EVENT_NEXTDAY_UPDATE); - HeartDataSubscribeTopic(TOPIC_EVENT_UTCTIME_UPDATE); - HeartDataSubscribeTopic(TOPIC_EVENT_WEARSTATE_UPDATE); -} - -Point* HeartModel::GetAveHeartRate(void) -{ - return healthDatas.heartRateAvg; -} - -void HeartModel::HandleMaxHeart(uint16 coord, uint16 value) -{ - healthDatas.heartRateMax.x = coord; - healthDatas.heartRateMax.y = value; - // 插入最大心率 - if (preMaxValue != healthDatas.heartRateMax.y && aveCount < HEART_AVE_NUM) { - if (preMaxX == healthDatas.heartRateMax.x && countMax < HEART_AVE_NUM) { - healthDatas.heartRateAvg[countMax].y = healthDatas.heartRateMax.y; - } else if (aveCount > NUM_2 && (healthDatas.heartRateMax.x == healthDatas.heartRateAvg[aveCount - 1].x)) { - healthDatas.heartRateAvg[aveCount - 1].y = healthDatas.heartRateMax.y; - } else { - healthDatas.heartRateAvg[aveCount] = healthDatas.heartRateMax; - countMax = aveCount; - aveCount++; - } - if (healthDatas.heartRateMax.x != 0) { - if (healthDatas.heartRateAvg[0].x == 0 && healthDatas.heartRateAvg[1].x == 0) { - for (int i = 1; i < (aveCount - 1); i++) { - healthDatas.heartRateAvg[i] = healthDatas.heartRateAvg[i + 1]; - } - aveCount--; - countMax--; - } - } + } +} +/*----------------------------------状态检测 + *----------------------------------*/ + +// 重新初始化 +void HeartModel::ClearDisplayData() { + /*显示的心率数据清空*/ + // currentheart = 0; + // timestamp_ms = 0; + displayheart = 0; + displayheart_max = 0; // 显示最大心率 + displayheart_min = 0; // 显示最小心率 +} +// 获取心率数据 +uint16_t HeartModel::GetHeartdata() { return currentheart; } + +uint16_t HeartModel::GetShowHeartdata() { return displayheart; } +uint16_t HeartModel::GetShowMaxHeartdata() { return displayheart_max; } +uint16_t HeartModel::GetShowMinHeartdata() { return displayheart_min; } +uint32_t HeartModel::GetCheckTime() { return timestamp_ms; } + +void HeartModel::SetCheckTime(uint32_t time) { timestamp_ms = time; } +void HeartModel::SetResult(HeartResult result) { heartresult_ = result; } +HeartResult HeartModel::GetResult() { return heartresult_; } +// 控制心率检测 +void HeartModel::Heart_Control(HeartState state, HeartCheck check) { + #ifdef PPG_HX3695 + //优先级低不对高优先级处理 + if (check < checkstate) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, + "Higher execution instruction exists"); + return; + } + + //被动 + if (check == HeartCheck::PASSIVITY) { + uapi_dev_runtime_set_hrs_passivity(1); + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, + "uapi_dev_runtime_set_hrs_passivity(1)"); + } else { + uapi_dev_runtime_set_hrs_passivity(0); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "uapi_dev_runtime_set_hrs_passivity(0)"); + } + + if (state == HeartState::End && heartstate == true) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HeartState End"); + //状态数全部清空 + valid_counter_ = 0; + disvalid_counter_ = 0; + unwear_counter_ = 0; + display_counter_ = 0; + displayheart = 0; + uint8_t md = PPG_SERVICE_CMD_TYPE_STOP_PPG_TEST; + errcode_t ret = send_ppg_cmd_msg(md); + if(ret != ERRCODE_SUCC) + { + send_ppg_cmd_msg(md); } - preMaxValue = healthDatas.heartRateMax.y; - preMaxX = healthDatas.heartRateMax.x; -} - -void HeartModel::HandleMinHeart(uint16 coord, uint16 value) -{ - // 最小心率 - healthDatas.heartRateMin.x = coord; - healthDatas.heartRateMin.y = value; - // 插入最小心率 - if (preMinValue != healthDatas.heartRateMin.y && aveCount < HEART_AVE_NUM) { - if (preMinX == healthDatas.heartRateMin.x && countMin < HEART_AVE_NUM) { - healthDatas.heartRateAvg[countMin].y = healthDatas.heartRateMin.y; - } else if (aveCount > NUM_2 && (healthDatas.heartRateMin.x == healthDatas.heartRateAvg[aveCount - 1].x)) { - healthDatas.heartRateAvg[aveCount - 1].y = healthDatas.heartRateMin.y; - } else { - healthDatas.heartRateAvg[aveCount] = healthDatas.heartRateMin; - countMin = aveCount; - aveCount++; - } - if (healthDatas.heartRateMin.x != 0) { - if (healthDatas.heartRateAvg[0].x == 0 && healthDatas.heartRateAvg[1].x == 0) { - for (int i = 0; i < (aveCount - 1); i++) { - healthDatas.heartRateAvg[i] = healthDatas.heartRateAvg[i + 1]; - } - aveCount--; - countMin--; - } - } + heartstate = false; + if (checkstate == HeartCheck::CARDCHECK) { + //重置传感器状态 + sensorstate = false; + uapi_dev_runtime_set_heartrate_detect_status(0); } - preMinValue = healthDatas.heartRateMin.y; - preMinX = healthDatas.heartRateMin.x; -} -void HeartModel::HeartRatePros(HeartDatas *heartInfo) -{ - uint16_t perSecHeartRate = 0; - uint16_t restHeartRate = 0; + //记录日志 + if (checkstate == HeartCheck::PASSIVITY) { + uapi_save_runtime_log(RUNTIME_LOG_OXYGEN_PASSIVE_MEASURE_END); + } else { + uapi_save_runtime_log(RUNTIME_LOG_HEART_MEASURE_END); + } - // 每秒心率 - perSecHeartRate = heartInfo->perSec; - if (perSecHeartRate > HEART_RATE_LIMIT_LOWER && perSecHeartRate <= HEART_RATE_LIMIT_UPPER) { - healthDatas.heartRatePerSec = perSecHeartRate; + // 复原检测状态 + checkstate = HeartCheck::RESTSTSTE; + } else if (state == HeartState::Start && heartstate == false) { + /*充电状态下不进行检测*/ + bool isCharging = get_charge_stat(); // 获取充电状态 + if (isCharging) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "充电不能检测"); + return; + } + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HeartState Start"); + uint8_t md = PPG_SERVICE_CMD_TYPE_DO_PPG_TEST; + send_ppg_cmd_msg(md); + heartstate = true; + checkstate = check; + + //记录日志 + if (checkstate == HeartCheck::PASSIVITY) { + uapi_save_runtime_log(RUNTIME_LOG_HEART_PASSIVE_MEASURE); + } else { + uapi_save_runtime_log(RUNTIME_LOG_HEART_MEASURE); + } + } + #endif +} +// 开始检测 +void HeartModel::Heart_Start(HeartCheck check) { + if (!sensorstate) { + displayheart = 0; + SetResult(HeartResult::NOT_TESTED); // 重置检测 + Heart_Control(HeartState::Start, check); + // ScreenTurnOn(60 * 1000); // 亮屏操作 600000ms 60秒关闭 + sensorstate = true; + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "开始心率检测"); + // 设置runtime + if (uapi_dev_runtime_get_heartrate_detect_status() == 0) { + uapi_dev_runtime_set_heartrate_detect_status(1); + ScreenAlwaysOnCtr(OPEN_SCREEN_ALWAYS_ON); + // 主动检测的亮屏60s + heart_start_screen60s_timer(); } + } +} - // 静息心率 - restHeartRate = heartInfo->rest; - if (restHeartRate > HEART_RATE_LIMIT_LOWER && restHeartRate <= HEART_RATE_LIMIT_UPPER) { - healthDatas.heartRateRest = restHeartRate; +// 结束检测 +void HeartModel::Heart_Stop() { + valid_counter_ = 0; + disvalid_counter_ = 0; + unwear_counter_ = 0; + // display_counter_ = 0; 取消再次检测的--操作 + // displayheart = 0; + + // ScreenTurnOff(); //恢复正常亮屏 + + /*主界面卡片检测 或者 被动检测*/ + if (checkstate == HeartCheck::PASSIVITY) { + if (heartresult_ == HeartResult::SUCCESS) { + Heart_Save(); + /*更新曲线*/ + GraphicService::GetInstance()->PostGraphicEvent( + std::bind(&HeartModel::Heart_Update_View, HeartModel::GetInstance())); } - HandleMinHeart(heartInfo->minX, heartInfo->minValue); - HandleMaxHeart(heartInfo->maxX, heartInfo->maxValue); - // 平均心率 - uint16_t count = aveCount + heartInfo->index; - if (aveCount < HEART_AVE_NUM) { - for (int i = aveCount; i < count; i++) { - if (healthDatas.heartRateMin.x != heartInfo->value[i - aveCount].x && healthDatas.heartRateMax.x != heartInfo->value[i - aveCount].x) { - healthDatas.heartRateAvg[aveCount].x = heartInfo->value[i - aveCount].x; - healthDatas.heartRateAvg[aveCount].y = heartInfo->value[i - aveCount].y; - aveCount++; - } - } + /*关闭被动检测*/ + Heart_Control(HeartState::End, HeartCheck::PASSIVITY); + return; + } + //呼吸训练模式下不进行息屏与保存 + if (sensorstate && uapi_dev_runtime_get_respiratory_training_status() != 1) { + // 恢复正常亮屏 + HeartModel::GetInstance()->heart_stop_screen60s_timer(); + // 取消常亮屏 + ScreenAlwaysOnCtr(CANCEL_SCREEN_ALWAYS_ON); + //设置runtime + + Heart_Result(); // 处理结果 + + //为了防止主界面卡片一直重复开传感器 + if (checkstate != HeartCheck::CARDCHECK) { + //重置传感器状态 + sensorstate = false; + uapi_dev_runtime_set_heartrate_detect_status(0); } + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "本次心率检测结束"); + } +} +// 保存检测数据 +void HeartModel::Heart_Save() { + + uint32_t timestamp = HeartResultPresenter::GetInstance()->GetCurrentTime(); + SetCheckTime(timestamp); + + HealthService::GetInstance()->send_heart_save(); + + // 更新最大和最小心率 + displayheart_max = + (displayheart_max < currentheart ? currentheart : displayheart_max); + + // 确保最小心率的第一次赋值大于50 + if (displayheart_min == 0 && currentheart > MIN_DISPLAY_HEART) { + displayheart_min = currentheart; // 初始化最小心率 + } else { + displayheart_min = + (displayheart_min > currentheart && currentheart > MIN_DISPLAY_HEART) + ? currentheart + : displayheart_min; + } + + // 将更新曲线写到这里提前更新 + HealthService::GetInstance()->UpdateHourlyHeartRate(timestamp_ms, + currentheart); + // WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "保存的心率数据:%d%ld", + // currentheart,data.timestamp); +} - for (int i = 0; i < aveCount - 1; i++) { - if (healthDatas.heartRateAvg[i].x == healthDatas.heartRateAvg[i + 1].x) { - if (healthDatas.heartRateAvg[i].y != healthDatas.heartRateMin.y && healthDatas.heartRateAvg[i].y != healthDatas.heartRateMax.y) { - for (int j = i; j < aveCount - 1; j++) { - healthDatas.heartRateAvg[j] = healthDatas.heartRateAvg[j + 1]; - } - aveCount--; - } else if (healthDatas.heartRateAvg[i + 1].y != healthDatas.heartRateMin.y && healthDatas.heartRateAvg[i + 1].y != healthDatas.heartRateMax.y) { - for (int j = i + 1; j < aveCount - 1; j++) { - healthDatas.heartRateAvg[j] = healthDatas.heartRateAvg[j + 1]; - } - aveCount--; - } +void HeartModel::Heart_Result() { + + if (heartresult_ == HeartResult::SUCCESS) { + // 获取心率提醒状态和阈值 + heartRemindState = ConfigModel::GetInstance()->get_configData_int( + ConfigModel::CONFIGMODEL_ITEM_HEARTRATE_REMIND); + thresholdValue = ConfigModel::GetInstance()->get_configData_int( + ConfigModel::CONFIGMODEL_ITEM_HEARTRATE_THRESHOLD_VALUE); + + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "心率提醒状态:%d,阈值:%d,當前值:%d", + heartRemindState, thresholdValue, currentheart); + + if (heartRemindState) { + // 获取当前心率状态 + thresholdState = ConfigModel::GetInstance()->get_configData_int( + ConfigModel::CONFIGMODEL_ITEM_HEARTRATE_MAX_MIN); + + if (currentheart != 0) { + if (thresholdState == 0 && currentheart < thresholdValue) { + // 当前心率低于阈值 + heartresult_ = HeartResult::LOW_RESULT; + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "检测结果:低结果情况,currentheart=%d,ThresholdValue=%d", + currentheart, thresholdValue); + } else if (thresholdState == 1 && currentheart > thresholdValue) { + // 当前心率高于阈值 + heartresult_ = HeartResult::HIGH_RESULT; + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "检测结果:高结果情况,currentheart=%d,ThresholdValue=%d", + currentheart, thresholdValue); } + } } - GraphicService::GetInstance()->PostGraphicEvent(std::bind(&HeartModel::RefreshHeartRateScreen, HeartModel::GetInstance(), - healthDatas.heartRatePerSec, healthDatas.heartRateRest, healthDatas.heartRateMax.y, healthDatas.heartRateMin.y)); + } + // 根据结果进行处理 + handleHeartResult(); } - -uint16_t HeartModel::GetAveHeartRateCount(void) -{ - return aveCount; +// 处理检测结果 +void HeartModel::handleHeartResult() { + switch (heartresult_) { + case HeartResult::SUCCESS: + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "检测结果:成功"); + Heart_Save(); + // 更新曲线 + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "准备更新UI"); + GraphicService::GetInstance()->PostGraphicEvent( + std::bind(&HeartModel::Heart_Update_View, HeartModel::GetInstance())); + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "更新UI完成"); + break; + + case HeartResult::NOT_WORN: + case HeartResult::TIMEOUT: + case HeartResult::INVALID_DATA: + logAndChangeSlice(heartresult_); + break; + + case HeartResult::LOW_RESULT: + Heart_Save(); + handleLowHeartRate(); + break; + + case HeartResult::HIGH_RESULT: + Heart_Save(); + handleHighHeartRate(); + break; + + default: + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "检测结果:未知状态"); + break; + } } - -uint16_t HeartModel::GetHeartRateMax(void) -{ - return healthDatas.heartRateMax.y; +//进行日志打印与界面切换 +void HeartModel::logAndChangeSlice(HeartResult result) { + const char *resultMsg = + (result == HeartResult::NOT_WORN) + ? "未佩戴状态" + : (result == HeartResult::TIMEOUT) ? "超时" : "无效数据"; + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "检测结果:%s情况", resultMsg); + uapi_set_screen_on_api(); // 亮屏 + //需要先判断界面 心率卡片界面 + if (MainViewSample::GetInstance()) { + if (MainViewSample::GetInstance()->GetHorCurrentCard() == HEART_RATE) + NativeAbility::GetInstance().ChangeSlice(VIEW_CHECK_ABNORMAL); + } else + NativeAbility::GetInstance().ChangeSlice(VIEW_CHECK_ABNORMAL); } - -uint16_t HeartModel::GetHeartRateMin(void) -{ - return healthDatas.heartRateMin.y; +// 处理低心率情况 +void HeartModel::handleLowHeartRate() { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "检测结果:低结果情况"); + HealthState lowHealthState = {HEART_CHECK, LOW, thresholdValue}; + HealthService::GetInstance()->SetHealthCurrent(lowHealthState); + uapi_set_screen_on_api(); // 亮屏 + if (MainViewSample::GetInstance()) { + if (MainViewSample::GetInstance()->GetHorCurrentCard() == HEART_RATE) + NativeAbility::GetInstance().ChangeSlice(VIEW_CHECK_INVALID); + } else + NativeAbility::GetInstance().ChangeSlice(VIEW_CHECK_INVALID); } - -void HeartModel::SetHeartRatePerSec(uint32 sec) -{ - healthDatas.heartRatePerSec = sec; - if (HeartRateView::GetInstance() == nullptr) { - return; +// 处理高心率情况 +void HeartModel::handleHighHeartRate() { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "检测结果:高结果情况"); + HealthState highHealthState = {HEART_CHECK, HIGH, thresholdValue}; + HealthService::GetInstance()->SetHealthCurrent(highHealthState); + uapi_set_screen_on_api(); // 亮屏 + if (MainViewSample::GetInstance()) { + if (MainViewSample::GetInstance()->GetHorCurrentCard() == HEART_RATE) + NativeAbility::GetInstance().ChangeSlice(VIEW_CHECK_INVALID); + } else + NativeAbility::GetInstance().ChangeSlice(VIEW_CHECK_INVALID); +} +// 设置佩戴状态 +void HeartModel::SetWearStatus() { + + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "佩戴状态 %d %d", + uapi_dev_runtime_get_heartrate_detect_status(), + unwear_counter_); + + // 如果处于训练模式,提前返回 + if (uapi_dev_runtime_get_train_status() == 1 || + // uapi_dev_runtime_get_heartrate_detect_status() == 0 || + uapi_dev_runtime_get_respiratory_training_status()) + return; + + unwear_counter_++; + uapi_save_runtime_log(RUNTIME_LOG_HEART_NOT_WEAR); + + // 设置佩戴状态 + if (checkstate == HeartCheck::CARDCHECK) { + if (unwear_counter_ > MAX_UNWEAR_COUNT) { + if (MainViewSample::GetInstance()) { + //只有在心率卡片界面才触发 + if (MainViewSample::GetInstance()->GetHorCurrentCard() == HEART_RATE) { + SetResult(HeartResult::NOT_WORN); + uapi_save_runtime_log(RUNTIME_LOG_HEART_ERROR_NOT_WEAR); + Heart_Stop(); + } + } } - HeartRateView::GetInstance()->RefreshHeartRatePerSec(healthDatas.heartRatePerSec); + } else { + SetResult(HeartResult::NOT_WORN); + uapi_save_runtime_log(RUNTIME_LOG_HEART_ERROR_NOT_WEAR); + Heart_Stop(); + } } -void HeartModel::SetAveHeartRateCount(uint16_t value) -{ - aveCount = value; +void HeartModel::UpHeartdata(uint16_t heart) { + // 如果处于训练模式,提前返回 + if (uapi_dev_runtime_get_train_status() == 1) + return; + + int max_valid_count = 0; + + // if (heart != 0) { + // if (display_counter_ >= DISPLAY_COUNT) { + // displayheart = heart; + // } else { + // displayheart = 0; + // } + // display_counter_++; + // } else { + // displayheart = 0; + // } + + displayheart = heart; + + // 更新心率和计数器 + if (displayheart != 0) { + currentheart = displayheart; // 更新当前心率 + valid_counter_++; // 增加有效计数器 + disvalid_counter_ = 0; // 清空无效计数器 + uapi_save_runtime_log(RUNTIME_LOG_HEART_VALID_VALUE); + } else { + disvalid_counter_++; // 增加无效计数器 + valid_counter_ = 0; // 清零有效计数器 + uapi_save_runtime_log(RUNTIME_LOG_HEART_INVALID_VALUE); + } + + // 检查无效计数器是否达标 + if (uapi_dev_runtime_get_sleep_monitoring_status()) //睡眠监测模式下,增加未佩戴个数最大值,避免误判 + max_valid_count = MAX_DISVALID_HRS_COUNT * 2; + else + max_valid_count = MAX_DISVALID_HRS_COUNT; + + if (disvalid_counter_ >= max_valid_count) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "检测结果:无效数达标 disvalid_counter:%d", disvalid_counter_); + SetResult(HeartResult::INVALID_DATA); // 标记为无效数据 + uapi_save_runtime_log(RUNTIME_LOG_HEAR_ERROR_INVALID_VALUE); + Heart_Stop(); + return; + } + + // 检查有效计数器是否达标 + if (valid_counter_ >= MAX_VALID_HRS_COUNT) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, + "检测结果:成功 valid_counter:%d currentheart:%d", + valid_counter_, currentheart); + uapi_save_runtime_log(RUNTIME_LOG_HEAR_SUCCESS); + SetResult(HeartResult::SUCCESS); // 标记为成功检测 + Heart_Stop(); + return; + } + + // 刷新心率显示 + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, + "[heart data update displayheart%d displayheart_max%d " + "displayheart_min%d]", + displayheart, displayheart_max, displayheart_min); + + // GraphicService::GetInstance()->PostGraphicEvent( + // std::bind(&HeartModel::RefreshHeartRateScreen, + // HeartModel::GetInstance(), + // displayheart)); } -void HeartModel::SetWearStatus(bool status) -{ - wearStatus = status; +void HeartModel::Heart_Update_View(void) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "更新心率界面"); + int hour = HealthService::GetInstance()->GetCurrentHour(); + if (HeartRateView::GetInstance() != nullptr) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "更新主界面卡片"); + HeartRateView::GetInstance()->Update_data_Chart(hour); + } + if (HeartChartView::GetInstance() != nullptr) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "更新测量心率卡片"); + HeartChartView::GetInstance()->Update_data_Chart(hour); + } } -bool HeartModel::GetWearStatus(void) -{ - return wearStatus; +void HeartModel::CleanAllData(void) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "Nextday!"); + if (MainViewSample::GetInstance() != nullptr && + HeartRateView::GetInstance() != nullptr) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "更新主界面心率卡片"); + HeartRateView::GetInstance()->CleanAllDataView(); + } + if (HeartChartView::GetInstance() != nullptr) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "更新测量心率卡片"); + HeartChartView::GetInstance()->CleanAllDataView(); + } } -void HeartModel::RefreshHeartRateScreen(uint16_t perSec, uint16_t rest, uint16_t maxRate, uint16_t minRate) -{ - UNUSED(rest); - Point *rateData; - int len = GetAveHeartRateCount(); - rateData = GetAveHeartRate(); - - uint16_t currentViewId = NativeAbility::GetInstance().GetCurSliceId(); - if (currentViewId == VIEW_MAIN && MainClockView::GetInstance() != nullptr) { - MainClockView::GetInstance()->RefreshHeartRate(perSec); +// 配置5个动态心率数据 +// 最大 最小 +void HeartModel::SetArrayData() { + // 如果没有进行心率检测,则默认为0-220 + if (displayheart_max == 0 || displayheart_min == 0) { + dynamic_heartrate[0] = 0; + dynamic_heartrate[1] = 40; + dynamic_heartrate[2] = 100; + dynamic_heartrate[3] = 160; + dynamic_heartrate[4] = 220; + return; // 直接返回 + } + + // 计算心率范围并添加缓冲 + uint16_t adjusted_min = + (displayheart_min > 10) ? (displayheart_min / 2) : displayheart_min; + uint16_t adjusted_max = + (displayheart_max < 210) ? (displayheart_max + 10) : displayheart_max; + + uint16_t range = adjusted_max - adjusted_min; + uint16_t interval = range / 4; // 每个部分的宽度 + + // 设置动态心率数据 + dynamic_heartrate[0] = adjusted_min; + dynamic_heartrate[1] = adjusted_min + interval; + dynamic_heartrate[2] = adjusted_min + 2 * interval; + dynamic_heartrate[3] = adjusted_min + 3 * interval; + dynamic_heartrate[4] = adjusted_max; + + // 确保所有值为整数 + for (int i = 0; i < 5; i++) { + dynamic_heartrate[i] = static_cast(round(dynamic_heartrate[i])); + } + + // 打印动态心率数据 + for (int i = 0; i < 5; i++) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "dynamic_heartrate[%d]=%d", i, + dynamic_heartrate[i]); + } +} +// 获取动态心率配置数组 +uint16_t *HeartModel::GetArrayData() { return dynamic_heartrate; } + +// 获取检测字符串 +// 获取检测字符串 +// TODO: 适配多国语言 +std::string HeartModel::GetCheckString() { + std::string check_string = "检测结果未知"; + + // 获取检测数据 + if (currentheart == 0) { + if (ConfigModel::GetInstance()->GetLanguage() == ZH_CN) { + check_string = "暂无检测数据"; + } else { + check_string = "No detection data is available"; } - - if (IndoorWalkPreparedView::GetInstance() != nullptr) { - IndoorWalkPreparedView::GetInstance()->RefreshHeartbeatData(perSec); + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "检测数据:%s", check_string.c_str()); + return check_string; + } + + // 获取目前的时间戳 + uint32_t currentTime; + if (uapi_get_timestampe_ss(¤tTime) != ERRCODE_SUCC) { + if (ConfigModel::GetInstance()->GetLanguage() == ZH_CN) { + check_string = "获取当前时间失败"; + } else { + check_string = "Get time failed"; } - if (IndoorWalkPresenter::GetInstance() != nullptr) { - IndoorWalkPresenter::GetInstance()->ModifiesHeartRate(perSec); + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "获取当前时间失败"); + return check_string; + } + + // 检查时间戳是否有效 + if (timestamp_ms == 0) { + if (ConfigModel::GetInstance()->GetLanguage() == ZH_CN) { + check_string = std::to_string(currentheart) + " " + "时间无效,无法检测"; + } else { + check_string = + std::to_string(currentheart) + " " + "Invalid time, cannot detect"; } + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "时间戳无效,无法检测:%s", + check_string.c_str()); + return check_string; + } + + // 进行时间戳相减计算 + uint32_t diff = currentTime - timestamp_ms; + uint32_t diff_min = diff / 60; + uint32_t diff_hour = diff_min / 60; + + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "当前时间:%d, 上次检测时间:%d", + currentTime, timestamp_ms); + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, + "时间差(秒):%d, 时间差(分钟):%d, 时间差(小时):%d", diff, + diff_min, diff_hour); + + // 根据时间差生成检测字符串 + if (diff_min < 1) { + if (ConfigModel::GetInstance()->GetLanguage() == ZH_CN) { + check_string = std::to_string(currentheart) + "次/分 " + "刚刚检测"; // + } else { + check_string = std::to_string(currentheart) + " bpm " + "Just detected"; + } + } else if (diff_hour < 1) { // Within one hour + if (ConfigModel::GetInstance()->GetLanguage() == ZH_CN) { + check_string = std::to_string(currentheart) + "次/分 " + + std::to_string(diff_min) + "分钟前"; + } else { + check_string = std::to_string(currentheart) + " bpm " + + std::to_string(diff_min) + " minutes ago"; + } + } else { + if (ConfigModel::GetInstance()->GetLanguage() == ZH_CN) { + check_string = std::to_string(currentheart) + "次/分 " + "超过一个小时前"; + } else { + check_string = + std::to_string(currentheart) + " bpm " + "More than an hour ago"; + } + } - if (MainViewSample::GetInstance() != nullptr && HeartRateView::GetInstance() != nullptr) { - if (MainViewSample::GetInstance()->GetHorCurrentCard() == HEART_RATE) { - HeartRateView::GetInstance()->SetHeartRateData(rateData, sizeof(Point) * len); - HeartRateView::GetInstance()->RefreshElectrocardiogram(); - HeartRateView::GetInstance()->RefreshHeartRatePerSec(perSec); - HeartRateView::GetInstance()->RefreshHeartRateMax(maxRate); - HeartRateView::GetInstance()->RefreshHeartRateMin(minRate); - } + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "检测结果:%s", check_string.c_str()); + return check_string; // Return the final string +} + +// 声明定时器变量 +static osTimerId_t g_screen60s_timer = nullptr; +static uint16_t SCREEN_60S_TIME = 60; + +static void heart_start_screen60s_timer_callbackProc(int data) { + WEARABLE_LOGD( + WEARABLE_LOG_MODULE_APP, + "HeartModel::heart_start_screen60s_timer_callbackProc,time = %d", + SCREEN_60S_TIME); + SCREEN_60S_TIME -= 30; + WEARABLE_LOGD( + WEARABLE_LOG_MODULE_APP, + "HeartModel::heart_start_screen60s_timer_callbackProc,time = %d", + SCREEN_60S_TIME); + if (SCREEN_60S_TIME <= 0) { + // 60s后息屏停止定时 + HeartModel::GetInstance()->heart_stop_screen60s_timer(); + // 取消常亮屏 + ScreenAlwaysOnCtr(CANCEL_SCREEN_ALWAYS_ON); + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "heart_stop_screen60s_timer"); + } +} +static void heart_start_screen60s_timer_callback(int data) { + GraphicService::GetInstance()->PostGraphicEvent( + std::bind(heart_start_screen60s_timer_callbackProc, data)); +} +void HeartModel::heart_start_screen60s_timer(uint32_t interval) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, + "HeartModel::heart_start_screen60s_timer"); + /* -------------------------- 1.检查定时器是否已经存在,如果存在则返回 + * ------------------------- */ + if (g_screen60s_timer != nullptr) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "Timer already exists!!"); + return; + } + /* --------------------------------- 2.创建定时器 + * -------------------------------- */ + g_screen60s_timer = + osTimerNew((osTimerFunc_t)heart_start_screen60s_timer_callback, + osTimerPeriodic, nullptr, nullptr); + // 检查定时器创建是否成功 + if (g_screen60s_timer == nullptr) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Timer create failed!!"); + return; + } + /* ----------------------------- 3.将毫秒转换为系统时钟节拍数 + * ---------------------------- */ + int tick = osMs2Tick(interval); + /* --------------------------------- 4.启动定时器 + * -------------------------------- */ + osStatus_t ret = osTimerStart(g_screen60s_timer, tick); + /* -------------------- 5.检查定时器启动是否成功,如果启动失败,删除定时器并置为 + * nullptr -------------------- */ + if (ret != osOK) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "osTimerDelete failed, ret = %lx!!", + ret); + if (g_screen60s_timer != nullptr) { + ret = osTimerDelete(g_screen60s_timer); + } + g_screen60s_timer = nullptr; + return; + } +} +void HeartModel::heart_stop_screen60s_timer(void) { + // 检查定时器是否存在 + if (g_screen60s_timer != nullptr) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "HeartModel::heart_stop_screen60s_timer"); + osTimerStop(g_screen60s_timer); + // 删除定时器并置为 nullptr + osStatus_t ret = osTimerDelete(g_screen60s_timer); + if (ret != osOK) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "osTimerDelete failed, ret = %lx!!", ret); } + g_screen60s_timer = nullptr; + SCREEN_60S_TIME = 60; + } } +void HeartModel::reset_heart_screen60s_timer_time() { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "reset_heart_screen60s_timer_time"); + SCREEN_60S_TIME = 60; + if (nullptr == g_screen60s_timer) { + ScreenAlwaysOnCtr(OPEN_SCREEN_ALWAYS_ON); // 重新常亮屏 + heart_start_screen60s_timer(); // 开启定时器 + } } +} // namespace OHOS diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/src/HeartNoteView.cpp b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/src/HeartNoteView.cpp new file mode 100644 index 000000000..4fc7ca970 --- /dev/null +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/src/HeartNoteView.cpp @@ -0,0 +1,115 @@ + +#include "heartrate/include/HeartNoteView.h" +#include "heartrate/include/HeartChartPresenter.h" +#include "ui_resource_string.h" +#include "uicomponents/UIComponents.h" +#include "wearable_log.h" +#include +namespace OHOS { + +static const char *ICON_PATH_NOTE = "/user/res/Blood/Error.bin"; + +HeartNoteView::HeartNoteView() { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartNoteView::HeartNoteView"); +} + +HeartNoteView::~HeartNoteView() { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartNoteView::~HeartNoteView"); + CrearAllView(); +} + +bool HeartNoteView::CrearAllView() { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartNoteView::CrearAllView"); + if (heartNoteView) { + heartNoteView->RemoveAll(); + if (noteimage) { + delete noteimage; + noteimage = nullptr; + } + if (StButton) { + delete StButton; + StButton = nullptr; + } + if (ReButton) { + delete ReButton; + ReButton = nullptr; + } + if (titleLabel) { + delete titleLabel; + titleLabel = nullptr; + } + if (noteLabel) { + delete noteLabel; + noteLabel = nullptr; + } + delete heartNoteView; + heartNoteView = nullptr; + } + return true; +} +UIScrollView *HeartNoteView::CreateHeartNoteView(void) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "CreateHeartNoteView::CreateHeartNoteView"); + /* -------------------------------------------------------------------------- + */ + if (heartNoteView == nullptr) { + heartNoteView = new UIScrollView(); + if (heartNoteView == nullptr) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "heartNoteView new fail"); + return nullptr; + } + } + heartNoteView->SetPosition(0, 0, 466, 466); + heartNoteView->SetScrollBlankSize(50); + heartNoteView->SetReboundSize(35); + heartNoteView->SetThrowDrag(true); + heartNoteView->SetMaxScrollDistance(1000); + heartNoteView->SetDirection(UIScrollView::VERTICAL); + // 设置拖拽监听器 + UIView::OnDragListener *dragListener = + static_cast(HeartChartPresenter::GetInstance()); + if (!dragListener) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, + "HeartChartPresenter::获取实例失败!"); + return nullptr; // 获取失败,返回空指针 + } + heartNoteView->SetOnDragListener(dragListener); + + /* 初始化图片 */ + InitImageView(noteimage, 193, 120, 80, 80, "image", ICON_PATH_NOTE); + + /*初始化title*/ + InitRollLabel(titleLabel, 83, 50, 300, 35, "title", STR_CHECKERROR, + DEFAULT_VECTOR_FONT_FILENAME, 30); + InitLabelExt(noteLabel, 53, 230, 360, 70, "time", STR_PWUWC, + DEFAULT_VECTOR_FONT_FILENAME, 30); + // 设置来回滚动属性 + noteLabel->SetLineBreakMode(UILabel::LINE_BREAK_OSCILLATION); + noteLabel->SetRollSpeed(23); + + /*初始化button*/ + InitButtonExt(StButton, 58, 320, 170, 90, CLICK_HEART_STOP, STR_STOP, 30); + StButton->SetStyle(STYLE_BACKGROUND_COLOR, 0xff191919); // 设置按键颜色 + + UIView::OnClickListener *buttonClickst = + static_cast( + HeartChartPresenter::GetInstance()); + StButton->SetOnClickListener(buttonClickst); + + InitButtonExt(ReButton, 238, 320, 170, 90, CLICK_HEART_RESTART, STR_RECHECK, + 30); + ReButton->SetStyle(STYLE_BACKGROUND_COLOR, 0xffFF8A36); // 设置按键颜色 + UIView::OnClickListener *buttonClickre = + static_cast( + HeartChartPresenter::GetInstance()); + ReButton->SetOnClickListener(buttonClickre); + + heartNoteView->Add(noteimage); + heartNoteView->Add(titleLabel); + heartNoteView->Add(noteLabel); + heartNoteView->Add(StButton); + heartNoteView->Add(ReButton); + + return heartNoteView; +} +} // namespace OHOS \ No newline at end of file diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/src/HeartRateCardView.cpp b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/src/HeartRateCardView.cpp new file mode 100644 index 000000000..1c938c0c1 --- /dev/null +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/src/HeartRateCardView.cpp @@ -0,0 +1,68 @@ +#include "heartrate/include/HeartRateCardView.h" +#include "heartrate/include/HeartChartView.h" + +namespace OHOS { +static HeartRateCardView *g_pHeartRateCardView = nullptr; +HeartRateCardView::HeartRateCardView() { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, + "HeartRateCardView::HeartRateCardView"); + SetPosition(0, 0, HORIZONTAL_RESOLUTION, VERTICAL_RESOLUTION); + g_pHeartRateCardView = this; +} +HeartRateCardView::~HeartRateCardView() { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, + "HeartRateCardView::~HeartRateCardView"); + ClearAll(); + g_pHeartRateCardView = nullptr; +} +HeartRateCardView *HeartRateCardView::GetInstance() { + return g_pHeartRateCardView; +} +void HeartRateCardView::ClearAll(void) { + if (viewiInitStatus == true) { + RemoveAll(); + if (heartRateGroupView != nullptr) { + heartRateGroupView->RemoveAll(); + heartRateCardView->HeartbeatImageAnimatorStop(); + delete heartRateCardView; + heartRateCardView = nullptr; + delete heartRateGroupView; + heartRateGroupView = nullptr; + } + } +} + +bool HeartRateCardView::InitView(void) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HeartRateCardView::InitView"); + heartRateCardView = new HeartChartView(); + if (heartRateCardView == nullptr) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, + "HeartChartView::new HeartChartView fail!"); + return false; + } + + heartRateGroupView = + dynamic_cast(heartRateCardView->GetchartGroup()); + if (heartRateGroupView == nullptr) { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, + "HeartChartView->HeartChartViewInit() == nullptr!!"); + return false; + } + + Add(heartRateGroupView); + return true; +} +UIViewGroup *HeartRateCardView::GetHeartRateCardView() { + return heartRateGroupView; +} +void HeartRateCardView::PreLoad(void) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HeartRateCardView::PreLoad"); + if (!viewiInitStatus) { + InitView(); + viewiInitStatus = true; + } +} +void HeartRateCardView::UnLoad(void) { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HeartRateCardView::UnLoad"); +} +} // namespace OHOS \ No newline at end of file diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/src/HeartRateView.cpp b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/src/HeartRateView.cpp index 32e84d6d0..0c8d3fc01 100644 --- a/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/src/HeartRateView.cpp +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/src/HeartRateView.cpp @@ -12,19 +12,22 @@ #include "ScreenModels.h" #include "ui_resource_image.h" #include "common/image_cache_manager.h" - -namespace OHOS { -static HeartRateView *g_pHeartRateView = nullptr; +#include "heart_blood/health_service/health_service.h" +#include "string.h" +#define HEART_DATA_TEST 0 +namespace OHOS +{ + static HeartRateView *g_pHeartRateView = nullptr; // 背景坐标图形 -#define ACT_IMAGE_X 0 // 图片坐标起点 -#define ACT_IMAGE_Y 115 // 图片坐标起点 -#define ACT_IMAGE_COOR_X 45 // 200刻度线到最左端的像素点 +#define ACT_IMAGE_X 38 // 图片坐标起点 +#define ACT_IMAGE_Y 130 // 图片坐标起点 +#define ACT_IMAGE_COOR_X 80 // 200刻度线到最左端的像素点 #define ACT_IMAGE_COOR_Y 145 // 200刻度线到顶端的像素点 #define ACT_IMAGE_COOR_PIXELS 160 // 实际背景坐标0到200心率值的实际像素点 #define ACT_IMAGE_COOR_VALUE HEART_RATE_LIMIT_UPPER // 图片刻度表示的心率范围 -#define ACT_IMAGE_COOR_WIDTH 454 -#define ACT_IMAGE_COOR_HEIGHT 220 +#define ACT_IMAGE_COOR_WIDTH 390 +#define ACT_IMAGE_COOR_HEIGHT 200 // 心电图坐标适配 #define COORDINATE_VALUE 5 // 余量 @@ -36,13 +39,120 @@ static HeartRateView *g_pHeartRateView = nullptr; #define COORDINATE_GRAD_MAX_OPA 180 // 心形心跳 -#define HEARTBEAT_IMAGE_WIDTH 92 -#define HEARTBEAT_IMAGE_HEIGHT 92 -#define HEARTBEAT_IMAGE_X 130 -#define HEARTBEAT_IMAGE_Y 25 -#define HEARTBEAT_IMAGE_NUM 19 -#define HEARTBEAT_DELAY 50 - +static constexpr int HEARTBEAT_IMAGE_WIDTH = 54; +static constexpr int HEARTBEAT_IMAGE_HEIGHT = 50; +static constexpr int HEARTBEAT_IMAGE_X = 111; +static constexpr int HEARTBEAT_IMAGE_Y = 57; +static constexpr int HEARTBEAT_IMAGE_NUM = 21; +static constexpr int HEARTBEAT_DELAY = 50; +// 心跳image +static ImageAnimatorInfo g_heartBeatImageInfo[HEARTBEAT_IMAGE_NUM] = { + {PNG_A004_070_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_071_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_072_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_073_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_074_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_075_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_076_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_077_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_078_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_079_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_080_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_081_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_082_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_083_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_084_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_085_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_086_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_087_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_088_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_089_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, + {PNG_A004_090_IMAGE_PATH, + {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, + HEARTBEAT_IMAGE_WIDTH, + HEARTBEAT_IMAGE_HEIGHT, + IMG_SRC_FILE_PATH}, +}; // 最高心率 #define TOP_IMAGE_WIDTH 32 #define TOP_IMAGE_HEIGHT 32 @@ -89,10 +199,10 @@ static HeartRateView *g_pHeartRateView = nullptr; #define REST_HEART_TEXT_HEIGHT2 (REST_HEART_TEXT_FONT_SIZE + 5) // 每秒心率 -#define PERSEC_HEART_RATE_FONT_SIZE 45 -#define PERSEC_HEART_RATE_X 225 -#define PERSEC_HEART_RATE_Y 55 -#define PERSEC_HEART_RATE_WIDTH 90 +#define PERSEC_HEART_RATE_FONT_SIZE 60 +#define PERSEC_HEART_RATE_X 202 +#define PERSEC_HEART_RATE_Y 62 +#define PERSEC_HEART_RATE_WIDTH 102 #define PERSEC_HEART_RATE_HEIGHT (PERSEC_HEART_RATE_FONT_SIZE + 5) #define PERSEC_HEART_TEXT_FONT_SIZE 30 @@ -101,686 +211,961 @@ static HeartRateView *g_pHeartRateView = nullptr; #define PERSEC_HEART_TEXT_WIDTH 75 #define PERSEC_HEART_TEXT_HEIGHT (PERSEC_HEART_TEXT_FONT_SIZE + 5) -// 心跳image -static ImageAnimatorInfo g_heartBeatImageInfo[HEARTBEAT_IMAGE_NUM] = { - {PNG_A004_070_IMAGE_PATH, {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, HEARTBEAT_IMAGE_WIDTH, HEARTBEAT_IMAGE_HEIGHT, - IMG_SRC_FILE_PATH}, - {PNG_A004_071_IMAGE_PATH, {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, HEARTBEAT_IMAGE_WIDTH, HEARTBEAT_IMAGE_HEIGHT, - IMG_SRC_FILE_PATH}, - {PNG_A004_072_IMAGE_PATH, {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, HEARTBEAT_IMAGE_WIDTH, HEARTBEAT_IMAGE_HEIGHT, - IMG_SRC_FILE_PATH}, - {PNG_A004_073_IMAGE_PATH, {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, HEARTBEAT_IMAGE_WIDTH, HEARTBEAT_IMAGE_HEIGHT, - IMG_SRC_FILE_PATH}, - {PNG_A004_074_IMAGE_PATH, {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, HEARTBEAT_IMAGE_WIDTH, HEARTBEAT_IMAGE_HEIGHT, - IMG_SRC_FILE_PATH}, - {PNG_A004_075_IMAGE_PATH, {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, HEARTBEAT_IMAGE_WIDTH, HEARTBEAT_IMAGE_HEIGHT, - IMG_SRC_FILE_PATH}, - {PNG_A004_076_IMAGE_PATH, {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, HEARTBEAT_IMAGE_WIDTH, HEARTBEAT_IMAGE_HEIGHT, - IMG_SRC_FILE_PATH}, - {PNG_A004_077_IMAGE_PATH, {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, HEARTBEAT_IMAGE_WIDTH, HEARTBEAT_IMAGE_HEIGHT, - IMG_SRC_FILE_PATH}, - {PNG_A004_078_IMAGE_PATH, {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, HEARTBEAT_IMAGE_WIDTH, HEARTBEAT_IMAGE_HEIGHT, - IMG_SRC_FILE_PATH}, - {PNG_A004_079_IMAGE_PATH, {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, HEARTBEAT_IMAGE_WIDTH, HEARTBEAT_IMAGE_HEIGHT, - IMG_SRC_FILE_PATH}, - - {PNG_A004_080_IMAGE_PATH, {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, HEARTBEAT_IMAGE_WIDTH, HEARTBEAT_IMAGE_HEIGHT, - IMG_SRC_FILE_PATH}, - {PNG_A004_081_IMAGE_PATH, {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, HEARTBEAT_IMAGE_WIDTH, HEARTBEAT_IMAGE_HEIGHT, - IMG_SRC_FILE_PATH}, - {PNG_A004_082_IMAGE_PATH, {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, HEARTBEAT_IMAGE_WIDTH, HEARTBEAT_IMAGE_HEIGHT, - IMG_SRC_FILE_PATH}, - {PNG_A004_083_IMAGE_PATH, {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, HEARTBEAT_IMAGE_WIDTH, HEARTBEAT_IMAGE_HEIGHT, - IMG_SRC_FILE_PATH}, - {PNG_A004_084_IMAGE_PATH, {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, HEARTBEAT_IMAGE_WIDTH, HEARTBEAT_IMAGE_HEIGHT, - IMG_SRC_FILE_PATH}, - {PNG_A004_085_IMAGE_PATH, {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, HEARTBEAT_IMAGE_WIDTH, HEARTBEAT_IMAGE_HEIGHT, - IMG_SRC_FILE_PATH}, - {PNG_A004_086_IMAGE_PATH, {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, HEARTBEAT_IMAGE_WIDTH, HEARTBEAT_IMAGE_HEIGHT, - IMG_SRC_FILE_PATH}, - {PNG_A004_087_IMAGE_PATH, {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, HEARTBEAT_IMAGE_WIDTH, HEARTBEAT_IMAGE_HEIGHT, - IMG_SRC_FILE_PATH}, - {PNG_A004_088_IMAGE_PATH, {HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y}, HEARTBEAT_IMAGE_WIDTH, HEARTBEAT_IMAGE_HEIGHT, - IMG_SRC_FILE_PATH}, -}; -HeartRateView::HeartRateView() -{ - WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HeartRateView::HeartRateView"); - dataNume = 0; - currIndex = 0; - serialIndex = 0; - maxRate = 0; - minRate = HEART_RATE_LIMIT_UPPER; - InitHeartRateData(); - SetPosition(0, 0, HORIZONTAL_RESOLUTION, VERTICAL_RESOLUTION); - - g_pHeartRateView = this; -} - -HeartRateView::~HeartRateView() -{ - WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HeartRateView::~HeartRateView"); - if (viewiInitStatus) { - int32_t i; - RemoveAll(); - delete imageViewCoordinate; - imageViewCoordinate = nullptr; + HeartRateView::HeartRateView() + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HeartRateView::HeartRateView"); + dataNume = 0; + currIndex = 0; + serialIndex = 0; + maxRate = 0; + minRate = HEART_RATE_LIMIT_UPPER; + InitHeartRateData(); + SetPosition(0, 0, HORIZONTAL_RESOLUTION, VERTICAL_RESOLUTION); - chart->ClearDataSerial(); - for (i = 0; i < HEART_AVE_NUM; i++) { - delete dataSerial[i]; - dataSerial[i] = nullptr; + g_pHeartRateView = this; + } + + HeartRateView::~HeartRateView() + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HeartRateView::~HeartRateView"); + if (viewiInitStatus == true) + { + int32_t i; + RemoveAll(); + // UnLoadHeartRateImageRes(); + delete imageViewCoordinate; + imageViewCoordinate = nullptr; + + chart->ClearDataSerial(); + for (i = 0; i < HEART_AVE_NUM; i++) + { + delete dataSerial[i]; + dataSerial[i] = nullptr; + } + heartchart->ClearDataSerial(); + delete heartSerial; + heartSerial = nullptr; + delete heartchart; + delete chart; + chart = nullptr; + delete imageViewTop; + imageViewTop = nullptr; + delete imageViewBottom; + imageViewBottom = nullptr; + delete dataTopAndbottom; + dataTopAndbottom = nullptr; + imageAnimator->Stop(); + delete imageAnimator; + imageAnimator = nullptr; + delete topRate; + topRate = nullptr; + delete bottomRate; + bottomRate = nullptr; + delete ratePerSec; + ratePerSec = nullptr; + delete ratePerSecText; + ratePerSecText = nullptr; + delete restRate; + restRate = nullptr; + delete restRateText1; + restRateText1 = nullptr; + delete restRateText2; + restRateText2 = nullptr; } - delete chart; - chart = nullptr; - delete imageViewTop; - imageViewTop = nullptr; - delete imageViewBottom; - imageViewBottom = nullptr; - delete dataTopAndbottom; - dataTopAndbottom = nullptr; - imageAnimator->Stop(); - delete imageAnimator; - imageAnimator = nullptr; - delete topRate; - topRate = nullptr; - delete bottomRate; - bottomRate = nullptr; - delete ratePerSec; - ratePerSec = nullptr; - delete ratePerSecText; - ratePerSecText = nullptr; - delete restRate; - restRate = nullptr; - delete restRateText1; - restRateText1 = nullptr; - delete restRateText2; - restRateText2 = nullptr; - } - g_pHeartRateView = nullptr; -} - -HeartRateView *HeartRateView::GetInstance(void) -{ - return g_pHeartRateView; -} + g_pHeartRateView = nullptr; + } -int32_t HeartRateView::InitHeartRateData(void) // 初始化心率数据,将存放心率数据的有效字节设置为无效值 -{ - heartRateData[0].x = INVALID_HEART_VALUE; - heartRateData[0].y = INVALID_HEART_VALUE; + HeartRateView *HeartRateView::GetInstance(void) + { + return g_pHeartRateView; + } + + int32_t HeartRateView::InitHeartRateData(void) // 初始化心率数据,将存放心率数据的有效字节设置为无效值 + { + int32_t ret; + + heartRateData[0].x = INVALID_HEART_VALUE; + heartRateData[0].y = INVALID_HEART_VALUE; - int32_t ret = memset_s(heartRateData, sizeof(Point) * HEART_AVE_NUM, INVALID_HEART_VALUE, sizeof(Point) * HEART_AVE_NUM); - if (ret != 0) { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartRateView::[InitHeartRateData] memset_s heartRateData fail! ret = %d", ret); + ret = memset_s(heartRateData, sizeof(Point) * HEART_AVE_NUM, INVALID_HEART_VALUE, sizeof(Point) * HEART_AVE_NUM); + if (ret != 0) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartRateView::[InitHeartRateData] memset_s heartRateData fail! ret = %d", ret); + } + return ret; } - return ret; -} -int32_t HeartRateView::SetHeartRateData(Point *rateData, uint32 rateDataSize) -{ - if (rateData == nullptr) { - return OHOS_FAILURE; + int32_t HeartRateView::SetHeartRateData(Point *rateData, uint32 rateDataSize) + { + int ret; + + if (rateData == nullptr) + { + return OHOS_FAILURE; + } + + if (rateDataSize > sizeof(Point) * HEART_AVE_NUM) + { + rateDataSize = sizeof(Point) * HEART_AVE_NUM; + } + InitHeartRateData(); + ret = memcpy_s(heartRateData, sizeof(Point) * HEART_AVE_NUM, rateData, rateDataSize); + if (ret != EOK) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartRateView::[HeartRateDataProc] memcpy_s heartRateData fail! ret = %d", ret); + return OHOS_FAILURE; + } + + return OHOS_SUCCESS; } + int32_t HeartRateView::HeartRateDataProc(void) + { + int32_t i, ret; + Point datain[HEART_AVE_NUM]; + + ret = memcpy_s(datain, sizeof(Point) * HEART_AVE_NUM, heartRateData, sizeof(Point) * HEART_AVE_NUM); + if (ret != EOK) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartRateView::[HeartRateDataProc] memcpy_s rateDataTmp fail! ret = %d", ret); + return OHOS_FAILURE; + } + + ret = memset_s(rateDataTmp, sizeof(Point) * HEART_AVE_NUM, INVALID_HEART_VALUE, sizeof(Point) * HEART_AVE_NUM); // 替换为无效值 + if (ret != EOK) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartRateView::[HeartRateDataProc] memset_s rateDataTmp fail! ret = %d", ret); + return OHOS_FAILURE; + } + + dataNume = 0; + for (i = 0; i < HEART_AVE_NUM; i += 15) // 每跨过15个点代表一个小时 + { + if (datain[i].x >= 0 && datain[i].x < HEART_AVE_NUM && datain[i].y > 0 && + datain[i].y <= HEART_RATE_LIMIT_UPPER) + { + rateDataTmp[dataNume].x = datain[i].x + COORDINATE_VALUE; + rateDataTmp[dataNume].y = datain[i].y * ACT_IMAGE_COOR_PIXELS / ACT_IMAGE_COOR_VALUE; + dataNume++; + } + } - if (rateDataSize > sizeof(Point) * HEART_AVE_NUM) { - rateDataSize = sizeof(Point) * HEART_AVE_NUM; + return OHOS_SUCCESS; } - InitHeartRateData(); - int32_t ret = memcpy_s(heartRateData, sizeof(Point) * HEART_AVE_NUM, rateData, rateDataSize); - if (ret != EOK) { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartRateView::[HeartRateDataProc] memcpy_s heartRateData fail! ret = %d", ret); - return OHOS_FAILURE; + + void HeartRateView::SetLabel(UILabel *label, LabelInfo labelInfo) + { + label->SetFont(DEFAULT_VECTOR_FONT_FILENAME, labelInfo.fontSize); + label->SetPosition(labelInfo.x, labelInfo.y); + label->Resize(labelInfo.width, labelInfo.height); + label->SetStyle(STYLE_BACKGROUND_COLOR, OPA_TRANSPARENT); + Add(label); } - return OHOS_SUCCESS; -} + void HeartRateView::HeartRateLabelDisplay(void) + { + LabelInfo PerSecLabel = {PERSEC_HEART_RATE_FONT_SIZE, PERSEC_HEART_RATE_X, PERSEC_HEART_RATE_Y, + PERSEC_HEART_RATE_WIDTH, PERSEC_HEART_RATE_HEIGHT}; + LabelInfo PerSecTextLabel = {PERSEC_HEART_TEXT_FONT_SIZE, PERSEC_HEART_TEXT_X, PERSEC_HEART_TEXT_Y, + PERSEC_HEART_TEXT_WIDTH, PERSEC_HEART_TEXT_HEIGHT}; + + LabelInfo topLabel = {HEART_RATE_LIMIT_FONT_SIZE, TOP_TEXT_X, TOP_TEXT_Y, TOP_TEXT_WIDTH, TOP_TEXT_HEIGHT}; + LabelInfo bottomLabel = {HEART_RATE_LIMIT_FONT_SIZE, BOTTOM_TEXT_X, BOTTOM_TEXT_Y, BOTTOM_TEXT_WIDTH, + BOTTOM_TEXT_HEIGHT}; + + topRate = new UILabel(); + bottomRate = new UILabel(); + ratePerSec = new UILabel(); + ratePerSecText = new UILabel(); + + if (topRate == nullptr || bottomRate == nullptr || ratePerSec == nullptr || ratePerSecText == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartRateView::[HeartRateLabelDisplay] new UILabel fail"); + } -int32_t HeartRateView::HeartRateDataProc(void) -{ - Point datain[HEART_AVE_NUM]; - int32_t ret = memcpy_s(datain, sizeof(Point) * HEART_AVE_NUM, heartRateData, sizeof(Point) * HEART_AVE_NUM); - if (ret != EOK) { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartRateView::[HeartRateDataProc] memcpy_s rateDataTmp fail! ret = %d", ret); - return OHOS_FAILURE; + // 实时心率 + SetLabel(ratePerSec, PerSecLabel); + SetLabel(ratePerSecText, PerSecTextLabel); + ratePerSec->SetText("--"); + ratePerSec->SetFont(GILROY_BOLD_FONT, PERSEC_HEART_RATE_FONT_SIZE); + ratePerSecText->SetText("次/分"); + + // 最高最低心率 + SetLabel(topRate, topLabel); + SetLabel(bottomRate, bottomLabel); + topRate->SetText("--"); + bottomRate->SetText("--"); } - ret = memset_s(rateDataTmp, sizeof(Point) * HEART_AVE_NUM, INVALID_HEART_VALUE, sizeof(Point) * HEART_AVE_NUM); // 替换为无效值 - if (ret != EOK) { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartRateView::[HeartRateDataProc] memset_s rateDataTmp fail! ret = %d", ret); - return OHOS_FAILURE; + void HeartRateView::HeartRateCoordinate(void) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HeartRateView::HeartRateCoordinate start"); + // 坐标图片 + imageViewCoordinate = new UIImageView(); + if (imageViewCoordinate == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartRateView::[HeartRateCoordinate] new imageViewCoordinate fail"); + return; + } + imageViewCoordinate->SetPosition(ACT_IMAGE_X, ACT_IMAGE_Y); + imageViewCoordinate->SetWidth(ACT_IMAGE_COOR_WIDTH); + imageViewCoordinate->SetHeight(ACT_IMAGE_COOR_HEIGHT); + Add(imageViewCoordinate); + + // 心电图坐标适配 + chart = new UIChartPolyline(); + if (chart == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartRateView::[HeartRateCoordinate] new chart fail"); + return; + } + chart->SetPosition(COORDINATE_POINT_X, COORDINATE_POINT_Y); + chart->SetWidth(COORDINATE_WIDTH); + chart->SetHeight(COORDINATE_HEIGHT); + chart->SetStyle(STYLE_BACKGROUND_COLOR, Color::Black().full); + chart->SetStyle(STYLE_BACKGROUND_OPA, 0); + chart->SetStyle(STYLE_LINE_WIDTH, 1); // line width + + UIXAxis &xAxis = chart->GetXAxis(); + UIYAxis &yAxis = chart->GetYAxis(); + xAxis.SetDataRange(0, COORDINATE_WIDTH); // 24小时对应的秒数 + yAxis.SetDataRange(0, COORDINATE_HEIGHT); + xAxis.SetLineColor(Color::GetColorFromRGBA(0, 0, 0, 0)); + yAxis.SetLineColor(Color::GetColorFromRGBA(0, 0, 0, 0)); + chart->SetGradientOpacity(COORDINATE_GRAD_MIN_OPA, COORDINATE_GRAD_MAX_OPA); + chart->SetVisible(false); // 设置不可见 + Add(chart); } + void HeartRateView::InitChartTest(void) + { + if (heartchart == nullptr) + { + heartchart = new UIChartPolyline(); + } + heartchart->SetPosition(95, 178); + heartchart->Resize(320, 110); + heartchart->SetViewId("uiChart"); + heartchart->SetStyle(STYLE_BACKGROUND_OPA, 0x00); + + UIXAxis &heartXAxis = heartchart->GetXAxis(); + UIYAxis &heartYAxis = heartchart->GetYAxis(); + heartXAxis.SetMarkNum(1); + heartXAxis.SetDataRange(0, 24); + heartXAxis.SetLineColor(Color::GetColorFromRGBA(0, 0, 0, 0)); + heartYAxis.SetMarkNum(1); + heartYAxis.SetDataRange(0, 220); + heartYAxis.SetLineColor(Color::GetColorFromRGBA(0, 0, 0, 0)); + + // heartchart->SetGradientOpacity(60, 0); + heartchart->SetGradientOpacity(COORDINATE_GRAD_MIN_OPA, COORDINATE_GRAD_MAX_OPA); + Add(heartchart); + } + void HeartRateView::Init_data_Chart() + { + if (heartchart == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Init_data_Chart new chart fail"); + return; + } + heartSerial = new UIChartDataSerial(); + heartSerial->SetMaxDataCount(24); +#if HEART_DATA_TEST + Point temp[] = { + {0, 150}, {1, 250}, {2, 170}, {3, 0}, {4, 140}, {5, 190}, {6, 100}, {7, 40}, {8, 10}, {9, 100}, {10, 60}, {11, 20}, {12, 150}, {13, 250}, {14, 170}, {15, 140}, {16, 78}, {17, 80}, {18, 100}, {19, 20}, {20, 100}, {21, 100}, {22, 100}, {23, 100}}; + std::copy(std::begin(temp), std::end(temp), heartdata); +#else + for (int serialIndex = 0; serialIndex < 24; serialIndex++) + { + heartdata[serialIndex].x = serialIndex; + heartdata[serialIndex].y = HealthService::GetInstance()->GetHourlyHeartRate(serialIndex); + } +#endif + heartSerial->AddPoints(heartdata, 24); + + // heartSerial->SetFillColor(Color::GetColorFromRGBA(0xea, 0x53, 0x15, 0xff)); + // heartSerial->SetLineColor(Color::GetColorFromRGBA(0xd8, 0x14, 0x14, 0xff)); + // heartSerial->EnableGradient(true); - dataNume = 0; - for (int32_t i = 0; i < HEART_AVE_NUM; i++) { - if (datain[i].x >= 0 && datain[i].x < HEART_AVE_NUM && datain[i].y > 0 && - datain[i].y <= HEART_RATE_LIMIT_UPPER) { - rateDataTmp[dataNume].x = datain[i].x + COORDINATE_VALUE; - rateDataTmp[dataNume].y = datain[i].y * ACT_IMAGE_COOR_PIXELS / ACT_IMAGE_COOR_VALUE; - dataNume++; + heartSerial->SetLineColor(Color::Red()); + heartSerial->SetFillColor(Color::Red()); + heartSerial->EnableGradient(true); + + heartchart->AddDataSerial(heartSerial); + heartchart->Invalidate(); + } + void HeartRateView::Update_data_Chart(int serialIndex) + { + if (heartchart == nullptr || topRate == nullptr || bottomRate == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Update_data_Chart fail %d", serialIndex); + return; } + + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"开始更新曲线"); + + /*清空原数据*/ + heartSerial->ClearData(); + + heartdata[serialIndex].x = serialIndex; + heartdata[serialIndex].y = HealthService::GetInstance()->GetHourlyHeartRate(serialIndex); + + heartSerial->AddPoints(heartdata, 24); + heartSerial->SetLineColor(Color::Red()); + heartSerial->SetFillColor(Color::Red()); + heartSerial->EnableGradient(true); + + heartchart->AddDataSerial(heartSerial); + heartchart->Invalidate(); + + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP,"更新曲线完成"); + // heartchart->RefreshChart(); } - return OHOS_SUCCESS; -} + void HeartRateView::CleanAllDataView() + { + if (heartchart == nullptr || topRate == nullptr || bottomRate == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "CleanAllDataView fail"); + return; + } + for (int serialIndex = 0; serialIndex < 24; serialIndex++) + { + heartdata[serialIndex].x = serialIndex; + heartdata[serialIndex].y = HealthService::GetInstance()->GetHourlyHeartRate(serialIndex); + } -void HeartRateView::SetLabel(UILabel *label, LabelInfo labelInfo) -{ - label->SetFont(DEFAULT_VECTOR_FONT_FILENAME, labelInfo.fontSize); - label->SetPosition(labelInfo.x, labelInfo.y); - label->Resize(labelInfo.width, labelInfo.height); - label->SetStyle(STYLE_BACKGROUND_COLOR, OPA_TRANSPARENT); - Add(label); -} - -void HeartRateView::HeartRateLabelDisplay(void) -{ - LabelInfo PerSecLabel = { PERSEC_HEART_RATE_FONT_SIZE, PERSEC_HEART_RATE_X, PERSEC_HEART_RATE_Y, - PERSEC_HEART_RATE_WIDTH, PERSEC_HEART_RATE_HEIGHT }; - LabelInfo PerSecTextLabel = { PERSEC_HEART_TEXT_FONT_SIZE, PERSEC_HEART_TEXT_X, PERSEC_HEART_TEXT_Y, - PERSEC_HEART_TEXT_WIDTH, PERSEC_HEART_TEXT_HEIGHT }; - - LabelInfo topLabel = { HEART_RATE_LIMIT_FONT_SIZE, TOP_TEXT_X, TOP_TEXT_Y, TOP_TEXT_WIDTH, TOP_TEXT_HEIGHT }; - LabelInfo bottomLabel = { HEART_RATE_LIMIT_FONT_SIZE, BOTTOM_TEXT_X, BOTTOM_TEXT_Y, BOTTOM_TEXT_WIDTH, - BOTTOM_TEXT_HEIGHT }; - - LabelInfo restRateLabel = { REST_HEART_RATE_FONT_SIZE, REST_HEART_RATE_X, REST_HEART_RATE_Y, REST_HEART_RATE_WIDTH, - REST_HEART_RATE_HEIGHT }; - LabelInfo restRateTextLabel1 = { REST_HEART_TEXT_FONT_SIZE, REST_HEART_TEXT_X1, REST_HEART_TEXT_Y1, - REST_HEART_TEXT_WIDTH1, REST_HEART_TEXT_HEIGHT1 }; - LabelInfo restRateTextLabel2 = { REST_HEART_TEXT_FONT_SIZE, REST_HEART_TEXT_X2, REST_HEART_TEXT_Y2, - REST_HEART_TEXT_WIDTH2, REST_HEART_TEXT_HEIGHT2 }; - - topRate = new UILabel(); - bottomRate = new UILabel(); - ratePerSec = new UILabel(); - ratePerSecText = new UILabel(); - restRate = new UILabel(); - restRateText1 = new UILabel(); - restRateText2 = new UILabel(); - - if (topRate == nullptr || bottomRate == nullptr || ratePerSec == nullptr || ratePerSecText == nullptr || - restRate == nullptr || restRateText1 == nullptr || restRateText2 == nullptr) { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartRateView::[HeartRateLabelDisplay] new UILabel fail"); - } - - // 实时心率 - SetLabel(ratePerSec, PerSecLabel); - SetLabel(ratePerSecText, PerSecTextLabel); - ratePerSec->SetText("--"); - ratePerSecText->SetText("次/分"); - - // 最高最低心率 - SetLabel(topRate, topLabel); - SetLabel(bottomRate, bottomLabel); - topRate->SetText("--"); - bottomRate->SetText("--"); - - // 静息心率 - SetLabel(restRate, restRateLabel); - SetLabel(restRateText1, restRateTextLabel1); - SetLabel(restRateText2, restRateTextLabel2); - restRateText1->SetText("静息"); - restRate->SetText("--"); - restRateText2->SetText("次/分"); -} - -void HeartRateView::HeartRateCoordinate(void) -{ - WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HeartRateView::HeartRateCoordinate start"); - // 坐标图片 - imageViewCoordinate = new UIImageView(); - if (imageViewCoordinate == nullptr) { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartRateView::[HeartRateCoordinate] new imageViewCoordinate fail"); - return; - } - imageViewCoordinate->SetPosition(ACT_IMAGE_X, ACT_IMAGE_Y); - imageViewCoordinate->SetWidth(ACT_IMAGE_COOR_WIDTH); - imageViewCoordinate->SetHeight(ACT_IMAGE_COOR_HEIGHT); - Add(imageViewCoordinate); - - // 心电图坐标适配 - chart = new UIChartPolyline(); - if (chart == nullptr) { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartRateView::[HeartRateCoordinate] new chart fail"); - return; - } - chart->SetPosition(COORDINATE_POINT_X, COORDINATE_POINT_Y); - chart->SetWidth(COORDINATE_WIDTH); - chart->SetHeight(COORDINATE_HEIGHT); - chart->SetStyle(STYLE_BACKGROUND_COLOR, Color::Black().full); - chart->SetStyle(STYLE_BACKGROUND_OPA, 0); - chart->SetStyle(STYLE_LINE_WIDTH, 1); // line width - - UIXAxis &xAxis = chart->GetXAxis(); - UIYAxis &yAxis = chart->GetYAxis(); - xAxis.SetDataRange(0, COORDINATE_WIDTH); // 24小时对应的秒数 - yAxis.SetDataRange(0, COORDINATE_HEIGHT); - xAxis.SetLineColor(Color::GetColorFromRGBA(0, 0, 0, 0)); - yAxis.SetLineColor(Color::GetColorFromRGBA(0, 0, 0, 0)); - chart->SetGradientOpacity(COORDINATE_GRAD_MIN_OPA, COORDINATE_GRAD_MAX_OPA); - Add(chart); -} - -void HeartRateView::InsertTopAndBottomRateImage(void) -{ - WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HeartRateView::InsertTopAndBottomRateImage start"); - imageViewTop = new UIImageView(); - imageViewBottom = new UIImageView(); - if (imageViewTop == nullptr || imageViewBottom == nullptr) { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartRateView::[InsertTopAndBottomRateImage] new imageViewTop or imageViewBottom fail"); - return; - } - imageViewTop->SetPosition(TOP_IMAGE_X, TOP_IMAGE_Y); - imageViewTop->SetWidth(TOP_IMAGE_WIDTH); - imageViewTop->SetHeight(TOP_IMAGE_HEIGHT); - Add(imageViewTop); - imageViewBottom->SetPosition(BOTTOM_IMAGE_X, BOTTOM_IMAGE_Y); - imageViewBottom->SetWidth(BOTTOM_IMAGE_WIDTH); - imageViewBottom->SetHeight(BOTTOM_IMAGE_HEIGHT); - Add(imageViewBottom); -} - -void HeartRateView::UpdataTopAndBottomRate(void) -{ - if (chart == nullptr) { - return; + /*清空原数据*/ + heartSerial->ClearData(); + heartSerial->AddPoints(heartdata, 24); + heartSerial->SetLineColor(Color::Red()); + heartSerial->SetFillColor(Color::Red()); + heartSerial->EnableGradient(true); + + heartchart->AddDataSerial(heartSerial); + heartchart->Invalidate(); + // heartchart->RefreshChart(); + + /*更新最大最小值*/ + SetDataTopAndBottom(); } - if (dataTopAndbottom != nullptr) { - chart->DeleteDataSerial(dataTopAndbottom); - delete dataTopAndbottom; - dataTopAndbottom = nullptr; + /*设置最大最小数据*/ + void HeartRateView::SetDataTopAndBottom() + { + int MaxHeart = HeartModel::GetInstance()->GetHeartRateMax(); + int MinHeart = HeartModel::GetInstance()->GetHeartRateMin(); + + if (topRate != nullptr) + { + topRate->SetText(MaxHeart > 0 ? (std::to_string(MaxHeart)).c_str() : "--"); + } + + if (bottomRate != nullptr) + { + bottomRate->SetText(MinHeart > 0 ? (std::to_string(MinHeart)).c_str() : "--"); + } + + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "MaxHeart: %d, MinHeart: %d", MaxHeart, MinHeart); } - dataTopAndbottom = new UIChartDataSerial(); - if (dataTopAndbottom == nullptr) { - return; + void HeartRateView::InsertTopAndBottomRateImage(void) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HeartRateView::InsertTopAndBottomRateImage start"); + imageViewTop = new UIImageView(); + imageViewBottom = new UIImageView(); + if (imageViewTop == nullptr || imageViewBottom == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartRateView::[InsertTopAndBottomRateImage] new imageViewTop or imageViewBottom fail"); + return; + } + imageViewTop->SetPosition(TOP_IMAGE_X, TOP_IMAGE_Y); + imageViewTop->SetWidth(TOP_IMAGE_WIDTH); + imageViewTop->SetHeight(TOP_IMAGE_HEIGHT); + Add(imageViewTop); + imageViewBottom->SetPosition(BOTTOM_IMAGE_X, BOTTOM_IMAGE_Y); + imageViewBottom->SetWidth(BOTTOM_IMAGE_WIDTH); + imageViewBottom->SetHeight(BOTTOM_IMAGE_HEIGHT); + Add(imageViewBottom); } - if (dataNume != 1) { - dataTopAndbottom->SetMaxDataCount(dataNume); // number of data points - dataTopAndbottom->AddPoints(rateDataTmp, dataNume); // number of data points - } else { - Point tmp[NUM_2]; - tmp[0].x = tmp[1].x = rateDataTmp[0].x; - tmp[0].y = tmp[1].y = rateDataTmp[0].y; - dataTopAndbottom->SetMaxDataCount(NUM_2); // number of data points - dataTopAndbottom->AddPoints(tmp, NUM_2); // number of data points - } - dataTopAndbottom->SetLineColor(Color::GetColorFromRGBA(0, 0, 0, 0)); // 设置透明 - chart->AddDataSerial(dataTopAndbottom); - chart->Invalidate(); - - UIChartDataSerial::PointStyle pointStyle; - // 最低心跳 - dataTopAndbottom->EnableBottomPoint(true); - pointStyle.radius = BOTTOM_RADIUS; // Inner radius - pointStyle.fillColor = Color::Gray(); - pointStyle.strokeWidth = BOTTOM_STROKE_WIDTH; // border width - pointStyle.strokeColor = Color::Black(); - dataTopAndbottom->SetBottomPointStyle(pointStyle); - chart->Invalidate(); - - uint16_t bottom = dataTopAndbottom->GetValleyData() * ACT_IMAGE_COOR_VALUE / ACT_IMAGE_COOR_PIXELS; - // 最高心跳 - dataTopAndbottom->EnableTopPoint(true); - pointStyle.fillColor = Color::Red(); - pointStyle.radius = TOP_RADIUS; // Inner radius - pointStyle.strokeColor = Color::Black(); - pointStyle.strokeWidth = TOP_STROKE_WIDTH; // border width - dataTopAndbottom->SetTopPointStyle(pointStyle); - chart->Invalidate(); - - uint16_t top = dataTopAndbottom->GetPeakData() * ACT_IMAGE_COOR_VALUE / ACT_IMAGE_COOR_PIXELS; - if (top <= HEART_RATE_LIMIT_UPPER) { - maxRate = (maxRate >= top) ? maxRate : top; - } - if (bottom != 0) { - minRate = (minRate <= bottom) ? minRate : bottom; - } -} - -void HeartRateView::ElectrocardiogramOnePoint(Point *rateData, uint16_t index) -{ - Point tmp[NUM_2]; - if (rateData == nullptr || chart == nullptr || index >= HEART_AVE_NUM || serialIndex >= HEART_AVE_NUM) { - return; + void HeartRateView::UpdataTopAndBottomRate(void) + { + uint16_t bottom, top; + if (chart == nullptr) + { + return; + } + if (dataTopAndbottom != nullptr) + { + chart->DeleteDataSerial(dataTopAndbottom); + delete dataTopAndbottom; + dataTopAndbottom = nullptr; + } + dataTopAndbottom = new UIChartDataSerial(); + if (dataTopAndbottom == nullptr) + { + return; + } + if (dataNume != 1) + { + dataTopAndbottom->SetMaxDataCount(dataNume); // number of data points + dataTopAndbottom->AddPoints(rateDataTmp, dataNume); // number of data points + } + else + { + Point tmp[NUM_2]; + tmp[0].x = tmp[1].x = rateDataTmp[0].x; + tmp[0].y = tmp[1].y = rateDataTmp[0].y; + dataTopAndbottom->SetMaxDataCount(NUM_2); // number of data points + dataTopAndbottom->AddPoints(tmp, NUM_2); // number of data points + } + dataTopAndbottom->SetLineColor(Color::GetColorFromRGBA(0, 0, 0, 0)); // 设置透明 + chart->AddDataSerial(dataTopAndbottom); + chart->Invalidate(); + + UIChartDataSerial::PointStyle pointStyle; + // 最低心跳 + dataTopAndbottom->EnableBottomPoint(true); + pointStyle.radius = BOTTOM_RADIUS; // Inner radius + pointStyle.fillColor = Color::Gray(); + pointStyle.strokeWidth = BOTTOM_STROKE_WIDTH; // border width + pointStyle.strokeColor = Color::Black(); + dataTopAndbottom->SetBottomPointStyle(pointStyle); + chart->Invalidate(); + + bottom = dataTopAndbottom->GetValleyData() * ACT_IMAGE_COOR_VALUE / ACT_IMAGE_COOR_PIXELS; + // 最高心跳 + dataTopAndbottom->EnableTopPoint(true); + pointStyle.fillColor = Color::Red(); + pointStyle.radius = TOP_RADIUS; // Inner radius + pointStyle.strokeColor = Color::Black(); + pointStyle.strokeWidth = TOP_STROKE_WIDTH; // border width + dataTopAndbottom->SetTopPointStyle(pointStyle); + chart->Invalidate(); + + top = dataTopAndbottom->GetPeakData() * ACT_IMAGE_COOR_VALUE / ACT_IMAGE_COOR_PIXELS; + if (top <= HEART_RATE_LIMIT_UPPER) + { + maxRate = (maxRate >= top) ? maxRate : top; + } + if (bottom != 0) + { + minRate = (minRate <= bottom) ? minRate : bottom; + } } + void HeartRateView::ElectrocardiogramOnePoint(Point *rateData, uint16_t index) + { + Point tmp[NUM_2]; + + if (rateData == nullptr || chart == nullptr || index >= HEART_AVE_NUM || serialIndex >= HEART_AVE_NUM) + { + return; + } - tmp[0].x = tmp[1].x = rateData[index].x; - tmp[0].y = tmp[1].y = rateData[index].y; + tmp[0].x = tmp[1].x = rateData[index].x; + tmp[0].y = tmp[1].y = rateData[index].y; - dataSerial[serialIndex] = new UIChartDataSerial(); - if (dataSerial[serialIndex] == nullptr) { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartRateView::[ElectrocardiogramOnePoint] new dataSerial[%d] fail", serialIndex); + dataSerial[serialIndex] = new UIChartDataSerial(); + if (dataSerial[serialIndex] == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartRateView::[ElectrocardiogramOnePoint] new dataSerial[%d] fail", serialIndex); + serialIndex++; + return; + } + + dataSerial[serialIndex]->SetMaxDataCount(HEART_AVE_NUM); // 设置最大显示的像素点 + dataSerial[serialIndex]->AddPoints(tmp, NUM_2); + dataSerial[serialIndex]->SetLineColor(Color::Red()); + dataSerial[serialIndex]->SetFillColor(Color::Red()); + dataSerial[serialIndex]->EnableGradient(true); + + chart->AddDataSerial(dataSerial[serialIndex]); + chart->Invalidate(); serialIndex++; - return; } - dataSerial[serialIndex]->SetMaxDataCount(HEART_AVE_NUM); // 设置最大显示的像素点 - dataSerial[serialIndex]->AddPoints(tmp, NUM_2); - dataSerial[serialIndex]->SetLineColor(Color::Red()); - dataSerial[serialIndex]->SetFillColor(Color::Red()); - dataSerial[serialIndex]->EnableGradient(true); - - chart->AddDataSerial(dataSerial[serialIndex]); - chart->Invalidate(); - serialIndex++; -} + void HeartRateView::ElectrocardiogramMultiPoint(Point *rateData, uint16_t rateDataNume) + { + uint16_t i = 0; + uint16_t j = 0; + uint16_t tmp = 1; + if (rateData == nullptr || chart == nullptr || rateDataNume > HEART_AVE_NUM) + { + return; + } -void HeartRateView::ElectrocardiogramMultiPoint(Point *rateData, uint16_t rateDataNume) -{ - uint16_t i = 0; - uint16_t j = 0; - uint16_t tmp = 1; - if (rateData == nullptr || chart == nullptr || rateDataNume > HEART_AVE_NUM) { - return; - } - - while (i < rateDataNume) { - while ((j + 1 < rateDataNume) && (rateData[j + 1].x - rateData[j].x <= NUM_4)) { // 15分钟对应的秒数 - tmp++; - j++; - } - if (tmp == 1) { - ElectrocardiogramOnePoint(rateData, i); - } else { - if (serialIndex >= HEART_AVE_NUM) { - return; + while (i < rateDataNume) + { + while ((j + 1 < rateDataNume) && (rateData[j + 1].x - rateData[j].x <= NUM_4)) + { // 15分钟对应的秒数 + tmp++; + j++; } - if (serialIndex > 0 && dataSerial[serialIndex - 1] != nullptr && i == 0) { - dataSerial[serialIndex - 1]->AddPoints(rateData + 1, tmp - 1); // number of data points - chart->Invalidate(); - } else { - dataSerial[serialIndex] = new UIChartDataSerial(); - if (dataSerial[serialIndex] == nullptr) { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartRateView::[ElectrocardiogramMultiPoint] new dataSerial[%d] fail", serialIndex); - serialIndex++; + if (tmp == 1) + { + ElectrocardiogramOnePoint(rateData, i); + } + else + { + if (serialIndex >= HEART_AVE_NUM) + { return; } - - dataSerial[serialIndex]->SetMaxDataCount(HEART_AVE_NUM); // number of data points - dataSerial[serialIndex]->AddPoints(rateData + i, tmp); // number of data points - dataSerial[serialIndex]->SetLineColor(Color::Red()); - dataSerial[serialIndex]->SetFillColor(Color::Red()); - dataSerial[serialIndex]->EnableGradient(true); - - chart->AddDataSerial(dataSerial[serialIndex]); - chart->Invalidate(); - serialIndex++; + if (serialIndex > 0 && dataSerial[serialIndex - 1] != nullptr && i == 0) + { + dataSerial[serialIndex - 1]->AddPoints(rateData + 1, tmp - 1); // number of data points + chart->Invalidate(); + } + else + { + dataSerial[serialIndex] = new UIChartDataSerial(); + if (dataSerial[serialIndex] == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartRateView::[ElectrocardiogramMultiPoint] new dataSerial[%d] fail", serialIndex); + serialIndex++; + return; + } + + dataSerial[serialIndex]->SetMaxDataCount(HEART_AVE_NUM); // number of data points + dataSerial[serialIndex]->AddPoints(rateData + i, tmp); // number of data points + dataSerial[serialIndex]->SetLineColor(Color::Red()); + dataSerial[serialIndex]->SetFillColor(Color::Red()); + dataSerial[serialIndex]->EnableGradient(true); + + chart->AddDataSerial(dataSerial[serialIndex]); + chart->Invalidate(); + serialIndex++; + } } + i += tmp; + j = i; + tmp = 1; } - i += tmp; - j = i; - tmp = 1; } -} -void HeartRateView::HeartRateElectrocardiogram(void) -{ - if (dataNume == 0) { - return; - } - serialIndex = 0; - if (dataNume != 1) { - ElectrocardiogramMultiPoint(rateDataTmp, dataNume); // 多个点 - } else { - ElectrocardiogramOnePoint(rateDataTmp, 0); // 一个点 + void HeartRateView::HeartRateElectrocardiogram(void) + { + if (dataNume == 0) + { + return; + } + serialIndex = 0; + if (dataNume != 1) + { + ElectrocardiogramMultiPoint(rateDataTmp, dataNume); // 多个点 + } + else + { + ElectrocardiogramOnePoint(rateDataTmp, 0); // 一个点 + } + currIndex = dataNume; } - currIndex = dataNume; -} -void HeartRateView::HeartbeatImageAnimator() -{ - imageAnimator = new UIImageAnimatorView(); - if (imageAnimator == nullptr) { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartRateView::[HeartbeatImageAnimator] new imageAnimator fail"); - return; - } - imageAnimator->SetPosition(HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y, HEARTBEAT_IMAGE_WIDTH, HEARTBEAT_IMAGE_HEIGHT); - imageAnimator->SetImageAnimatorSrc(g_heartBeatImageInfo, HEARTBEAT_IMAGE_NUM, HEARTBEAT_DELAY); - imageAnimator->SetRepeat(true); - Add(imageAnimator); - imageAnimator->Start(); -} - -void HeartRateView::HeartbeatImageAnimatorStart(void) -{ - if (imageAnimator != nullptr) { + void HeartRateView::HeartbeatImageAnimator() + { + imageAnimator = new UIImageAnimatorView(); + if (imageAnimator == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartRateView::[HeartbeatImageAnimator] new imageAnimator fail"); + return; + } + imageAnimator->SetPosition(HEARTBEAT_IMAGE_X, HEARTBEAT_IMAGE_Y, HEARTBEAT_IMAGE_WIDTH, HEARTBEAT_IMAGE_HEIGHT); + imageAnimator->SetImageAnimatorSrc(g_heartBeatImageInfo, HEARTBEAT_IMAGE_NUM, HEARTBEAT_DELAY); + imageAnimator->SetRepeat(true); + Add(imageAnimator); imageAnimator->Start(); } -} -void HeartRateView::HeartbeatImageAnimatorStop(void) -{ - if (imageAnimator != nullptr) { - imageAnimator->Stop(); + void HeartRateView::HeartbeatImageAnimatorStart(void) + { + if (imageAnimator != nullptr) + { + imageAnimator->Start(); + } } -} -bool HeartRateView::InitView(void) -{ - WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HeartRateView::HeartRateView::InitView"); - HeartRateDataProc(); - HeartRateLabelDisplay(); - HeartbeatImageAnimator(); - HeartRateCoordinate(); - InsertTopAndBottomRateImage(); - HeartRateElectrocardiogram(); - UpdataTopAndBottomRate(); - HeartbeatImageAnimatorStop(); - InitRefreshInterface(); - return true; -} - -void HeartRateView::PreLoad(void) -{ - if (!viewiInitStatus) { - if (InitView()) { - viewiInitStatus = true; + void HeartRateView::HeartbeatImageAnimatorStop(void) + { + if (imageAnimator != nullptr) + { + imageAnimator->Stop(); } } - if (!resLoadStatus) { - // ScreenModels::GetInstance()->LoadAppImages(HEART_IAMGES, imageViewTop, HEART_HEARTRATE_TOP); - // ScreenModels::GetInstance()->LoadAppImages(HEART_IAMGES, imageViewBottom, HEART_HEARTRATE_BOTTOM); - // ScreenModels::GetInstance()->LoadAppImages(HEART_IAMGES, imageViewCoordinate, HEART_HEARTRATECOOR); - resLoadStatus = true; + bool HeartRateView::InitView(void) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HeartRateView::InitView"); + HeartRateDataProc(); + HeartRateLabelDisplay(); + HeartbeatImageAnimator(); + HeartRateCoordinate(); + InitChartTest(); + Init_data_Chart(); + InsertTopAndBottomRateImage(); + HeartRateElectrocardiogram(); + UpdataTopAndBottomRate(); + // HeartbeatImageAnimatorStop(); 进入界面进行 动画播放 + InitRefreshInterface(); + return true; } -} -void HeartRateView::UnLoad(void) -{ - if (resLoadStatus) { - ImageInfo* img = nullptr; - imageViewTop->SetSrc(img); - imageViewBottom->SetSrc(img); - imageViewCoordinate->SetSrc(img); - ImageCacheManager::GetInstance().UnloadAllInMultiRes(HEART_IAMGES); - resLoadStatus = false; + /*预加载心率图片资源*/ + void HeartRateView::PreLoadHeartRateImageRes(void) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartRateView::PreLoadHeartRateImageRes"); + if (!resLoadStatus) + { + /*心率背景图*/ + ScreenModels::GetInstance()->LoadAppImages(HEART_IAMGES, imageViewTop, HEART_RATE_TOP); + ScreenModels::GetInstance()->LoadAppImages(HEART_IAMGES, imageViewBottom, HEART_RATE_BOTTOM); + ScreenModels::GetInstance()->LoadAppImages(HEART_IAMGES, imageViewCoordinate, HEART_RATE_COOR); + resLoadStatus = true; + } } -} -void HeartRateView::InitRefreshInterface(void) -{ - WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HeartRateView::HeartRateView::InitRefreshInterface"); - - Point *rateData = HeartModel::GetInstance()->GetAveHeartRate(); - uint16_t len = HeartModel::GetInstance()->GetAveHeartRateCount(); - SetHeartRateData(rateData, sizeof(Point) * len); - uint16_t maxHeartRate = HeartModel::GetInstance()->GetHeartRateMax(); - uint16_t minHeartRate = HeartModel::GetInstance()->GetHeartRateMin(); - RefreshElectrocardiogram(); - if (maxHeartRate > 0 && maxHeartRate < HEART_RATE_LIMIT_UPPER) { - RefreshHeartRateMax(HeartModel::GetInstance()->GetHeartRateMax()); - } - if (minHeartRate > 0 && minHeartRate < HEART_RATE_LIMIT_UPPER) { - RefreshHeartRateMin(HeartModel::GetInstance()->GetHeartRateMin()); + /*卸载心率图片资源*/ + void HeartRateView::UnLoadHeartRateImageRes(void) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartRateView::UnLoadHeartRateImageRes"); + if (resLoadStatus) + { + ImageInfo *img = nullptr; + imageViewTop->SetSrc(img); + imageViewBottom->SetSrc(img); + imageViewCoordinate->SetSrc(img); + // ImageCacheManager::GetInstance().UnloadAllInMultiRes(HEART_IAMGES); + ImageCacheManager::GetInstance().UnloadOneInMultiRes(HEART_RATE_TOP, HEART_IAMGES); + ImageCacheManager::GetInstance().UnloadOneInMultiRes(HEART_RATE_BOTTOM, HEART_IAMGES); + ImageCacheManager::GetInstance().UnloadOneInMultiRes(HEART_RATE_COOR, HEART_IAMGES); + resLoadStatus = false; + } } -} -// 刷新心率曲线 -void HeartRateView::RefreshElectrocardiogram(void) -{ - int32_t ret = HeartRateDataProc(); - if (ret != OHOS_SUCCESS) { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartRateView::[RefreshElectrocardiogram()] fail"); - return; + void HeartRateView::PreLoad(void) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartRateView::PreLoad"); + if (!viewiInitStatus) + { + if (InitView()) + { + viewiInitStatus = true; + } + } + PreLoadHeartRateImageRes(); } - Point *rate = rateDataTmp; - if (chart == nullptr) { - return; + void HeartRateView::UnLoad(void) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartRateView::UnLoad"); + UnLoadHeartRateImageRes(); } - if (currIndex >= HEART_AVE_NUM) { - currIndex = HEART_AVE_NUM; + void HeartRateView::InitRefreshInterface(void) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HeartRateView::HeartRateView::InitRefreshInterface"); + + Point *rateData = HeartModel::GetInstance()->GetAveHeartRate(); + uint16_t len = HeartModel::GetInstance()->GetAveHeartRateCount(); + SetHeartRateData(rateData, sizeof(Point) * len); + // 展示最大,最小,最近一次心率 + uint16_t maxRate = HeartModel::GetInstance()->GetShowMaxHeartdata(); + uint16_t minRate = HeartModel::GetInstance()->GetShowMinHeartdata(); + uint16_t perRate = HeartModel::GetInstance()->GetShowHeartdata(); + + RefreshHeartRateMax(maxRate); + RefreshHeartRateMin(minRate); + HeartModel::GetInstance()->SetHeartRatePerSec(perRate); } - if (dataNume > currIndex) { - uint16_t tmp = dataNume - currIndex; - if (currIndex > 0) { - rate += (currIndex - 1); - tmp += 1; + + // 刷新心率曲线 + void HeartRateView::RefreshElectrocardiogram(void) + { + int32_t ret; + uint16_t tmp, count; + Point *rate = nullptr; + Point modPoint; + + ret = HeartRateDataProc(); + if (ret != OHOS_SUCCESS) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartRateView::[RefreshElectrocardiogram()] fail"); + return; + } + rate = rateDataTmp; + + if (chart == nullptr) + { + return; } - ElectrocardiogramMultiPoint(rate, tmp); - currIndex = dataNume; - } else if (dataNume == currIndex) { // 当前点平均心率刷新 - if (serialIndex > 0 && serialIndex <= HEART_AVE_NUM && dataSerial[serialIndex - 1] != nullptr) { - Point modPoint; - modPoint.x = rate[currIndex - 1].x; - modPoint.y = rate[currIndex - 1].y; - uint16_t count = dataSerial[serialIndex - 1]->GetDataCount(); - dataSerial[serialIndex - 1]->ModifyPoint(count - 1, modPoint); - chart->Invalidate(); + if (currIndex >= HEART_AVE_NUM) + { + currIndex = HEART_AVE_NUM; } - } else { - return; + if (dataNume > currIndex) + { + tmp = dataNume - currIndex; + if (currIndex > 0) + { + rate += (currIndex - 1); + tmp += 1; + } + ElectrocardiogramMultiPoint(rate, tmp); + currIndex = dataNume; + } + else if (dataNume == currIndex) + { // 当前点平均心率刷新 + if (serialIndex > 0 && serialIndex <= HEART_AVE_NUM && dataSerial[serialIndex - 1] != nullptr) + { + modPoint.x = rate[currIndex - 1].x; + modPoint.y = rate[currIndex - 1].y; + + count = dataSerial[serialIndex - 1]->GetDataCount(); + dataSerial[serialIndex - 1]->ModifyPoint(count - 1, modPoint); + chart->Invalidate(); + } + } + else + { + return; + } + UpdataTopAndBottomRate(); // 最高、最低心率 } - UpdataTopAndBottomRate(); // 最高、最低心率 -} -// 清空心率曲线 -void HeartRateView::ClearElectrocardiogram(void) -{ - int32_t i; - dataNume = 0; - currIndex = 0; - maxRate = 0; - minRate = HEART_RATE_LIMIT_UPPER; - InitHeartRateData(); + // 清空心率曲线 + void HeartRateView::ClearElectrocardiogram(void) + { + int32_t i; + dataNume = 0; + currIndex = 0; + maxRate = 0; + minRate = HEART_RATE_LIMIT_UPPER; + InitHeartRateData(); + + if (chart == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "chart == nullptr"); + return; + } - if (chart == nullptr) { - WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "chart == nullptr"); - return; - } + if (ratePerSec != nullptr && topRate != nullptr && bottomRate != nullptr && restRate != nullptr) + { + ratePerSec->SetText("--"); + topRate->SetText("--"); + bottomRate->SetText("--"); + restRate->SetText("--"); + } - if (ratePerSec != nullptr && topRate != nullptr && bottomRate != nullptr && restRate != nullptr) { - ratePerSec->SetText("--"); - topRate->SetText("--"); - bottomRate->SetText("--"); - restRate->SetText("--"); - } + chart->DeleteDataSerial(dataTopAndbottom); + delete dataTopAndbottom; + dataTopAndbottom = nullptr; + for (i = 0; i < serialIndex; i++) + { + delete dataSerial[i]; + dataSerial[i] = nullptr; + } + chart->ClearDataSerial(); - chart->DeleteDataSerial(dataTopAndbottom); - delete dataTopAndbottom; - dataTopAndbottom = nullptr; - for (i = 0; i < serialIndex; i++) { - delete dataSerial[i]; - dataSerial[i] = nullptr; + serialIndex = 0; + chart->Invalidate(); } - chart->ClearDataSerial(); - serialIndex = 0; - chart->Invalidate(); -} + // 刷新每秒上报的心率 + void HeartRateView::RefreshHeartRatePerSec(uint16_t value) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartRateView %d", value); -// 刷新每秒上报的心率 -void HeartRateView::RefreshHeartRatePerSec(uint16_t value) -{ - char heartRate[NUM_4] = "--"; - int32_t ret = 0; + if (ratePerSec == nullptr) + { + return; + } - if (ratePerSec == nullptr) { - return; + // 判断心率值,并设置文本 + if (value == 0 || value < 50) + { + ratePerSec->SetText("--"); + } + else + { + std::string ratePerSecStr = std::to_string(value); + ratePerSec->SetText(ratePerSecStr.c_str()); + } } - if (value == 0) { - ratePerSec->SetText("--"); - HeartbeatImageAnimatorStop(); - return; - } - HeartbeatImageAnimatorStart(); - if (value > NUM_99) { - ret = sprintf_s(heartRate, sizeof(heartRate), "%u", value); - } else { - ret = sprintf_s(heartRate, sizeof(heartRate), " %u", value); - } - if (ret > EOK) { - ratePerSec->SetText(heartRate); - } -} + // 刷新最大心率 + void HeartRateView::RefreshHeartRateMax(uint16_t max) + { + if (topRate == nullptr) + { + return; + } -// 刷新最大心率 -void HeartRateView::RefreshHeartRateMax(uint16_t max) -{ - char top[NUM_4] = "--"; - int32_t ret = 0; - maxRate = (maxRate >= max) ? maxRate : max; - if (topRate == nullptr) { - return; - } - if (maxRate <= HEART_RATE_LIMIT_LOWER) { - topRate->SetText("--"); - return; - } - ret = sprintf_s(top, sizeof(top), "%u", maxRate); - if (ret > EOK) { - topRate->SetText(top); + // 设置刷新文本 + if (max >= HEART_RATE_LIMIT_UPPER || max < 60) + { + topRate->SetText("--"); + } + else + { + std::string topRateStr = std::to_string(max); + topRate->SetText(topRateStr.c_str()); + } } -} -// 刷新最小心率 -void HeartRateView::RefreshHeartRateMin(uint16_t min) -{ - char bottom[NUM_4] = "--"; - int32_t ret = 0; + // 刷新最小心率 + void HeartRateView::RefreshHeartRateMin(uint16_t min) + { + if (bottomRate == nullptr) + { + return; + } - minRate = (minRate <= min) ? minRate : min; - if (bottomRate == nullptr) { - return; - } - if (minRate >= HEART_RATE_LIMIT_UPPER) { - bottomRate->SetText("--"); - return; - } - ret = sprintf_s(bottom, sizeof(bottom), "%u", minRate); - if (ret > EOK) { - bottomRate->SetText(bottom); + // 设置刷新文本 + if (min >= HEART_RATE_LIMIT_UPPER || min < 60) + { + bottomRate->SetText("--"); + } + else + { + std::string bottomRateStr = std::to_string(min); + bottomRate->SetText(bottomRateStr.c_str()); + } } -} + // 刷新静息心率 + void HeartRateView::RefreshRestHeartRate(uint16_t value) + { + char heartRate[NUM_4] = "--"; + int32_t ret = 0; + + if (restRate == nullptr) + { + return; + } -// 刷新静息心率 -void HeartRateView::RefreshRestHeartRate(uint16_t value) -{ - char heartRate[NUM_4] = "--"; - int32_t ret = 0; + if (value == 0 || value == (uint16_t)0xFFFF) + { + // 无效值 + restRate->SetText("--"); + } + else + { + if (value > NUM_99) + { + ret = sprintf_s(heartRate, sizeof(heartRate), "%u", value); + } + else + { + ret = sprintf_s(heartRate, sizeof(heartRate), " %u", value); + } - if (restRate == nullptr) { - return; + if (ret > EOK) + { + restRate->SetText(heartRate); + } + } } - if (value == 0 || value == (uint16_t)0xFFFF) { // 无效值 - restRate->SetText("--"); - } else { - if (value > NUM_99) { - ret = sprintf_s(heartRate, sizeof(heartRate), "%u", value); - } else { - ret = sprintf_s(heartRate, sizeof(heartRate), " %u", value); +#if 0 +#ifdef __cplusplus + extern "C" + { +#endif + /* 定时器回调函数 */ + void HeartTimerCallback() + { + g_motionTimes++; + HeartCardPresenter *gHeartCardPresenter = HeartPresenter::GetInstance(); + if (gHeartCardPresenter == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartTimerCallback::gHeartCardPresenter new fail"); + return; + } + // gHeartCardPresenter->ModifiesTime(); + // PRINT("HeartTimerCallback\r\n"); } - if (ret > EOK) { - restRate->SetText(heartRate); + /* 开启定时器 */ + void InitTimer(void) + { + if (g_startCounting != NULL) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HeartModel::HeartTimer already exists!!"); + return; + } + g_startCounting = osTimerNew((osTimerFunc_t)HeartTimerCallback, osTimerPeriodic, NULL, NULL); + if (g_startCounting == NULL) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartModel::HeartTimer osTimerNew failed!!"); + return; + } + int tick = osMs2Tick(MS_ONE_SECONDS); + osStatus_t retTimer = osTimerStart(g_startCounting, tick); + if (retTimer != osOK) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartModel::HeartTimer osTimerStart failed, ret = %lx!!", retTimer); + if (g_startCounting != NULL) + { + retTimer = osTimerDelete(g_startCounting); + if (retTimer != osOK) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartModel::osTimerDelete failed, ret = %lx!!", retTimer); + return; + } + g_startCounting = NULL; + } + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "InitTimer!"); + return; + } } + /* 关闭定时器 */ + void DisableTimer(void) + { + if (g_startCounting != NULL) + { + osStatus_t ret = osTimerDelete(g_startCounting); + if (ret != osOK) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ScanTimerCallback osTimerDelete failed, ret = %lx!!", ret); + return; + } + g_startCounting = NULL; + PRINT("g_motionTimes:%d\r\n", sportdata->duration); + g_motionTimes = 0; + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "DisableTimer!"); + } + } + /* 暂停定时器 */ + void PauseTimer(void) + { + // 检查定时器是否存在 + if (g_startCounting != NULL) + { + // 暂停定时器,但不删除它 + osStatus_t ret = osTimerStop(g_startCounting); + if (ret != osOK) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "StopWatch_PauseTimer osTimerStop failed, ret = %lx!!", ret); + } + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "PauseTimer!"); + } + } + + /*恢复定时器*/ + void ResumeTimer(void) + { + // 检查定时器是否存在 + if (g_startCounting != NULL) + { + int tick = osMs2Tick(MS_ONE_SECONDS); + // 恢复定时器 + osStatus_t ret = osTimerStart(g_startCounting, tick); + if (ret != osOK) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ResumeTimer osTimerStart failed, ret = %lx!!", ret); + } + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ResumeTimer!"); + } + } + +#ifdef __cplusplus } -} +#endif +#endif } // namespace OHOS diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/src/HeartResultPresenter.cpp b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/src/HeartResultPresenter.cpp new file mode 100644 index 000000000..f64c063df --- /dev/null +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/src/HeartResultPresenter.cpp @@ -0,0 +1,163 @@ +/* + * Copyright (c) CompanyNameMagicTag 2021-2021. All rights reserved. + * Description: heart view + * Author: + * Create: 2021-08-01 + */ + +#include "heartrate/include/HeartResultPresenter.h" +#include "common/task_manager.h" +#include "HeartModel.h" + +#include "heartrate/include/HeartDetectionView.h" +#include "heartrate/include/HeartResultView.h" + +#include "components/ui_label.h" +#include "components/ui_label_ext.h" + +#include "ChangeSliceListener.h" +#include "broadcast_service.h" +#include +#include "iostream" +#include +#include +#include +#include +#include "wearable_log.h" +#include "cmsis_os.h" +#include "securec.h" +#include "broadcast_service.h" +#include "graphic_service.h" +#include +#include +#include + +#ifdef PPG_HX3695 +#include "ppg_service.h" +#endif + +#include "power_display_service.h" +#include "custom_utils.h" + +#ifdef ENABLE_CYWEE +#include "cywee_service.h" +#endif + +// #include "battery_hal.h" + +#include "heart_blood/health_service/health_service.h" +#include "NativeRegisterManager.h" + +#define BLOODKEYABLE 1 +namespace OHOS +{ + + REGIST_SLICE(VIEW_HEART_RESULT, HeartResultView, HeartResultPresenter); + + + static constexpr uint16_t PROGRESS_VALUE_MIN = 0; + static constexpr uint16_t PROGRESS_VALUE_MAX = 10; + + + static HeartResultPresenter *g_pHeartResultPresenter; + /* -------------------------------------------------------------------------- */ + // 获取当前的时间戳 + uint32_t HeartResultPresenter::GetCurrentTime() + { + uint32_t time; + if (uapi_get_timestampe_ss(&time) != ERRCODE_SUCC) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "Failed to get timestamp"); + return 0; + } + return time; + } + + // 获取时间差,现在传进来的是两个时间戳 + int HeartResultPresenter::GetTDOA(uint32_t new_time, uint32_t old_time) + { + if (new_time == old_time || old_time > new_time) + { + return 0; + } + int time_diff_seconds = new_time - old_time; + // 转换为分钟的差值 + int time_diff_minutes = time_diff_seconds / 60; + return time_diff_minutes; + } + /* -------------------------------------------------------------------------- */ + HeartResultPresenter::HeartResultPresenter() + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HeartResultPresenter::new HeartResultPresenter"); + g_pHeartResultPresenter = this; + } + HeartResultPresenter::~HeartResultPresenter() + { + g_pHeartResultPresenter = nullptr; + } + HeartResultPresenter *HeartResultPresenter::GetInstance() + { + return g_pHeartResultPresenter; + } + void HeartResultPresenter::OnStart() + { + Presenter::OnStart(); + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HeartResultPresenter::On Start "); + } + void HeartResultPresenter::OnPause(void) {} + + void HeartResultPresenter::OnResume(void) {} + + void HeartResultPresenter::OnStop(void) {} + + bool HeartResultPresenter::OnDrag(UIView &view, const DragEvent &event) + { + return true; + } + bool HeartResultPresenter::OnDragEnd(UIView &view, const DragEvent &event) + { + if (event.GetDragDirection() == DragEvent::DIRECTION_LEFT_TO_RIGHT) + { + // NativeAbility::GetInstance().ChangeSlice(VIEW_APPLIST); + NativeAbility::GetInstance().Back(TransitionType::TRANSITION_BACK_TO_HEXAGONS); + return true; + } + return false; + } + bool HeartResultPresenter::OnKeyAct(UIView &view, const KeyEvent &event) + { + unsigned short keyID = event.GetKeyId(); + unsigned short keyState = event.GetState(); + // 如果是power键,且是亮屏状态,按键释放就返回上一级 + if (keyID == static_cast(ZliteKeyCode::ZLITE_KEY_POWER) && keyState == 1 && uapi_get_screen_state() == 0) + { + // NativeAbility::GetInstance().ChangeSlice(VIEW_APPLIST); + NativeAbility::GetInstance().Back(TransitionType::TRANSITION_BACK_TO_HEXAGONS); + } + return true; + } + + bool HeartResultPresenter::OnClick(UIView &view, const ClickEvent &event) + { + if (strcmp(view.GetViewId(), CLICK_HEART) == 0) + { + // 如果正在充电进入提醒界面 + // bool isCharging = get_charge_stat(); + bool isCharging = false; + if (isCharging) + { + HealthState highHealthState; + highHealthState.checkType = CHARGE; + HealthService::GetInstance()->SetHealthCurrent(highHealthState); + NativeAbility::GetInstance().ChangeSlice(VIEW_CHECK_INVALID, TransitionType::TRANSITION_BACK_TO_HEXAGONS); + } + else + { + NativeAbility::GetInstance().EnterSlice(VIEW_HEART_CHECK, TransitionType::TRANSITION_BACK_TO_HEXAGONS); + } + } + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "HeartPresenter::OnClick"); + return true; + } + +} \ No newline at end of file diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/src/HeartResultView.cpp b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/src/HeartResultView.cpp new file mode 100644 index 000000000..c008893d5 --- /dev/null +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/heartrate/src/HeartResultView.cpp @@ -0,0 +1,203 @@ +/*** + * @Date: 2024-04-15 10:55:58 + * @LastEditors: Caisking 3449750381@qq.com + * @LastEditTime: 2024-07-30 16:39:56 + * @FilePath: /FD230/code/sdk/application/wearable/fd230app/nativeui/heartrate/src/HeartResultView.cpp + */ + +#include "common/image_cache_manager.h" +#include "ui_resource_image.h" +#include +#include "components/ui_button.h" +#include "MainViewSample.h" +#include "components/ui_view_group.h" +#include "DialModelSPO2.h" +#include "DialModelHeartRate.h" +#include "HeartModel.h" + +#include "UiConfig.h" +#include "uicomponents/UIComponents.h" +#include "MainPresenterSample.h" + +#include "heartrate/include/HeartResultPresenter.h" +#include "heartrate/include/HeartResultView.h" +namespace OHOS +{ + static HeartResultView *g_pHeartResultView{nullptr}; + static const char *HEARTBACKPATH = "/user/res/Blood/beijing.bin"; + + HeartResultView::HeartResultView() + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartResultView::HeartResultView"); + g_pHeartResultView = this; + } + + HeartResultView::~HeartResultView() + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartResultView::~HeartResultView"); + DeInit(); + g_pHeartResultView = nullptr; + } + + HeartResultView *HeartResultView::GetInstance() + { + return g_pHeartResultView; + } + + /* -------------------------------------------------------------------------- */ + void HeartResultView::UpHeartText() + { + // 更新心率数据 + uint16_t heart = HeartModel::GetInstance()->GetHeartdata(); + if (heart != 0) // 判断是否为默认数据 + { + // 更新数据 + std::string heartrateStr = std::to_string(heart); + heartLabel->SetText(heartrateStr.c_str()); + + // 获取时间差 + uint32_t time = HeartResultPresenter::GetInstance()->GetCurrentTime(); + uint32_t check_time = HeartModel::GetInstance()->GetCheckTime(); + int time_diff = HeartResultPresenter::GetInstance()->GetTDOA(time, check_time); + + if (time_diff == 0) + { + timeLabel->SetTextId(STR_CHECKNEW); + } + else if (time_diff <= 60) + { + UpdateLabel(timeLabel, time_diff, STR_CHECKTIME); + } + else + { + timeLabel->SetTextId(STR_CHECKLONG); + } + } + else + { + heartLabel->SetText("--"); + timeLabel->SetTextId(STR_CHECKNO); + } + } + + /* -------------------------------------------------------------------------- */ + /*** + * @description: + * @return 添加按键是否成功 + */ + bool HeartResultView::AddButton() + { + InitButtonExt(checkButton, 118, 336, 230, 80, CLICK_HEART, STR_CHECK, 30); + checkButton->SetStyle(STYLE_BACKGROUND_COLOR, 0xffFF5A36); // 设置按键颜色 + // 设置按键监听 + UIView::OnClickListener *clickListener = (UIView::OnClickListener *)OHOS::HeartResultPresenter::GetInstance(); + checkButton->SetOnClickListener(clickListener); + + AddViewToRootContainer(checkButton); + return true; + } + /*** + * @description: + * @return 初始化标签是否成功 + */ + bool HeartResultView::InitLable() + { + /*初始化title*/ + InitLabelExt(titleLabel, 83, 50, 300, 35, "title", STR_HEARTDATA, DEFAULT_VECTOR_FONT_FILENAME, 30); + /*初始化心率值label*/ + InitUILabel(heartLabel, 83, 32, 300, 300, "bloodtext", "--", DEFAULT_VECTOR_FONT_FILENAME, 140); + /*初始化检测时间*/ + InitLabelExt(timeLabel, 53, 270, 360, 35, "time", STR_CHECKNO, DEFAULT_VECTOR_FONT_FILENAME, 30); + // 设置来回滚动属性 + timeLabel->SetLineBreakMode(UILabel::LINE_BREAK_OSCILLATION); + timeLabel->SetRollSpeed(23); + + UpHeartText(); + + AddViewToRootContainer(titleLabel); + AddViewToRootContainer(heartLabel); + AddViewToRootContainer(timeLabel); + + return true; + } + /*** + * @description: + * @return 初始化背景是否成功 + */ + bool HeartResultView::Initbackground() + { + + background = new UIImageView(); + background->SetPosition(0, 0, 466, 466); + background->SetSrc(HEARTBACKPATH); + + AddViewToRootContainer(background); + return true; + } + /*** + * @description: + * @return 是否初始化成功 + */ + bool HeartResultView::HeartResultViewInit() + { + + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "bool HeartResultView::InitView()"); + if (!Initbackground()) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Initbackground error!"); + }; + if (!InitLable()) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "InitLable error!"); + }; + if (!AddButton()) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "AddButton error!"); + }; + return true; + } + /*** + * @description: + * @return 删除组件 + */ + void HeartResultView::DeInit() + { + if (background != nullptr) + { + delete background; + background = nullptr; + } + if (heartLabel != nullptr) + { + delete heartLabel; + heartLabel = nullptr; + } + if (timeLabel != nullptr) + { + delete timeLabel; + timeLabel = nullptr; + } + if (titleLabel != nullptr) + { + delete titleLabel; + titleLabel = nullptr; + } + } + + void HeartResultView::OnStart() + { + + + if (!HeartResultViewInit()) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "HeartResultView::InitHeartView fail"); + } + + + GetRootContainer()->SetDraggable(true); + GetRootContainer()->SetTouchable(true); + GetRootContainer()->SetOnDragListener(presenter_); + // GetRootContainer()->SetOnKeyActListener(presenter_); + } + +}