${CMAKE_CURRENT_SOURCE_DIR}/nativeui/stress/src/StressFailView.cpp
${CMAKE_CURRENT_SOURCE_DIR}/nativeui/stress/src/StressPresenter.cpp
+ #疲劳度
+ ${CMAKE_CURRENT_SOURCE_DIR}/nativeui/fatiguelevel/src/FatigueMainView.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/nativeui/fatiguelevel/src/FatigueMeasureView.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/nativeui/fatiguelevel/src/FatigueUnderMeasureView.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/nativeui/fatiguelevel/src/FatigueAnalysisView.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/nativeui/fatiguelevel/src/FatigueModel.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/nativeui/fatiguelevel/src/FatigueResultView.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/nativeui/fatiguelevel/src/FatigueWearView.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/nativeui/fatiguelevel/src/FatigueFailView.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/nativeui/fatiguelevel/src/FatiguePresenter.cpp
+
${CMAKE_CURRENT_SOURCE_DIR}/nativeui/bluetooth/src/BluetoothDeviceCaseListAdapter.cpp
${CMAKE_CURRENT_SOURCE_DIR}/nativeui/bluetooth/src/BluetoothDeviceListView.cpp
void InitBloodSlice(void);
void InitBloodPressureSlice(void);
void InitStressSlice(void);
+ void InitFatigueLevelSlice(void);
void InitCheckAbnormalSlice(void);
void InitCheckInvalidSlice(void);
void InitHeartResultSlice(void);
static constexpr const char *PNG_APPLIST_SPO2_IMAGE = APP_LIST_PATH "/booldoxygen.bin"; // 血氧
static constexpr const char *PNG_APPLIST_BP_MESSURE_IMAGE = APP_LIST_PATH "/blood_pressure.bin"; // 血压测量
static constexpr const char *PNG_APPLIST_ECG_IMAGE = APP_LIST_PATH "/ecg.bin"; // 心电(ECG)测量
+ static constexpr const char *PNG_APPLIST_STRESS_IMAGE = APP_LIST_PATH "/stress.bin"; // 压力测量
+ static constexpr const char *PNG_APPLIST_FATIGUE_IMAGE = APP_LIST_PATH "/Fatigue_level.bin"; // 疲劳度测量
static constexpr const char *PNG_APPLIST_EMOTION_IMAGE = APP_LIST_PATH "/emotion.bin"; // 情绪测量
static constexpr const char *PNG_APPLIST_BP_IMAGE = APP_LIST_PATH "/bp_calibration.bin"; // 血压校准
static constexpr const char *PNG_APPLIST_HEART_IMAGE = APP_LIST_PATH "/heart.bin"; // 心率
static constexpr const char *PNG_APPLIST_BP_IMAGE_BIG = APP_LIST_PATH "/applist_big_icon/bp_calibration.bin"; // 血压校准
static constexpr const char *PNG_APPLIST_EMOTION_IMAGE_BIG = APP_LIST_PATH "/applist_big_icon/emotion.bin"; // 情绪测量
static constexpr const char *PNG_APPLIST_ECG_IMAGE_BIG = APP_LIST_PATH "/applist_big_icon/ecg.bin"; // 心电(ECG)测量
+ static constexpr const char *PNG_APPLIST_STRESS_IMAGE_BIG = APP_LIST_PATH "/applist_big_icon/stress.bin"; // 压力测量
+ static constexpr const char *PNG_APPLIST_FATIGUE_IMAGE_BIG = APP_LIST_PATH "/applist_big_icon/fatigue_level.bin"; // 疲劳度测量
static constexpr const char *PNG_APPLIST_HEART_IMAGE_BIG = APP_LIST_PATH "/applist_big_icon/heart.bin"; // 心率
static constexpr const char *PNG_APPLIST_SETTING_IMAGE_BIG = APP_LIST_PATH "/applist_big_icon/setting.bin"; // 设置
static constexpr const char *PNG_APPLIST_CALLER_IMAGE_BIG = APP_LIST_PATH "/applist_big_icon/phone.bin"; // 打电话
/*压力检测*/
#include "stress/include/StressPresenter.h"
#include "stress/include/StressMainView.h"
+/*疲劳度检测*/
+#include "fatiguelevel/include/FatiguePresenter.h"
+#include "fatiguelevel/include/FatigueMainView.h"
/*心率监测*/
#include "heartrate/include/HeartDetectionView.h"
#include "heartrate/include/HeartDetectionPresenter.h"
{VIEW_EMOTION, &NativeLauncher::InitEmotionSlice},
/*压力监测*/
{VIEW_PRESSURE, &NativeLauncher::InitStressSlice},
+ /*疲劳度监测*/
+ {VIEW_FATIGUE, &NativeLauncher::InitFatigueLevelSlice},
/*心率检测*/
{VIEW_HEART_CHECK, &NativeLauncher::InitHeartCheckSlice},
{VIEW_HEART_RESULT, &NativeLauncher::InitHeartResultSlice},
// 压力监测界面
void NativeLauncher::InitStressSlice(void)
{
- WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "NativeLauncher::InitBloodPressureSlice");
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "NativeLauncher::InitStressSlice");
SliceProxy *stressView = new AbilitySliceProxy<StressMainView, StressPresenter>;
if (stressView == nullptr)
{
return;
}
NativeAbility::GetInstance().AddSliceProxy(VIEW_PRESSURE, stressView);
+ }
+ // 疲劳度监测界面
+ void NativeLauncher::InitFatigueLevelSlice(void)
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "NativeLauncher::InitFatigueLevelSlice");
+ SliceProxy *fatigueView = new AbilitySliceProxy<FatigueMainView, FatiguePresenter>;
+ if (fatigueView == nullptr)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "fatigueView is nullptr");
+ return;
+ }
+ NativeAbility::GetInstance().AddSliceProxy(VIEW_FATIGUE, fatigueView);
}
// 心率监测界面
void NativeLauncher::InitHeartCheckSlice(void)
// #endif
#if defined(BOARD_W9) || defined(BOARD_N9)
//ECG
- {VIEW_ECG, PNG_APPLIST_ECG_IMAGE_BIG, PNG_APPLIST_ECG_IMAGE, PNG_APPLIST_DEFAULT_IMG, "ECG", STR_BP_CHECK, nullptr},
+ //{VIEW_ECG, PNG_APPLIST_ECG_IMAGE_BIG, PNG_APPLIST_ECG_IMAGE, PNG_APPLIST_DEFAULT_IMG, "ECG", STR_BP_CHECK, nullptr},
//情绪
//{VIEW_EMOTION, PNG_APPLIST_EMOTION_IMAGE_BIG, PNG_APPLIST_EMOTION_IMAGE, PNG_APPLIST_DEFAULT_IMG, "情绪", STR_EMOTION, nullptr},
//压力
//{VIEW_PRESSURE, PNG_APPLIST_STRESS_IMAGE_BIG, PNG_APPLIST_STRESS_IMAGE, PNG_APPLIST_DEFAULT_IMG, "压力", STR_STRESS, nullptr},
//疲劳度
- //{VIEW_FATIGUE, PNG_APPLIST_FATIGUE_IMAGE_BIG, PNG_APPLIST_FATIGUE_IMAGE, PNG_APPLIST_DEFAULT_IMG, "疲劳度", STR_FATIGUE, nullptr},
+ {VIEW_FATIGUE, PNG_APPLIST_FATIGUE_IMAGE_BIG, PNG_APPLIST_FATIGUE_IMAGE, PNG_APPLIST_DEFAULT_IMG, "疲劳度", STR_BP_CHECK, nullptr},
#endif
{VIEW_SLEEP, PNG_APPLIST_SLEEP_IMAGE_BIG, PNG_APPLIST_SLEEP_IMAGE, PNG_APPLIST_DEFAULT_IMG, "睡眠", STR_SLEEP, nullptr},
{VIEW_TRAINING, PNG_APPLIST_TRAINING_IMAGE_BIG, PNG_APPLIST_TRAINING_IMAGE, PNG_APPLIST_DEFAULT_IMG, "运动", STR_TRAINING, nullptr},
--- /dev/null
+#ifndef FATIGUE_ANALYSIS_VIEW_H
+#define FATIGUE_ANALYSIS_VIEW_H
+
+#include "components/ui_view_group.h"
+#include "components/ui_label_ext.h"
+#include "components/ui_image_animator.h"
+namespace OHOS
+{
+ class FatigueAnalysisView
+ {
+ public:
+ FatigueAnalysisView();
+ ~FatigueAnalysisView();
+ static FatigueAnalysisView *GetInstance(void);
+ UIViewGroup *FatigueAnalysisInit();
+ void startorstopAnalysisAni(bool state);
+
+ private:
+ void ClearAll(void);
+ UIViewGroup *group{nullptr};
+ UILabelExt *titleLabel{nullptr};
+ UILabelExt *remindLabel{nullptr};
+ UIImageAnimatorView *FatigueAnaAni{nullptr};
+ ImageAnimatorInfo FatigueAnaAniImageInfo[30];
+ };
+}
+#endif
\ No newline at end of file
--- /dev/null
+#ifndef BP_FATIGUEFAIL_VIEW_H
+#define BP_FATIGUEFAIL_VIEW_H
+
+#include "components/ui_label.h"
+#include "components/ui_label_ext.h"
+#include "components/ui_button.h"
+#include "components/ui_label_button.h"
+#include "components/ui_view_group.h"
+#include "components/ui_scroll_view.h"
+#include "components/ui_label_button_ext.h"
+namespace OHOS
+{
+ static constexpr const char *FAILBUTTON_FATIGUE = "FailButton";
+
+ class FatigueFailView
+ {
+ public:
+ FatigueFailView();
+ ~FatigueFailView();
+ static FatigueFailView *GetInstance();
+ UIViewGroup * FatigueFailInit();
+ void DeInit();
+ bool AddButton();
+ bool InitLable();
+ bool Initbackground();
+
+
+ private:
+ UIImageView *error = nullptr;
+ UILabelExt *titleLable = nullptr;
+ UILabelButton *checkButton{nullptr};
+ UIViewGroup *group{nullptr};
+ };
+}
+
+#endif // 校准失败界面
\ No newline at end of file
--- /dev/null
+
+
+#ifndef Fatigue_MAIN_VIEW_H
+#define Fatigue_MAIN_VIEW_H
+
+#include "View.h"
+#include "BaseView.h"
+#include "components/ui_view_group.h"
+#include "fatiguelevel/include/FatigueMeasureView.h"
+#include "fatiguelevel/include/FatigueUnderMeasureView.h"
+#include "fatiguelevel/include/FatigueResultView.h"
+#include "fatiguelevel/include/FatigueWearView.h"
+#include "fatiguelevel/include/FatigueFailView.h"
+#include "fatiguelevel/include/FatigueResultView.h"
+#include "fatiguelevel/include/FatigueAnalysisView.h"
+
+namespace OHOS
+{
+ typedef enum : uint8_t
+ {
+ FATIGUEMEASUREVIEW = 0, // 疲劳度测量界面
+ FATIGUEUNDERMEASUREVIEW, // 测量中界面
+ FATIGUEANALYSISEVIEW, // 分析界面
+ FATIGUERESULTVIEW, // 测量结果界面
+ FATIGUEWEARVIEW, // 佩戴错误界面
+ FATIGUEFAILVIEW, // 测量失败界面
+ MAX_FATIGUEVIEW,
+ } FatigueVIEWID;
+
+ class FatiguePresenter;
+ class FatigueMainView : public View<FatiguePresenter>
+ {
+ public:
+ FatigueMainView();
+ virtual ~FatigueMainView();
+ static FatigueMainView *GetInstance(void);
+ void OnStop() override;
+ void OnSetUpView() override;
+ void OnTearDownView() override;
+ void OnStart() override;
+
+ bool ChangeFatigueMeasureView(int16_t);
+ bool ChangeFatigueUnderMeasureView(int16_t);
+ bool ChangeFatigueResultView(int16_t);
+ bool ChangeFatigueWearView(int16_t);
+ bool ChangeFatigueFailView(int16_t);
+ bool ChangeFatigueAnalysisView(int16_t);
+
+ bool ClickFunc(int16_t interface);
+ void ChangeView(int16_t hideView, int16_t showView);
+
+ private:
+ FatigueMeasureView *g_pFatigueMeasureView{nullptr};
+ FatigueUnderMeasureView *g_pFatigueUnderMeasureView{nullptr};
+ FatigueResultView *g_pFatigueResultView{nullptr};
+ FatigueFailView *g_pFatigueFailView{nullptr};
+ FatigueWearView *g_pFatigueWearView{nullptr};
+ FatigueAnalysisView *g_pFatigueAnalysisView{nullptr};
+
+ private:
+ void DeInit();
+ UIViewGroup *group[MAX_FATIGUEVIEW]{nullptr};
+ };
+}
+
+#endif // 血压主界面
\ No newline at end of file
--- /dev/null
+
+#ifndef BP_FATIGUEMEASURE_VIEW_H
+#define BP_FATIGUEMEASURE_VIEW_H
+
+#include "components/ui_label.h"
+#include "components/ui_label_ext.h"
+#include "components/ui_button.h"
+#include "components/ui_label_button.h"
+#include "components/ui_view_group.h"
+#include "components/ui_scroll_view.h"
+#include "components/ui_label_button_ext.h"
+namespace OHOS
+{
+ static constexpr const char *STARTBUTTON_FATIGUE = "startkButton"; // 开始测量按钮
+
+ class FatigueMeasureView
+ {
+ public:
+ FatigueMeasureView();
+ ~FatigueMeasureView();
+ static FatigueMeasureView *GetInstance();
+ UIViewGroup * FatigueMeasureInit();
+ void DeInit();
+ bool AddButton();
+ bool InitLable();
+ bool Initbackground();
+
+
+ private:
+ UIImageView *error = nullptr;
+ UILabelExt *titleLable = nullptr;
+ UILabelExt *resultremindLable = nullptr;
+ UILabelButton *checkButton{nullptr};
+ UIViewGroup *group{nullptr};
+ };
+}
+
+#endif // 校准失败界面
\ No newline at end of file
--- /dev/null
+#ifndef FATIGUE_MODEL_H
+#define FATIGUE_MODEL_H
+
+#include <stdint.h>
+#include <string>
+
+
+namespace OHOS {
+// 血压检测状态
+enum class FatigueState {
+ //结束
+ FATIGUE_End = 0,
+ //疲劳度检测中
+ FATIGUE_MEASURE,
+ //结果分析中
+ FATIGUE_ANALYSIS,
+ //普通状态
+ FATIGUE_NORMAL,
+ //暂停
+ FATIGUE_PAUSE,
+
+ FATIGUE_STATE_MAX,
+};
+// 疲劳度检测结果
+enum class FatigueRESULT {
+ NOT_TESTED = 0, // 未检测
+ SUCCESS, // 检测成功
+ NOT_WORN, // 未佩戴检测
+ TIMEOUT, // 检测超时
+ HIGH_RESULT, // 检测结果过高
+ LOW_RESULT, // 检测结果过低
+ INVALID_DATA // 无效数据
+};
+
+#define Fatigue_ANLYSISI_TIME_MAX 5
+
+class FatigueModel {
+public:
+ FatigueModel();
+ ~FatigueModel();
+ static FatigueModel *GetInstance();
+
+ //当前状态管理
+ void Fatigue_SetState(FatigueState state);
+ FatigueState GetCurrentState();
+ //控制血压检测
+ void Fatigue_Control(FatigueState state);
+
+ ///////////////////////////////////////////////
+ void Fatigue_StartTimer(uint32_t interval = 1*1000);// 1s定时器
+ void Fatigue_StopTimer(void);
+
+
+private:
+ FatigueState current_state = FatigueState::FATIGUE_NORMAL;
+};
+} // namespace OHOS
+
+#endif
--- /dev/null
+
+
+#ifndef Fatigue_RESULT_PRESENTER_H
+#define Fatigue_RESULT_PRESENTER_H
+
+#include "Presenter.h"
+#include "ModelListenerSample.h"
+#include "components/ui_circle_progress.h"
+#include "ohos_types.h"
+#include "KeyInputListener.h"
+#include "common/key_code.h"
+#include "fatiguelevel/include/FatigueMainView.h"
+#include "fatiguelevel/include/FatigueModel.h"
+
+namespace OHOS
+{
+ class FatigueMainView;
+ class FatiguePresenter : public Presenter<FatigueMainView>,
+ public UIView::OnClickListener,
+ public RootView::OnKeyActListener,
+ public UIView::OnDragListener
+ {
+ public:
+ FatiguePresenter();
+ virtual ~FatiguePresenter();
+ static FatiguePresenter *GetInstance(void);
+
+ void OnStart() override;
+ void OnPause() override;
+ void OnResume() override;
+ void OnStop() override;
+
+ bool OnDrag(UIView &view, const DragEvent &event) override;
+ bool OnDragEnd(UIView &view, const DragEvent &event) override;
+ bool OnClick(UIView &view, const ClickEvent &event) override;
+ bool OnKeyAct(UIView &view, const KeyEvent &event) override; // 增加按键事件
+
+ };
+}
+
+#endif
--- /dev/null
+
+#ifndef BP_FATIGUERESULT_VIEW_H
+#define BP_FATIGUERESULT_VIEW_H
+
+#include "components/ui_label.h"
+#include "components/ui_label_ext.h"
+#include "components/ui_button.h"
+#include "components/ui_label_button.h"
+#include "components/ui_view_group.h"
+#include "components/ui_scroll_view.h"
+#include "components/ui_label_button_ext.h"
+namespace OHOS
+{
+
+ class FatigueResultView
+ {
+ public:
+ FatigueResultView();
+ ~FatigueResultView();
+ static FatigueResultView *GetInstance();
+ UIViewGroup * FatigueResultInit();
+ void DeInit();
+ bool AddButton();
+ bool InitLable();
+ bool Initbackground();
+
+
+ private:
+ UIImageView *error = nullptr;
+ UILabelExt *titleLable = nullptr;
+ UILabelExt *resultremindLable = nullptr;
+ UILabelExt *resultLable = nullptr;
+ UIViewGroup *group{nullptr};
+ };
+}
+
+#endif // 校准失败界面
\ No newline at end of file
--- /dev/null
+
+#ifndef BP_FatigueUnderMeasureView_VIEW_H
+#define BP_FatigueUnderMeasureView_VIEW_H
+
+#include "components/ui_label.h"
+#include "components/ui_label_ext.h"
+#include "components/ui_button.h"
+#include "components/ui_label_button.h"
+#include "components/ui_view_group.h"
+#include "components/ui_scroll_view.h"
+#include "components/ui_label_button_ext.h"
+namespace OHOS
+{
+ static constexpr const char *UNDERBUTTON_FATIGUE = "undermeasureButton"; // 开始测量按钮
+
+ class FatigueUnderMeasureView
+ {
+ public:
+ FatigueUnderMeasureView();
+ ~FatigueUnderMeasureView();
+ static FatigueUnderMeasureView *GetInstance();
+ UIViewGroup * FatigueUnderMeasureInit();
+ void DeInit();
+ bool AddButton();
+ bool InitLable();
+ bool Initbackground();
+
+
+ private:
+ UIImageView *error = nullptr;
+ UILabelExt *titleLable = nullptr;
+ UILabelExt *resultremindLable = nullptr;
+ UILabelButton *checkButton{nullptr};
+ UIViewGroup *group{nullptr};
+ };
+}
+
+#endif // 校准失败界面
\ No newline at end of file
--- /dev/null
+
+#ifndef BP_FATIGUEWEAR_VIEW_H
+#define BP_FATIGUEWEAR_VIEW_H
+
+#include "components/ui_label.h"
+#include "components/ui_label_ext.h"
+#include "components/ui_button.h"
+#include "components/ui_label_button.h"
+#include "components/ui_view_group.h"
+#include "components/ui_scroll_view.h"
+#include "components/ui_label_button_ext.h"
+namespace OHOS
+{
+ static constexpr const char *WEARBUTTON_FITIGUE = "WearButton"; // 开始测量按钮
+
+ class FatigueWearView
+ {
+ public:
+ FatigueWearView();
+ ~FatigueWearView();
+ static FatigueWearView *GetInstance();
+ UIViewGroup * FatigueWearInit();
+ void DeInit();
+ bool AddButton();
+ bool InitLable();
+ bool Initbackground();
+
+
+ private:
+ UIImageView *error = nullptr;
+ UILabelExt *titleLable = nullptr;
+ UILabelButton *checkButton{nullptr};
+ UIViewGroup *group{nullptr};
+ };
+}
+
+#endif // 校准失败界面
\ No newline at end of file
--- /dev/null
+#include "fatiguelevel/include/FatigueAnalysisView.h"
+#include "fatiguelevel/include/FatiguePresenter.h"
+#include "wearable_log.h"
+#include "UiConfig.h"
+#include "common/image_cache_manager.h"
+namespace OHOS
+{
+
+ const char *FatigueAnaAniImagePath[] = {
+ PNG_STRESS_IMAGE_00,
+ PNG_STRESS_IMAGE_01,
+ PNG_STRESS_IMAGE_02,
+ PNG_STRESS_IMAGE_03,
+ PNG_STRESS_IMAGE_04,
+ PNG_STRESS_IMAGE_05,
+ PNG_STRESS_IMAGE_06,
+ PNG_STRESS_IMAGE_07,
+ PNG_STRESS_IMAGE_08,
+ PNG_STRESS_IMAGE_09,
+ PNG_STRESS_IMAGE_10,
+ PNG_STRESS_IMAGE_11,
+ PNG_STRESS_IMAGE_12,
+ PNG_STRESS_IMAGE_13,
+ PNG_STRESS_IMAGE_14,
+ PNG_STRESS_IMAGE_15,
+ PNG_STRESS_IMAGE_16,
+ PNG_STRESS_IMAGE_17,
+ PNG_STRESS_IMAGE_18,
+ PNG_STRESS_IMAGE_19,
+ PNG_STRESS_IMAGE_20,
+ PNG_STRESS_IMAGE_21,
+ PNG_STRESS_IMAGE_22,
+ PNG_STRESS_IMAGE_23,
+ PNG_STRESS_IMAGE_24,
+ PNG_STRESS_IMAGE_25,
+ PNG_STRESS_IMAGE_26,
+ PNG_STRESS_IMAGE_27,
+ PNG_STRESS_IMAGE_28,
+ PNG_STRESS_IMAGE_29,
+ };
+
+ static FatigueAnalysisView *g_pFatigueAnalysisView = nullptr;
+ FatigueAnalysisView::FatigueAnalysisView()
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "FatigueAnalysisView::FatigueAnalysisView");
+ g_pFatigueAnalysisView = this;
+ }
+
+ FatigueAnalysisView::~FatigueAnalysisView()
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "FatigueAnalysisView::~FatigueAnalysisView");
+ ClearAll();
+ g_pFatigueAnalysisView = nullptr;
+ }
+
+ FatigueAnalysisView *FatigueAnalysisView::GetInstance(void)
+ {
+ return g_pFatigueAnalysisView;
+ }
+
+ void FatigueAnalysisView::ClearAll(void)
+ {
+ if (group)
+ {
+ group->RemoveAll();
+ delete group;
+ group = nullptr;
+ delete titleLabel;
+ titleLabel = nullptr;
+ delete remindLabel;
+ remindLabel = nullptr;
+ if (FatigueAnaAni)
+ {
+ FatigueAnaAni->Stop();
+ delete FatigueAnaAni;
+ FatigueAnaAni = nullptr;
+ }
+ }
+ }
+
+ void FatigueAnalysisView::startorstopAnalysisAni(bool state)
+ {
+ if (FatigueAnaAni)
+ {
+ if (state)
+ {
+ FatigueAnaAni->Start();
+ }
+ else
+ {
+ FatigueAnaAni->Stop();
+ }
+ }
+ }
+
+ UIViewGroup *FatigueAnalysisView::FatigueAnalysisInit()
+ {
+ if (group == nullptr)
+ {
+ group = new UIViewGroup();
+ if (group == nullptr)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "group null!");
+ return nullptr;
+ }
+ }
+ group->SetPosition(0, 0, HORIZONTAL_RESOLUTION, VERTICAL_RESOLUTION);
+ group->SetTouchable(true);
+ group->SetDraggable(true);
+ // UIView::OnDragListener *dragListener = (UIView::OnDragListener *)OHOS::FatiguePresenter::GetInstance();
+ // group->SetOnDragListener(dragListener);
+ /* -------------------------------------------------------------------------- */
+ FatigueAnaAni = new UIImageAnimatorView();
+ if (FatigueAnaAni == nullptr)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "AlipayBindAni::AlipayInitImageAni new FatigueAnaAni fail");
+ return nullptr;
+ }
+ for (uint8_t i = 0; i < (sizeof(FatigueAnaAniImagePath) / sizeof(FatigueAnaAniImagePath[0])); i++)
+ {
+ FatigueAnaAniImageInfo[i].imageInfo = ImageCacheManager::GetInstance().LoadSingleRes(FatigueAnaAniImagePath[i]);
+ FatigueAnaAniImageInfo[i].imageType = IMG_SRC_IMAGE_INFO;
+ FatigueAnaAniImageInfo[i].pos.x = 0;
+ FatigueAnaAniImageInfo[i].pos.y = 0;
+ FatigueAnaAniImageInfo[i].width = 466;
+ FatigueAnaAniImageInfo[i].height = 466;
+ }
+ FatigueAnaAni->SetPosition(0, 0, 466, 466);
+ FatigueAnaAni->SetImageAnimatorSrc(FatigueAnaAniImageInfo, (sizeof(FatigueAnaAniImagePath) / sizeof(FatigueAnaAniImagePath[0])), 100);
+ FatigueAnaAni->SetRepeat(true);
+ FatigueAnaAni->SetAutoEnable(false);
+ FatigueAnaAni->SetResizeMode(UIImageView::FILL);
+ group->Add(FatigueAnaAni);
+ /* -------------------------------------------------------------------------- */
+ if (titleLabel == nullptr)
+ {
+ titleLabel = new UILabelExt();
+ if (titleLabel == nullptr)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "titleLabel null!");
+ return nullptr;
+ }
+ }
+ titleLabel->SetPosition((HORIZONTAL_RESOLUTION - 300) / 2, 50, 300, 35);
+ titleLabel->SetStyle(STYLE_TEXT_FONT, 30);
+ titleLabel->SetStyle(STYLE_LINE_HEIGHT, 35);
+ titleLabel->SetText("疲劳度");
+ titleLabel->SetLineBreakMode(UILabel::LINE_BREAK_OSCILLATION);
+ titleLabel->SetRollSpeed(23);
+ titleLabel->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
+ titleLabel->SetFont(DEFAULT_VECTOR_FONT_FILENAME, 30);
+ group->Add(titleLabel);
+ /* -------------------------------------------------------------------------- */
+ if (remindLabel == nullptr)
+ {
+ remindLabel = new UILabelExt();
+ if (remindLabel == nullptr)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "remindLabel null!");
+ return nullptr;
+ }
+ }
+ remindLabel->SetPosition((HORIZONTAL_RESOLUTION - 300) / 2, 360, 300, 35);
+ remindLabel->SetStyle(STYLE_TEXT_FONT, 30);
+ remindLabel->SetStyle(STYLE_LINE_HEIGHT, 35);
+ remindLabel->SetText("数据分析中，请耐心等待结果");
+ remindLabel->SetTextColor(Color::White());
+ remindLabel->SetLineBreakMode(UILabel::LINE_BREAK_WRAP);
+ remindLabel->SetRollSpeed(23);
+ remindLabel->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
+ remindLabel->SetFont(DEFAULT_VECTOR_FONT_FILENAME, 30);
+ group->Add(remindLabel);
+ return group;
+ }
+}
\ No newline at end of file
--- /dev/null
+/***
+ * @Date: 2024-04-15 10:55:58
+ * @LastEditors: Caisking 3449750381@qq.com
+ * @LastEditTime: 2024-07-31 14:36:25
+ * @FilePath: /FD230/code/sdk/application/wearable/fd230/nativeapp/nativeui/fatigue/src/FatigueFailView.cpp
+ */
+
+#include "ui_resource_image.h"
+#include "UiConfig.h"
+#include "wearable_log.h"
+#include "uicomponents/UIComponents.h"
+#include "fatiguelevel/include/FatiguePresenter.h"
+#include "fatiguelevel/include/FatigueFailView.h"
+namespace OHOS
+{
+ static FatigueFailView *g_pFatigueFailView{nullptr};
+ static const char *BPBACKPATH = "/user/res/BPCalibration/error.bin";
+
+ FatigueFailView::FatigueFailView()
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "FatigueFailView::FatigueFailView");
+ g_pFatigueFailView = this;
+ }
+ FatigueFailView::~FatigueFailView()
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "FatigueFailView::~FatigueFailView");
+ DeInit();
+ g_pFatigueFailView = nullptr;
+ }
+ FatigueFailView *FatigueFailView::GetInstance()
+ {
+ return g_pFatigueFailView;
+ }
+ void FatigueFailView::DeInit()
+ {
+ if (group)
+ {
+ group->RemoveAll();
+ delete group;
+ group = nullptr;
+ }
+ if (error != nullptr)
+ {
+ delete error;
+ error = nullptr;
+ }
+ if (titleLable != nullptr)
+ {
+ delete titleLable;
+ titleLable = nullptr;
+ }
+
+ if (checkButton != nullptr)
+ {
+ delete checkButton;
+ checkButton = nullptr;
+ }
+ }
+ /* -------------------------------------------------------------------------- */
+ /***
+ * @description:
+ * @return 添加按键是否成功
+ */
+ bool FatigueFailView::AddButton()
+ {
+ InitLabelButton(checkButton, 124, 352, 217, 63, "errorcheckButton", "重新测量", 35);
+ checkButton->SetViewId(FAILBUTTON_FATIGUE);
+ checkButton->SetStyle(STYLE_BACKGROUND_COLOR, 0xff191919); // 设置按键颜色
+ checkButton->SetTextColor(Color::White());
+ // 设置按键监听
+ UIView::OnClickListener *clickListener = (UIView::OnClickListener *)OHOS::FatiguePresenter::GetInstance();
+ checkButton->SetOnClickListener(clickListener);
+
+ group->Add(checkButton);
+ return true;
+ }
+ /***
+ * @description:
+ * @return 初始化标签是否成功
+ */
+ bool FatigueFailView::InitLable()
+ {
+
+ InitLabel(titleLable, 87, 85, 272, 45, "titleLable", "测量失败", DEFAULT_VECTOR_FONT_FILENAME, 35);
+ /*初始化检测时间*/
+ group->Add(titleLable);
+
+ return true;
+ }
+ /***
+ * @description:
+ * @return 初始化背景是否成功
+ */
+ bool FatigueFailView::Initbackground()
+ {
+ error = new UIImageView();
+ error->SetPosition(163, 170, 140, 140);
+ error->SetSrc(BPBACKPATH);
+ group->Add(error);
+ return true;
+ }
+ /***
+ * @description:
+ * @return 是否初始化成功
+ */
+ UIViewGroup *FatigueFailView::FatigueFailInit()
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "bool FatigueFailView::InitView()");
+ group = new UIViewGroup();
+ if (group == nullptr)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "AlarmPopUpView::group null!");
+ return nullptr;
+ }
+ group->SetPosition(0, 0, HORIZONTAL_RESOLUTION, VERTICAL_RESOLUTION);
+ if (!Initbackground())
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Initbackground error!");
+ return nullptr;
+ };
+ if (!InitLable())
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "InitLable error!");
+ return nullptr;
+ };
+ if (!AddButton())
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "AddButton error!");
+ return nullptr;
+ };
+ return group;
+ }
+
+}
--- /dev/null
+/***
+ * @Date: 2024-04-15 10:55:58
+ * @LastEditors: Caisking 3449750381@qq.com
+ * @LastEditTime: 2024-07-31 14:36:25
+ * @FilePath: /FD230/code/sdk/application/wearable/fd230/nativeapp/nativeui/fatigue/src/FatigueMainView.cpp
+ */
+
+#include "common/image_cache_manager.h"
+#include "ui_resource_image.h"
+#include <ui_scroll_view.h>
+#include "components/ui_button.h"
+#include "MainViewSample.h"
+#include "components/ui_view_group.h"
+#include "DialModelSPO2.h"
+#include "DialModelHeartRate.h"
+
+#include "UiConfig.h"
+#include "uicomponents/UIComponents.h"
+#include "MainPresenterSample.h"
+
+#include "fatiguelevel/include/FatiguePresenter.h"
+#include "fatiguelevel/include/FatigueMainView.h"
+#include "wearable_log.h"
+namespace OHOS
+{
+ static FatigueMainView *g_pFatigueMainView{nullptr};
+
+ FatigueMainView::FatigueMainView()
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "FatigueMainView::FatigueMainView");
+ g_pFatigueMainView = this;
+ }
+
+ FatigueMainView::~FatigueMainView()
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "FatigueMainView::~FatigueMainView");
+ DeInit();
+ g_pFatigueMainView = nullptr;
+ }
+
+ FatigueMainView *FatigueMainView::GetInstance()
+ {
+ return g_pFatigueMainView;
+ }
+
+ void FatigueMainView::DeInit()
+ {
+
+ if (g_pFatigueMeasureView)
+ {
+ delete g_pFatigueMeasureView;
+ g_pFatigueMeasureView = nullptr;
+ }
+ if (g_pFatigueUnderMeasureView)
+ {
+ delete g_pFatigueUnderMeasureView;
+ g_pFatigueUnderMeasureView = nullptr;
+ }
+ if (g_pFatigueResultView)
+ {
+ delete g_pFatigueResultView;
+ g_pFatigueResultView = nullptr;
+ }
+ }
+
+ void FatigueMainView::OnStart()
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "FatigueMainView::OnStart");
+ View<FatiguePresenter>::OnStart();
+ SetContainerView(new UIViewGroup());
+ if (GetContainer() == nullptr)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "container_ new fail!!");
+ return;
+ }
+ container_->SetPosition(0, 0, Screen::GetInstance().GetWidth(), Screen::GetInstance().GetHeight());
+ container_->SetDraggable(true);
+ container_->SetTouchable(true);
+ container_->SetOnDragListener(presenter_);
+
+ ChangeView(MAX_FATIGUEVIEW, FATIGUEMEASUREVIEW); // 切换到第一个界面
+
+ // 增加按键监听
+ RootView::OnKeyActListener *keyactListener = (RootView::OnKeyActListener *)OHOS::FatiguePresenter::GetInstance();
+ RootView::GetInstance()->SetOnKeyActListener(keyactListener);
+ }
+ void FatigueMainView::OnSetUpView()
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "FatigueMainView::OnSetUpView");
+ View<FatiguePresenter>::OnSetUpView();
+ Draw();
+ }
+ void FatigueMainView::OnTearDownView()
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "FatigueMainView::OnTearDownView");
+ View<FatiguePresenter>::OnTearDownView();
+ return;
+ }
+
+ void FatigueMainView::OnStop()
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "FatigueMainView::OnStop");
+ View<FatiguePresenter>::OnStop();
+ if (container_ != nullptr)
+ {
+ container_->RemoveAll();
+ delete container_;
+ container_ = nullptr;
+ }
+ return;
+ }
+
+ bool FatigueMainView::ChangeFatigueMeasureView(int16_t thisView)
+ {
+ // 检查视图是否已初始化
+ if (group[thisView] == nullptr)
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "fatigueView::ChangeFatigueMeasureView");
+ g_pFatigueMeasureView = new FatigueMeasureView();
+ if (g_pFatigueMeasureView == nullptr)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "fatigueView:: new scrollView[%d] fail", thisView);
+ return false;
+ }
+ // 初始化视图并添加到视图组
+ group[thisView] = g_pFatigueMeasureView->FatigueMeasureInit();
+ container_->Add(group[thisView]);
+ }
+ return true;
+ }
+ bool FatigueMainView::ChangeFatigueUnderMeasureView(int16_t thisView)
+ {
+ // 检查视图是否已初始化
+ if (group[thisView] == nullptr)
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "fatigueView::ChangeFatigueUnderMeasureView");
+ g_pFatigueUnderMeasureView = new FatigueUnderMeasureView();
+ if (g_pFatigueUnderMeasureView == nullptr)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "fatigueView:: new scrollView[%d] fail", thisView);
+ return false;
+ }
+ // 初始化视图并添加到视图组
+ group[thisView] = g_pFatigueUnderMeasureView->FatigueUnderMeasureInit();
+ container_->Add(group[thisView]);
+ }
+ return true;
+ }
+ bool FatigueMainView::ChangeFatigueResultView(int16_t thisView)
+ {
+ // 检查视图是否已初始化
+ if (group[thisView] == nullptr)
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "fatigueView::ChangeFatigueResultView");
+ g_pFatigueResultView = new FatigueResultView();
+ if (g_pFatigueResultView == nullptr)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "fatigueView:: new scrollView[%d] fail", thisView);
+ return false;
+ }
+ // 初始化视图并添加到视图组
+ group[thisView] = g_pFatigueResultView->FatigueResultInit();
+ container_->Add(group[thisView]);
+ }
+ return true;
+ }
+ bool FatigueMainView::ChangeFatigueWearView(int16_t thisView)
+ {
+ // 检查视图是否已初始化
+ if (group[thisView] == nullptr)
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "fatigueView::ChangeFatigueWearView");
+ g_pFatigueWearView = new FatigueWearView();
+ if (g_pFatigueWearView == nullptr)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "fatigueView:: new scrollView[%d] fail", thisView);
+ return false;
+ }
+ // 初始化视图并添加到视图组
+ group[thisView] = g_pFatigueWearView->FatigueWearInit();
+ container_->Add(group[thisView]);
+ }
+ return true;
+ }
+ bool FatigueMainView::ChangeFatigueFailView(int16_t thisView)
+ {
+ // 检查视图是否已初始化
+ if (group[thisView] == nullptr)
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "fatigueView::ChangeFatigueResultView");
+ g_pFatigueFailView = new FatigueFailView();
+ if (g_pFatigueFailView == nullptr)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "fatigueView:: new scrollView[%d] fail", thisView);
+ return false;
+ }
+ // 初始化视图并添加到视图组
+ group[thisView] = g_pFatigueFailView->FatigueFailInit();
+ container_->Add(group[thisView]);
+ }
+ return true;
+ }
+ bool FatigueMainView::ChangeFatigueAnalysisView(int16_t thisView)
+ {
+ // 检查视图是否已初始化
+ if (group[thisView] == nullptr)
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "fatigueView::ChangeFatigueResultView");
+ g_pFatigueAnalysisView = new FatigueAnalysisView();
+ if (g_pFatigueAnalysisView == nullptr)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "fatigueView:: new scrollView[%d] fail", thisView);
+ return false;
+ }
+ // 初始化视图并添加到视图组
+ group[thisView] = g_pFatigueAnalysisView->FatigueAnalysisInit();
+ container_->Add(group[thisView]);
+ }
+ return true;
+ }
+
+ /**
+ * 视图映射结构体 - 将视图ID映射到对应的视图切换函数
+ */
+ struct FatigueViewMapper
+ {
+ const int16_t viewId; // 视图ID
+ bool (FatigueMainView::*func)(int16_t); // 对应的视图切换函数指针
+ };
+
+ static const FatigueViewMapper ViewMapper[] = {
+ {FATIGUEMEASUREVIEW, &FatigueMainView::ChangeFatigueMeasureView},
+ {FATIGUEUNDERMEASUREVIEW, &FatigueMainView::ChangeFatigueUnderMeasureView},
+ {FATIGUEANALYSISEVIEW, &FatigueMainView::ChangeFatigueAnalysisView},
+ {FATIGUERESULTVIEW, &FatigueMainView::ChangeFatigueResultView},
+ {FATIGUEWEARVIEW, &FatigueMainView::ChangeFatigueWearView},
+ {FATIGUEFAILVIEW, &FatigueMainView::ChangeFatigueFailView},
+ };
+
+ bool FatigueMainView::ClickFunc(int16_t interface)
+ {
+ 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 FatigueMainView::ChangeView(int16_t hideView, int16_t showView)
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "FatigueMainView::ChangeView");
+ if (hideView > MAX_FATIGUEVIEW)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "FatigueMainView:: SystemViewId Overstep ones bounds");
+ return;
+ }
+ if (hideView != MAX_FATIGUEVIEW)
+ {
+ if (group[hideView] == nullptr)
+ {
+ return;
+ }
+ group[hideView]->SetVisible(false);
+ }
+ ClickFunc(showView);
+ group[showView]->SetVisible(true);
+ container_->Invalidate();
+ }
+
+}
--- /dev/null
+/***
+ * @Date: 2024-04-15 10:55:58
+ * @LastEditors: Caisking 3449750381@qq.com
+ * @LastEditTime: 2024-07-31 14:36:25
+ * @FilePath: /FD230/code/sdk/application/wearable/fd230/nativeapp/nativeui/fatiguelevel/src/FatigueMeasureView.cpp
+ */
+
+#include "ui_resource_image.h"
+#include "UiConfig.h"
+#include "wearable_log.h"
+#include "uicomponents/UIComponents.h"
+#include "fatiguelevel/include/FatiguePresenter.h"
+#include "fatiguelevel/include/FatigueMeasureView.h"
+namespace OHOS
+{
+ static FatigueMeasureView *g_pFatigueMeasureView{nullptr};
+ static const char *BPBACKPATH = "/user/res/BPCalibration/J1.bin";
+
+ FatigueMeasureView::FatigueMeasureView()
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "FatigueMeasureView::FatigueMeasureView");
+ g_pFatigueMeasureView = this;
+ }
+ FatigueMeasureView::~FatigueMeasureView()
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "FatigueMeasureView::~FatigueMeasureView");
+ DeInit();
+ g_pFatigueMeasureView = nullptr;
+ }
+ FatigueMeasureView *FatigueMeasureView::GetInstance()
+ {
+ return g_pFatigueMeasureView;
+ }
+ void FatigueMeasureView::DeInit()
+ {
+ if (group)
+ {
+ group->RemoveAll();
+ delete group;
+ group = nullptr;
+ }
+ if (error != nullptr)
+ {
+ delete error;
+ error = nullptr;
+ }
+ if (titleLable != nullptr)
+ {
+ delete titleLable;
+ titleLable = nullptr;
+ }
+ if (resultremindLable != nullptr)
+ {
+ delete resultremindLable;
+ resultremindLable = nullptr;
+ }
+ if (checkButton != nullptr)
+ {
+ delete checkButton;
+ checkButton = nullptr;
+ }
+ }
+ /* -------------------------------------------------------------------------- */
+ /***
+ * @description:
+ * @return 添加按键是否成功
+ */
+ bool FatigueMeasureView::AddButton()
+ {
+ InitLabelButton(checkButton, 124, 352, 217, 63, "errorcheckButton", "测量", 35);
+ checkButton->SetViewId(STARTBUTTON_FATIGUE);
+ checkButton->SetStyle(STYLE_BACKGROUND_COLOR, 0xff00cbf0); // 设置按键颜色
+ checkButton->SetTextColor(Color::White());
+ // 设置按键监听
+ UIView::OnClickListener *clickListener = (UIView::OnClickListener *)OHOS::FatiguePresenter::GetInstance();
+ checkButton->SetOnClickListener(clickListener);
+
+ group->Add(checkButton);
+ return true;
+ }
+ /***
+ * @description:
+ * @return 初始化标签是否成功
+ */
+ bool FatigueMeasureView::InitLable()
+ {
+
+ InitLabel(titleLable, 188, 30, 95, 45, "titleLable", "疲劳度", DEFAULT_VECTOR_FONT_FILENAME, 35);
+ InitLabel(resultremindLable, 68, 239, 337, 100, "resultremindLable", "---", DEFAULT_VECTOR_FONT_FILENAME, 100);
+ resultremindLable->SetLineBreakMode(UILabel::LINE_BREAK_WRAP);
+ resultremindLable->SetTextColor(Color::White());
+ /*初始化检测时间*/
+ group->Add(titleLable);
+ group->Add(resultremindLable);
+
+ return true;
+ }
+ /***
+ * @description:
+ * @return 初始化背景是否成功
+ */
+ bool FatigueMeasureView::Initbackground()
+ {
+ error = new UIImageView();
+ error->SetPosition(140, 65, 111, 118);
+ error->SetSrc(BPBACKPATH);
+ group->Add(error);
+ return true;
+ }
+ /***
+ * @description:
+ * @return 是否初始化成功
+ */
+ UIViewGroup *FatigueMeasureView::FatigueMeasureInit()
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "bool FatigueMeasureView::InitView()");
+ group = new UIViewGroup();
+ if (group == nullptr)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "AlarmPopUpView::group null!");
+ return nullptr;
+ }
+ group->SetPosition(0, 0, HORIZONTAL_RESOLUTION, VERTICAL_RESOLUTION);
+ if (!Initbackground())
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Initbackground error!");
+ return nullptr;
+ };
+ if (!InitLable())
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "InitLable error!");
+ return nullptr;
+ };
+ if (!AddButton())
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "AddButton error!");
+ return nullptr;
+ };
+ return group;
+ }
+
+}
--- /dev/null
+#include "fatiguelevel/include/FatigueModel.h"
+#include "fatiguelevel/include/FatiguePresenter.h"
+#include "fatiguelevel/include/FatigueMainView.h"
+#include "fatiguelevel/include/FatigueAnalysisView.h"
+
+
+
+
+#include "wearable_log.h"
+#include <cmsis_os.h>
+#include <cmsis_os2.h>
+#include <service/graphic_service.h>
+
+#include "AppViewIDs.h"
+#include "ConfigModel.h"
+#include "NativeAbility.h"
+
+#include "battery_hal.h"
+#include "custom_utils.h"
+#include "ppg_service.h"
+
+namespace OHOS
+{
+/**
+ * @brief Constructor for the FatigueModel class.
+ */
+
+#define FATIGUE_MEASURE_TIME_MAX 30
+#define FATIGUE_ANALYSIS_TIME_MAX 5
+
+ // 声明定时器变量
+ static osTimerId_t g_timer = nullptr;
+ static int Time = 30;
+ static FatigueState statefalg = FatigueState::FATIGUE_MEASURE;
+
+ FatigueModel::FatigueModel() {}
+ FatigueModel::~FatigueModel() {}
+ FatigueModel *FatigueModel::GetInstance(void)
+ {
+ static FatigueModel instance;
+ return &instance;
+ }
+
+
+ // 管理当前状态
+ void FatigueModel::Fatigue_SetState(FatigueState state) { current_state = state; }
+ FatigueState FatigueModel::GetCurrentState() { return current_state; }
+
+ // 进行传感器、定时器等控制
+ void FatigueModel::Fatigue_Control(FatigueState state)
+ {
+ if (state == current_state)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,"Fatigue_Control: Already in current state");
+ return;
+ }
+ switch (state)
+ {
+ case FatigueState::FATIGUE_NORMAL:
+ {
+ /*
+ 关闭定时器
+ 关闭传感器
+ 关闭常亮
+ */
+ Fatigue_StopTimer();
+ ScreenAlwaysOnCtr(CANCEL_SCREEN_ALWAYS_ON);
+ Time = FATIGUE_MEASURE_TIME_MAX;
+ break;
+ }
+ case FatigueState::FATIGUE_MEASURE:
+ {
+ /*
+ 开启定时器
+ 开启传感器
+ 开启常亮
+ */
+ Fatigue_StartTimer();
+ ScreenAlwaysOnCtr(OPEN_SCREEN_ALWAYS_ON); // 后期 周期被动状态 需要做区别
+
+ if (Time != FATIGUE_MEASURE_TIME_MAX)
+ Time = FATIGUE_MEASURE_TIME_MAX; // 重置时间
+
+ break;
+ }
+ case FatigueState::FATIGUE_ANALYSIS:
+ {
+ /*
+ 开启定时器
+ 开启传感器
+ 开启常亮
+ */
+ Fatigue_StartTimer();
+ ScreenAlwaysOnCtr(OPEN_SCREEN_ALWAYS_ON); // 后期 周期被动状态 需要做区别
+
+ if (Time != FATIGUE_ANALYSIS_TIME_MAX)
+ Time = FATIGUE_ANALYSIS_TIME_MAX; // 重置时间
+
+ break;
+ }
+
+ default:
+ /*未知状态，全部状态重置*/
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Fatigue_Control: Invalid state");
+ Fatigue_SetState(FatigueState::FATIGUE_NORMAL);
+ Fatigue_StopTimer();
+ Time = FATIGUE_MEASURE_TIME_MAX;
+ return;
+ }
+ // 更新状态
+ Fatigue_SetState(state);
+ }
+ ///////////////////////////////////////////////////////////////////////////////////////
+
+ /*定时器到期时的处理*/
+ static void Fatigue_TimerCallbackProc(int data)
+ {
+
+ // 倒计时
+ Time--;
+ // 提前检查无效时间
+ if (Time < 0)
+ {
+ FatigueModel::GetInstance()->Fatigue_StopTimer();
+ FatigueModel::GetInstance()->Fatigue_SetState(FatigueState::FATIGUE_NORMAL);
+ if (statefalg == FatigueState::FATIGUE_ANALYSIS) //在分析中
+ {
+ FatigueMainView::GetInstance()->ChangeView(FATIGUEANALYSISEVIEW,FATIGUERESULTVIEW);
+ FatigueAnalysisView::GetInstance()->startorstopAnalysisAni(false);
+ statefalg = FatigueState::FATIGUE_MEASURE;
+ }
+ else if(statefalg == FatigueState::FATIGUE_MEASURE)//在检测中
+ {
+ // 测量成功
+ FatigueModel::GetInstance()->Fatigue_Control(FatigueState::FATIGUE_ANALYSIS);
+ FatigueMainView::GetInstance()->ChangeView(FATIGUEUNDERMEASUREVIEW, FATIGUEANALYSISEVIEW);
+ FatigueAnalysisView::GetInstance()->startorstopAnalysisAni(true);
+ statefalg = FatigueState::FATIGUE_ANALYSIS;
+
+
+ // 测量失败
+
+ }
+ return;
+ }
+
+ FatigueState current_state_time = FatigueModel::GetInstance()->GetCurrentState();
+ // 根据状态处理
+ switch (current_state_time)
+ {
+ case FatigueState::FATIGUE_NORMAL:
+ FatigueModel::GetInstance()->Fatigue_StopTimer();
+ FatigueModel::GetInstance()->Fatigue_SetState(FatigueState::FATIGUE_NORMAL);
+ return;
+
+ case FatigueState::FATIGUE_MEASURE:
+ {
+ break;
+ }
+ case FatigueState::FATIGUE_ANALYSIS:
+ {
+ break;
+ }
+
+ default:
+ FatigueModel::GetInstance()->Fatigue_StopTimer();
+ // 显示错误界面提示
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "current_state is error!!");
+ return;
+ }
+ }
+
+ /*
+ * @brief 回调函数
+ */
+ static void Fatigue_TimerCallback(int data)
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "Fatigue_TimerCallback %d", data);
+ GraphicService::GetInstance()->PostGraphicEvent(
+ std::bind(Fatigue_TimerCallbackProc, data));
+ }
+
+ /*
+ * @brief 开启定时器函数
+ * @param interval 时间间隔，单位ms
+ */
+ void FatigueModel::Fatigue_StartTimer(uint32_t interval)
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "FatigueModel::Fatigue_StartTimer");
+ /* -------------------------- 1.检查定时器是否已经存在，如果存在则返回
+ * ------------------------- */
+ if (g_timer != nullptr)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Timer already exists!!");
+ return;
+ }
+
+ /* --------------------------------- 2.创建定时器
+ * -------------------------------- */
+ g_timer = osTimerNew((osTimerFunc_t)Fatigue_TimerCallback, osTimerPeriodic,
+ nullptr, nullptr);
+ // 检查定时器创建是否成功
+ if (g_timer == nullptr)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Timer create failed!!");
+ return;
+ }
+
+ /* ----------------------------- 3.将毫秒转换为系统时钟节拍数
+ * ---------------------------- */
+ int tick = osMs2Tick(interval);
+
+ /* --------------------------------- 4.启动定时器
+ * -------------------------------- */
+ osStatus_t ret = osTimerStart(g_timer, tick);
+ /* -------------------- 5.检查定时器启动是否成功,如果启动失败，删除定时器并置为
+ * nullptr -------------------- */
+ if (ret != osOK)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "osTimerDelete failed, ret = %lx!!",
+ ret);
+ if (g_timer != nullptr)
+ {
+ ret = osTimerDelete(g_timer);
+ }
+ g_timer = nullptr;
+ return;
+ }
+ }
+ /*
+ * @brief 停止定时器
+ */
+ void FatigueModel::Fatigue_StopTimer(void)
+ {
+ // 检查定时器是否存在
+ if (g_timer != nullptr)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "FatigueModel::Fatigue_StopTimer");
+ osTimerStop(g_timer);
+ // 删除定时器并置为 nullptr
+ osStatus_t ret = osTimerDelete(g_timer);
+ if (ret != osOK)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP,
+ "osTimerDelete failed, ret = %lx!!", ret);
+ }
+ g_timer = nullptr;
+ }
+ }
+
+} // namespace OHOS
--- /dev/null
+/*
+ * Copyright (c) CompanyNameMagicTag 2021-2021. All rights reserved.
+ * Description: bloodOxygen view
+ * Author:
+ * Create: 2021-08-01
+ */
+
+#include "fatiguelevel/include/FatiguePresenter.h"
+#include "common/task_manager.h"
+
+#include "components/ui_label.h"
+#include "components/ui_label_ext.h"
+
+#include "ChangeSliceListener.h"
+#include "broadcast_service.h"
+#include <fstream>
+#include "iostream"
+#include <sstream>
+#include <string>
+#include <cstdlib>
+#include <ctime>
+#include "wearable_log.h"
+#include "cmsis_os.h"
+#include "securec.h"
+#include "broadcast_service.h"
+#include "graphic_service.h"
+#include <chrono>
+#include <thread>
+#include <sys/time.h>
+
+#include "ppg_service.h"
+#include "displaybrightness/include/DisplayBrightnessModel.h"
+#include "power_display_service.h"
+#include "custom_utils.h"
+#include "cywee_service.h"
+#include "battery_hal.h"
+
+#include "gfx_utils/mem_check.h"
+#include "map"
+
+#define FatigueKEYABLE 1
+namespace OHOS
+{
+ static constexpr uint16_t PROGRESS_VALUE_MIN = 0;
+ static constexpr uint16_t PROGRESS_VALUE_MAX = 10;
+ static int16_t passflag = 0; // 第几次校准成功标志位
+
+ static FatiguePresenter *g_pFatiguePresenter;
+ /* -------------------------------------------------------------------------- */
+ FatiguePresenter::FatiguePresenter()
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "FatiguePresenter::new FatiguePresenter");
+ g_pFatiguePresenter = this;
+#ifdef MEM_CHECK
+ MemCheck::GetInstance()->EnableLeakCheck(true);
+#endif
+ }
+ FatiguePresenter::~FatiguePresenter()
+ {
+ g_pFatiguePresenter = nullptr;
+#ifdef MEM_CHECK
+ MemCheck::GetInstance()->EnableLeakCheck(false);
+#endif
+ }
+ FatiguePresenter *FatiguePresenter::GetInstance()
+ {
+ return g_pFatiguePresenter;
+ }
+ void FatiguePresenter::OnStart()
+ {
+ Presenter<FatigueMainView>::OnStart();
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "FatiguePresenter::On Start ");
+ }
+ void FatiguePresenter::OnPause(void) {}
+
+ void FatiguePresenter::OnResume(void) {}
+
+ void FatiguePresenter::OnStop(void)
+ {
+ }
+
+ bool FatiguePresenter::OnDrag(UIView &view, const DragEvent &event)
+ {
+ return true;
+ }
+ bool FatiguePresenter::OnDragEnd(UIView &view, const DragEvent &event)
+ {
+ if (event.GetDragDirection() == DragEvent::DIRECTION_LEFT_TO_RIGHT)
+ {
+ // NativeAbility::GetInstance().ChangeSlice(VIEW_APPLIST);
+ NativeAbility::GetInstance().Back(TransitionType::TRANSITION_BACK_TO_HEXAGONS);
+ return true;
+ }
+ return false;
+ }
+ bool FatiguePresenter::OnKeyAct(UIView &view, const KeyEvent &event)
+ {
+ unsigned short keyID = event.GetKeyId();
+ unsigned short keyState = event.GetState();
+ // 如果是power键,且是亮屏状态，按键释放就返回上一级
+ if (keyID == static_cast<uint16_t>(ZliteKeyCode::ZLITE_KEY_POWER) &&
+ keyState == 1 && uapi_get_screen_state() == 0)
+ {
+ // NativeAbility::GetInstance().ChangeSlice(VIEW_APPLIST);
+ NativeAbility::GetInstance().Back(TransitionType::TRANSITION_BACK_TO_HEXAGONS);
+ }
+ return true;
+ }
+
+ bool FatiguePresenter::OnClick(UIView &view, const ClickEvent &event)
+ {
+
+ if (strcmp(view.GetViewId(), STARTBUTTON_FATIGUE) == 0)
+ {
+ FatigueModel::GetInstance()->Fatigue_Control(FatigueState::FATIGUE_MEASURE);
+ FatigueMainView::GetInstance()->ChangeView(FATIGUEMEASUREVIEW, FATIGUEUNDERMEASUREVIEW);
+ }
+
+ return true;
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "FatiguePresenter::OnClick");
+ }
+
+}
\ No newline at end of file
--- /dev/null
+/***
+ * @Date: 2024-04-15 10:55:58
+ * @LastEditors: Caisking 3449750381@qq.com
+ * @LastEditTime: 2024-07-31 14:36:25
+ * @FilePath: /FD230/code/sdk/application/wearable/fd230/nativeapp/nativeui/fatigue/src/FatigueResultView.cpp
+ */
+
+#include "ui_resource_image.h"
+#include "UiConfig.h"
+#include "wearable_log.h"
+#include "uicomponents/UIComponents.h"
+#include "fatiguelevel/include/FatiguePresenter.h"
+#include "fatiguelevel/include/FatigueResultView.h"
+namespace OHOS
+{
+ static FatigueResultView *g_pFatigueResultView{nullptr};
+ static const char *BPBACKPATH = "/user/res/BPCalibration/J1.bin";
+
+ FatigueResultView::FatigueResultView()
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "FatigueResultView::FatigueResultView");
+ g_pFatigueResultView = this;
+ }
+ FatigueResultView::~FatigueResultView()
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "FatigueResultView::~FatigueResultView");
+ DeInit();
+ g_pFatigueResultView = nullptr;
+ }
+ FatigueResultView *FatigueResultView::GetInstance()
+ {
+ return g_pFatigueResultView;
+ }
+ void FatigueResultView::DeInit()
+ {
+ if (group)
+ {
+ group->RemoveAll();
+ delete group;
+ group = nullptr;
+ }
+ if (error != nullptr)
+ {
+ delete error;
+ error = nullptr;
+ }
+ if (titleLable != nullptr)
+ {
+ delete titleLable;
+ titleLable = nullptr;
+ }
+ if (resultremindLable != nullptr)
+ {
+ delete resultremindLable;
+ resultremindLable = nullptr;
+ }
+ if (resultLable != nullptr)
+ {
+ delete resultLable;
+ resultLable = nullptr;
+ }
+
+ }
+ /* -------------------------------------------------------------------------- */
+ /***
+ * @description:
+ * @return 初始化标签是否成功
+ */
+ bool FatigueResultView::InitLable()
+ {
+
+ InitLabel(titleLable, 200, 30, 70, 45, "titleLable", "疲劳度", DEFAULT_VECTOR_FONT_FILENAME, 35);
+ InitLabel(resultremindLable, 68, 239, 337, 100, "resultremindLable", "30", DEFAULT_VECTOR_FONT_FILENAME, 100);
+ resultremindLable->SetLineBreakMode(UILabel::LINE_BREAK_WRAP);
+ resultremindLable->SetTextColor(Color::White());
+ InitLabel(resultLable, 200, 362, 70, 45, "resultremindLable", "正常", DEFAULT_VECTOR_FONT_FILENAME, 35);
+ /*初始化检测时间*/
+ group->Add(titleLable);
+ group->Add(resultremindLable);
+ group->Add(resultLable);
+
+
+ return true;
+ }
+ /***
+ * @description:
+ * @return 初始化背景是否成功
+ */
+ bool FatigueResultView::Initbackground()
+ {
+ error = new UIImageView();
+ error->SetPosition(140, 65, 111, 118);
+ error->SetSrc(BPBACKPATH);
+ group->Add(error);
+ return true;
+ }
+ /***
+ * @description:
+ * @return 是否初始化成功
+ */
+ UIViewGroup *FatigueResultView::FatigueResultInit()
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "bool FatigueResultView::InitView()");
+ group = new UIViewGroup();
+ if (group == nullptr)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "AlarmPopUpView::group null!");
+ return nullptr;
+ }
+ group->SetPosition(0, 0, HORIZONTAL_RESOLUTION, VERTICAL_RESOLUTION);
+ if (!Initbackground())
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Initbackground error!");
+ return nullptr;
+ };
+ if (!InitLable())
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "InitLable error!");
+ return nullptr;
+ };
+ return group;
+ }
+
+}
--- /dev/null
+/***
+ * @Date: 2024-04-15 10:55:58
+ * @LastEditors: Caisking 3449750381@qq.com
+ * @LastEditTime: 2024-07-31 14:36:25
+ * @FilePath: /FD230/code/sdk/application/wearable/fd230/nativeapp/nativeui/fatigue/src/FatigueUnderMeasureView.cpp
+ */
+
+#include "ui_resource_image.h"
+#include "UiConfig.h"
+#include "wearable_log.h"
+#include "uicomponents/UIComponents.h"
+#include "fatiguelevel/include/FatiguePresenter.h"
+#include "fatiguelevel/include/FatigueUnderMeasureView.h"
+namespace OHOS
+{
+ static FatigueUnderMeasureView *g_pFatigueUnderMeasureView{nullptr};
+ static const char *BPBACKPATH = "/user/res/BPCalibration/J1.bin";
+
+ FatigueUnderMeasureView::FatigueUnderMeasureView()
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "FatigueUnderMeasureView::FatigueUnderMeasureView");
+ g_pFatigueUnderMeasureView = this;
+ }
+ FatigueUnderMeasureView::~FatigueUnderMeasureView()
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "FatigueUnderMeasureView::~FatigueUnderMeasureView");
+ DeInit();
+ g_pFatigueUnderMeasureView = nullptr;
+ }
+ FatigueUnderMeasureView *FatigueUnderMeasureView::GetInstance()
+ {
+ return g_pFatigueUnderMeasureView;
+ }
+ void FatigueUnderMeasureView::DeInit()
+ {
+ if (group)
+ {
+ group->RemoveAll();
+ delete group;
+ group = nullptr;
+ }
+ if (error != nullptr)
+ {
+ delete error;
+ error = nullptr;
+ }
+ if (titleLable != nullptr)
+ {
+ delete titleLable;
+ titleLable = nullptr;
+ }
+ if (resultremindLable != nullptr)
+ {
+ delete resultremindLable;
+ resultremindLable = nullptr;
+ }
+ if (checkButton != nullptr)
+ {
+ delete checkButton;
+ checkButton = nullptr;
+ }
+ }
+ /* -------------------------------------------------------------------------- */
+ /***
+ * @description:
+ * @return 添加按键是否成功
+ */
+ bool FatigueUnderMeasureView::AddButton()
+ {
+ InitLabelButton(checkButton, 124, 352, 217, 63, "errorcheckButton", "测量中", 35);
+ checkButton->SetViewId(UNDERBUTTON_FATIGUE);
+ checkButton->SetStyle(STYLE_BACKGROUND_COLOR, 0xff00cbf0); // 设置按键颜色
+ checkButton->SetTextColor(Color::White());
+ // 设置按键监听
+ UIView::OnClickListener *clickListener = (UIView::OnClickListener *)OHOS::FatiguePresenter::GetInstance();
+ checkButton->SetOnClickListener(clickListener);
+
+ group->Add(checkButton);
+ return true;
+ }
+ /***
+ * @description:
+ * @return 初始化标签是否成功
+ */
+ bool FatigueUnderMeasureView::InitLable()
+ {
+
+ InitLabel(titleLable, 188, 30, 95, 45, "titleLable", "疲劳度", DEFAULT_VECTOR_FONT_FILENAME, 35);
+ InitLabel(resultremindLable, 68, 239, 337, 100, "resultremindLable", "---", DEFAULT_VECTOR_FONT_FILENAME, 100);
+ resultremindLable->SetLineBreakMode(UILabel::LINE_BREAK_WRAP);
+ resultremindLable->SetTextColor(Color::White());
+ /*初始化检测时间*/
+ group->Add(titleLable);
+ group->Add(resultremindLable);
+
+ return true;
+ }
+ /***
+ * @description:
+ * @return 初始化背景是否成功
+ */
+ bool FatigueUnderMeasureView::Initbackground()
+ {
+ error = new UIImageView();
+ error->SetPosition(140, 65, 111, 118);
+ error->SetSrc(BPBACKPATH);
+ group->Add(error);
+ return true;
+ }
+ /***
+ * @description:
+ * @return 是否初始化成功
+ */
+ UIViewGroup *FatigueUnderMeasureView::FatigueUnderMeasureInit()
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "bool FatigueUnderMeasureView::InitView()");
+ group = new UIViewGroup();
+ if (group == nullptr)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "AlarmPopUpView::group null!");
+ return nullptr;
+ }
+ group->SetPosition(0, 0, HORIZONTAL_RESOLUTION, VERTICAL_RESOLUTION);
+ if (!Initbackground())
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Initbackground error!");
+ return nullptr;
+ };
+ if (!InitLable())
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "InitLable error!");
+ return nullptr;
+ };
+ if (!AddButton())
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "AddButton error!");
+ return nullptr;
+ };
+ return group;
+ }
+
+}
--- /dev/null
+/***
+ * @Date: 2024-04-15 10:55:58
+ * @LastEditors: Caisking 3449750381@qq.com
+ * @LastEditTime: 2024-07-31 14:36:25
+ * @FilePath: /FD230/code/sdk/application/wearable/fd230/nativeapp/nativeui/fatigue/src/FatigueWearView.cpp
+ */
+
+#include "ui_resource_image.h"
+#include "UiConfig.h"
+#include "wearable_log.h"
+#include "uicomponents/UIComponents.h"
+#include "fatiguelevel/include/FatiguePresenter.h"
+#include "fatiguelevel/include/FatigueWearView.h"
+namespace OHOS
+{
+ static FatigueWearView *g_pFatigueWearView{nullptr};
+ static const char *BPBACKPATH = "/user/res/BPCalibration/error.bin";
+
+ FatigueWearView::FatigueWearView()
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "FatigueWearView::FatigueWearView");
+ g_pFatigueWearView = this;
+ }
+ FatigueWearView::~FatigueWearView()
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "FatigueWearView::~FatigueWearView");
+ DeInit();
+ g_pFatigueWearView = nullptr;
+ }
+ FatigueWearView *FatigueWearView::GetInstance()
+ {
+ return g_pFatigueWearView;
+ }
+ void FatigueWearView::DeInit()
+ {
+ if (group)
+ {
+ group->RemoveAll();
+ delete group;
+ group = nullptr;
+ }
+ if (error != nullptr)
+ {
+ delete error;
+ error = nullptr;
+ }
+ if (titleLable != nullptr)
+ {
+ delete titleLable;
+ titleLable = nullptr;
+ }
+ if (checkButton != nullptr)
+ {
+ delete checkButton;
+ checkButton = nullptr;
+ }
+ }
+ /* -------------------------------------------------------------------------- */
+ /***
+ * @description:
+ * @return 添加按键是否成功
+ */
+ bool FatigueWearView::AddButton()
+ {
+ InitLabelButton(checkButton, 124, 352, 217, 63, "errorcheckButton", "重新测量", 35);
+ checkButton->SetViewId(WEARBUTTON_FITIGUE);
+ checkButton->SetStyle(STYLE_BACKGROUND_COLOR, 0xff191919); // 设置按键颜色
+ checkButton->SetTextColor(Color::White());
+ // 设置按键监听
+ UIView::OnClickListener *clickListener = (UIView::OnClickListener *)OHOS::FatiguePresenter::GetInstance();
+ checkButton->SetOnClickListener(clickListener);
+
+ group->Add(checkButton);
+ return true;
+ }
+ /***
+ * @description:
+ * @return 初始化标签是否成功
+ */
+ bool FatigueWearView::InitLable()
+ {
+
+ InitLabel(titleLable, 87, 85, 272, 45, "titleLable", "请正确佩戴手表检测", DEFAULT_VECTOR_FONT_FILENAME, 35);
+ /*初始化检测时间*/
+ group->Add(titleLable);
+
+ return true;
+ }
+ /***
+ * @description:
+ * @return 初始化背景是否成功
+ */
+ bool FatigueWearView::Initbackground()
+ {
+ error = new UIImageView();
+ error->SetPosition(163, 170, 140, 140);
+ error->SetSrc(BPBACKPATH);
+ group->Add(error);
+ return true;
+ }
+ /***
+ * @description:
+ * @return 是否初始化成功
+ */
+ UIViewGroup *FatigueWearView::FatigueWearInit()
+ {
+ WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "bool FatigueWearView::InitView()");
+ group = new UIViewGroup();
+ if (group == nullptr)
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "AlarmPopUpView::group null!");
+ return nullptr;
+ }
+ group->SetPosition(0, 0, HORIZONTAL_RESOLUTION, VERTICAL_RESOLUTION);
+ if (!Initbackground())
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "Initbackground error!");
+ return nullptr;
+ };
+ if (!InitLable())
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "InitLable error!");
+ return nullptr;
+ };
+ if (!AddButton())
+ {
+ WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "AddButton error!");
+ return nullptr;
+ };
+ return group;
+ }
+
+}
namespace OHOS
{
- class StressView;
- class StressPresenter : public Presenter<StressView>,
+ class StressMainView;
+ class StressPresenter : public Presenter<StressMainView>,
public UIView::OnClickListener,
public RootView::OnKeyActListener,
public UIView::OnDragListener
}
void StressPresenter::OnStart()
{
- Presenter<StressView>::OnStart();
+ Presenter<StressMainView>::OnStart();
WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "StressPresenter::On Start ");
}
void StressPresenter::OnPause(void) {}
projects / mirrors / FD230.git / commitdiff