From: luozheng <1732036298@qq.com> Date: Wed, 26 Mar 2025 07:34:54 +0000 (+0800) Subject: 呼吸训练slice合并提交 X-Git-Tag: leiniao_debug_1.0.0_20250922_020716~393 X-Git-Url: http://git.snicker.com.cn/css/static/gitweb.css?a=commitdiff_plain;h=d2a0b772638f83871c463b37a037f2a8d1f21cf3;p=mirrors%2FFD230.git 呼吸训练slice合并提交 --- diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/respiratorytraining/include/RespiratoryTrainingCompletedView.h b/code/sdk/application/wearable/fd230/nativeapp/nativeui/respiratorytraining/include/RespiratoryTrainingCompletedView.h new file mode 100644 index 000000000..3fb267ad5 --- /dev/null +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/respiratorytraining/include/RespiratoryTrainingCompletedView.h @@ -0,0 +1,73 @@ +/* + * @Author: luozheng 1732036298@qq.com + * @Date: 2024-06-08 18:24:24 + * @LastEditors: luozheng 1732036298@qq.com + * @LastEditTime: 2024-06-11 14:41:30 + * @FilePath: /FD230/code/sdk/application/wearable/fd230app/nativeui/respiratorytraining/include/RespiratoryTrainingCompletedCompletedView.h + */ + +#ifndef RESPIRATORY_TRAINING_COMPLETED_VIEW_H +#define RESPIRATORY_TRAINING_COMPLETED_VIEW_H + + +#include "View.h" +#include "components/ui_scroll_view.h" +#include "components/ui_label_ext.h" +#include "components/ui_label_button_ext.h" +#include "components/ui_image_view.h" + +namespace OHOS +{ + static constexpr int MAX_NUM = 3; + static constexpr const char *RTCLABELBUTTON = "RTCLabelButton"; + static constexpr const char *RTCVectorImagePath = "/user/res/RespiratoryTraining/RTCVector.bin"; + static constexpr const char *RTCGroupListImagePath = "/user/res/RespiratoryTraining/RTCGroupList.bin"; + class RespiratoryTrainingCompletedView + { + public: + struct LabelConfig + { + int16_t left; + int16_t top; + int16_t width; + int16_t height; + int16_t fontSize; // 字体大小 + int16_t lineHeigh; // 行高 + const char *text; + int16_t textId; + uint8_t lineBreakMode; // 断行模式。 + }; + + struct ImageConfig + { + int16_t x; + int16_t y; + int16_t w; + int16_t h; + }; + + RespiratoryTrainingCompletedView(); + ~RespiratoryTrainingCompletedView(); + static RespiratoryTrainingCompletedView *GetInstance(void); + UIScrollView *RespiratoryTrainingCompletedViewInit(void); + + private: + void ClearAll(void); + bool CreateRespiratoryTrainingCompletedScrollView(); + bool CreateRespiratoryTrainingCompletedLabelView(); + bool CreateRespiratoryTrainingCompletedImageView(); + bool CreateRespiratoryTrainingCompletedLabelButtonView(); + UILabelExt *LabelExtViewInit(const LabelConfig &labelconfig); + UILabel *LabelViewInit(const LabelConfig &labelconfig); + UIImageView *ImageViewInit(ImageConfig &imageconfig); + UIScrollView *ScrollView{nullptr}; + UILabelExt *Title{nullptr}; + UILabelExt *RespiratoryTrainingLabel{nullptr}; + UIImageView *RespiratoryTrainingImage{nullptr}; + UILabelExt *RTCStaticLabelView[MAX_NUM]{nullptr}; + UILabel *RTCDynamicLabelView[MAX_NUM]{nullptr}; + UIImageView *RTCImageView[MAX_NUM]{nullptr}; + UILabelButtonExt *RTCLabelButton{nullptr}; + }; +} +#endif \ No newline at end of file diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/respiratorytraining/include/RespiratoryTrainingDurationSelectionView.h b/code/sdk/application/wearable/fd230/nativeapp/nativeui/respiratorytraining/include/RespiratoryTrainingDurationSelectionView.h new file mode 100644 index 000000000..7955be9d3 --- /dev/null +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/respiratorytraining/include/RespiratoryTrainingDurationSelectionView.h @@ -0,0 +1,66 @@ +/* + * @Author: luozheng 1732036298@qq.com + * @Date: 2024-09-29 17:51:20 + * @LastEditors: luozheng 1732036298@qq.com + * @LastEditTime: 2024-10-04 17:47:43 + * @FilePath: /FD230/code/sdk/application/wearable/fd230app/nativeui/respiratorytraining/include/RespiratoryTrainingDurationSelectionView.h + */ +#ifndef RESPIRATORY_TRAINING_DURATION_SELECTION_VIEW_H +#define RESPIRATORY_TRAINING_DURATION_SELECTION_VIEW_H +#include "components/ui_scroll_view.h" +#include "components/ui_label_ext.h" +#include "components/ui_label_button_ext.h" + +#include "components/ui_image_view.h" +namespace OHOS +{ +#define MAX_NUM_TRAINING_DURATION 5 + + static constexpr const char *RESPIRATORYTRAINING_DURATIONSELECTION_VIEW = "RespiratoryTrainingDurationSelectionView"; + static constexpr const char *TRAINING_DURATION_ONE_MIN = "training_duration_one_min"; + static constexpr const char *TRAINING_DURATION_TWO_MIN = "training_duration_two_min"; + static constexpr const char *TRAINING_DURATION_THREE_MIN = "training_duration_three_min"; + static constexpr const char *TRAINING_DURATION_FOUR_MIN = "training_duration_four_min"; + static constexpr const char *TRAINING_DURATION_FIVE_MIN = "training_duration_five_min"; + class RespiratoryTrainingDurationSelectionView + { + public: + struct LabelButtonConfig + { + int16_t left; + int16_t top; + int16_t width; + int16_t height; + const char *viewId; + }; + struct LabelConfig + { + int16_t left; + int16_t top; + int16_t width; + int16_t height; + int16_t fontSize; + int16_t lineHeigh; + const char *text; + int16_t textId; + uint8_t lineBreakMode; + }; + RespiratoryTrainingDurationSelectionView(/* args */); + ~RespiratoryTrainingDurationSelectionView(); + static RespiratoryTrainingDurationSelectionView *GetInstance(void); + UIScrollView *RespiratoryTrainingDurationSelectionViewInit(void); + void UpdateRespiratoryTrainingDurationSelectionView(void); + + private: + UILabelExt *LabelViewinit(LabelConfig &labelconfig); + UILabelButtonExt *LabelButtonViewInit(LabelButtonConfig &labelbuttonconfig); + void ClearAll(void); + UIScrollView *scrollView = nullptr; + UILabelExt *TitleLabel = nullptr; // 标题 + UILabelExt *DurationLabel[MAX_NUM_TRAINING_DURATION]{nullptr}; // 亮屏时长标签 + UILabelButtonExt *DurationButton[MAX_NUM_TRAINING_DURATION]{nullptr}; // 放置组件的按钮 + UIImageView *temp{nullptr}; + }; + +} +#endif \ No newline at end of file diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/respiratorytraining/include/RespiratoryTrainingModel.h b/code/sdk/application/wearable/fd230/nativeapp/nativeui/respiratorytraining/include/RespiratoryTrainingModel.h new file mode 100644 index 000000000..a6ad2c5d6 --- /dev/null +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/respiratorytraining/include/RespiratoryTrainingModel.h @@ -0,0 +1,49 @@ +/* + * @Author: luozheng 1732036298@qq.com + * @Date: 2024-06-11 16:26:13 + * @LastEditors: luozheng 1732036298@qq.com + * @LastEditTime: 2024-10-09 12:22:31 + * @FilePath: /FD230/code/sdk/application/wearable/fd230app/nativeui/respiratorytraining/include/RespiratoryTrainingModel.h + */ +#ifndef RESPIRATORY_TRAINING_MODEL_H +#define RESPIRATORY_TRAINING_MODEL_H + +#include +#include +#include "string" +namespace OHOS +{ + class RespiratoryTrainingModel + { + public: + static RespiratoryTrainingModel &GetInstance(void); + void AddRespiratoryTrainingTimes(void); + std::string GetRespiratoryTrainingTotalTime(void); + int GetAverageHeartRate(void); + void calculateHeartrateTotal(void); + void ResumeStatus(); + + void RT_StartTimer(uint64_t interval); + void RT_StopTimer(void); + + int GetRespiratoryTrainingSelectTime(); + void SetRespiratoryTrainingSelectTime(int time); + uint64_t GetRespiratoryTrainingTime(); + void ClearTotalRespiratoryTrainingTime(void); + + private: + RespiratoryTrainingModel(); + ~RespiratoryTrainingModel(); + RespiratoryTrainingModel(const RespiratoryTrainingModel &) = delete; + RespiratoryTrainingModel &operator=(const RespiratoryTrainingModel &) = delete; + + int RespiratoryTrainingTimes{0}; // 呼吸训练次数 + int RespiratoryTrainingTime{0}; + std::string HeartRateValue{nullptr}; + int count{0}; + float heartTotal{0}; + int selectTime{1}; + }; +} + +#endif \ No newline at end of file diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/respiratorytraining/include/RespiratoryTrainingPresenter.h b/code/sdk/application/wearable/fd230/nativeapp/nativeui/respiratorytraining/include/RespiratoryTrainingPresenter.h new file mode 100644 index 000000000..913e5fe12 --- /dev/null +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/respiratorytraining/include/RespiratoryTrainingPresenter.h @@ -0,0 +1,48 @@ +/* + * @Author: luozheng 1732036298@qq.com + * @Date: 2024-06-08 09:36:33 + * @LastEditors: luozheng 1732036298@qq.com + * @LastEditTime: 2024-10-05 12:29:42 + * @FilePath: /FD230/code/sdk/application/wearable/fd230app/nativeui/respiratorytraining/include/RespiratoryTrainingPresenter.h + */ + +#ifndef RESPIRATORY_TRAINING_PRESENTER_H +#define RESPIRATORY_TRAINING_PRESENTER_H + +#include "Presenter.h" +#include "View.h" + +namespace OHOS +{ + + class RespiratoryTrainingView; + class RespiratoryTrainingPresenter : public Presenter, + public UIView::OnClickListener, + public RootView::OnKeyActListener, + public UIView::OnDragListener + { + public: + RespiratoryTrainingPresenter(); + virtual ~RespiratoryTrainingPresenter(); + + void OnStart() override; + void OnPause() override; + void OnResume() override; + void OnStop() override; + + static RespiratoryTrainingPresenter *GetInstance(); + + int GetRespiratoryTrainingSelectTime(); + std::string GetRespiratoryTrainingSelectTime1(); + + private: + bool OnClick(UIView &view, const ClickEvent &event) override; + bool OnDrag(UIView &view, const DragEvent &event) override; + bool OnDragEnd(UIView &view, const DragEvent &event) override; + bool OnKeyAct(UIView &view, const KeyEvent &event) override; // 增加按键事件 + + bool X_DRAG_FLAG{false}; + }; +} + +#endif \ No newline at end of file diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/respiratorytraining/include/RespiratoryTrainingView.h b/code/sdk/application/wearable/fd230/nativeapp/nativeui/respiratorytraining/include/RespiratoryTrainingView.h new file mode 100644 index 000000000..09d1549a7 --- /dev/null +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/respiratorytraining/include/RespiratoryTrainingView.h @@ -0,0 +1,116 @@ +/* + * @Author: luozheng 1732036298@qq.com + * @Date: 2024-06-08 09:36:01 + * @LastEditors: luozheng 1732036298@qq.com + * @LastEditTime: 2025-02-24 17:35:35 + * @FilePath: /FD230/code/sdk/application/wearable/fd230app/nativeui/respiratorytraining/include/RespiratoryTrainingView.h + */ + +#ifndef RESPIRATORY_TRAINING_VIEW_H +#define RESPIRATORY_TRAINING_VIEW_H + + +#include "View.h" +#include "components/ui_label_ext.h" +#include +#include "components/ui_image_animator.h" +#include "components/ui_image_view.h" +#include "components/root_view.h" +#include "hal_tick.h" +#include "components/ui_scroll_view.h" +#include "respiratorytraining/include/RespiratoryTrainingCompletedView.h" +#include "respiratorytraining/include/RespiratoryTrainingDurationSelectionView.h" + +namespace OHOS +{ + typedef enum + { + RESPIRATORYTRAINING = 0, + RESPIRATORYTRAININGCOMPLETED, + RESPIRATORY_TRAINING_DURATION_SELECTION, // 训练时长选择 + MAX_RESPIRATORYTRAININGID, + } RESPIRATORYTRAININGVIEWID; + + class RespiratoryTrainingCallback : public AnimatorCallback + { + public: + explicit RespiratoryTrainingCallback(UIImageView *img) : img_(img) {} + ~RespiratoryTrainingCallback() override {} + void Callback(UIView *view) override; + void SetTextView(UILabelExt *view) + { + breath = view; + } + + uint32_t startTimestamp = 0; + + private: + UIImageView *img_ = nullptr; + UILabelExt *breath = nullptr; + bool isBreathIn = false; + int16_t angle = 0; + int16_t step = -1; + float scale = 0; + uint16_t curTime = 0; + uint16_t prepareTiem = 0; + uint16_t durationTime = 5 * 1000; // 5000: means 5000ms + int16_t startVal = durationTime; + int16_t endVal = durationTime / 2; // 2: half + bool isprepare{false}; + int prepare_count = 0; + }; + + static constexpr int RESPIRATORY_TRAINING_IMAGE_ANIMATOR_VIEW_X = 193; + static constexpr int RESPIRATORY_TRAINING_IMAGE_ANIMATOR_VIEW_Y = 110; + static constexpr int RESPIRATORY_TRAINING_IMAGE_ANIMATOR_VIEW_W = 80; + static constexpr int RESPIRATORY_TRAINING_IMAGE_ANIMATOR_VIEW_H = 80; + static constexpr int RESPIRATORY_TRAINING_IMAGE_ANIMATOR_VIEW_TIMEOFUPDATE = 100; + static constexpr int RESPIRATORY_TRAINING_IMAGE_ANIMATOR_VIEW_NUM_FRAMES = 25; // 呼吸训练动画帧数 + static ImageAnimatorInfo RespiratoryTrainingImageInfo[RESPIRATORY_TRAINING_IMAGE_ANIMATOR_VIEW_NUM_FRAMES]; + + class RespiratoryTrainingPresenter; + class RespiratoryTrainingView : public View, public UIView::OnClickListener + { + + public: + RespiratoryTrainingView(); + virtual ~RespiratoryTrainingView(); + static RespiratoryTrainingView *GetInstance(void); + bool ClickFunc(int16_t interface); + void ChangeView(int16_t hideView, int16_t showView); + bool ChangeRespiratoryTrainingView(int16_t thisView); + bool ChangeRespiratoryTrainingCompletedView(int16_t thisView); + bool ChangeRespiratoryTrainingDurationSelectionView(int16_t thisView); + Animator *GetRespiratoryTrainingAnimator_(); + bool StartRespiratoryTraining(); + void OnStart() override; + bool OnClick(UIView &view, const ClickEvent &event) override; + + private: + void RespiratoryTrainingViewInit(void); + void ClearAll(void); + bool InitRespiratoryTrainingElements(); + bool InitRespiratoryTrainingElements2(); + bool InitRespiratoryTrainingCallBackAndAnimator(); + bool InitRespiratoryTrainingScrollView(); + void HandStartRespiratoryTraining(); + UIScrollView *RespiratoryTrainingScrollView[MAX_RESPIRATORYTRAININGID]{nullptr}; + RespiratoryTrainingCompletedView *p_RespiratoryTrainingCompletedView{nullptr}; + RespiratoryTrainingDurationSelectionView *p_RespiratoryTrainingDurationSelectionView{nullptr}; + RespiratoryTrainingCallback *RespiratoryTrainingCallBack_ = nullptr; + Animator *RespiratoryTrainingAnimator_ = nullptr; + UIImageView *RespiratoryTrainingImg_ = nullptr; + UILabelExt *RespiratoryTrainingStartNote_ = nullptr; + UILabelExt *RespiratoryTrainingLabel_ = nullptr; + bool animateStart_ = false; + /* -------------------------------------------------------------------------- */ + UILabelExt *titlelabel{nullptr}; // 标题 + UILabelExt *TrainingDurationSelectiontitlelabel{nullptr}; // 选择的训练时长 + UIImageView *Image{nullptr}; + UILabelButton *RespiratoryTrainingStartButton = nullptr; // 训练开始按钮 + UILabelExt *RespiratoryTrainingStartLabel = nullptr; // 训练开始标签 + /* -------------------------------------------------------------------------- */ + }; + +} +#endif \ No newline at end of file diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/respiratorytraining/src/RespiratoryTrainingCompletedView.cpp b/code/sdk/application/wearable/fd230/nativeapp/nativeui/respiratorytraining/src/RespiratoryTrainingCompletedView.cpp new file mode 100644 index 000000000..962b347da --- /dev/null +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/respiratorytraining/src/RespiratoryTrainingCompletedView.cpp @@ -0,0 +1,338 @@ +/* + * @Author: luozheng 1732036298@qq.com + * @Date: 2024-05-07 11:25:58 + * @LastEditors: luozheng 1732036298@qq.com + * @LastEditTime: 2025-02-25 15:09:29 + * @FilePath: /FD230/code/sdk/application/wearable/fd230app/nativeui/RespiratoryTrainingCompleted/src/RespiratoryTrainingCompletedView.cpp + */ + +#include "respiratorytraining/include/RespiratoryTrainingCompletedView.h" +#include "wearable_log.h" +#include "ui_resource_string.h" +#include "respiratorytraining/include/RespiratoryTrainingPresenter.h" +#include "common/image_cache_manager.h" +#include "respiratorytraining/include/RespiratoryTrainingModel.h" + +namespace OHOS +{ + + static RespiratoryTrainingCompletedView *g_pRespiratoryTrainingCompletedView{nullptr}; + + RespiratoryTrainingCompletedView::RespiratoryTrainingCompletedView() + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingCompletedView::RespiratoryTrainingCompletedView"); + g_pRespiratoryTrainingCompletedView = this; + } + + RespiratoryTrainingCompletedView::~RespiratoryTrainingCompletedView() + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingCompletedView::~RespiratoryTrainingCompletedView"); + ClearAll(); + g_pRespiratoryTrainingCompletedView = nullptr; + } + + RespiratoryTrainingCompletedView *RespiratoryTrainingCompletedView::GetInstance() + { + return g_pRespiratoryTrainingCompletedView; + } + + void RespiratoryTrainingCompletedView::ClearAll(void) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingCompletedView::ClearAll Start!!"); + if (ScrollView != nullptr) + { + ScrollView->RemoveAll(); + ImageCacheManager::GetInstance().UnloadSingleRes(RTCVectorImagePath); + ImageCacheManager::GetInstance().UnloadSingleRes(RTCGroupListImagePath); + + if (Title != nullptr) + { + delete Title; + Title = nullptr; + } + + if (RespiratoryTrainingImage != nullptr) + { + delete RespiratoryTrainingImage; + RespiratoryTrainingImage = nullptr; + } + + if (RespiratoryTrainingLabel != nullptr) + { + delete RespiratoryTrainingLabel; + RespiratoryTrainingLabel = nullptr; + } + for (int i = 0; i < MAX_NUM; i++) + { + if (RTCStaticLabelView[i] != nullptr) + { + delete RTCStaticLabelView[i]; + RTCStaticLabelView[i] = nullptr; + } + + if (RTCDynamicLabelView[i] != nullptr) + { + delete RTCDynamicLabelView[i]; + RTCDynamicLabelView[i] = nullptr; + } + + if (RTCImageView[i] != nullptr) + { + delete RTCImageView[i]; + RTCImageView[i] = nullptr; + } + } + + if (RTCLabelButton != nullptr) + { + delete RTCLabelButton; + RTCLabelButton = nullptr; + } + + delete ScrollView; + ScrollView = nullptr; + } + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingCompletedView::ClearAll End!!"); + } + + UILabelExt *RespiratoryTrainingCompletedView::LabelExtViewInit(const LabelConfig &labelconfig) + { + UILabelExt *label = new UILabelExt(); + if (label == nullptr) + { + return nullptr; + } + label->SetPosition(labelconfig.left, labelconfig.top, labelconfig.width, labelconfig.height); // 位置大小 + label->SetStyle(STYLE_TEXT_FONT, labelconfig.fontSize); // 字体大小 + label->SetStyle(STYLE_LINE_HEIGHT, labelconfig.lineHeigh); // 字体行高 + label->SetTextId(labelconfig.textId); // 内容 + label->SetLineBreakMode(labelconfig.lineBreakMode); // 断行模式。 + label->SetAlign(TEXT_ALIGNMENT_LEFT, TEXT_ALIGNMENT_CENTER); + label->SetFont(DEFAULT_VECTOR_FONT_FILENAME, labelconfig.fontSize); + return label; + } + + UILabel *RespiratoryTrainingCompletedView::LabelViewInit(const LabelConfig &labelconfig) + { + UILabel *label = new UILabel(); + if (label == nullptr) + { + return nullptr; + } + label->SetPosition(labelconfig.left, labelconfig.top, labelconfig.width, labelconfig.height); // 位置大小 + label->SetStyle(STYLE_TEXT_FONT, labelconfig.fontSize); // 字体大小 + label->SetStyle(STYLE_LINE_HEIGHT, labelconfig.lineHeigh); // 字体行高 + label->SetText(labelconfig.text); // 内容 + label->SetLineBreakMode(labelconfig.lineBreakMode); // 断行模式。 + label->SetAlign(TEXT_ALIGNMENT_LEFT, TEXT_ALIGNMENT_CENTER); + label->SetFont(DEFAULT_VECTOR_FONT_FILENAME, labelconfig.fontSize); + return label; + } + + UIImageView *RespiratoryTrainingCompletedView::ImageViewInit(ImageConfig &imageconfig) + { + UIImageView *Image = new UIImageView(); + if (Image == nullptr) + { + return nullptr; + } + Image->SetPosition(imageconfig.x, imageconfig.y, imageconfig.w, imageconfig.h); + return Image; + } + + bool RespiratoryTrainingCompletedView::CreateRespiratoryTrainingCompletedScrollView() + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingCompletedView::CreateRespiratoryTrainingCompletedScrollView"); + ScrollView = new UIScrollView(); + if (ScrollView == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ScrollView new fail!"); + return false; + } + ScrollView->SetPosition(0, 0, Screen::GetInstance().GetWidth(), Screen::GetInstance().GetHeight()); + ScrollView->SetScrollBlankSize(75); + ScrollView->SetReboundSize(35); + ScrollView->SetHorizontalScrollState(false); + ScrollView->SetTouchable(true); + ScrollView->SetDraggable(true); + ScrollView->RequestFocus(); + ScrollView->SetRotateFactor(1.0); + + return true; + } + + bool RespiratoryTrainingCompletedView::CreateRespiratoryTrainingCompletedLabelView() + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingCompletedView::CreateRespiratoryTrainingCompletedLabelView"); + /* ---------------------------------- Title --------------------------------- */ + LabelConfig labelconfig = { + .left = 83, + .top = 52, + .width = 300, + .height = 35, + .fontSize = 30, + .lineHeigh = 35, + .textId = STR_TRAINING_COMPLETE, // 训练完成 + .lineBreakMode = UILabel::LINE_BREAK_MARQUEE, + }; + Title = LabelExtViewInit(labelconfig); + if (nullptr == Title) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Title is nullptr!"); + return false; + } + Title->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER); + ScrollView->Add(Title); + /* ------------------------ RespiratoryTrainingLabel ------------------------ */ + labelconfig.left = 147; + labelconfig.top = 150; + labelconfig.width = 240; + labelconfig.textId = STR_BREATH_TRAINING; // 呼吸训练 + RespiratoryTrainingLabel = LabelExtViewInit(labelconfig); + if (nullptr == RespiratoryTrainingLabel) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingLabel is nullptr!"); + return false; + } + ScrollView->Add(RespiratoryTrainingLabel); + /* -------------------------------------------------------------------------- */ + int y1 = 248, y2 = 286; + const int textId[MAX_NUM] = {STR_THIS_BREATH, STR_MEAN_HEART_RATE_MIN, STR_TODAYS_BREATHING_TRAINING}; + int value = RespiratoryTrainingModel::GetInstance().GetAverageHeartRate(); + std::string select_time; + if (RespiratoryTrainingPresenter::GetInstance()) + { + select_time = RespiratoryTrainingPresenter::GetInstance()->GetRespiratoryTrainingSelectTime1(); + } + std::string heartRateValue = (value == 0 ? "--" : std::to_string(value)); + std::string trainingTotalTime = RespiratoryTrainingModel::GetInstance().GetRespiratoryTrainingTotalTime(); + const char *text[MAX_NUM] = {select_time.c_str(), heartRateValue.c_str(), trainingTotalTime.c_str()}; + OHOS::ColorType RTCDynamicLabelTextColor[MAX_NUM] = { + Color::GetColorFromRGBA(0x1d, 0xda, 0xc4, 0xff), + Color::GetColorFromRGBA(0xff, 0x5a, 0x36, 0xff), + Color::GetColorFromRGBA(0xff, 0x8a, 0x36, 0xff), + }; + for (int i = 0; i < MAX_NUM; i++) + { + labelconfig.left = 138; + labelconfig.top = y1 + 130 * i; + labelconfig.width = 240; + labelconfig.height = 35; + labelconfig.fontSize = 30; + labelconfig.lineHeigh = 35; + labelconfig.textId = textId[i]; + labelconfig.lineBreakMode = UILabel::LINE_BREAK_MARQUEE; + RTCStaticLabelView[i] = LabelExtViewInit(labelconfig); + if (nullptr == RTCStaticLabelView[i]) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "RTCStaticLabelView[%d] is nullptr!", i); + return false; + } + RTCStaticLabelView[i]->SetTextColor(Color::GetColorFromRGBA(0xff, 0xff, 0xff, 0x7f)); + ScrollView->Add(RTCStaticLabelView[i]); + /* -------------------------------------------------------------------------- */ + labelconfig.left = 138; + labelconfig.top = y2 + 130 * i; + labelconfig.height = 47; + labelconfig.fontSize = 40; + labelconfig.lineHeigh = 47; + labelconfig.text = text[i]; + RTCDynamicLabelView[i] = LabelViewInit(labelconfig); + if (nullptr == RTCDynamicLabelView[i]) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "RTCDynamicLabelView[%d] is nullptr!", i); + return false; + } + RTCDynamicLabelView[i]->SetTextColor(RTCDynamicLabelTextColor[i]); + RTCDynamicLabelView[i]->SetFont(DEFAULT_VECTOR_FONT_FILENAME_EN, 30); + ScrollView->Add(RTCDynamicLabelView[i]); + } + return true; + } + + bool RespiratoryTrainingCompletedView::CreateRespiratoryTrainingCompletedImageView() + { + RespiratoryTrainingImage = new UIImageView(); + if (RespiratoryTrainingImage == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingImage is nullptr!!"); + return false; + } + RespiratoryTrainingImage->SetPosition(61, 122, 90, 90); + RespiratoryTrainingImage->SetAutoEnable(false); + RespiratoryTrainingImage->SetResizeMode(UIImageView::CENTER); + ImageInfo *imgInfo = ImageCacheManager::GetInstance().LoadSingleRes(RTCVectorImagePath); + if (imgInfo == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Load image failed!"); + return false; + } + RespiratoryTrainingImage->SetSrc(imgInfo); + ScrollView->Add(RespiratoryTrainingImage); + /* -------------------------------------------------------------------------- */ + ImageConfig imageconfig = { + .x = 89, + .y = 212, + .w = 42, + .h = 130, + }; + // 加载呼吸训练Vector图片 + imgInfo = ImageCacheManager::GetInstance().LoadSingleRes(RTCGroupListImagePath); + for (int i = 0; i < MAX_NUM; i++) + { + imageconfig.y = 212 + (i * 130); + RTCImageView[i] = ImageViewInit(imageconfig); + if (RTCImageView[i] == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "RTCImageView[%d] is nullptr!", i); + return false; + } + RTCImageView[i]->SetSrc(imgInfo); + ScrollView->Add(RTCImageView[i]); + } + return true; + } + + bool RespiratoryTrainingCompletedView::CreateRespiratoryTrainingCompletedLabelButtonView() + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingCompletedView::CreateRespiratoryTrainingCompletedLabelButtonView"); + RTCLabelButton = new UILabelButtonExt(); + if (RTCLabelButton == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "RTCLabelButton is nullptr!"); + return false; + } + RTCLabelButton->SetPosition(43, 622); + RTCLabelButton->Resize(380, 100); + RTCLabelButton->SetViewId(RTCLABELBUTTON); + RTCLabelButton->SetStyle(STYLE_BACKGROUND_COLOR, 0xff191919); + // RTCLabelButton->SetText("关闭"); + RTCLabelButton->SetTextId(STR_CLOSE); + RTCLabelButton->SetFont(DEFAULT_VECTOR_FONT_FILENAME, 30); + RTCLabelButton->SetStyleForState(STYLE_BACKGROUND_COLOR, 0xff000000, UIButton::PRESSED); + RTCLabelButton->SetStyleForState(STYLE_BORDER_COLOR, 0xffffffff, UIButton::PRESSED); + RTCLabelButton->SetStyleForState(STYLE_BORDER_OPA, 0x00, UIButton::PRESSED); + UIView::OnClickListener *labelButtonClick = static_cast(RespiratoryTrainingPresenter::GetInstance()); + if (labelButtonClick == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "labelButtonClick is nullptr!"); + return false; + } + RTCLabelButton->SetOnClickListener(labelButtonClick); + ScrollView->Add(RTCLabelButton); + return true; + } + + // 呼吸训练完成视图初始化 + UIScrollView *RespiratoryTrainingCompletedView::RespiratoryTrainingCompletedViewInit(void) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingCompletedView::RespiratoryTrainingCompletedViewInit"); + if (!CreateRespiratoryTrainingCompletedScrollView() || !CreateRespiratoryTrainingCompletedLabelView() || + !CreateRespiratoryTrainingCompletedImageView() || !CreateRespiratoryTrainingCompletedLabelButtonView()) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingCompletedViewInit fail!!"); + return nullptr; + } + return ScrollView; + } +} \ No newline at end of file diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/respiratorytraining/src/RespiratoryTrainingDurationSelectionView.cpp b/code/sdk/application/wearable/fd230/nativeapp/nativeui/respiratorytraining/src/RespiratoryTrainingDurationSelectionView.cpp new file mode 100644 index 000000000..eea5598b0 --- /dev/null +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/respiratorytraining/src/RespiratoryTrainingDurationSelectionView.cpp @@ -0,0 +1,229 @@ +/* + * @Author: luozheng 1732036298@qq.com + * @Date: 2024-09-29 15:57:59 + * @LastEditors: luozheng 1732036298@qq.com + * @LastEditTime: 2024-11-05 14:40:12 + * @FilePath: /FD230/code/sdk/application/wearable/fd230app/nativeui/respiratorytraining/src/RespiratoryTrainingDurationSelectionView.cpp + */ +#include "respiratorytraining/include/RespiratoryTrainingDurationSelectionView.h" +#include "respiratorytraining/include/RespiratoryTrainingPresenter.h" +#include "respiratorytraining/include/RespiratoryTrainingModel.h" +#include "wearable_log.h" +#include "UiConfig.h" +#include "dock/focus_manager.h" +#include "ui_resource_string.h" +namespace OHOS +{ + + static RespiratoryTrainingDurationSelectionView *g_pRespiratoryTrainingDurationSelectionView{nullptr}; + RespiratoryTrainingDurationSelectionView::RespiratoryTrainingDurationSelectionView(/* args */) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingDurationSelectionView::RespiratoryTrainingDurationSelectionView"); + g_pRespiratoryTrainingDurationSelectionView = this; + } + + RespiratoryTrainingDurationSelectionView::~RespiratoryTrainingDurationSelectionView() + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingDurationSelectionView::~RespiratoryTrainingDurationSelectionView"); + ClearAll(); + g_pRespiratoryTrainingDurationSelectionView = nullptr; + } + + RespiratoryTrainingDurationSelectionView *RespiratoryTrainingDurationSelectionView::GetInstance(void) + { + return g_pRespiratoryTrainingDurationSelectionView; + } + + void RespiratoryTrainingDurationSelectionView::ClearAll(void) + { + if (scrollView) + { + scrollView->RemoveAll(); + delete TitleLabel; + TitleLabel = nullptr; + for (int i = 0; i < MAX_NUM_TRAINING_DURATION; i++) + { + delete DurationLabel[i]; + DurationLabel[i] = nullptr; + delete DurationButton[i]; + DurationButton[i] = nullptr; + } + delete temp; + temp = nullptr; + delete scrollView; + scrollView = nullptr; + } + } + + UILabelExt *RespiratoryTrainingDurationSelectionView::LabelViewinit(LabelConfig &labelconfig) + { + UILabelExt *label = new UILabelExt(); + if (label == nullptr) + { + return nullptr; + } + label->SetPosition(labelconfig.left, labelconfig.top, labelconfig.width, labelconfig.height); + label->SetStyle(STYLE_TEXT_FONT, labelconfig.fontSize); + label->SetStyle(STYLE_LINE_HEIGHT, labelconfig.lineHeigh); + label->SetTextId(labelconfig.textId); + // label->SetText(labelconfig.text); + label->SetLineBreakMode(labelconfig.lineBreakMode); + label->SetAlign(TEXT_ALIGNMENT_LEFT, TEXT_ALIGNMENT_CENTER); + label->SetRollSpeed(23); + label->SetFont(DEFAULT_VECTOR_FONT_FILENAME, labelconfig.fontSize); + return label; + } + + UILabelButtonExt *RespiratoryTrainingDurationSelectionView::LabelButtonViewInit(LabelButtonConfig &labelbuttonconfig) + { + UILabelButtonExt *labelButton = new UILabelButtonExt(); + if (labelButton == nullptr) + { + return nullptr; + } + labelButton->SetPosition(labelbuttonconfig.left, labelbuttonconfig.top); + labelButton->Resize(labelbuttonconfig.width, labelbuttonconfig.height); + labelButton->SetViewId(labelbuttonconfig.viewId); + labelButton->SetStyle(STYLE_BACKGROUND_COLOR, 0xff191919); + labelButton->SetImagePosition(300, 30); + labelButton->SetImageSrc(PNG_CHECKBOX_OFF_IMAGE, PNG_CHECKBOX_OFF_IMAGE); + // labelButton->SetTextId(labelbuttonconfig.textId); + // labelButton->SetAlign(TEXT_ALIGNMENT_LEFT); + // labelButton->SetLabelPosition(100, 0); + // labelButton->SetFont(DEFAULT_VECTOR_FONT_FILENAME, labelbuttonconfig.fontSize); + // labelButton->SetStyle(STYLE_LINE_HEIGHT, labelbuttonconfig.lineHeigh); + labelButton->SetStyleForState(STYLE_BACKGROUND_COLOR, 0xff000000, UIButton::PRESSED); + return labelButton; + } + + UIScrollView *RespiratoryTrainingDurationSelectionView::RespiratoryTrainingDurationSelectionViewInit(void) + { + if (scrollView == nullptr) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "ThemeStyleView::InitThemeStyleScrollView"); + scrollView = new UIScrollView(); + if (scrollView == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "scrollView new fail!"); + return nullptr; + } + scrollView->SetPosition(0, 0, Screen::GetInstance().GetWidth(), Screen::GetInstance().GetHeight()); + scrollView->SetViewId(RESPIRATORYTRAINING_DURATIONSELECTION_VIEW); + scrollView->SetScrollBlankSize(30); + scrollView->SetReboundSize(30); + scrollView->SetDirection(1); + scrollView->SetTouchable(true); + scrollView->SetDraggable(true); + scrollView->SetThrowDrag(true); // 设置手指抬起屏幕后是否继续滚动。 + scrollView->SetMaxScrollDistance(1000); // 设置手指抬起屏幕后的最大滚动距离。 + scrollView->SetSwipeACCLevel(200); /*设置手指抬起屏幕后的补偿距离。*/ + scrollView->SetRotateFactor(1.0); + FocusManager::GetInstance()->RequestFocus(scrollView); + FocusManager::GetInstance()->RequestFocusByDirection(FOCUS_DIRECTION_UP); + UIView::OnDragListener *dragListener = static_cast(RespiratoryTrainingPresenter::GetInstance()); + if (dragListener == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "dragListener is nullptr!"); + return nullptr; + } + scrollView->SetOnDragListener(dragListener); + /* -------------------------------------------------------------------------- */ + TitleLabel = new UILabelExt(); + if (TitleLabel == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "TitleLabel new fail!"); + return nullptr; + } + TitleLabel->SetPosition(83, 50, 300, 35); + TitleLabel->SetTextId(STR_DURATION_SETTINGS); // 时长设置 + TitleLabel->SetStyle(STYLE_TEXT_FONT, 30); + TitleLabel->SetStyle(STYLE_LINE_HEIGHT, 35); + TitleLabel->SetLineBreakMode(UILabel::LINE_BREAK_OSCILLATION); + TitleLabel->SetFont(DEFAULT_VECTOR_FONT_FILENAME, 30); + TitleLabel->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER); + scrollView->Add(TitleLabel); + /* -------------------------------------------------------------------------- */ + UIView::OnClickListener *clickListener = static_cast(RespiratoryTrainingPresenter::GetInstance()); + if (clickListener == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "clickListener is nullptr!"); + return nullptr; + } + LabelButtonConfig labelbuttonconfig; + const char *viewId[MAX_NUM_TRAINING_DURATION] = {TRAINING_DURATION_ONE_MIN, TRAINING_DURATION_TWO_MIN, TRAINING_DURATION_THREE_MIN, TRAINING_DURATION_FOUR_MIN, TRAINING_DURATION_FIVE_MIN}; + for (int i = 0; i < MAX_NUM_TRAINING_DURATION; i++) + { + labelbuttonconfig.left = 43; + labelbuttonconfig.top = 120 + 120 * i; + labelbuttonconfig.width = 380; + labelbuttonconfig.height = 100; + labelbuttonconfig.viewId = viewId[i]; + DurationButton[i] = LabelButtonViewInit(labelbuttonconfig); + if (DurationButton[i] == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "DurationButton[%d] is nullptr", i); + return nullptr; + } + DurationButton[i]->SetOnClickListener(clickListener); + scrollView->Add(DurationButton[i]); + } + /* -------------------------------------------------------------------------- */ + int16_t textId[MAX_NUM_TRAINING_DURATION] = {STR_1_MIN, STR_2_MIN,STR_3_MIN,STR_4_MIN, STR_5_MIN}; + // const char *text[MAX_NUM_TRAINING_DURATION] = {"1分钟", "2分钟", "3分钟", "4分钟", "5分钟"}; + LabelConfig labelConfig = { + .left = 103, + .top = 153, + .width = 210, + .height = 35, + .fontSize = 30, + .lineHeigh = 35, + .textId = 0, + .lineBreakMode = UILabel::LINE_BREAK_OSCILLATION, + }; + for (int16_t i = 0; i < MAX_NUM_TRAINING_DURATION; i++) + { + labelConfig.top = 153 + 120 * i; + labelConfig.textId = textId[i]; + // labelConfig.text = text[i]; + DurationLabel[i] = LabelViewinit(labelConfig); + if (DurationLabel[i] == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "DurationLabel[%d] is nullptr", i); + return nullptr; + } + scrollView->Add(DurationLabel[i]); + } + /* -------------------------------------------------------------------------- */ + if (temp == nullptr) + { + temp = new UIImageView(); + if (temp == nullptr) + { + return nullptr; + } + int y = DurationButton[MAX_NUM_TRAINING_DURATION - 1]->GetY() + DurationButton[MAX_NUM_TRAINING_DURATION - 1]->GetHeight(); + temp->SetPosition(43, y, 380, 40); + temp->SetVisible(false); + scrollView->Add(temp); + } + } + UpdateRespiratoryTrainingDurationSelectionView(); + return scrollView; + } + + void RespiratoryTrainingDurationSelectionView::UpdateRespiratoryTrainingDurationSelectionView(void) + { + for (int i = 0; i < MAX_NUM_TRAINING_DURATION; i++) + { + if (i == RespiratoryTrainingModel::GetInstance().GetRespiratoryTrainingSelectTime() - 1) + { + DurationButton[i]->SetImageSrc(PNG_CHECKBOX_ON_IMAGE, PNG_CHECKBOX_ON_IMAGE); + } + else + { + DurationButton[i]->SetImageSrc(PNG_CHECKBOX_OFF_IMAGE, PNG_CHECKBOX_OFF_IMAGE); + } + DurationButton[i]->Invalidate(); + } + } +} diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/respiratorytraining/src/RespiratoryTrainingModel.cpp b/code/sdk/application/wearable/fd230/nativeapp/nativeui/respiratorytraining/src/RespiratoryTrainingModel.cpp new file mode 100644 index 000000000..044b28e35 --- /dev/null +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/respiratorytraining/src/RespiratoryTrainingModel.cpp @@ -0,0 +1,249 @@ +/* + * @Author: luozheng 1732036298@qq.com + * @Date: 2024-06-11 16:26:20 + * @LastEditors: luozheng 1732036298@qq.com + * @LastEditTime: 2024-11-05 14:40:25 + * @FilePath: /FD230/code/sdk/application/wearable/fd230app/nativeui/respiratorytraining/src/RespiratoryTrainingModel.cpp + */ +#include "respiratorytraining/include/RespiratoryTrainingModel.h" +#include "wearable_log.h" +#include +#include +#include +#include +#include +#include "respiratorytraining/include/RespiratoryTrainingView.h" +#include +#include "gfx_utils/mem_check.h" +#include "ConfigModel.h" + +#include +#include +#include +#include +#include +#include +#include +#ifdef FD230_650 +#include "heartrate/include/HeartModel.h" +#endif +namespace OHOS +{ + // 声明定时器变量 + static osTimerId_t g_timer = NULL; + static constexpr uint64_t ONE_MIN = 60000 * 1; // 1分钟 + static constexpr uint64_t TWO_MIN = 60000 * 2; // 2分钟 + static constexpr uint64_t THREE_MIN = 60000 * 3; // 3分钟 + static constexpr uint64_t FOUR_MIN = 60000 * 4; // 4分钟 + static constexpr uint64_t FIVE_MIN = 60000 * 5; // 5分钟 + + RespiratoryTrainingModel::RespiratoryTrainingModel() {} + + RespiratoryTrainingModel::~RespiratoryTrainingModel() {} + + RespiratoryTrainingModel &RespiratoryTrainingModel::GetInstance() + { + static RespiratoryTrainingModel instance; + return instance; + } + + // 获取训练时长,单位min + int RespiratoryTrainingModel::GetRespiratoryTrainingSelectTime() + { + return ConfigModel::GetInstance()->get_configData_int(ConfigModel::CONFIGMODEL_ITEM_RESPIRATORY_TRAINING_DURATION_SELECTION); + } + + // 设置训练时长,单位min + void RespiratoryTrainingModel::SetRespiratoryTrainingSelectTime(int time) + { + ConfigModel::GetInstance()->set_condigData_Int(ConfigModel::CONFIGMODEL_ITEM_RESPIRATORY_TRAINING_DURATION_SELECTION, time); + } + + uint64_t RespiratoryTrainingModel::GetRespiratoryTrainingTime() + { + int time = RespiratoryTrainingModel::GetInstance().GetRespiratoryTrainingSelectTime(); + uint64_t time_; + switch (time) + { + case 1: + time_ = ONE_MIN; + break; + case 2: + time_ = TWO_MIN; + break; + case 3: + time_ = THREE_MIN; + break; + case 4: + time_ = FOUR_MIN; + break; + case 5: + time_ = FIVE_MIN; + break; + default: + time_ = ONE_MIN; + break; + } + return time_; + } + + // 每进行一次呼吸训练,呼吸训练次数自加1 + void RespiratoryTrainingModel::AddRespiratoryTrainingTimes() + { + RespiratoryTrainingTimes += 1; + } + + // 获取呼吸训练总时间 + std::string RespiratoryTrainingModel::GetRespiratoryTrainingTotalTime(void) + { + RespiratoryTrainingTime += GetRespiratoryTrainingSelectTime(); + return (std::to_string(RespiratoryTrainingTime) + "min"); + } + + // 获取平均心率值 + int RespiratoryTrainingModel::GetAverageHeartRate(void) + { + if (count != 0) + { + return heartTotal / count; + } + return 0; + } + + // 清除当日的呼吸训练时间 + void RespiratoryTrainingModel::ClearTotalRespiratoryTrainingTime(void) + { + if (RespiratoryTrainingTime != 0) + { + RespiratoryTrainingTime = 0; + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ClearTotalRespiratoryTrainingTime success!!"); + } + } + + void RespiratoryTrainingModel::calculateHeartrateTotal(void) + { + // 获取当前时间(以微秒为单位) + uint32_t currentTime = static_cast(std::chrono::duration_cast(std::chrono::system_clock::now().time_since_epoch()).count()); + + // 记录和检查上一次调用的时间 + static uint32_t lastCallTime = 0; + if (currentTime - lastCallTime < 1000000) + { + // 小于1秒 + return; + } + lastCallTime = currentTime; // 更新最后调用时间 + +#ifdef FD230_650 + uint16_t heartrate = HeartModel::GetInstance()->GetShowHeartdata(); + + if (heartrate != 0) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "heartrate = %d", heartrate); + heartTotal += heartrate; + count++; + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "heartTotal = %0.f,count = %d,h_rate = %d", heartTotal, count, heartrate); + } +#endif + } + + void RespiratoryTrainingModel::ResumeStatus() + { + heartTotal = 0; + count = 0; +#ifdef FD230_650 + HeartModel::GetInstance()->Heart_Control(HeartState::End, HeartCheck::INITIATIVE); // 关闭心率检测 +#endif + uapi_dev_runtime_set_respiratory_training_status(0); // 如果直接退出也要设置为0 + } + /* -------------------------------------------------------------------------- */ + /*定时器到期时的处理*/ + static void RT_TimerCallbackProc(int data) + { + RespiratoryTrainingView *p_RespiratoryTrainingView = RespiratoryTrainingView::GetInstance(); + if (p_RespiratoryTrainingView == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "p_RespiratoryTrainingView is nullptr!!"); + return; + } + uapi_dev_runtime_set_respiratory_training_status(0); // 训练结束runtime设置为0 + RespiratoryTrainingModel::GetInstance().RT_StopTimer(); // 停止定时器 + RespiratoryTrainingModel::GetInstance().AddRespiratoryTrainingTimes(); // 呼吸训练次数加1 + p_RespiratoryTrainingView->GetRespiratoryTrainingAnimator_()->Stop(); // 关闭呼吸动画 +#ifdef FD230_650 + HeartModel::GetInstance()->Heart_Control(HeartState::End, HeartCheck::INITIATIVE); // 关闭心率检测 +#endif + p_RespiratoryTrainingView->ChangeView(RESPIRATORYTRAINING, RESPIRATORYTRAININGCOMPLETED); + ScreenAlwaysOnCtr(CANCEL_SCREEN_ALWAYS_ON); /*取消常亮屏*/ + return; + } + + /* + * @brief 回调函数 + */ + static void RT_TimerCallback(int data) + { + GraphicService::GetInstance()->PostGraphicEvent(std::bind(RT_TimerCallbackProc, data)); + } + + /* + * @brief 开启定时器函数 + * @param interval 时间间隔,单位ms + */ + void RespiratoryTrainingModel::RT_StartTimer(uint64_t interval) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingModel::RT_StartTimer"); + /* -------------------------- 1.检查定时器是否已经存在,如果存在则返回 ------------------------- */ + if (g_timer != NULL) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Timer already exists!!"); + return; + } + + /* --------------------------------- 2.创建定时器 -------------------------------- */ + g_timer = osTimerNew((osTimerFunc_t)RT_TimerCallback, osTimerPeriodic, NULL, NULL); + // 检查定时器创建是否成功 + if (g_timer == NULL) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Timer create failed!!"); + return; + } + + /* ----------------------------- 3.将毫秒转换为系统时钟节拍数 ---------------------------- */ + int tick = osMs2Tick(interval); + + /* --------------------------------- 4.启动定时器 -------------------------------- */ + osStatus_t ret = osTimerStart(g_timer, tick); + /* -------------------- 5.检查定时器启动是否成功,如果启动失败,删除定时器并置为 NULL -------------------- */ + if (ret != osOK) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "osTimerDelete failed, ret = %lx!!", ret); + if (g_timer != NULL) + { + ret = osTimerDelete(g_timer); + } + g_timer = NULL; + return; + } + } + + /* + * @brief 停止定时器 + */ + void RespiratoryTrainingModel::RT_StopTimer(void) + { + // 检查定时器是否存在 + if (g_timer != NULL) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingModel::RT_StopTimer"); + osTimerStop(g_timer); + // 删除定时器并置为 NULL + osStatus_t ret = osTimerDelete(g_timer); + if (ret != osOK) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "osTimerDelete failed, ret = %lx!!", ret); + } + g_timer = NULL; + } + } +} diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/respiratorytraining/src/RespiratoryTrainingPresenter.cpp b/code/sdk/application/wearable/fd230/nativeapp/nativeui/respiratorytraining/src/RespiratoryTrainingPresenter.cpp new file mode 100644 index 000000000..26ba3227b --- /dev/null +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/respiratorytraining/src/RespiratoryTrainingPresenter.cpp @@ -0,0 +1,205 @@ +/* + * @Author: luozheng 1732036298@qq.com + * @Date: 2024-05-07 11:26:06 + * @LastEditors: luozheng 1732036298@qq.com + * @LastEditTime: 2024-11-05 14:52:23 + * @FilePath: /FD230/code/sdk/application/wearable/fd230app/nativeui/RespiratoryTraining/src/RespiratoryTrainingPresenter.cpp + */ + +#include "AppViewIDs.h" +#include "NativeAbility.h" +#include "respiratorytraining/include/RespiratoryTrainingPresenter.h" +#include "respiratorytraining/include/RespiratoryTrainingView.h" +#include "common/key_code.h" +#include +#include "UiConfig.h" +#include +#include +#include "respiratorytraining/include/RespiratoryTrainingModel.h" +#include "gfx_utils/mem_check.h" +#include "map" +#include "ui_resource_string.h" +#include "NativeRegisterManager.h" +namespace OHOS +{ + REGIST_MENU_PRO(VIEW_RESPIRATORY_TRAINING, RespiratoryTrainingView, RespiratoryTrainingPresenter, + PNG_APPLIST_BREATHE_IMAGE_BIG, PNG_APPLIST_BREATHE_IMAGE, PNG_APPLIST_BREATHE_IMAGE, "呼吸训练", STR_BREATH_TRAINING); + + // 当前Presenter属性实例化的内存指针 + static RespiratoryTrainingPresenter *g_pRespiratoryTrainingPresenter = nullptr; + + RespiratoryTrainingPresenter::RespiratoryTrainingPresenter() + { + g_pRespiratoryTrainingPresenter = this; +#ifdef MEM_CHECK + MemCheck::GetInstance()->EnableLeakCheck(true); +#endif + } + + RespiratoryTrainingPresenter::~RespiratoryTrainingPresenter() + { + g_pRespiratoryTrainingPresenter = nullptr; +#ifdef MEM_CHECK + MemCheck::GetInstance()->EnableLeakCheck(false); +#endif + } + + RespiratoryTrainingPresenter *RespiratoryTrainingPresenter::GetInstance() + { + return g_pRespiratoryTrainingPresenter; + } + + void RespiratoryTrainingPresenter::OnStart() + { + // ScreenAlwaysOnCtr(OPEN_SCREEN_ALWAYS_ON); + } + + void RespiratoryTrainingPresenter::OnPause(void) + { + Presenter::OnPause(); + } + + void RespiratoryTrainingPresenter::OnResume(void) + { + Presenter::OnResume(); + } + + void RespiratoryTrainingPresenter::OnStop(void) + { + ScreenAlwaysOnCtr(CANCEL_SCREEN_ALWAYS_ON); + RespiratoryTrainingModel::GetInstance().RT_StopTimer(); + RespiratoryTrainingModel::GetInstance().ResumeStatus(); + } + + bool RespiratoryTrainingPresenter::OnClick(UIView &view, const ClickEvent &event) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingPresenter::OnClick"); + std::string viewId = view.GetViewId(); + if (viewId == RTCLABELBUTTON) + { + NativeAbility::GetInstance().Back(TransitionType::TRANSITION_BACK_TO_HEXAGONS); + return true; + } + std::map viewMap = { + {TRAINING_DURATION_ONE_MIN, 1}, + {TRAINING_DURATION_TWO_MIN, 2}, + {TRAINING_DURATION_THREE_MIN, 3}, + {TRAINING_DURATION_FOUR_MIN, 4}, + {TRAINING_DURATION_FIVE_MIN, 5}, + }; + auto it = viewMap.find(viewId); + if (it != viewMap.end()) + { + if (viewId == it->first) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "select time = %d", it->second); + RespiratoryTrainingModel::GetInstance().SetRespiratoryTrainingSelectTime(it->second); + if (RespiratoryTrainingDurationSelectionView::GetInstance()) + { + RespiratoryTrainingDurationSelectionView::GetInstance()->UpdateRespiratoryTrainingDurationSelectionView(); + } + } + } + return true; + } + + bool RespiratoryTrainingPresenter::OnDrag(UIView &view, const DragEvent &event) + { + UNUSED(view); + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingPresenter::OnDrag"); + if ((event.GetDeltaX() > X_DRAG_OFFSET) && (event.GetDeltaX() > (DOUBLES * MATH_ABS(event.GetDeltaY())))) // 拖动过程中判断是否是水平滑动 + { + RespiratoryTrainingPresenter::X_DRAG_FLAG = true; + } + return true; + } + + bool RespiratoryTrainingPresenter::OnDragEnd(UIView &view, const DragEvent &event) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingPresenter::OnDragEnd"); + if (event.GetDragDirection() == DragEvent::DIRECTION_LEFT_TO_RIGHT && RespiratoryTrainingPresenter::X_DRAG_FLAG) + { + std::string viewId = view.GetViewId(); + if (viewId == RESPIRATORYTRAINING_DURATIONSELECTION_VIEW) + { + view_->ChangeView(RESPIRATORY_TRAINING_DURATION_SELECTION, RESPIRATORYTRAINING); + } + else + { + NativeAbility::GetInstance().Back(TransitionType::TRANSITION_BACK_TO_HEXAGONS); + } + RespiratoryTrainingPresenter::X_DRAG_FLAG = false; + } + return true; + } + + bool RespiratoryTrainingPresenter::OnKeyAct(UIView &view, const KeyEvent &event) // 增加按键事件 + { + UNUSED(view); + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingPresenter::OnKeyAct"); + uint16_t keyID = event.GetKeyId(); + uint16_t keyState = event.GetState(); + // 如果是power键,且是亮屏状态,按键释放就返回上一级 + if (keyID == static_cast(ZliteKeyCode::ZLITE_KEY_POWER) && keyState == 1 && uapi_get_screen_state() == 0) + { + NativeAbility::GetInstance().Back(TransitionType::TRANSITION_BACK_TO_HEXAGONS); + } + return true; + } + + int RespiratoryTrainingPresenter::GetRespiratoryTrainingSelectTime() + { + int time = RespiratoryTrainingModel::GetInstance().GetRespiratoryTrainingSelectTime(); + int textId; + switch (time) + { + case 1: + textId = STR_ONE_MIN; + break; + case 2: + textId = STR_TWO_MIN; + break; + case 3: + textId = STR_THREE_MIN; + break; + case 4: + textId = STR_FOUR_MIN; + break; + case 5: + textId = STR_FIVE_MIN; + break; + default: + textId = STR_TWO_MIN; + break; + } + return textId; + } + + std::string RespiratoryTrainingPresenter::GetRespiratoryTrainingSelectTime1() + { + int time = RespiratoryTrainingModel::GetInstance().GetRespiratoryTrainingSelectTime(); + std::string text; + switch (time) + { + case 1: + text = "1min"; + break; + case 2: + text = "2min"; + break; + case 3: + text = "3min"; + break; + case 4: + text = "4min"; + break; + case 5: + text = "5min"; + break; + default: + text = "1min"; + break; + } + return text; + } +} \ No newline at end of file diff --git a/code/sdk/application/wearable/fd230/nativeapp/nativeui/respiratorytraining/src/RespiratoryTrainingView.cpp b/code/sdk/application/wearable/fd230/nativeapp/nativeui/respiratorytraining/src/RespiratoryTrainingView.cpp new file mode 100644 index 000000000..f3acf6be6 --- /dev/null +++ b/code/sdk/application/wearable/fd230/nativeapp/nativeui/respiratorytraining/src/RespiratoryTrainingView.cpp @@ -0,0 +1,577 @@ +/* + * @Author: luozheng 1732036298@qq.com + * @Date: 2024-05-07 11:25:58 + * @LastEditors: luozheng 1732036298@qq.com + * @LastEditTime: 2025-02-24 17:34:43 + * @FilePath: /FD230/code/sdk/application/wearable/fd230app/nativeui/RespiratoryTraining/src/RespiratoryTrainingView.cpp + */ + +#include "respiratorytraining/include/RespiratoryTrainingPresenter.h" +#include "respiratorytraining/include/RespiratoryTrainingView.h" +#include "wearable_log.h" +#include "common/image_cache_manager.h" +#include "animator/easing_equation.h" +#include "ui_resource_string.h" +#include "respiratorytraining/include/RespiratoryTrainingModel.h" +#include "heartrate/include/HeartModel.h" + +#include +#include + +#include "vibrator_service.h" + +namespace OHOS +{ + + static constexpr uint16_t ONE_MIN = 60000; // 1分钟 + static RespiratoryTrainingView *g_pRespiratoryTrainingView{nullptr}; + + RespiratoryTrainingView::RespiratoryTrainingView() + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingView::RespiratoryTrainingView"); + g_pRespiratoryTrainingView = this; + } + + RespiratoryTrainingView::~RespiratoryTrainingView() + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingView::~RespiratoryTrainingView"); + ClearAll(); + g_pRespiratoryTrainingView = nullptr; + } + + RespiratoryTrainingView *RespiratoryTrainingView::GetInstance() + { + return g_pRespiratoryTrainingView; + } + + bool RespiratoryTrainingView::ChangeRespiratoryTrainingView(int16_t thisView) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingView::ChangeRespiratoryTrainingView"); + if (RespiratoryTrainingScrollView[thisView] == nullptr) + { + AddViewToRootContainer(RespiratoryTrainingScrollView[thisView]); + } + if (TrainingDurationSelectiontitlelabel) + { + TrainingDurationSelectiontitlelabel->SetTextId(presenter_->GetRespiratoryTrainingSelectTime()); + TrainingDurationSelectiontitlelabel->ForceResetText(); + } + return true; + } + + bool RespiratoryTrainingView::ChangeRespiratoryTrainingCompletedView(int16_t thisView) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingView::ChangeRespiratoryTrainingCompletedView"); + if (RespiratoryTrainingScrollView[thisView] == nullptr) + { + p_RespiratoryTrainingCompletedView = new RespiratoryTrainingCompletedView(); + if (p_RespiratoryTrainingCompletedView == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "new scrollView[%d] fail", thisView); + return false; + } + UIScrollView *scrollView = p_RespiratoryTrainingCompletedView->RespiratoryTrainingCompletedViewInit(); + if (scrollView == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingCompletedViewInit fail!!"); + return false; + } + RespiratoryTrainingScrollView[thisView] = scrollView; + AddViewToRootContainer(RespiratoryTrainingScrollView[thisView]); + } + return true; + } + + bool RespiratoryTrainingView::ChangeRespiratoryTrainingDurationSelectionView(int16_t thisView) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingView::ChangeRespiratoryTrainingCompletedView"); + if (RespiratoryTrainingScrollView[thisView] == nullptr) + { + p_RespiratoryTrainingDurationSelectionView = new RespiratoryTrainingDurationSelectionView(); + if (p_RespiratoryTrainingDurationSelectionView == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "new scrollView[%d] fail", thisView); + return false; + } + UIScrollView *scrollView = p_RespiratoryTrainingDurationSelectionView->RespiratoryTrainingDurationSelectionViewInit(); + if (scrollView == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingDurationSelectionViewInit fail!!"); + return false; + } + RespiratoryTrainingScrollView[thisView] = scrollView; + AddViewToRootContainer(RespiratoryTrainingScrollView[thisView]); + } + return true; + } + + struct RespiratoryTrainingViewMapper + { + const int16_t viewId; + bool (RespiratoryTrainingView::*func)(int16_t thisView); + }; + + static const RespiratoryTrainingViewMapper ViewMapper[] = { + {RESPIRATORYTRAINING, &RespiratoryTrainingView::ChangeRespiratoryTrainingView}, + {RESPIRATORYTRAININGCOMPLETED, &RespiratoryTrainingView::ChangeRespiratoryTrainingCompletedView}, + {RESPIRATORY_TRAINING_DURATION_SELECTION, &RespiratoryTrainingView::ChangeRespiratoryTrainingDurationSelectionView}, + }; + + bool RespiratoryTrainingView::ClickFunc(int16_t interface) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingView::ClickFunc"); + int funcSize = sizeof(ViewMapper) / sizeof(ViewMapper[0]); + for (int i = 0; i < funcSize; i++) + { + if (interface == ViewMapper[i].viewId) + { + bool jug = (this->*(ViewMapper[i].func))(interface); + if (jug == false) + { + return false; + } + return true; + } + } + return false; + } + + void RespiratoryTrainingView::ChangeView(int16_t hideView, int16_t showView) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingView::ChangeView"); + if (hideView > MAX_RESPIRATORYTRAININGID) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Overstep ones bounds"); + return; + } + RespiratoryTrainingScrollView[hideView]->SetVisible(false); + ClickFunc(showView); + RespiratoryTrainingScrollView[showView]->SetVisible(true); + Draw(); + } + + Animator *RespiratoryTrainingView::GetRespiratoryTrainingAnimator_() + { + if (RespiratoryTrainingAnimator_ == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingAnimator_ is nullptr!!"); + return nullptr; + } + return RespiratoryTrainingAnimator_; + } + + const static int16_t BUTTON_WIDTH = 320; + const static int16_t BUTTON_HEIGHT = 100; + const static int16_t INTERVAL_STEP = 80; + const Vector2 VIEW_CENTER = {120, 120}; + static constexpr const char *RespiratoryTrainingImagePath = "/user/res/RespiratoryTraining/RespiratoryTraining.bin"; + static constexpr const char *RespiratoryTrainingImageBGPath = "/user/res/RespiratoryTraining/RespiratoryTraining_BG.bin"; + + void RespiratoryTrainingCallback::Callback(UIView *view) + { + RespiratoryTrainingModel::GetInstance().calculateHeartrateTotal(); + // 1.计算当前时间与开始时间的差值,用于控制动画的时间。 + uint32_t currentTime = HALTick::GetInstance().GetTime(); + curTime = currentTime - startTimestamp; + + // 2.判断当前时间是否大于等于训练总时长,若是则进行下一步操作。 + if (curTime >= durationTime) + { + prepare_count++; + // 计算动画缩放比例 + scale = static_cast(EasingEquation::QuadEaseInOut(startVal, endVal, durationTime, durationTime)) / durationTime; + + // 切换起始值和结束值,更新下一次呼吸的状态。 + std::swap(startVal, endVal); + startTimestamp = currentTime; + + if (prepare_count >= 2) + { + // 只有在准备时间结束后才切换呼吸状态和文本 + isBreathIn = !isBreathIn; + if (isBreathIn) + { + // breath->SetText("现在吸气"); + breath->SetTextId(STR_INHALE_NOW); + } + else + { + // breath->SetText("现在呼气"); + breath->SetTextId(STR_EXHALE_NOW); + } + // 震动提醒 + ui_api_vibrate_once_func(); + breath->ForceResetText(); + } + } + else + { + // 继续进行呼吸动画的变化 + scale = static_cast(EasingEquation::QuadEaseInOut(startVal, endVal, curTime, durationTime)) / durationTime; + } + + // 根据动画步长 step 更新图片的旋转角度 angle + angle += step; + if (angle <= -360) + { + angle = 0; + } + + // 根据计算得到的缩放比例 scale 对图片进行缩放操作,并根据角度对图片进行旋转操作 + img_->Scale({scale, scale}, VIEW_CENTER); + img_->Rotate(angle, VIEW_CENTER); + img_->Invalidate(); + } + + void RespiratoryTrainingView::HandStartRespiratoryTraining() + { + if (titlelabel && TrainingDurationSelectiontitlelabel && Image && RespiratoryTrainingStartButton && RespiratoryTrainingStartLabel) + { + titlelabel->SetVisible(false); + TrainingDurationSelectiontitlelabel->SetVisible(false); + Image->SetVisible(false); + RespiratoryTrainingStartButton->SetVisible(false); + RespiratoryTrainingStartLabel->SetVisible(false); + } + + if (RespiratoryTrainingStartNote_ && RespiratoryTrainingImg_) + { + RespiratoryTrainingStartNote_->SetVisible(true); + RespiratoryTrainingImg_->SetVisible(true); + } + ScreenAlwaysOnCtr(OPEN_SCREEN_ALWAYS_ON); // 开始训练后常亮屏 + uapi_dev_runtime_set_respiratory_training_status(1); // 训练开始runtime设置为1 + StartRespiratoryTraining(); // 开始呼吸训练 +#ifdef FD230_650 + HeartModel::GetInstance()->Heart_Control(HeartState::Start, HeartCheck::INITIATIVE); // 开启心率检测 +#endif + RespiratoryTrainingModel::GetInstance().RT_StartTimer(RespiratoryTrainingModel::GetInstance().GetRespiratoryTrainingTime()); // 开启定时器 + ui_api_vibrate_once_func(); // 震动 + } + + bool RespiratoryTrainingView::OnClick(UIView &view, const ClickEvent &event) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingView::OnClick"); + UNUSED(event); + + if (&view == RespiratoryTrainingStartButton) + { + HandStartRespiratoryTraining(); + } + else if (&view == TrainingDurationSelectiontitlelabel) + { + ChangeView(RESPIRATORYTRAINING, RESPIRATORY_TRAINING_DURATION_SELECTION); + } + return true; + } + + // 开始呼吸训练 + bool RespiratoryTrainingView::StartRespiratoryTraining() + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingView::StartRespiratoryTraining"); + if (!animateStart_) + { + RespiratoryTrainingAnimator_->Start(); + animateStart_ = true; + if (RespiratoryTrainingStartNote_ != nullptr) + { + RespiratoryTrainingScrollView[RESPIRATORYTRAINING]->Remove(RespiratoryTrainingStartNote_); + delete RespiratoryTrainingStartNote_; + RespiratoryTrainingStartNote_ = nullptr; + } + RespiratoryTrainingLabel_ = new UILabelExt(); + if (RespiratoryTrainingLabel_ == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingLabel_ new fail"); + return false; + } + RespiratoryTrainingLabel_->SetPosition(53, 320, 360, 70); + RespiratoryTrainingLabel_->SetTextId(STR_KEEP_STILL_FOCUS_ON_BREATHING); // 准备 + RespiratoryTrainingLabel_->SetStyle(STYLE_TEXT_FONT, 30); + RespiratoryTrainingLabel_->SetStyle(STYLE_LINE_HEIGHT, 35); + RespiratoryTrainingLabel_->SetLineBreakMode(UILabel::LINE_BREAK_WRAP); + RespiratoryTrainingLabel_->SetFont(DEFAULT_VECTOR_FONT_FILENAME, 30); + RespiratoryTrainingLabel_->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER); + RespiratoryTrainingLabel_->SetStyle(STYLE_BACKGROUND_OPA, OPA_TRANSPARENT); + RespiratoryTrainingScrollView[RESPIRATORYTRAINING]->Add(RespiratoryTrainingLabel_); + RespiratoryTrainingCallBack_->SetTextView(RespiratoryTrainingLabel_); + RespiratoryTrainingCallBack_->startTimestamp = HALTick::GetInstance().GetTime(); + RespiratoryTrainingScrollView[RESPIRATORYTRAINING]->Invalidate(); + } + return true; + } + + bool RespiratoryTrainingView::InitRespiratoryTrainingElements() + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingView::InitRespiratoryTrainingElements"); + // 加载呼吸训练图片 + ImageInfo *imgInfo = ImageCacheManager::GetInstance().LoadSingleRes(RespiratoryTrainingImagePath); + if (imgInfo == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Load image failed!"); + return false; + } + + // 创建并设置呼吸训练图片 + RespiratoryTrainingImg_ = new UIImageView(); + if (RespiratoryTrainingImg_ == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingImg_ new failed!"); + return false; + } + RespiratoryTrainingImg_->SetSrc(imgInfo); + RespiratoryTrainingImg_->SetPosition(113, 70, 240, 240); + RespiratoryTrainingImg_->SetStyle(STYLE_IMAGE_OPA, OPA_OPAQUE); + RespiratoryTrainingImg_->SetStyle(STYLE_BACKGROUND_OPA, OPA_TRANSPARENT); + RespiratoryTrainingImg_->SetAutoEnable(false); + RespiratoryTrainingImg_->SetResizeMode(UIImageView::ImageResizeMode::CENTER); + RespiratoryTrainingImg_->SetVisible(false); + RespiratoryTrainingScrollView[RESPIRATORYTRAINING]->Add(RespiratoryTrainingImg_); + /* -------------------------------------------------------------------------- */ + RespiratoryTrainingStartNote_ = new UILabelExt(); + if (RespiratoryTrainingStartNote_ == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingStartNote_ new failed!"); + return false; + } + RespiratoryTrainingStartNote_->SetPosition(53, 320, 360, 70); + RespiratoryTrainingStartNote_->SetStyle(STYLE_TEXT_FONT, 30); + RespiratoryTrainingStartNote_->SetStyle(STYLE_LINE_HEIGHT, 35); + // RespiratoryTrainingStartNote_->SetText("保持不动,将注意力集中在呼吸上"); + RespiratoryTrainingStartNote_->SetTextId(STR_KEEP_STILL_FOCUS_ON_BREATHING); + RespiratoryTrainingStartNote_->SetLineBreakMode(UILabel::LINE_BREAK_WRAP); + RespiratoryTrainingStartNote_->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER); + RespiratoryTrainingStartNote_->SetFont(DEFAULT_VECTOR_FONT_FILENAME, 30); + RespiratoryTrainingStartNote_->SetVisible(false); + RespiratoryTrainingScrollView[RESPIRATORYTRAINING]->Add(RespiratoryTrainingStartNote_); + return true; + } + + bool RespiratoryTrainingView::InitRespiratoryTrainingElements2() + { + titlelabel = new UILabelExt(); + if (titlelabel == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "titlelabel new failed!"); + return false; + } + titlelabel->SetPosition(83, 50, 300, 35); + titlelabel->SetStyle(STYLE_TEXT_FONT, 30); + titlelabel->SetStyle(STYLE_LINE_HEIGHT, 35); + titlelabel->SetTextId(STR_BREATH_TRAINING); + titlelabel->SetLineBreakMode(UILabel::LINE_BREAK_OSCILLATION); + titlelabel->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER); + titlelabel->SetFont(DEFAULT_VECTOR_FONT_FILENAME, 30); + RespiratoryTrainingScrollView[RESPIRATORYTRAINING]->Add(titlelabel); + /* -------------------------------------------------------------------------- */ + TrainingDurationSelectiontitlelabel = new UILabelExt(); + if (TrainingDurationSelectiontitlelabel == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "TrainingDurationSelectiontitlelabel new failed!"); + return false; + } + TrainingDurationSelectiontitlelabel->SetPosition(83, 95, 300, 35); + TrainingDurationSelectiontitlelabel->SetStyle(STYLE_TEXT_FONT, 30); + TrainingDurationSelectiontitlelabel->SetStyle(STYLE_LINE_HEIGHT, 35); + TrainingDurationSelectiontitlelabel->SetTextId(presenter_->GetRespiratoryTrainingSelectTime()); + TrainingDurationSelectiontitlelabel->SetLineBreakMode(UILabel::LINE_BREAK_OSCILLATION); + TrainingDurationSelectiontitlelabel->SetTextColor(Color::GetColorFromRGBA(0x66, 0x66, 0x66, 0xff)); + TrainingDurationSelectiontitlelabel->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER); + TrainingDurationSelectiontitlelabel->SetFont(DEFAULT_VECTOR_FONT_FILENAME, 30); + TrainingDurationSelectiontitlelabel->SetTouchable(true); + TrainingDurationSelectiontitlelabel->SetOnClickListener(this); + RespiratoryTrainingScrollView[RESPIRATORYTRAINING]->Add(TrainingDurationSelectiontitlelabel); + /* -------------------------------------------------------------------------- */ + Image = new UIImageView(); + if (Image == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Image new failed!"); + return false; + } + Image->SetSrc(RespiratoryTrainingImageBGPath); + Image->SetPosition(133, 133, 200, 200); + Image->SetStyle(STYLE_IMAGE_OPA, OPA_OPAQUE); + Image->SetStyle(STYLE_BACKGROUND_OPA, OPA_TRANSPARENT); + Image->SetAutoEnable(false); + Image->SetResizeMode(UIImageView::CENTER); + RespiratoryTrainingScrollView[RESPIRATORYTRAINING]->Add(Image); + /* -------------------------------------------------------------------------- */ + RespiratoryTrainingStartButton = new UILabelButtonExt(); + if (RespiratoryTrainingStartButton == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Image new failed!"); + return false; + } + RespiratoryTrainingStartButton->SetPosition(93, 330, 280, 90); + RespiratoryTrainingStartButton->SetOnClickListener(this); + RespiratoryTrainingStartButton->SetStyle(STYLE_BACKGROUND_COLOR, 0xff4fc34c); + RespiratoryTrainingStartButton->SetFont(DEFAULT_VECTOR_FONT_FILENAME, 30); + RespiratoryTrainingStartButton->SetStyleForState(STYLE_BACKGROUND_OPA, 0x00, UIButton::PRESSED); + RespiratoryTrainingScrollView[RESPIRATORYTRAINING]->Add(RespiratoryTrainingStartButton); + /* -------------------------------------------------------------------------- */ + RespiratoryTrainingStartLabel = new UILabelExt(); + if (RespiratoryTrainingStartLabel == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingStartLabel new failed!"); + return false; + } + RespiratoryTrainingStartLabel->SetPosition(143, 358, 180, 35); + RespiratoryTrainingStartLabel->SetStyle(STYLE_TEXT_FONT, 30); + RespiratoryTrainingStartLabel->SetStyle(STYLE_LINE_HEIGHT, 35); + RespiratoryTrainingStartLabel->SetTextId(STR_START); // 开始 + RespiratoryTrainingStartLabel->SetLineBreakMode(UILabel::LINE_BREAK_OSCILLATION); + RespiratoryTrainingStartLabel->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER); + RespiratoryTrainingStartLabel->SetFont(DEFAULT_VECTOR_FONT_FILENAME, 30); + RespiratoryTrainingScrollView[RESPIRATORYTRAINING]->Add(RespiratoryTrainingStartLabel); + return true; + } + + bool RespiratoryTrainingView::InitRespiratoryTrainingCallBackAndAnimator() + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingView::InitRespiratoryTrainingCallBackAndAnimator"); + RespiratoryTrainingCallBack_ = new RespiratoryTrainingCallback(RespiratoryTrainingImg_); + if (RespiratoryTrainingCallBack_ == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "callBack new fail"); + return false; + } + + RespiratoryTrainingAnimator_ = new Animator(RespiratoryTrainingCallBack_, RespiratoryTrainingImg_, 0, true); + if (RespiratoryTrainingAnimator_ == nullptr) + { + delete RespiratoryTrainingCallBack_; + RespiratoryTrainingCallBack_ = nullptr; + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Animator new fail"); + return false; + } + + animateStart_ = false; + + return true; + } + + bool RespiratoryTrainingView::InitRespiratoryTrainingScrollView() + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingCompletedView::CreateRespiratoryTrainingCompletedScrollView"); + RespiratoryTrainingScrollView[RESPIRATORYTRAINING] = new UIScrollView(); + if (RespiratoryTrainingScrollView[RESPIRATORYTRAINING] == nullptr) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ScrollView new fail!"); + return false; + } + RespiratoryTrainingScrollView[RESPIRATORYTRAINING]->SetPosition(0, 0, Screen::GetInstance().GetWidth(), Screen::GetInstance().GetHeight()); + // RespiratoryTrainingScrollView[RESPIRATORYTRAINING]->SetScrollBlankSize(50); + // RespiratoryTrainingScrollView[RESPIRATORYTRAINING]->SetReboundSize(35); + RespiratoryTrainingScrollView[RESPIRATORYTRAINING]->SetHorizontalScrollState(false); + RespiratoryTrainingScrollView[RESPIRATORYTRAINING]->SetTouchable(true); + RespiratoryTrainingScrollView[RESPIRATORYTRAINING]->SetDraggable(true); + AddViewToRootContainer(RespiratoryTrainingScrollView[RESPIRATORYTRAINING]); + + return true; + } + + void RespiratoryTrainingView::RespiratoryTrainingViewInit(void) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingView::RespiratoryTrainingViewInit"); + if (!InitRespiratoryTrainingScrollView() || !InitRespiratoryTrainingElements() || + !InitRespiratoryTrainingElements2() || !InitRespiratoryTrainingCallBackAndAnimator()) + { + WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "RecordListViewInit fail!!"); + return; + } +#if 0 + StartRespiratoryTraining(); // 开始呼吸训练 + HeartModel::GetInstance()->Heart_Control(HeartState::Start, HeartCheck::INITIATIVE); // 开启心率检测 + RespiratoryTrainingModel::GetInstance().RT_StartTimer(ONE_MIN); // 开启一个一分钟的定时器 + ui_api_vibrate_once_func(); // 震动提醒 +#endif + } + + void RespiratoryTrainingView::ClearAll(void) + { + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[RespiratoryTrainingView]ClearAll start"); + if (RespiratoryTrainingScrollView[RESPIRATORYTRAINING] != nullptr) + { + RespiratoryTrainingScrollView[RESPIRATORYTRAINING]->RemoveAll(); + delete RespiratoryTrainingScrollView[RESPIRATORYTRAINING]; + RespiratoryTrainingScrollView[RESPIRATORYTRAINING] = nullptr; + } + + if (RespiratoryTrainingAnimator_ != nullptr) + { + RespiratoryTrainingAnimator_->Stop(); + delete RespiratoryTrainingAnimator_; + RespiratoryTrainingAnimator_ = nullptr; + } + + if (RespiratoryTrainingCallBack_ != nullptr) + { + delete RespiratoryTrainingCallBack_; + RespiratoryTrainingCallBack_ = nullptr; + } + + if (RespiratoryTrainingImg_ != nullptr) + { + ImageCacheManager::GetInstance().UnloadSingleRes(RespiratoryTrainingImagePath); + delete RespiratoryTrainingImg_; + RespiratoryTrainingImg_ = nullptr; + } + + if (RespiratoryTrainingLabel_ != nullptr) + { + delete RespiratoryTrainingLabel_; + RespiratoryTrainingLabel_ = nullptr; + } + if (RespiratoryTrainingStartNote_ != nullptr) + { + delete RespiratoryTrainingStartNote_; + RespiratoryTrainingStartNote_ = nullptr; + } + if (titlelabel != nullptr) + { + delete titlelabel; + titlelabel = nullptr; + } + if (TrainingDurationSelectiontitlelabel != nullptr) + { + delete TrainingDurationSelectiontitlelabel; + TrainingDurationSelectiontitlelabel = nullptr; + } + if (Image != nullptr) + { + delete Image; + Image = nullptr; + } + if (RespiratoryTrainingStartButton != nullptr) + { + delete RespiratoryTrainingStartButton; + RespiratoryTrainingStartButton = nullptr; + } + if (RespiratoryTrainingStartLabel != nullptr) + { + delete RespiratoryTrainingStartLabel; + RespiratoryTrainingStartLabel = nullptr; + } + + if (p_RespiratoryTrainingCompletedView != nullptr) + { + delete p_RespiratoryTrainingCompletedView; + p_RespiratoryTrainingCompletedView = nullptr; + RespiratoryTrainingScrollView[RESPIRATORYTRAININGCOMPLETED] = nullptr; + } + + if (p_RespiratoryTrainingDurationSelectionView != nullptr) + { + delete p_RespiratoryTrainingDurationSelectionView; + p_RespiratoryTrainingDurationSelectionView = nullptr; + RespiratoryTrainingScrollView[RESPIRATORY_TRAINING_DURATION_SELECTION] = nullptr; + } + + WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "[RespiratoryTrainingView]ClearAll end!!"); + } + + void RespiratoryTrainingView::OnStart() + { + RespiratoryTrainingViewInit(); + } +} \ No newline at end of file diff --git a/code/sdk/build/config/target_config/brandy/config.py b/code/sdk/build/config/target_config/brandy/config.py index 41e18ef61..6f8e33d6d 100644 --- a/code/sdk/build/config/target_config/brandy/config.py +++ b/code/sdk/build/config/target_config/brandy/config.py @@ -386,8 +386,8 @@ target = { # "ppg_sensor", # "ppgBleService", # "mag_sensor", - # "vibrator", - # "vibrator_service", + "vibrator", + "vibrator_service", # "lwIP", # "slip", # "cat1_service",