${CMAKE_CURRENT_SOURCE_DIR}/nativeui/respiratorytraining/src/RespiratoryTrainingView.cpp
${CMAKE_CURRENT_SOURCE_DIR}/nativeui/respiratorytraining/src/RespiratoryTrainingCompletedView.cpp
${CMAKE_CURRENT_SOURCE_DIR}/nativeui/respiratorytraining/src/RespiratoryTrainingModel.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/nativeui/respiratorytraining/src/RespiratoryTrainingDurationSelectionView.cpp
#显示方式
${CMAKE_CURRENT_SOURCE_DIR}/nativeui/themestyle/src/ThemeStyleModel.cpp
--- /dev/null
+/*
+ * @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 "BaseView.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
* @Author: luozheng 1732036298@qq.com
* @Date: 2024-06-11 16:26:13
* @LastEditors: luozheng 1732036298@qq.com
- * @LastEditTime: 2024-09-28 20:13:17
+ * @LastEditTime: 2024-10-04 19:59:41
* @FilePath: /FD230/code/sdk/application/wearable/fd230app/nativeui/respiratorytraining/include/RespiratoryTrainingModel.h
*/
#ifndef RESPIRATORY_TRAINING_MODEL_H
public:
static RespiratoryTrainingModel &GetInstance(void);
void AddRespiratoryTrainingTimes(void);
- std::string GetRespiratoryTrainingTotalTime(void) ;
+ std::string GetRespiratoryTrainingTotalTime(void);
int GetAverageHeartRate(void);
void calculateHeartrateTotal(void);
void ResumeStatus();
-
+
void RT_StartTimer(uint32_t interval);
void RT_StopTimer(void);
+ int GetRespiratoryTrainingSelectTime();
+ void SetRespiratoryTrainingSelectTime(int time);
+ uint64_t GetRespiratoryTrainingTime();
+ void ClearTotalRespiratoryTrainingTime(void);
+
private:
RespiratoryTrainingModel();
~RespiratoryTrainingModel();
RespiratoryTrainingModel &operator=(const RespiratoryTrainingModel &) = delete;
int RespiratoryTrainingTimes{0}; // 呼吸训练次数
- std::string RespiratoryTrainingTime{nullptr};
+ int RespiratoryTrainingTime{0};
std::string HeartRateValue{nullptr};
int count{0};
float heartTotal{0};
+ int selectTime{1};
};
}
* @Author: luozheng 1732036298@qq.com
* @Date: 2024-06-08 09:36:33
* @LastEditors: luozheng 1732036298@qq.com
- * @LastEditTime: 2024-06-08 11:00:44
+ * @LastEditTime: 2024-10-04 18:26:41
* @FilePath: /FD230/code/sdk/application/wearable/fd230app/nativeui/respiratorytraining/include/RespiratoryTrainingPresenter.h
*/
static RespiratoryTrainingPresenter *GetInstance();
+ std::string GetRespiratoryTrainingSelectTime();
+ std::string GetRespiratoryTrainingSelectTime1();
+
private:
bool OnClick(UIView &view, const ClickEvent &event) override;
bool OnDrag(UIView &view, const DragEvent &event) override;
* @Author: luozheng 1732036298@qq.com
* @Date: 2024-06-08 09:36:01
* @LastEditors: luozheng 1732036298@qq.com
- * @LastEditTime: 2024-06-13 09:22:22
+ * @LastEditTime: 2024-10-04 17:47:26
* @FilePath: /FD230/code/sdk/application/wearable/fd230app/nativeui/respiratorytraining/include/RespiratoryTrainingView.h
*/
#include "hal_tick.h"
#include "components/ui_scroll_view.h"
#include "respiratorytraining/include/RespiratoryTrainingCompletedView.h"
+#include "respiratorytraining/include/RespiratoryTrainingDurationSelectionView.h"
namespace OHOS
{
{
RESPIRATORYTRAINING = 0,
RESPIRATORYTRAININGCOMPLETED,
+ RESPIRATORY_TRAINING_DURATION_SELECTION, // 训练时长选择
MAX_RESPIRATORYTRAININGID,
} RESPIRATORYTRAININGVIEWID;
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;
private:
void RespiratoryTrainingViewInit(void);
void ClearAll(void);
-#if 0
- void InitializeRespiratoryTrainingImageInfo();
- void SetAnimatorViewProperties();
- void CreateRespiratoryTrainingAnimatorView();
- void CreateRespiratoryTrainingLabelView();
- void SetLabelViewProperties();
- UILabelExt *RespiratoryTrainingLabelView{nullptr};
- UIImageAnimatorView *RespiratoryTrainingAnimatorView{nullptr}; // 呼吸训练动画
- const char **RespiratoryTrainingArray{nullptr};
-#endif
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;
- // UILabelButton *RespiratoryTrainingStart_ = 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; // 训练开始标签
+ /* -------------------------------------------------------------------------- */
};
}
* @Author: luozheng 1732036298@qq.com
* @Date: 2024-05-07 11:25:58
* @LastEditors: luozheng 1732036298@qq.com
- * @LastEditTime: 2024-09-28 20:06:40
+ * @LastEditTime: 2024-10-04 19:53:55
* @FilePath: /FD230/code/sdk/application/wearable/fd230app/nativeui/RespiratoryTrainingCompleted/src/RespiratoryTrainingCompletedView.cpp
*/
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 heartRateValue = std::to_string(value);
+ 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] = {"01:00", heartRateValue.c_str(), trainingTotalTime.c_str()};
+ 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),
return false;
}
RTCDynamicLabelView[i]->SetTextColor(RTCDynamicLabelTextColor[i]);
+ RTCDynamicLabelView[i]->SetFont(DEFAULT_VECTOR_FONT_FILENAME_EN, 30);
ScrollView->Add(RTCDynamicLabelView[i]);
}
return true;
--- /dev/null
+/*
+ * @Author: luozheng 1732036298@qq.com
+ * @Date: 2024-09-29 15:57:59
+ * @LastEditors: luozheng 1732036298@qq.com
+ * @LastEditTime: 2024-10-04 20:24:42
+ * @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"
+namespace OHOS
+{
+
+ static RespiratoryTrainingDurationSelectionView *g_pRespiratoryTrainingDurationSelectionView{nullptr};
+ RespiratoryTrainingDurationSelectionView::RespiratoryTrainingDurationSelectionView(/* args */)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingDurationSelectionView::RespiratoryTrainingDurationSelectionView");
+ g_pRespiratoryTrainingDurationSelectionView = this;
+ }
+
+ RespiratoryTrainingDurationSelectionView::~RespiratoryTrainingDurationSelectionView()
+ {
+ WEARABLE_LOGE(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(70);
+ 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(800); /*设置手指抬起屏幕后的补偿距离。*/
+ scrollView->SetRotateFactor(1.0);
+ FocusManager::GetInstance()->RequestFocus(scrollView);
+ FocusManager::GetInstance()->RequestFocusByDirection(FOCUS_DIRECTION_UP);
+ UIView::OnDragListener *dragListener = static_cast<UIView::OnDragListener *>(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->SetText("时长设置"); // 时长设置
+ 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<UIView::OnClickListener *>(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_CELLULAR_DISPLAY, 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();
+ }
+ }
+}
* @Author: luozheng 1732036298@qq.com
* @Date: 2024-06-11 16:26:20
* @LastEditors: luozheng 1732036298@qq.com
- * @LastEditTime: 2024-09-28 20:12:26
+ * @LastEditTime: 2024-10-04 20:05:04
* @FilePath: /FD230/code/sdk/application/wearable/fd230app/nativeui/respiratorytraining/src/RespiratoryTrainingModel.cpp
*/
#include "respiratorytraining/include/RespiratoryTrainingModel.h"
#include "heartrate/include/HeartModel.h"
#include <custom_utils.h>
#include "gfx_utils/mem_check.h"
+#include "ConfigModel.h"
+
+#include <chrono>
+#include <iomanip>
+#include <iostream>
+#include <sstream>
+#include <thread>
+#include <unordered_map>
namespace OHOS
{
// 声明定时器变量
static osTimerId_t g_timer = NULL;
- static int Time = 0;
- static constexpr int ONE_MINUTE = 60; // 一分钟
- static bool START_FLAG = false;
+ 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() {}
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()
{
// 获取呼吸训练总时间
std::string RespiratoryTrainingModel::GetRespiratoryTrainingTotalTime(void)
{
- RespiratoryTrainingTime = std::to_string(RespiratoryTrainingTimes) + "min";
- return RespiratoryTrainingTime;
+ RespiratoryTrainingTime += GetRespiratoryTrainingSelectTime();
+ return (std::to_string(RespiratoryTrainingTime) + "min");
}
- //获取平均心率值
+ // 获取平均心率值
int RespiratoryTrainingModel::GetAverageHeartRate(void)
{
- if(count != 0) {
+ 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)
{
- heartTotal += HeartModel::GetInstance()->GetShowHeartdata();
- count++;
+ // 获取当前时间（以微秒为单位）
+ uint32_t currentTime = static_cast<uint32_t>(std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::system_clock::now().time_since_epoch()).count());
+
+ // 记录和检查上一次调用的时间
+ static uint32_t lastCallTime = 0;
+ if (currentTime - lastCallTime < 1000000)
+ {
+ // 小于1秒
+ return;
+ }
+ lastCallTime = currentTime; // 更新最后调用时间
+
+ 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);
+ }
}
void RespiratoryTrainingModel::ResumeStatus()
{
- Time = 5;
- START_FLAG = false;
+ heartTotal = 0;
+ count = 0;
HeartModel::GetInstance()->Heart_Control(HeartState::End, HeartCheck::INITIATIVE); // 关闭心率检测
}
/* -------------------------------------------------------------------------- */
/*定时器到期时的处理*/
static void RT_TimerCallbackProc(int data)
{
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "RT_TimerCallbackProc,Time = %d", Time);
RespiratoryTrainingView *p_RespiratoryTrainingView = RespiratoryTrainingView::GetInstance();
if (p_RespiratoryTrainingView == nullptr)
{
* @Author: luozheng 1732036298@qq.com
* @Date: 2024-05-07 11:26:06
* @LastEditors: luozheng 1732036298@qq.com
- * @LastEditTime: 2024-08-14 10:24:30
+ * @LastEditTime: 2024-10-04 18:05:11
* @FilePath: /FD230/code/sdk/application/wearable/fd230app/nativeui/RespiratoryTraining/src/RespiratoryTrainingPresenter.cpp
*/
#include <string>
#include "respiratorytraining/include/RespiratoryTrainingModel.h"
#include "gfx_utils/mem_check.h"
+#include "map"
namespace OHOS
{
if (viewId == RTCLABELBUTTON)
{
NativeAbility::GetInstance().Back(TransitionType::TRANSITION_BACK_TO_HEXAGONS);
+ return true;
+ }
+ std::map<std::string, int> 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_LOGE(WEARABLE_LOG_MODULE_APP, "select time = %d", it->second);
+ RespiratoryTrainingModel::GetInstance().SetRespiratoryTrainingSelectTime(it->second);
+ if (RespiratoryTrainingDurationSelectionView::GetInstance())
+ {
+ RespiratoryTrainingDurationSelectionView::GetInstance()->UpdateRespiratoryTrainingDurationSelectionView();
+ }
+ }
}
return true;
}
bool RespiratoryTrainingPresenter::OnDragEnd(UIView &view, const DragEvent &event)
{
- UNUSED(view);
WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingPresenter::OnDragEnd");
if (event.GetDragDirection() == DragEvent::DIRECTION_LEFT_TO_RIGHT && RespiratoryTrainingPresenter::X_DRAG_FLAG)
{
- NativeAbility::GetInstance().Back(TransitionType::TRANSITION_BACK_TO_HEXAGONS);
+ 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;
}
return true;
}
+
+ std::string RespiratoryTrainingPresenter::GetRespiratoryTrainingSelectTime()
+ {
+ int time = RespiratoryTrainingModel::GetInstance().GetRespiratoryTrainingSelectTime();
+ std::string text;
+ switch (time)
+ {
+ case 1:
+ text = "1分钟 >";
+ break;
+ case 2:
+ text = "2分钟 >";
+ break;
+ case 3:
+ text = "3分钟 >";
+ break;
+ case 4:
+ text = "4分钟 >";
+ break;
+ case 5:
+ text = "5分钟 >";
+ break;
+ default:
+ text = "1分钟 >";
+ break;
+ }
+ return text;
+ }
+
+ 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
* @Author: luozheng 1732036298@qq.com
* @Date: 2024-05-07 11:25:58
* @LastEditors: luozheng 1732036298@qq.com
- * @LastEditTime: 2024-09-28 20:13:37
+ * @LastEditTime: 2024-10-04 18:26:22
* @FilePath: /FD230/code/sdk/application/wearable/fd230app/nativeui/RespiratoryTraining/src/RespiratoryTrainingView.cpp
*/
{
container_->Add(RespiratoryTrainingScrollView[thisView]);
}
+ if (TrainingDurationSelectiontitlelabel)
+ {
+ TrainingDurationSelectiontitlelabel->SetText(presenter_->GetRespiratoryTrainingSelectTime().c_str());
+ }
return true;
}
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "new scrollView[%d] fail", thisView);
return false;
}
- RespiratoryTrainingScrollView[thisView] = p_RespiratoryTrainingCompletedView->RespiratoryTrainingCompletedViewInit();
+ UIScrollView *scrollView = p_RespiratoryTrainingCompletedView->RespiratoryTrainingCompletedViewInit();
+ if (scrollView == nullptr)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingCompletedViewInit fail!!");
+ return false;
+ }
+ RespiratoryTrainingScrollView[thisView] = scrollView;
+ container_->Add(RespiratoryTrainingScrollView[thisView]);
+ }
+ return true;
+ }
+
+ bool RespiratoryTrainingView::ChangeRespiratoryTrainingDurationSelectionView(int16_t thisView)
+ {
+ WEARABLE_LOGE(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;
container_->Add(RespiratoryTrainingScrollView[thisView]);
}
return true;
static const RespiratoryTrainingViewMapper ViewMapper[] = {
{RESPIRATORYTRAINING, &RespiratoryTrainingView::ChangeRespiratoryTrainingView},
{RESPIRATORYTRAININGCOMPLETED, &RespiratoryTrainingView::ChangeRespiratoryTrainingCompletedView},
+ {RESPIRATORY_TRAINING_DURATION_SELECTION, &RespiratoryTrainingView::ChangeRespiratoryTrainingDurationSelectionView},
};
bool RespiratoryTrainingView::ClickFunc(int16_t interface)
RootView::GetInstance()->SetOnKeyActListener(keyactListener);
}
-#if 0
- void RespiratoryTrainingView::ClearAll(void)
- {
- if (container_ != nullptr)
- {
- container_->RemoveAll();
- delete container_;
- container_ = 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;
- }
- }
-
- // 初始化呼吸训练动画图片信息
- void RespiratoryTrainingView::InitializeRespiratoryTrainingImageInfo()
- {
- for (uint8_t i = 0; i < RESPIRATORY_TRAINING_IMAGE_ANIMATOR_VIEW_NUM_FRAMES; i++)
- {
- RespiratoryTrainingImageInfo[i].imagePath = (RespiratoryTrainingArray[i]);
- RespiratoryTrainingImageInfo[i].imageType = RespiratoryTrainingImg_SRC_FILE_PATH;
- RespiratoryTrainingImageInfo[i].pos.x = RESPIRATORY_TRAINING_IMAGE_ANIMATOR_VIEW_X;
- RespiratoryTrainingImageInfo[i].pos.y = RESPIRATORY_TRAINING_IMAGE_ANIMATOR_VIEW_Y;
- RespiratoryTrainingImageInfo[i].width = RESPIRATORY_TRAINING_IMAGE_ANIMATOR_VIEW_W;
- RespiratoryTrainingImageInfo[i].height = RESPIRATORY_TRAINING_IMAGE_ANIMATOR_VIEW_H;
- }
- }
-
- // 设置动画属性
- void RespiratoryTrainingView::SetAnimatorViewProperties()
- {
- RespiratoryTrainingAnimatorView->SetPosition(RESPIRATORY_TRAINING_IMAGE_ANIMATOR_VIEW_X, RESPIRATORY_TRAINING_IMAGE_ANIMATOR_VIEW_Y);
- RespiratoryTrainingAnimatorView->Resize(RESPIRATORY_TRAINING_IMAGE_ANIMATOR_VIEW_W, RESPIRATORY_TRAINING_IMAGE_ANIMATOR_VIEW_H);
- RespiratoryTrainingAnimatorView->SetStyle(STYLE_BACKGROUND_COLOR, 0xffffffff);
- RespiratoryTrainingAnimatorView->SetStyle(STYLE_BACKGROUND_OPA, 0xff);
- RespiratoryTrainingAnimatorView->SetImageAnimatorSrc(RespiratoryTrainingImageInfo, RESPIRATORY_TRAINING_IMAGE_ANIMATOR_VIEW_NUM_FRAMES, RESPIRATORY_TRAINING_IMAGE_ANIMATOR_VIEW_TIMEOFUPDATE);
- RespiratoryTrainingAnimatorView->SetRepeat(true);
- RespiratoryTrainingAnimatorView->Start();
- }
-
- // 创建呼吸训练动画视图
- void RespiratoryTrainingView::CreateRespiratoryTrainingAnimatorView()
- {
- RespiratoryTrainingArray = RespiratoryTrainingView::GetInstance()->CreateImagePathsArray("/user/res/remind/RESPIRATORY_TRAINING_/", "bin", RESPIRATORY_TRAINING_IMAGE_ANIMATOR_VIEW_NUM_FRAMES);
-
- if (RespiratoryTrainingAnimatorView == nullptr)
- {
- RespiratoryTrainingAnimatorView = new UIImageAnimatorView();
- if (RespiratoryTrainingAnimatorView == nullptr)
- {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[CreateDeviceRESPIRATORY_TRAINING_ingView]RespiratoryTrainingAnimatorView new fail");
- return;
- }
-
- InitializeRespiratoryTrainingImageInfo();
- SetAnimatorViewProperties();
- }
- }
-
- // 创建呼吸训练标签视图
- void RespiratoryTrainingView::CreateRespiratoryTrainingLabelView()
- {
- if (RespiratoryTrainingLabelView == nullptr)
- {
- RespiratoryTrainingLabelView = new UILabelExt();
- if (RespiratoryTrainingLabelView == nullptr)
- {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "[CreateDeviceRESPIRATORY_TRAINING_ingView]RespiratoryTrainingLabelView new fail");
- return;
- }
- SetLabelViewProperties();
- }
- }
-
- void RespiratoryTrainingView::SetLabelViewProperties()
- {
- RespiratoryTrainingLabelView->SetPosition(83, 320, 360, 70);
- }
-
- void RespiratoryTrainingView::RespiratoryTrainingViewInit(void)
- {
- CreateRespiratoryTrainingAnimatorView();
- CreateRespiratoryTrainingLabelView();
- }
-#endif
-
const static int16_t BUTTON_WIDTH = 320;
const static int16_t BUTTON_HEIGHT = 100;
const static int16_t INTERVAL_STEP = 80;
const Vector2<float> 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();
+ RespiratoryTrainingModel::GetInstance().calculateHeartrateTotal();
// 1.计算当前时间与开始时间的差值，用于控制动画的时间。
uint32_t currentTime = HALTick::GetInstance().GetTime();
curTime = currentTime - startTimestamp;
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);
+ }
+
+ StartRespiratoryTraining(); // 开始呼吸训练
+ HeartModel::GetInstance()->Heart_Control(HeartState::Start, HeartCheck::INITIATIVE); // 开启心率检测
+ 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(view);
UNUSED(event);
-#if 0
- if (!animateStart_)
+
+ if (&view == RespiratoryTrainingStartButton)
{
- RespiratoryTrainingAnimator_->Start();
- animateStart_ = false;
- if (RespiratoryTrainingStart_ != nullptr)
- {
- RespiratoryTrainingScrollView[RESPIRATORYTRAINING]->Remove(RespiratoryTrainingStart_);
- delete RespiratoryTrainingStart_;
- RespiratoryTrainingStart_ = nullptr;
- }
- RespiratoryTrainingLabel_ = new UILabelExt();
- if (RespiratoryTrainingLabel_ == nullptr)
- {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingLabel_ new fail");
- return false;
- }
- RespiratoryTrainingLabel_->SetPosition(53, 320, 360, 70); // 180, 380, 100, 50: left, right, width, height
- // RespiratoryTrainingLabel_->SetText("现在呼气");
- RespiratoryTrainingLabel_->SetTextId(STR_EXHALE_NOW);
- 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();
+ HandStartRespiratoryTraining();
+ }
+ else if (&view == TrainingDurationSelectiontitlelabel)
+ {
+ ChangeView(RESPIRATORYTRAINING, RESPIRATORY_TRAINING_DURATION_SELECTION);
}
-#endif
return true;
}
RespiratoryTrainingImg_->SetStyle(STYLE_BACKGROUND_OPA, OPA_TRANSPARENT);
RespiratoryTrainingImg_->SetAutoEnable(false);
RespiratoryTrainingImg_->SetResizeMode(UIImageView::ImageResizeMode::CENTER);
+ RespiratoryTrainingImg_->SetVisible(false);
RespiratoryTrainingScrollView[RESPIRATORYTRAINING]->Add(RespiratoryTrainingImg_);
-
-#if 0
- // 创建并设置呼吸训练开始按钮
- RespiratoryTrainingStart_ = new UILabelButton();
- if (RespiratoryTrainingStart_ == nullptr)
- {
- WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingStart_ new failed!");
- return false;
- }
- RespiratoryTrainingStart_->SetPosition(158, 320, 150, 75);
- RespiratoryTrainingStart_->SetText("Start");
- RespiratoryTrainingStart_->SetFont(DEFAULT_VECTOR_FONT_FILENAME, 30);
- RespiratoryTrainingStart_->SetOnClickListener(this);
- RespiratoryTrainingScrollView[RESPIRATORYTRAINING]->Add(RespiratoryTrainingStart_);
-#else
-
+ /* -------------------------------------------------------------------------- */
RespiratoryTrainingStartNote_ = new UILabelExt();
if (RespiratoryTrainingStartNote_ == nullptr)
{
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;
-#endif
+ }
+
+ 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->SetText(presenter_->GetRespiratoryTrainingSelectTime().c_str());
+ 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()
return false;
}
RespiratoryTrainingScrollView[RESPIRATORYTRAINING]->SetPosition(0, 0, Screen::GetInstance().GetWidth(), Screen::GetInstance().GetHeight());
- RespiratoryTrainingScrollView[RESPIRATORYTRAINING]->SetScrollBlankSize(50);
- RespiratoryTrainingScrollView[RESPIRATORYTRAINING]->SetReboundSize(35);
+ // RespiratoryTrainingScrollView[RESPIRATORYTRAINING]->SetScrollBlankSize(50);
+ // RespiratoryTrainingScrollView[RESPIRATORYTRAINING]->SetReboundSize(35);
RespiratoryTrainingScrollView[RESPIRATORYTRAINING]->SetHorizontalScrollState(false);
RespiratoryTrainingScrollView[RESPIRATORYTRAINING]->SetTouchable(true);
RespiratoryTrainingScrollView[RESPIRATORYTRAINING]->SetDraggable(true);
{
WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "RespiratoryTrainingView::RespiratoryTrainingViewInit");
if (!InitRespiratoryTrainingScrollView() || !InitRespiratoryTrainingElements() ||
- !InitRespiratoryTrainingCallBackAndAnimator())
+ !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)
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!!");
}
#include "ConfigModelC.h"
#include "heart_blood/health_service/health_service.h"
#include "vibrator_service.h"
+#include "respiratorytraining/include/RespiratoryTrainingModel.h"
#define DIALDATASET 1
//#include "Systemupgrade.h"
/* ---------------------------------- 健康数据相关 ---------------------------------- */
// 清空当日的心率血氧数据
HealthService::GetInstance()->CleanHealthData();
+ RespiratoryTrainingModel::GetInstance().ClearTotalRespiratoryTrainingTime();
// 通知UI更新
GraphicService::GetInstance()->PostGraphicEvent(
std::bind(&OHOS::HeartModel::CleanAllData, OHOS::HeartModel::GetInstance()));
{
unused(req);
WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "MsgCenterNotifyDebugOutProc !");
- NotificationManager::GetInstance()->ShowNotify(showDebugOutputNotify, (uint16_t)topic, true);
+ if (CheckPriority(topic))
+ {
+ NotificationManager::GetInstance()->SetNotifyPriority(PRIORITY_ONE);
+ NotificationManager::GetInstance()->ShowNotify(showDebugOutputNotify, (uint16_t)topic, true);
+ }
}
//每日训练数据刷新
void MsgCenterNotifyActivityProc(const Topic topic, Request* req)
--- /dev/null
+version https://git-lfs.github.com/spec/v1
+oid sha256:b510277397ae32dea9d06e919cd012b66e3054a5f567e328d14a72e7e3c4054b
+size 38424
CONFIGMODEL_ITEM_FLASHLIGHT_COLOR_VALUE, // color value
CONFIGMODEL_ITEM_FLASHLIGHT_FLASHING_LEVEL, // flashing level
+ CONFIGMODEL_ITEM_RESPIRATORY_TRAINING_DURATION_SELECTION, // 呼吸训练时长选择
CONFIGMODEL_ITEM_MAX,
{ConfigDataType::DATATYPE_INT, "color_index", "0" }, // CONFIGMODEL_ITEM_FLASHLIGHT_COLOR_INDEX, // color index
{ConfigDataType::DATATYPE_INT, "color_value", "0" }, // CONFIGMODEL_ITEM_FLASHLIGHT_COLOR_VALUE, // color value
{ConfigDataType::DATATYPE_INT, "flashing_level", "0" }, // CONFIGMODEL_ITEM_FLASHLIGHT_FLASHING_LEVEL, // flashing level
+ {ConfigDataType::DATATYPE_INT, "rt_select_time", "1" }, // CONFIGMODEL_ITEM_RESPIRATORY_TRAINING_DURATION_SELECTION,呼吸训练选择的时长
};
ConfigModel(); // 私有构造函数，确保无法在外部实例化
projects / mirrors / FD230.git / commitdiff