1774 lines
68 KiB
C++
1774 lines
68 KiB
C++
#include "TjdUiAppSportPage.h"
|
||
#include "TjdUiAppSportDrawGuiAPI.h"
|
||
#include "TjdUiAppSportPresenter.h"
|
||
#include "TjdUiAppSportView.h"
|
||
#include "TjdUiImageIds.h"
|
||
#include "TjdUiMultiLanguageExt.h"
|
||
#include "TjdUiUtils.h"
|
||
#include "common/image_cache_manager.h"
|
||
#include "debug_print.h"
|
||
#include "graphic_math.h"
|
||
#include "graphic_service.h"
|
||
#include "motor.h"
|
||
#include "notification_manager.h"
|
||
#include "service_sport.h"
|
||
#include "sql_fit.h"
|
||
#include "sql_setting.h"
|
||
#include "sys_config.h"
|
||
#include <iomanip>
|
||
#include <sstream>
|
||
#include <stdio.h>
|
||
|
||
#define ENABLE_PRINT_INFO 1
|
||
#if ENABLE_PRINT_INFO
|
||
#define static_print_info(...) sys_ui_log_i(__VA_ARGS__) // 一般信息打印宏控制
|
||
#define static_print_warn(...) sys_ui_log_w(__VA_ARGS__) // 警告信息打印一般常开
|
||
#define static_print_error(...) sys_ui_log_e(__VA_ARGS__) // 错误信息打印一般常开
|
||
#define static_print_debug(...) sys_ui_log_d(__VA_ARGS__) // 调试信息打印
|
||
#else
|
||
#define static_print_info(...)
|
||
#define static_print_warn(...)
|
||
#define static_print_error(...)
|
||
#define static_print_debug(...)
|
||
#endif
|
||
|
||
#define SPORT_IMAGE_BIN_PATH TJD_IMAGE_PATH "img_sport.bin"
|
||
#define CONFIRM_CANCEL_RES_BIN_PATH TJD_IMAGE_PATH "img_confirm_cancel.bin"
|
||
|
||
using namespace OHOS;
|
||
|
||
namespace TJD {
|
||
// clang-format off
|
||
static OHOS::GraphicTimer *popupTimer_ = nullptr; // 弹窗定时器
|
||
static OHOS::GraphicTimer *finishTimer_ = nullptr; // 弹窗定时器
|
||
static SportGoalSelectView *g_pv_SportGoalSelectView = nullptr;
|
||
static CommonViewGoalPage *g_pv_CommonViewGoalPage = nullptr;
|
||
static RemindGoalListView *g_pv_RemindGoalListView = nullptr;
|
||
static DistnaceGoalSelectView *g_pv_DistnaceGoalSelectView = nullptr;
|
||
static CaloriesGoalSelectView *g_pv_CaloriesGoalSelectView = nullptr;
|
||
uint8_t DistanceRemindPickView::curSelectDistanceIndex = PER_1000_METERS_INDEX;
|
||
uint8_t TimeRemindPickView::curSelectTimeIndex = PER_THIRTY_MIN_INDEX;
|
||
uint8_t CommonViewGoalPage::CurSelectGoalView = MAX_SELECT_VIEW_INDEX;
|
||
static int16_t HorizontalCenter(int16_t width) { return (OHOS::HORIZONTAL_RESOLUTION - width) / 2; }
|
||
|
||
#pragma region 运动设置主界面（运动目标页）
|
||
static const char *distUiPickerData[] = {
|
||
"500m", "1000m", "1500m", "2000m", "2500m", "3000m", "3500m", "4000m",
|
||
"4500m", "5000m", "5500m", "6000m", "6500m", "7000m", "7500m", "8000m",
|
||
"8500m", "9000m", "9500m", "10000m", "10500m", "11000m", "11500m", "12000m",
|
||
"12500m", "13000m", "13500m", "14000m", "14500m", "15000m"
|
||
};
|
||
|
||
static const char *caloriesUiPickerData[] = {
|
||
"50", "100", "150", "200", "250", "300", "350", "400", "450", "500", "550", "600", "650", "700",
|
||
"750", "800", "850", "900", "950", "1000", "1050", "1100", "1150", "1200", "1250", "1300", "1350", "1400",
|
||
"1450", "1500", "1550", "1600", "1650", "1700", "1750", "1800", "1850", "1900", "1950", "2000",
|
||
};
|
||
|
||
// clang-format off
|
||
GoalSelectViewInfo g_pv_CommonViewItemInfo[][2] = {
|
||
{{static_cast<GoalSelectView>(GOAL_SELECT_ITEM), IMG_SPORT_INDOOR_DIS, STR_ID_209, STR_ID_596, "distItemGoals"},
|
||
{static_cast<GoalSelectView>(REMIND_SELECT_ITEM), IMG_SPORT_ICON_REMIND, STR_ID_229, STR_ID_595,
|
||
"distItemReminds"}},
|
||
|
||
{{static_cast<GoalSelectView>(GOAL_SELECT_ITEM), IMG_SPORT_INDOOR_TIME, STR_ID_594, STR_ID_597, "timeItemGoals"},//时间
|
||
{static_cast<GoalSelectView>(REMIND_SELECT_ITEM), IMG_SPORT_ICON_REMIND, STR_ID_229, STR_ID_595,
|
||
"timeItemReminds"}},
|
||
|
||
{{static_cast<GoalSelectView>(GOAL_SELECT_ITEM), IMG_SPORT_INDOOR_KCAL, STR_ID_201, STR_ID_598, "CaloriesItemGoals"},
|
||
{static_cast<GoalSelectView>(REMIND_SELECT_ITEM), IMG_SPORT_ICON_REMIND, STR_ID_229, STR_ID_595,
|
||
"CaloriesItemReminds"}},
|
||
|
||
{{static_cast<GoalSelectView>(GOAL_SELECT_ITEM), IMG_SPORT_INDOOR_TARGET, STR_ID_208, STR_ID_208,
|
||
"FreeTrainItemGoals"},
|
||
{static_cast<GoalSelectView>(REMIND_SELECT_ITEM), IMG_SPORT_ICON_REMIND, STR_ID_229, STR_ID_595,
|
||
"FreeTrainItemReminds"}},
|
||
|
||
};
|
||
|
||
GoalSelectViewInfo g_pv_GoalSelect[] = {
|
||
{DISTANCE_SELECT_VIEW,IMG_SPORT_INDOOR_DIS, STR_ID_209, STR_ID_596, "distanceSelect" },
|
||
{TIME_SELECT_VIEW,IMG_SPORT_INDOOR_TIME, STR_ID_594, STR_ID_597, "timeSelect" },//时间
|
||
{CALORIES_SELECT_VIEW,IMG_SPORT_INDOOR_KCAL, STR_ID_201, STR_ID_598, "caloriesSelect" },
|
||
{FREE_TRAINING_SELECT_VIEW,IMG_SPORT_INDOOR_TARGET,STR_ID_208, STR_ID_597, "freeTrainingSelect" },
|
||
};
|
||
|
||
RemindItemInfo g_pv_CommonRemindGoalList[] = {
|
||
{HEART_RATE_INDEX, IMG_SPORT_HR_DESC, STR_ID_00, STR_ID_217, "heartRatePick"},
|
||
{TIME_INDEX, IMG_SPORT_INDOOR_TIME, STR_ID_594, STR_ID_220, "timePick"},
|
||
{ONCE_INDEX, IMG_SPORT_DIN, STR_ID_599, STR_ID_225, "distPick"},
|
||
};
|
||
|
||
HeartRateItemInfo g_pv_HeartRateItemInfo[] = {
|
||
{FIRAT_SECTOR_INDEX,IMG_SPORT_ONE, STR_ID_600, STR_ID_110},
|
||
{SECOND_SECTOR_INDEX,IMG_SPORT_TWO, STR_ID_601, STR_ID_110},
|
||
{THREE_SECTOR_INDEX,IMG_SPORT_THREE, STR_ID_602, STR_ID_110},
|
||
{FOUR_SECTOR_INDEX,IMG_SPORT_FOUR, STR_ID_603, STR_ID_110},
|
||
{NONE_SECTOR_INDEX,IMG_SPORT_TWO, STR_ID_217, STR_ID_110},
|
||
};
|
||
|
||
TimeOrDistRemindItemInfo g_pv_TimeRemindItemInfo[] = {
|
||
{PER_TEN_MIN_INDEX, STR_ID_218, 0},
|
||
{PER_TWENTY_MIN_INDEX, STR_ID_219, 0},
|
||
{PER_THIRTY_MIN_INDEX, STR_ID_220, 0},
|
||
{PER_FORTY_MIN_INDEX, STR_ID_221, 0},
|
||
{PER_FIFTY_MIN_INDEX, STR_ID_222, 0},
|
||
{PER_SIXTY_MIN_INDEX, STR_ID_223, 0},
|
||
{UNSELECT_MIN_INDEX, STR_ID_217, 0},
|
||
};
|
||
|
||
TimeOrDistRemindItemInfo g_pv_DistanceRemindItemInfo[] = {
|
||
{ PER_500_METERS_INDEX, STR_ID_224, 1},
|
||
{ PER_1000_METERS_INDEX, STR_ID_225, 1},
|
||
{ PER_2000_METERS_INDEX, STR_ID_226, 1},
|
||
{ PER_3000_METERS_INDEX, STR_ID_227, 1},
|
||
{ PER_5000_METERS_INDEX, STR_ID_228, 1},
|
||
{ UNSELECT_DISTANCE_INDEX, STR_ID_217, 1},
|
||
};
|
||
// clang-format on
|
||
static inline int16_t CalculateBottomHidePos(OHOS::UIView &screenBottomView)
|
||
{
|
||
const int16_t lastItemBottom = screenBottomView.GetY() + screenBottomView.GetHeight();
|
||
return (lastItemBottom + (OHOS::VERTICAL_RESOLUTION / 2) - (screenBottomView.GetHeight() / 2));
|
||
}
|
||
|
||
bool ItemViewOnclickListener::OnClick(OHOS::UIView &view, const OHOS::ClickEvent &event)
|
||
{
|
||
printf("ItemViewOnclickListener::OnClick id = %s\n", view.GetViewId());
|
||
auto sportView = TjdUiAppSportView::GetInstance();
|
||
// auto iconIndex = sportView->currentIconIndex_;
|
||
if (view.GetViewId() == "distanceSelect") {
|
||
sportView->ShowTargetView(SPORT_GOAL_DISTANCES_VIEW, static_cast<uint8_t>(DISTANCE_SELECT_VIEW));
|
||
} else if (view.GetViewId() == "timeSelect") {
|
||
sportView->ShowTargetView(SPORT_GOAL_TIME_VIEW, static_cast<uint8_t>(TIME_SELECT_VIEW));
|
||
} else if (view.GetViewId() == "caloriesSelect") {
|
||
sportView->ShowTargetView(SPORT_GOAL_CALORIES_VIEW, static_cast<uint8_t>(CALORIES_SELECT_VIEW));
|
||
} else if (view.GetViewId() == "freeTrainingSelect") {
|
||
CommonViewGoalPage::CurSelectGoalView = FREE_TRAINING_SELECT_VIEW;
|
||
sportView->ShowTargetView(SPORT_GOAL_FREE_TRAINING_VIEW, static_cast<uint8_t>(FREE_TRAINING_SELECT_VIEW));
|
||
}
|
||
|
||
return true;
|
||
}
|
||
#pragma endregion
|
||
|
||
#pragma region 室外运动列表页
|
||
OHOS::UIView *SportGoalSelectAdapter::GetView(OHOS::UIView *inView, int16_t index)
|
||
{
|
||
std::list<GoalSelectViewInfo> *ItemList_ = SportGoalSelectView::GetInstance()->ItemList_;
|
||
|
||
if (ItemList_->empty() || index > ItemList_->size() - 1 || index < 0) {
|
||
return nullptr;
|
||
}
|
||
|
||
auto node = ItemList_->begin();
|
||
std::advance(node, index);
|
||
|
||
if (inView == nullptr) {
|
||
itemView_ = new ItemView(*node, index);
|
||
} else {
|
||
itemView_ = static_cast<ItemView *>(inView);
|
||
}
|
||
|
||
itemView_->UpdateView(*node, index);
|
||
return itemView_;
|
||
}
|
||
|
||
uint16_t SportGoalSelectAdapter::GetCount() { return SportGoalSelectView::GetInstance()->ItemList_->size(); }
|
||
|
||
SportGoalSelectAdapter::~SportGoalSelectAdapter()
|
||
{
|
||
if (itemView_ != nullptr) {
|
||
delete itemView_;
|
||
itemView_ = nullptr;
|
||
}
|
||
}
|
||
|
||
ItemView::ItemView(GoalSelectViewInfo &info, uint8_t i)
|
||
{
|
||
auto image = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(info.imgIconResId, SPORT_IMAGE_BIN_PATH);
|
||
bool ifLastItem = (i == INTDOOR_MAX_INDEX) ? true : false;
|
||
SetPosition(0, 0, 450, 128);
|
||
SetStyle(OHOS::STYLE_BACKGROUND_COLOR, 0xff202020);
|
||
SetStyle(OHOS::STYLE_BORDER_RADIUS, 55);
|
||
SetViewIndex(info.index);
|
||
|
||
icon_.SetPosition(18, 13, 92, 92);
|
||
if (image != nullptr) {
|
||
icon_.SetSrc(image);
|
||
}
|
||
|
||
name_.SetPosition(0, 14 + ifLastItem * 22, 450, 56);
|
||
name_.SetFont(TJD_VECTOR_FONT_FILENAME, 42);
|
||
// name_.SetText(info.name);
|
||
// name_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
|
||
name_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
|
||
printf("name_ height = %d\n", name_.GetHeight());
|
||
|
||
if (i < INTDOOR_MAX_INDEX) {
|
||
goal_.SetPosition(0, 73, 450, 40);
|
||
goal_.SetFont(TJD_VECTOR_FONT_FILENAME, 30);
|
||
goal_.SetTextId(info.goalId);
|
||
goal_.SetStyle(STYLE_TEXT_OPA, 0xff * 0.2);
|
||
// goal_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
|
||
goal_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
|
||
printf("goal_ height = %d\n", goal_.GetHeight());
|
||
}
|
||
|
||
image = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_SPORT_INDOOR_MORE, SPORT_IMAGE_BIN_PATH);
|
||
moreIcon_.SetPosition(401, 52, 14, 24);
|
||
if (image != nullptr) {
|
||
moreIcon_.SetSrc(image);
|
||
}
|
||
|
||
SetTouchable(true);
|
||
SetOnClickListener(&itemViewOnclickListener);
|
||
|
||
Add(&icon_);
|
||
Add(&name_);
|
||
Add(&goal_);
|
||
Add(&moreIcon_);
|
||
}
|
||
|
||
void ItemView::UpdateView(GoalSelectViewInfo &info, uint8_t index)
|
||
{
|
||
SetVisible(true);
|
||
SetViewIndex(index);
|
||
SetViewId(info.itemId);
|
||
auto image = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(info.imgIconResId, SPORT_IMAGE_BIN_PATH);
|
||
if (image != nullptr) {
|
||
icon_.SetSrc(image);
|
||
}
|
||
|
||
bool ifLastItem = (index == INTDOOR_FREE_TRAINING_INDEX) ? true : false;
|
||
printf("UpdateView index = %d, ifLastItem = %d\n", index, ifLastItem);
|
||
name_.SetTextId(info.nameId);
|
||
name_.SetY(14 + ifLastItem * 22);
|
||
|
||
switch (info.index) {
|
||
case INTDOOR_DISTANCE_INDEX:
|
||
goal_.SetText(g_pv_SportGoal[TjdUiAppSportView::currentIconIndex_].distGoal.c_str());
|
||
break;
|
||
case INTDOOR_TIME_INDEX:
|
||
printf("line = %d=====g_pv_SportGoal[%d].timeGoal=%s\n", __LINE__, TjdUiAppSportView::currentIconIndex_,
|
||
g_pv_SportGoal[index].timeGoal.c_str());
|
||
goal_.SetText(g_pv_SportGoal[TjdUiAppSportView::currentIconIndex_].timeGoal.c_str());
|
||
break;
|
||
case INTDOOR_CALORIES_INDEX:
|
||
printf("line = %d=====g_pv_SportGoal[%d].caloriesGoal=%s\n", __LINE__, TjdUiAppSportView::currentIconIndex_,
|
||
g_pv_SportGoal[index].caloriesGoal.c_str());
|
||
goal_.SetText(g_pv_SportGoal[TjdUiAppSportView::currentIconIndex_].caloriesGoal.c_str());
|
||
break;
|
||
case INTDOOR_FREE_TRAINING_INDEX:
|
||
goal_.SetText("");
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
// goal_.SetPosition(HorizontalCenter(goal_.GetWidth()), 74);
|
||
|
||
image = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_SPORT_INDOOR_MORE, SPORT_IMAGE_BIN_PATH);
|
||
if (image != nullptr) {
|
||
moreIcon_.SetSrc(image);
|
||
}
|
||
}
|
||
|
||
SportGoalSelectAdapter *sportGoalSelectAdapter_{nullptr};
|
||
SportGoalSelectView::SportGoalSelectView()
|
||
{
|
||
InitList();
|
||
g_pv_SportGoalSelectView = this;
|
||
SetPosition(0, 0, OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
|
||
SetDraggable(true);
|
||
SetOnDragListener(TjdUiAppSportPresenter::GetInstance());
|
||
|
||
mainTitle_.SetPosition(0, 17, 466, 37);
|
||
mainTitle_.SetFont(TJD_VECTOR_FONT_FILENAME, 28);
|
||
mainTitle_.SetText("室外运动");
|
||
// mainTitle_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
|
||
mainTitle_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
|
||
|
||
if (sportGoalSelectList_ == nullptr) {
|
||
sportGoalSelectList_ = new UITransformList();
|
||
}
|
||
|
||
if (sportGoalSelectAdapter_ == nullptr) {
|
||
sportGoalSelectAdapter_ = new SportGoalSelectAdapter();
|
||
}
|
||
|
||
sportGoalSelectList_->SetPosition(0, 0, Screen::GetInstance().GetWidth(), Screen::GetInstance().GetHeight());
|
||
sportGoalSelectList_->SetItemTransformFunc(&TransformItemBaseOnPosition);
|
||
sportGoalSelectList_->SetAdapter(sportGoalSelectAdapter_);
|
||
sportGoalSelectList_->SetThrowDrag(true);
|
||
sportGoalSelectList_->SetStyle(STYLE_BACKGROUND_OPA, OPA_TRANSPARENT);
|
||
// sportGoalSelectList_->SetMaxScrollDistance(1000); // 1000: max scroll distance
|
||
// sportGoalSelectList_->SetSwipeACCLevel(800); // 800: compensation distance
|
||
sportGoalSelectList_->SetDragACCLevel(5); // 5: drag acceleration
|
||
sportGoalSelectList_->SetYScrollBarVisible(true);
|
||
sportGoalSelectList_->SetReboundSize((VERTICAL_RESOLUTION - 120) / 2);
|
||
sportGoalSelectList_->ScrollBy(60);
|
||
sportGoalSelectList_->SetScrollBlankSize((VERTICAL_RESOLUTION - 120) / 2);
|
||
sportGoalSelectList_->SetSelectPosition(VERTICAL_RESOLUTION / 2);
|
||
sportGoalSelectList_->SetRotateFactor(-10);
|
||
sportGoalSelectList_->SetRotateThreshold(8);
|
||
// listScrollListener.SetSource(sportGoalSelectList_, &mainTitle_);
|
||
// sportGoalSelectList_->SetScrollStateListener(&listScrollListener);
|
||
|
||
Add(&mainTitle_);
|
||
Add(sportGoalSelectList_);
|
||
// Add(&hide_);
|
||
}
|
||
|
||
void SportGoalSelectView::ReMeasure()
|
||
{
|
||
if (sportGoalSelectList_ == nullptr || mainTitle_.GetText() == nullptr) {
|
||
return;
|
||
}
|
||
const OHOS::UIView *head = sportGoalSelectList_->GetChildrenHead();
|
||
if (head == nullptr) {
|
||
return;
|
||
}
|
||
const int16_t scrollDistance = head->GetRect().GetTop();
|
||
if (head->GetViewIndex() == 0) {
|
||
OHOS::Vector2<int16_t> trans = {0, scrollDistance - mainTitle_.GetHeight() - 32};
|
||
mainTitle_.Translate(trans);
|
||
mainTitle_.SetVisible(true);
|
||
} else {
|
||
mainTitle_.SetVisible(false);
|
||
}
|
||
|
||
/* 标题渐进透明度 */
|
||
int16_t titleTop = -mainTitle_.GetRect().GetTop();
|
||
if (titleTop < 0) {
|
||
titleTop = 0;
|
||
}
|
||
mainTitle_.SetStyle(OHOS::STYLE_TEXT_OPA, EasingEquation::QuintEaseOut(OHOS::OPA_OPAQUE, OHOS::OPA_TRANSPARENT,
|
||
titleTop, mainTitle_.GetHeight()));
|
||
}
|
||
|
||
void SportGoalSelectView::InitList()
|
||
{
|
||
auto &image = OHOS::ImageCacheManager::GetInstance();
|
||
|
||
if (ItemList_ == nullptr) {
|
||
ItemList_ = new std::list<GoalSelectViewInfo>();
|
||
}
|
||
ItemList_->clear();
|
||
|
||
for (uint8_t i = 0; i < MAX_SELECT_VIEW_INDEX; i++) {
|
||
imgItemInfo[i] = image.LoadOneInMultiRes(g_pv_GoalSelect[i].imgIconResId, SPORT_IMAGE_BIN_PATH);
|
||
ItemList_->push_back({g_pv_GoalSelect[i].index, g_pv_GoalSelect[i].imgIconResId, g_pv_GoalSelect[i].nameId,
|
||
g_pv_GoalSelect[i].goalId, g_pv_GoalSelect[i].itemId});
|
||
}
|
||
}
|
||
|
||
SportGoalSelectView *SportGoalSelectView::GetInstance() { return g_pv_SportGoalSelectView; }
|
||
|
||
void SportGoalSelectView::SportGoalSelectViewRefresh()
|
||
{
|
||
|
||
auto index = TjdUiAppSportView::currentIconIndex_;
|
||
mainTitle_.SetTextId(g_pv_Sport[index].sportTypeId);
|
||
int16_t startY = 17 + mainTitle_.GetHeight() + 8;
|
||
int16_t interval = 8;
|
||
|
||
switch (index) {
|
||
case SPORT_TYPE_01_OUTDOOR_RUNNING_INDEX:
|
||
case SPORT_TYPE_02_OUTDOOR_WALKING_INDEX:
|
||
case SPORT_TYPE_04_FOOTBALL_INDEX:
|
||
case SPORT_TYPE_05_BASKETBALL_INDEX:
|
||
case SPORT_TYPE_12_ON_FOOT_INDEX:
|
||
case SPORT_TYPE_13_STAIRCASE_INDEX:
|
||
|
||
case SPORT_TYPE_09_INDOOR_SWIMMI_INDEX:
|
||
case SPORT_TYPE_10_OUTDOOR_SWIMM_INDEX:
|
||
case SPORT_TYPE_11_CYCLING_INDEX:
|
||
case SPORT_TYPE_51_RIDING_INDEX ... SPORT_TYPE_57_MOTORBOAT_INDEX:
|
||
ifDistance = true;
|
||
break;
|
||
default:
|
||
ifDistance = false;
|
||
break;
|
||
}
|
||
|
||
ItemList_->clear();
|
||
auto &image = OHOS::ImageCacheManager::GetInstance();
|
||
if (ifDistance) {
|
||
for (uint8_t i = 0; i < MAX_SELECT_VIEW_INDEX; i++) {
|
||
imgItemInfo[i] = image.LoadOneInMultiRes(g_pv_GoalSelect[i].imgIconResId, SPORT_IMAGE_BIN_PATH);
|
||
ItemList_->push_back({g_pv_GoalSelect[i].index, g_pv_GoalSelect[i].imgIconResId, g_pv_GoalSelect[i].nameId,
|
||
g_pv_GoalSelect[i].goalId, g_pv_GoalSelect[i].itemId});
|
||
}
|
||
|
||
} else {
|
||
for (uint8_t i = 1; i < MAX_SELECT_VIEW_INDEX; i++) {
|
||
imgItemInfo[i] = image.LoadOneInMultiRes(g_pv_GoalSelect[i].imgIconResId, SPORT_IMAGE_BIN_PATH);
|
||
ItemList_->push_back({g_pv_GoalSelect[i].index, g_pv_GoalSelect[i].imgIconResId, g_pv_GoalSelect[i].nameId,
|
||
g_pv_GoalSelect[i].goalId, g_pv_GoalSelect[i].itemId});
|
||
}
|
||
}
|
||
sportGoalSelectList_->RefreshList();
|
||
Invalidate();
|
||
}
|
||
|
||
void SportGoalSelectView::HideView()
|
||
{
|
||
// SportList::GetInstance()->customSportList_->RefreshList();
|
||
SetVisible(false);
|
||
}
|
||
|
||
void SportGoalSelectView::SetListTitleVisible(bool visible)
|
||
{
|
||
if (visible)
|
||
sportGoalSelectList_->SetVisible(true);
|
||
else
|
||
sportGoalSelectList_->SetVisible(false);
|
||
}
|
||
|
||
void SportGoalSelectView::ShowView()
|
||
{
|
||
SportGoalSelectViewRefresh();
|
||
OHOS::FocusManager::GetInstance()->ClearFocus();
|
||
sportGoalSelectList_->RequestFocus();
|
||
SetVisible(true);
|
||
}
|
||
|
||
SportGoalSelectView::~SportGoalSelectView()
|
||
{
|
||
ifDistance = false;
|
||
g_pv_SportGoalSelectView = nullptr;
|
||
RemoveAll();
|
||
for (int i = 0; i < MAX_SELECT_VIEW_INDEX; ++i) {
|
||
if (itemViews_[i] != nullptr) {
|
||
itemViews_[i]->RemoveAll();
|
||
delete itemViews_[i];
|
||
itemViews_[i] = nullptr;
|
||
}
|
||
}
|
||
|
||
for (int i = 0; i < MAX_SELECT_VIEW_INDEX; ++i) {
|
||
if (imgItemInfo[i] != nullptr) {
|
||
delete imgItemInfo[i];
|
||
imgItemInfo[i] = nullptr;
|
||
}
|
||
}
|
||
|
||
if (sportGoalSelectList_ != nullptr) {
|
||
// sportGoalSelectList_->ClearFocus();
|
||
sportGoalSelectList_->RemoveAll();
|
||
delete sportGoalSelectList_;
|
||
sportGoalSelectList_ = nullptr;
|
||
}
|
||
|
||
// if (sportGoalSelectAdapter_ != nullptr) { // <20><><EFBFBD><EFBFBD>ᵼ<EFBFBD><E1B5BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
// static int a = 0;
|
||
// printf("line = %d=====a=%d=====\n", __LINE__, a++);
|
||
// delete sportGoalSelectAdapter_;
|
||
// printf("line = %d===========\n", __LINE__);
|
||
// sportGoalSelectAdapter_ = nullptr;
|
||
// printf("line = %d===========\n", __LINE__);
|
||
// }
|
||
}
|
||
|
||
#pragma endregion
|
||
|
||
#pragma region 通用目标页
|
||
void CommonGoalItemOnclickListener::EnterCallBack(OHOS::UIView &view)
|
||
{
|
||
static_print_info("======cxin is click CommonGoalItemOnclickListener::EnterCallBack===%s=\n", view.GetViewId());
|
||
auto sportModel = TjdUiAppSportModel::GetInstance();
|
||
if (view.GetViewId() == "distStart") {
|
||
// std::string distStr = "1000m"; // 用于调试测试
|
||
std::string distStr = g_pv_SportGoal[TjdUiAppSportView::currentIconIndex_].distGoal;
|
||
g_pv_SportGoal[TjdUiAppSportView::currentIconIndex_].sportGoal = distStr;
|
||
sportModel->SetDistancePopUpRemind(distStr);
|
||
} else if (view.GetViewId() == "timeStart") {
|
||
std::string timeStr = g_pv_SportGoal[TjdUiAppSportView::currentIconIndex_].timeGoal;
|
||
g_pv_SportGoal[TjdUiAppSportView::currentIconIndex_].sportGoal = timeStr;
|
||
// std::string timeStr = "00H01min"; // 用于调试测试
|
||
sportModel->SetTimePopUpRemind(timeStr);
|
||
} else if (view.GetViewId() == "caloriesStart") {
|
||
std::string calStr = g_pv_SportGoal[TjdUiAppSportView::currentIconIndex_].caloriesGoal;
|
||
g_pv_SportGoal[TjdUiAppSportView::currentIconIndex_].sportGoal = calStr;
|
||
sportModel->SetCaloriesPopUpRemind(calStr);
|
||
}
|
||
}
|
||
|
||
bool CommonGoalItemOnclickListener::OnClick(OHOS::UIView &view, const OHOS::ClickEvent &event)
|
||
{
|
||
static_print_info("======cxin is click CommonGoalItemOnclickListener::OnClick===%s=\n", view.GetViewId());
|
||
auto sportView = TjdUiAppSportView::GetInstance();
|
||
if (view.GetViewId() == "distItemGoals") {
|
||
sportView->ShowTargetView(DISTANCE_GOAL_SELECT_VIEW);
|
||
} else if (view.GetViewId() == "timeItemGoals") {
|
||
auto sportView = TjdUiAppSportView::GetInstance();
|
||
sportView->ShowTargetView(TIME_GOAL_SELECT_VIEW);
|
||
} else if (view.GetViewId() == "CaloriesItemGoals") {
|
||
sportView->ShowTargetView(CALORIES_GOAL_SELECT_VIEW);
|
||
} else if (view.GetViewId() == "distItemReminds" || view.GetViewId() == "timeItemReminds" ||
|
||
view.GetViewId() == "CaloriesItemReminds" || view.GetViewId() == "FreeTrainItemReminds") {
|
||
if (view.GetViewId() == "distItemReminds")
|
||
sportView->lastViewIndex_ = SPORT_GOAL_DISTANCES_VIEW;
|
||
else if (view.GetViewId() == "timeItemReminds")
|
||
sportView->lastViewIndex_ = SPORT_GOAL_TIME_VIEW;
|
||
else if (view.GetViewId() == "CaloriesItemReminds")
|
||
sportView->lastViewIndex_ = SPORT_GOAL_CALORIES_VIEW;
|
||
else if (view.GetViewId() == "FreeTrainItemReminds")
|
||
sportView->lastViewIndex_ = SPORT_GOAL_FREE_TRAINING_VIEW;
|
||
|
||
sportView->ShowTargetView(SPORT_REMIND_SELECT_VIEW);
|
||
} else if (view.GetViewId() == "distStart" || view.GetViewId() == "timeStart" ||
|
||
view.GetViewId() == "caloriesStart" || view.GetViewId() == "freeTrainStart") {
|
||
static_print_info("aaaaa viewid = %s\n", view.GetViewId());
|
||
EnterCallBack(view);
|
||
sportView->ShowTargetView(COUNT_DOWN_VIEW, TjdUiAppSportView::currentIconIndex_);
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
CommonGoalItemView::CommonGoalItemView(GoalSelectViewInfo &info)
|
||
{
|
||
auto image = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(info.imgIconResId, SPORT_IMAGE_BIN_PATH);
|
||
SetPosition(0, 0, 450, 128);
|
||
SetStyle(OHOS::STYLE_BACKGROUND_COLOR, 0xff202020);
|
||
SetStyle(OHOS::STYLE_BORDER_RADIUS, 64);
|
||
SetViewIndex(info.index);
|
||
SetViewId(info.itemId);
|
||
|
||
icon_.SetPosition(12, 18, 92, 92);
|
||
if (image != nullptr) {
|
||
icon_.SetSrc(image);
|
||
}
|
||
|
||
name_.SetPosition(0, 14, 450, 56);
|
||
name_.SetFont(TJD_VECTOR_FONT_FILENAME, 42);
|
||
name_.SetTextId(info.nameId);
|
||
// name_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
|
||
name_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
|
||
|
||
goal_.SetPosition(0, 73, 450, 40);
|
||
goal_.SetFont(TJD_VECTOR_FONT_FILENAME, 30);
|
||
goal_.SetTextId(info.goalId);
|
||
goal_.SetStyle(STYLE_TEXT_OPA, 0xff * 0.2);
|
||
// goal_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
|
||
goal_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
|
||
|
||
image = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_SPORT_INDOOR_MORE, SPORT_IMAGE_BIN_PATH);
|
||
moreIcon_.SetPosition(401, 52, 14, 24);
|
||
if (image != nullptr) {
|
||
moreIcon_.SetSrc(image);
|
||
}
|
||
|
||
SetTouchable(true);
|
||
SetOnClickListener(&goalItemOnclickListener);
|
||
|
||
Add(&icon_);
|
||
Add(&name_);
|
||
Add(&goal_);
|
||
Add(&moreIcon_);
|
||
}
|
||
|
||
static void timeTimerCallBack(void *arg)
|
||
{
|
||
GraphicService::GetInstance()->PostGraphicEvent(
|
||
std::bind([](void *arg) { CommonViewGoalPage::GetInstance()->UpdateLocalTime(); }, arg));
|
||
}
|
||
|
||
CommonViewGoalPage::CommonViewGoalPage(GoalSelectView index)
|
||
{
|
||
index_ = index;
|
||
g_pv_CommonViewGoalPage = this;
|
||
|
||
uint32_t imageId[4] = {IMG_SPORT_START_DIS, IMG_SPORT_START_TIME, IMG_SPORT_START_CAL, IMG_SPORT_START_ZDY};
|
||
|
||
char *startId[4] = {"distStart", "timeStart", "caloriesStart", "freeTrainStart"};
|
||
|
||
SetPosition(0, 0, OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
|
||
SetDraggable(true);
|
||
SetOnDragListener(TjdUiAppSportPresenter::GetInstance());
|
||
|
||
rtc_class_ops *rtc = tjd_driver_rtc_get_ops();
|
||
struct rtc_time localTime;
|
||
rtc->get_rtc_time(&localTime);
|
||
char timeStr[15] = {0};
|
||
sprintf(timeStr, "%02d.%02d", localTime.tm_hour, localTime.tm_min);
|
||
timeTitle_.SetText(timeStr);
|
||
InitLabel(timeTitle_, 28, 193, 17, timeStr);
|
||
|
||
int16_t startY = 80;
|
||
int16_t interval = 8;
|
||
|
||
for (int i = 0; i < MAX_COMMON_VIEW_ITEM_INDEX; ++i) {
|
||
if (FREE_TRAINING_SELECT_VIEW == index && i == 0) {
|
||
startY = 154;
|
||
continue;
|
||
}
|
||
goalItemViews_[i] = new CommonGoalItemView(g_pv_CommonViewItemInfo[index][i]);
|
||
goalItemViews_[i]->SetPosition(8, startY, 450, 128);
|
||
Add(goalItemViews_[i]);
|
||
startY += 128 + interval;
|
||
}
|
||
|
||
auto image = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(imageId[index], SPORT_IMAGE_BIN_PATH);
|
||
if (image != nullptr) {
|
||
startIcon_.SetSrc(image);
|
||
startIcon_.SetPosition(187, 352);
|
||
}
|
||
|
||
if (timeTimer_ == nullptr)
|
||
timeTimer_ = new OHOS::GraphicTimer(1000, timeTimerCallBack, nullptr, true);
|
||
|
||
startIcon_.SetTouchable(true);
|
||
startIcon_.SetViewId(startId[index]);
|
||
startIcon_.SetOnClickListener(&startIconOnclickListener);
|
||
|
||
Add(&startIcon_);
|
||
Add(&timeTitle_);
|
||
}
|
||
|
||
void CommonViewGoalPage::GoalPageDataRefresh()
|
||
{
|
||
char tempStr[20] = {0};
|
||
uint16_t selectIndex = 0;
|
||
uint8_t curTouchIndex = TjdUiAppSportView::currentIconIndex_;
|
||
|
||
switch (index_) {
|
||
case DISTANCE_SELECT_VIEW:
|
||
goalItemViews_[0]->goal_.SetText(g_pv_SportGoal[curTouchIndex].distGoal.c_str());
|
||
break;
|
||
case TIME_SELECT_VIEW:
|
||
goalItemViews_[0]->goal_.SetText(g_pv_SportGoal[curTouchIndex].timeGoal.c_str());
|
||
break;
|
||
case CALORIES_SELECT_VIEW:
|
||
goalItemViews_[0]->goal_.SetText(g_pv_SportGoal[curTouchIndex].caloriesGoal.c_str());
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
if (index_ != FREE_TRAINING_SELECT_VIEW) {
|
||
static_cast<UITransformGroup *>(goalItemViews_[0])->Scale(OHOS::Vector2<float>(0.9, 0.9), {233, 60});
|
||
goalItemViews_[0]->Invalidate();
|
||
}
|
||
}
|
||
|
||
void CommonViewGoalPage::UpdateLocalTime()
|
||
{
|
||
rtc_class_ops *rtc = tjd_driver_rtc_get_ops();
|
||
struct rtc_time localTime;
|
||
rtc->get_rtc_time(&localTime);
|
||
char timeStr[15] = {0};
|
||
sprintf(timeStr, "%02d.%02d", localTime.tm_hour, localTime.tm_min);
|
||
timeTitle_.SetText(timeStr);
|
||
}
|
||
|
||
void CommonViewGoalPage::ShowView()
|
||
{
|
||
GoalPageDataRefresh(); // 接口有问题，先不用
|
||
Invalidate();
|
||
SetVisible(true);
|
||
timeTimer_->Start();
|
||
}
|
||
|
||
void CommonViewGoalPage::HideView()
|
||
{
|
||
timeTimer_->Stop();
|
||
SetVisible(false);
|
||
}
|
||
|
||
CommonViewGoalPage *CommonViewGoalPage::GetInstance(void) { return g_pv_CommonViewGoalPage; }
|
||
|
||
CommonViewGoalPage::~CommonViewGoalPage()
|
||
{
|
||
static_print_info("CommonViewGoalPage==line[%d]==func[%s]\n", __LINE__, __func__);
|
||
g_pv_CommonViewGoalPage = nullptr;
|
||
RemoveAll();
|
||
if (timeTimer_ != nullptr) {
|
||
timeTimer_->Stop();
|
||
delete timeTimer_;
|
||
timeTimer_ = nullptr;
|
||
}
|
||
|
||
for (int i = 0; i < MAX_COMMON_VIEW_ITEM_INDEX; ++i) {
|
||
if (goalItemViews_[i] != nullptr) {
|
||
goalItemViews_[i]->RemoveAll();
|
||
delete goalItemViews_[i];
|
||
goalItemViews_[i] = nullptr;
|
||
}
|
||
}
|
||
}
|
||
#pragma endregion
|
||
|
||
#pragma region CommonUiPicker
|
||
CommonUiPicker::CommonUiPicker(const char *uiPickerId, ColorType highlightColor, const char *uiPickerData[],
|
||
uint8_t len, int64_t highlightBgColor)
|
||
{
|
||
SetPosition(0, 0, OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
|
||
uiPicker_.SetPosition(54, 97);
|
||
uiPicker_.Resize(358, 235);
|
||
uiPicker_.SetViewId(uiPickerId);
|
||
uiPicker_.SetStyle(STYLE_BACKGROUND_COLOR, 0xff000000);
|
||
uiPicker_.SetStyle(STYLE_BACKGROUND_OPA, 0xff);
|
||
uiPicker_.SetBackgroundFont(TJD_VECTOR_FONT_FILENAME, 50);
|
||
uiPicker_.SetHighlightFont(TJD_VECTOR_FONT_FILENAME, 70);
|
||
uiPicker_.SetItemHeight(90);
|
||
uiPicker_.SetTextColor(Color::GetColorFromRGBA(0x26, 0x26, 0x26, 0xff), highlightColor);
|
||
uiPicker_.SetValues(uiPickerData, len);
|
||
uiPicker_.SetVisible(true);
|
||
highLightBg_.SetPosition(54, 164);
|
||
highLightBg_.Resize(358, 100);
|
||
highLightBg_.SetStyle(STYLE_BORDER_WIDTH, 4);
|
||
highLightBg_.SetStyle(STYLE_BORDER_RADIUS, 16);
|
||
highLightBg_.SetStyle(STYLE_BORDER_COLOR, highlightBgColor);
|
||
Add(&uiPicker_);
|
||
Add(&highLightBg_);
|
||
}
|
||
|
||
void CommonUiPicker::ViewRequestFocus()
|
||
{
|
||
OHOS::FocusManager::GetInstance()->ClearFocus();
|
||
uiPicker_.RequestFocus();
|
||
}
|
||
|
||
#pragma endregion
|
||
|
||
#pragma region 距离、卡路里监听器
|
||
bool GoalOnclickListener::OnClick(OHOS::UIView &view, const OHOS::ClickEvent &event)
|
||
{
|
||
auto sportView = TjdUiAppSportView::GetInstance();
|
||
static_print_info("======GoalOnclickListener::OnClick===%s=\n", view.GetViewId());
|
||
if (view.GetViewId() == "distConfirm") {
|
||
sportView->ShowTargetView(SPORT_GOAL_DISTANCES_VIEW);
|
||
} else if (view.GetViewId() == "caloriesConfirm") {
|
||
sportView->ShowTargetView(SPORT_GOAL_CALORIES_VIEW);
|
||
}
|
||
|
||
return true;
|
||
}
|
||
#pragma endregion
|
||
|
||
#pragma region 距离目标选择
|
||
DistnaceGoalSelectView::DistnaceGoalSelectView()
|
||
{
|
||
g_pv_DistnaceGoalSelectView = this;
|
||
SetPosition(0, 0, OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
|
||
SetTouchable(true);
|
||
SetDraggable(true);
|
||
SetOnDragListener(TjdUiAppSportPresenter::GetInstance());
|
||
|
||
// InitLabel(lbTitle_, 28, 203, 17, "距离");
|
||
lbTitle_.SetFont(TJD_VECTOR_FONT_FILENAME, 28);
|
||
lbTitle_.SetTextId(STR_ID_209);
|
||
// lbTitle_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
|
||
lbTitle_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
|
||
lbTitle_.SetPosition(0, 17, 466, 37);
|
||
|
||
distancePicker_ =
|
||
new CommonUiPicker("distancePicker", Color::GetColorFromRGBA(0x00, 0xB1, 0x36, 0xff), distUiPickerData,
|
||
sizeof(distUiPickerData) / sizeof(distUiPickerData[0]), 0xFF00B136);
|
||
distancePicker_->uiPicker_.SetSelected(5);
|
||
OHOS::ImageInfo *imgInfo = ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_SPORT_BJ, SPORT_IMAGE_BIN_PATH);
|
||
UiDrawImage(&imgConfirm, 187, 352, "distConfirm", imgInfo);
|
||
imgConfirm.SetTouchable(true);
|
||
imgConfirm.SetOnClickListener(&distnaceGoalOnclickListener);
|
||
|
||
Add(distancePicker_);
|
||
Add(&lbTitle_);
|
||
Add(&imgConfirm);
|
||
}
|
||
|
||
void DistnaceGoalSelectView::ShowView()
|
||
{
|
||
distancePicker_->ViewRequestFocus();
|
||
SetVisible(true);
|
||
}
|
||
|
||
void DistnaceGoalSelectView::HideView()
|
||
{
|
||
distancePickIndex = distancePicker_->uiPicker_.GetSelected();
|
||
g_pv_SportGoal[TjdUiAppSportView::currentIconIndex_].distGoal = (char *)distUiPickerData[distancePickIndex];
|
||
g_pv_SportGoal[TjdUiAppSportView::currentIconIndex_].sportGoal =
|
||
g_pv_SportGoal[TjdUiAppSportView::currentIconIndex_].distGoal;
|
||
CommonViewGoalPage::CurSelectGoalView = DISTANCE_SELECT_VIEW;
|
||
static_print_info("===distancePickIndex = %d\n", distancePickIndex);
|
||
SetVisible(false);
|
||
}
|
||
|
||
DistnaceGoalSelectView *DistnaceGoalSelectView::GetInstance(void) { return g_pv_DistnaceGoalSelectView; }
|
||
|
||
DistnaceGoalSelectView::~DistnaceGoalSelectView()
|
||
{
|
||
static_print_info("CommonViewGoalPage==line[%d]==func[%s]\n", __LINE__, __func__);
|
||
g_pv_DistnaceGoalSelectView = nullptr;
|
||
RemoveAll();
|
||
if (distancePicker_ != nullptr) {
|
||
delete distancePicker_;
|
||
distancePicker_ = nullptr;
|
||
}
|
||
}
|
||
|
||
#pragma endregion
|
||
|
||
#pragma region 时间目标选择
|
||
void SportTimerPickerOnListener::OnSelectTimePicker(OHOS::UIPicker &picker) { TjdUiUtils::ViewRequestFocus(picker); }
|
||
|
||
void SportTimerPickerOnListener::OnEnter(int32_t hour, int32_t minute)
|
||
{
|
||
char tempStr[16] = {0};
|
||
sprintf(tempStr, "%02dH%02dmin", hour, minute);
|
||
g_pv_SportGoal[TjdUiAppSportView::currentIconIndex_].timeGoal = tempStr;
|
||
g_pv_SportGoal[TjdUiAppSportView::currentIconIndex_].sportGoal = tempStr;
|
||
CommonViewGoalPage::CurSelectGoalView = TIME_SELECT_VIEW;
|
||
printf("SportTimeSelectView::EnterCallback hour:%d, minute:%d, tempStr:%s\n", hour, minute, tempStr);
|
||
if (hour == 0 && minute == 0) {
|
||
return;
|
||
}
|
||
TjdUiAppSportView::GetInstance()->ShowTargetView(SPORT_GOAL_TIME_VIEW);
|
||
}
|
||
|
||
TimeGoalSelectView::TimeGoalSelectView()
|
||
{
|
||
SetPosition(0, 0, OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
|
||
SetDraggable(true);
|
||
SetOnDragListener(TjdUiAppSportPresenter::GetInstance());
|
||
|
||
if (timePicker == nullptr) {
|
||
timePicker = new TjdUITimePicker();
|
||
}
|
||
timePicker->SetTitleId(STR_ID_594); //时间
|
||
// timePicker->SetEnterViewType(TjdUIEnterViewBase::EnterViewType::OK);
|
||
timePicker->SetPosition(0, 0, 466, 466);
|
||
timePicker->SetOkSmallBackground(0xff00C487);
|
||
timePicker->SetHighlightColor(0xff00C487);
|
||
timePicker->SetItemSelectdEnterListener(&timePickerOnListener);
|
||
|
||
ImageInfo *imgInfo = ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_SPORT_TIME_BJ, SPORT_IMAGE_BIN_PATH);
|
||
timePicker->SetOkSrc(imgInfo);
|
||
|
||
Add(timePicker);
|
||
}
|
||
|
||
#pragma endregion
|
||
|
||
#pragma region 卡路里目标选择
|
||
CaloriesGoalSelectView::CaloriesGoalSelectView()
|
||
{
|
||
g_pv_CaloriesGoalSelectView = this;
|
||
SetPosition(0, 0, OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
|
||
SetTouchable(true);
|
||
SetDraggable(true);
|
||
SetOnDragListener(TjdUiAppSportPresenter::GetInstance());
|
||
|
||
// InitLabel(lbTitle_, 28, 203, 17, "卡路里");
|
||
lbTitle_.SetFont(TJD_VECTOR_FONT_FILENAME, 28);
|
||
lbTitle_.SetTextId(STR_ID_201);
|
||
// lbTitle_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
|
||
lbTitle_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
|
||
lbTitle_.SetPosition(0, 17, 466, 37);
|
||
|
||
caloriesPicker_ =
|
||
new CommonUiPicker("caloriesPicker", Color::GetColorFromRGBA(0xFC, 0x3C, 0x01, 0xff), caloriesUiPickerData,
|
||
sizeof(caloriesUiPickerData) / sizeof(caloriesUiPickerData[0]), 0xFFFC3C01);
|
||
OHOS::ImageInfo *imgInfo =
|
||
ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_SPORT_CALORIES_BJ, SPORT_IMAGE_BIN_PATH);
|
||
UiDrawImage(&imgConfirm, 187, 352, "caloriesConfirm", imgInfo);
|
||
imgConfirm.SetTouchable(true);
|
||
imgConfirm.SetOnClickListener(&caloriesGoalOnclickListener);
|
||
|
||
Add(caloriesPicker_);
|
||
Add(&lbTitle_);
|
||
Add(&imgConfirm);
|
||
}
|
||
|
||
void CaloriesGoalSelectView::ShowView()
|
||
{
|
||
caloriesPicker_->ViewRequestFocus();
|
||
SetVisible(true);
|
||
}
|
||
|
||
void CaloriesGoalSelectView::HideView()
|
||
{
|
||
char tempStr[20] = {0};
|
||
caloriesPickIndex = caloriesPicker_->uiPicker_.GetSelected();
|
||
sprintf(tempStr, "%s Kcal", caloriesUiPickerData[caloriesPickIndex]);
|
||
g_pv_SportGoal[TjdUiAppSportView::currentIconIndex_].caloriesGoal = tempStr;
|
||
g_pv_SportGoal[TjdUiAppSportView::currentIconIndex_].sportGoal = tempStr;
|
||
CommonViewGoalPage::CurSelectGoalView = CALORIES_SELECT_VIEW;
|
||
SetVisible(false);
|
||
}
|
||
|
||
CaloriesGoalSelectView *CaloriesGoalSelectView::GetInstance() { return g_pv_CaloriesGoalSelectView; }
|
||
|
||
CaloriesGoalSelectView::~CaloriesGoalSelectView()
|
||
{
|
||
static_print_info("CaloriesGoalSelectView==line[%d]==func[%s]\n", __LINE__, __func__);
|
||
g_pv_CaloriesGoalSelectView = nullptr;
|
||
RemoveAll();
|
||
if (caloriesPicker_ != nullptr) {
|
||
delete caloriesPicker_;
|
||
caloriesPicker_ = nullptr;
|
||
}
|
||
}
|
||
#pragma endregion
|
||
|
||
#pragma region 提醒目标页
|
||
bool RemindGoalListItemOnclickListener::OnClick(OHOS::UIView &view, const OHOS::ClickEvent &event)
|
||
{
|
||
auto sportView = TjdUiAppSportView::GetInstance();
|
||
if (view.GetViewId() == "heartRatePick") {
|
||
sportView->ShowTargetView(HEART_RATE_PICK_VIEW);
|
||
} else if (view.GetViewId() == "timePick") {
|
||
sportView->ShowTargetView(TIME_PICK_VIEW);
|
||
} else if (view.GetViewId() == "distPick") {
|
||
sportView->ShowTargetView(DISTANCE_PICK_VIEW);
|
||
}
|
||
return true;
|
||
}
|
||
|
||
RemindGoalListItemView::RemindGoalListItemView(RemindItemInfo &info)
|
||
{
|
||
RemoveAll();
|
||
static_print_info("RemindGoalListItemView::RemindGoalListItemView\n");
|
||
auto image = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(info.iconResId, SPORT_IMAGE_BIN_PATH);
|
||
SetPosition(0, 0, 450, 130);
|
||
SetStyle(OHOS::STYLE_BACKGROUND_COLOR, 0xff202020);
|
||
SetStyle(OHOS::STYLE_BORDER_RADIUS, 70);
|
||
SetViewId(info.itemId);
|
||
// SetViewIndex(index);
|
||
|
||
icon_.SetPosition(16, 19, 92, 92);
|
||
if (image != nullptr) {
|
||
icon_.SetSrc(image);
|
||
}
|
||
|
||
name_.SetFont(TJD_VECTOR_FONT_FILENAME, 42);
|
||
name_.SetTextId(info.nameId);
|
||
// name_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
|
||
name_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
|
||
name_.SetPosition(0, 15, 450, 56);
|
||
printf("name width = %d, height = %d\n", name_.GetWidth(), name_.GetHeight());
|
||
|
||
goal_.SetFont(TJD_VECTOR_FONT_FILENAME, 30);
|
||
goal_.SetTextId(info.goalId);
|
||
goal_.SetStyle(STYLE_TEXT_OPA, 0xff * 0.2);
|
||
goal_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_OSCILLATION);
|
||
goal_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
|
||
goal_.SetPosition(143, 74, 180, 40);
|
||
|
||
image = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_SPORT_INDOOR_MORE, SPORT_IMAGE_BIN_PATH);
|
||
moreIcon_.SetPosition(401, 53, 14, 24);
|
||
if (image != nullptr) {
|
||
moreIcon_.SetSrc(image);
|
||
}
|
||
|
||
SetTouchable(true);
|
||
SetOnClickListener(&remindGoalListItemOnclickListener);
|
||
|
||
Add(&icon_);
|
||
Add(&name_);
|
||
Add(&goal_);
|
||
Add(&moreIcon_);
|
||
}
|
||
|
||
RemindGoalListView::RemindGoalListView()
|
||
{
|
||
g_pv_RemindGoalListView = this;
|
||
SetPosition(0, 0, OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
|
||
SetTouchable(true);
|
||
SetDraggable(true);
|
||
SetOnDragListener(TjdUiAppSportPresenter::GetInstance());
|
||
|
||
// InitLabel(remindTitle_, 28, 203, 17, "提醒");
|
||
remindTitle_.SetFont(TJD_VECTOR_FONT_FILENAME, 28);
|
||
remindTitle_.SetTextId(STR_ID_229);
|
||
// remindTitle_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
|
||
remindTitle_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
|
||
remindTitle_.SetPosition(0, 17, 466, 37);
|
||
|
||
int16_t startY = 50;
|
||
int16_t interval = 3;
|
||
for (int i = 0; i < REMIND_GOAL_MAX_INDEX; ++i) {
|
||
remindItemViews_[i] = new RemindGoalListItemView(g_pv_CommonRemindGoalList[i]);
|
||
remindItemViews_[i]->SetPosition(8, startY, 450, 130);
|
||
Add(remindItemViews_[i]);
|
||
startY += 130 + interval;
|
||
}
|
||
Add(&remindTitle_);
|
||
}
|
||
|
||
void RemindGoalListView::RemindGoalListViewRefresh()
|
||
{
|
||
string remindGoal = g_pv_SportGoal[TjdUiAppSportView::currentIconIndex_].heartRateRemindGoal;
|
||
remindItemViews_[HEART_RATE_INDEX]->goal_.SetText(remindGoal.c_str());
|
||
remindItemViews_[HEART_RATE_INDEX]->goal_.SetX(
|
||
(HORIZONTAL_RESOLUTION - remindItemViews_[HEART_RATE_INDEX]->goal_.GetWidth()) / 2);
|
||
|
||
remindGoal = g_pv_SportGoal[TjdUiAppSportView::currentIconIndex_].timeRemindGoal;
|
||
remindItemViews_[TIME_INDEX]->goal_.SetText(remindGoal.c_str());
|
||
remindItemViews_[TIME_INDEX]->SetY(178);
|
||
|
||
remindGoal = g_pv_SportGoal[TjdUiAppSportView::currentIconIndex_].distRemindGoal;
|
||
remindItemViews_[ONCE_INDEX]->goal_.SetText(remindGoal.c_str());
|
||
|
||
static_cast<UITransformGroup *>(remindItemViews_[HEART_RATE_INDEX])
|
||
->Scale(OHOS::Vector2<float>(0.8, 0.8), {(float)remindItemViews_[HEART_RATE_INDEX]->GetWidth() / 2,
|
||
(float)remindItemViews_[HEART_RATE_INDEX]->GetHeight() / 2});
|
||
|
||
static_cast<UITransformGroup *>(remindItemViews_[ONCE_INDEX])
|
||
->Scale(OHOS::Vector2<float>(0.74, 0.74), {(float)remindItemViews_[ONCE_INDEX]->GetWidth() / 2,
|
||
(float)remindItemViews_[ONCE_INDEX]->GetHeight() / 2});
|
||
|
||
remindItemViews_[ONCE_INDEX]->SetY(304);
|
||
remindItemViews_[ONCE_INDEX]->Invalidate();
|
||
|
||
Invalidate();
|
||
}
|
||
|
||
void RemindGoalListView::ShowView()
|
||
{
|
||
RemindGoalListViewRefresh();
|
||
SetVisible(true);
|
||
}
|
||
|
||
RemindGoalListView::~RemindGoalListView()
|
||
{
|
||
static_print_info("RemindGoalListView==line[%d]==func[%s]\n", __LINE__, __func__);
|
||
g_pv_RemindGoalListView = nullptr;
|
||
RemoveAll();
|
||
};
|
||
|
||
RemindGoalListView *RemindGoalListView::GetInstance(void) { return g_pv_RemindGoalListView; }
|
||
|
||
#pragma endregion
|
||
|
||
#pragma region 心率区间选择
|
||
HeartRateItemView::HeartRateItemView(const HeartRateItemInfo &info)
|
||
{
|
||
iconRes_ = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(info.imgIconResId, SPORT_IMAGE_BIN_PATH);
|
||
selectRes_ = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_SPORT_ICON_SELECT, SPORT_IMAGE_BIN_PATH);
|
||
unSelectRes_ = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_SPORT_ICON_NO, SPORT_IMAGE_BIN_PATH);
|
||
SetPosition(0, 0, 450, 128);
|
||
SetStyle(OHOS::STYLE_BACKGROUND_COLOR, 0xff202020);
|
||
SetStyle(OHOS::STYLE_BORDER_RADIUS, 64);
|
||
SetViewIndex(info.index);
|
||
|
||
icon_.SetPosition(28, 38, 52, 52);
|
||
if (iconRes_ != nullptr) {
|
||
icon_.SetSrc(iconRes_);
|
||
}
|
||
|
||
content_.SetTextId(info.contentId);
|
||
content_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
|
||
content_.SetAlign(OHOS::TEXT_ALIGNMENT_LEFT, OHOS::TEXT_ALIGNMENT_CENTER);
|
||
|
||
printf("content_ width = %d, height = %d\n", content_.GetWidth(), content_.GetHeight());
|
||
|
||
unit_.SetFont(TJD_VECTOR_FONT_FILENAME, 28);
|
||
unit_.SetTextId(info.unitId);
|
||
unit_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
|
||
unit_.SetStyle(STYLE_TEXT_OPA, 0xff * 0.2);
|
||
unit_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
|
||
unit_.SetPosition(263, 45, 79, 37);
|
||
printf("unit width = %d, height = %d\n", unit_.GetWidth(), unit_.GetHeight());
|
||
|
||
switch_.SetPosition(382, 44, 40, 40);
|
||
switch_.SetViewIndex(info.index);
|
||
switch_.SetStyle(STYLE_BACKGROUND_COLOR, 0xffffffff);
|
||
switch_.SetSrc(selectRes_);
|
||
|
||
SetTouchable(true);
|
||
|
||
Add(&icon_);
|
||
Add(&content_);
|
||
Add(&unit_);
|
||
Add(&switch_);
|
||
}
|
||
|
||
void HeartRateItemView::RefreshItem(const HeartRateItemInfo &itemInfo, int16_t index)
|
||
{
|
||
itemInfo_ = itemInfo;
|
||
SetViewIndex(itemInfo.index);
|
||
icon_.SetSrc(iconRes_);
|
||
if (itemInfo.contentId == STR_ID_217) {
|
||
content_.SetPosition(108, 36, 149, 50);
|
||
content_.SetFont(TJD_VECTOR_FONT_FILENAME, 42);
|
||
unit_.SetVisible(false);
|
||
icon_.SetVisible(false);
|
||
} else {
|
||
content_.SetPosition(108, 39, 149, 50);
|
||
content_.SetFont(TJD_DIN_MEDIUM_FONT_FILENAME, 42);
|
||
unit_.SetVisible(true);
|
||
icon_.SetVisible(true);
|
||
}
|
||
content_.SetTextId(itemInfo.contentId);
|
||
|
||
if (g_HeartRateReminder[TjdUiAppSportView::currentIconIndex_][itemInfo_.index] == true) {
|
||
switch_.SetSrc(selectRes_);
|
||
} else {
|
||
switch_.SetSrc(unSelectRes_);
|
||
}
|
||
}
|
||
|
||
bool HeartRateItemView::OnClickEvent(const OHOS::ClickEvent &event)
|
||
{
|
||
uint8_t selectCount = 0;
|
||
for (uint8_t i = 0; i < 5; i++) {
|
||
if (g_HeartRateReminder[TjdUiAppSportView::currentIconIndex_][i])
|
||
selectCount++;
|
||
}
|
||
|
||
if (selectCount == 1 && g_HeartRateReminder[TjdUiAppSportView::currentIconIndex_][itemInfo_.index])
|
||
return true;
|
||
|
||
if (selectCount == 1 && itemInfo_.index != NONE_SECTOR_INDEX) {
|
||
OHOS::UIView *childView = static_cast<OHOS::UITransformList *>(GetParent())->GetChildrenTail();
|
||
static_cast<HeartRateItemView *>(childView)->switch_.SetSrc(unSelectRes_);
|
||
g_HeartRateReminder[TjdUiAppSportView::currentIconIndex_][NONE_SECTOR_INDEX] = false;
|
||
} else if (itemInfo_.index == NONE_SECTOR_INDEX) {
|
||
OHOS::UIView *childView = static_cast<OHOS::UITransformList *>(GetParent())->GetChildrenHead();
|
||
while (childView != nullptr) {
|
||
static_cast<HeartRateItemView *>(childView)->switch_.SetSrc(unSelectRes_);
|
||
childView = childView->GetNextSibling();
|
||
}
|
||
|
||
for (uint8_t i = 0; i < 5; i++) {
|
||
g_HeartRateReminder[TjdUiAppSportView::currentIconIndex_][i] = false;
|
||
}
|
||
}
|
||
|
||
g_HeartRateReminder[TjdUiAppSportView::currentIconIndex_][itemInfo_.index] =
|
||
!g_HeartRateReminder[TjdUiAppSportView::currentIconIndex_][itemInfo_.index];
|
||
if (g_HeartRateReminder[TjdUiAppSportView::currentIconIndex_][itemInfo_.index] == true) {
|
||
switch_.SetSrc(selectRes_);
|
||
} else {
|
||
switch_.SetSrc(unSelectRes_);
|
||
}
|
||
return true;
|
||
}
|
||
|
||
HeartRatePickView::HeartRatePickView()
|
||
{
|
||
SetPosition(0, 0, OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
|
||
SetDraggable(true);
|
||
SetOnDragListener(TjdUiAppSportPresenter::GetInstance());
|
||
|
||
// InitLabel(heartRateTitle_, 28, 203, 17, "提醒");
|
||
heartRateTitle_.SetFont(TJD_VECTOR_FONT_FILENAME, 28);
|
||
heartRateTitle_.SetTextId(STR_ID_229);
|
||
// heartRateTitle_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
|
||
heartRateTitle_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
|
||
heartRateTitle_.SetPosition(0, 17, 466, 37);
|
||
|
||
heartRateListItemInfo_.clear();
|
||
for (int i = 0; i < HEART_RATE_MAX_INDEX; ++i) {
|
||
heartRateListItemInfo_.push_back(g_pv_HeartRateItemInfo[i]);
|
||
}
|
||
|
||
heartRateAdapterPtr_ =
|
||
new TjdUITransformListGroupAdapter<HeartRateItemInfo, HeartRateItemView, std::list<HeartRateItemInfo>>(
|
||
heartRateListItemInfo_);
|
||
heartRateListView_ = new TjdUITransformListGroup(heartRateAdapterPtr_);
|
||
heartRateListView_->AddCustomView(&heartRateTitle_, TjdUITransformListGroup::CustomViewPos::TITLE);
|
||
heartRateListView_->SetTitleOffset(70);
|
||
|
||
Add(heartRateListView_);
|
||
}
|
||
|
||
void HeartRatePickView::ShowView()
|
||
{
|
||
heartRateListView_->RefreshList();
|
||
OHOS::FocusManager::GetInstance()->ClearFocus();
|
||
heartRateListView_->RequestFocus();
|
||
SetVisible(true);
|
||
}
|
||
|
||
void HeartRatePickView::HideView()
|
||
{
|
||
uint8_t selectCount = 0;
|
||
uint8_t curSelectIndex = 0;
|
||
g_pv_SportGoal[TjdUiAppSportView::currentIconIndex_].heartRateRemindGoal.clear();
|
||
for (uint8_t i = 0; i < 5; i++) {
|
||
sql_fit_set_sport_heart_rate_remind_value(i, g_HeartRateReminder[TjdUiAppSportView::currentIconIndex_][i]);
|
||
if (g_HeartRateReminder[TjdUiAppSportView::currentIconIndex_][i]) {
|
||
selectCount++;
|
||
curSelectIndex = i;
|
||
}
|
||
}
|
||
|
||
static_print_info("===selectCount = %d,curSelectIndex = %d\n", selectCount, curSelectIndex);
|
||
if (selectCount == 1 && curSelectIndex == NONE_SECTOR_INDEX) {
|
||
g_pv_SportGoal[TjdUiAppSportView::currentIconIndex_].heartRateRemindGoal =
|
||
FontGlobalManager::GetInstance()->GetText(STR_ID_217);
|
||
} else if (selectCount == 1) {
|
||
g_pv_SportGoal[TjdUiAppSportView::currentIconIndex_].heartRateRemindGoal =
|
||
std::string(FontGlobalManager::GetInstance()->GetText(g_pv_HeartRateItemInfo[curSelectIndex].contentId)) +
|
||
std::string(" ") +
|
||
std::string(FontGlobalManager::GetInstance()->GetText(g_pv_HeartRateItemInfo[curSelectIndex].unitId));
|
||
} else {
|
||
string heartRateRemindGoal = "";
|
||
uint8_t count = 0;
|
||
for (uint8_t j = 0; j < HEART_RATE_MAX_INDEX; j++) {
|
||
{
|
||
if (g_HeartRateReminder[TjdUiAppSportView::currentIconIndex_][j]) {
|
||
if (count < selectCount - 1) {
|
||
heartRateRemindGoal += std::string(FontGlobalManager::GetInstance()->GetText(
|
||
g_pv_HeartRateItemInfo[j].contentId)) +
|
||
std::string("、");
|
||
} else
|
||
heartRateRemindGoal +=
|
||
std::string(FontGlobalManager::GetInstance()->GetText(g_pv_HeartRateItemInfo[j].contentId));
|
||
count++;
|
||
}
|
||
}
|
||
}
|
||
|
||
g_pv_SportGoal[TjdUiAppSportView::currentIconIndex_].heartRateRemindGoal = heartRateRemindGoal;
|
||
}
|
||
SetVisible(false);
|
||
}
|
||
|
||
HeartRatePickView::~HeartRatePickView()
|
||
{
|
||
RemoveAll();
|
||
|
||
if (heartRateAdapterPtr_ != nullptr) {
|
||
delete heartRateAdapterPtr_;
|
||
heartRateAdapterPtr_ = nullptr;
|
||
}
|
||
|
||
if (heartRateListView_ != nullptr) {
|
||
heartRateListView_->RemoveAll();
|
||
delete heartRateListView_;
|
||
heartRateListView_ = nullptr;
|
||
}
|
||
};
|
||
|
||
#pragma endregion
|
||
|
||
#pragma region 时间提醒、距离提醒item
|
||
TimeOrDistRemindItemView::TimeOrDistRemindItemView(const TimeOrDistRemindItemInfo &info)
|
||
{
|
||
selectRes_ = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_SPORT_ICON_SELECT, SPORT_IMAGE_BIN_PATH);
|
||
unSelectRes_ = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_SPORT_ICON_NO, SPORT_IMAGE_BIN_PATH);
|
||
SetPosition(0, 0, 450, 128);
|
||
SetStyle(OHOS::STYLE_BACKGROUND_COLOR, 0xff202020);
|
||
SetStyle(OHOS::STYLE_BORDER_RADIUS, 64);
|
||
|
||
content_.SetFont(TJD_VECTOR_FONT_FILENAME, 36);
|
||
content_.SetTextId(info.contentId);
|
||
content_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_MARQUEE);
|
||
content_.SetAlign(OHOS::TEXT_ALIGNMENT_LEFT, OHOS::TEXT_ALIGNMENT_CENTER);
|
||
content_.SetPosition(42, 36, 300, 56);
|
||
|
||
switch_.SetPosition(382, 44, 40, 40);
|
||
switch_.SetViewIndex(info.index);
|
||
switch_.SetStyle(STYLE_BACKGROUND_COLOR, 0xffffffff);
|
||
switch_.SetSrc(selectRes_);
|
||
|
||
SetTouchable(true);
|
||
|
||
Add(&content_);
|
||
Add(&switch_);
|
||
}
|
||
|
||
void TimeOrDistRemindItemView::RefreshItem(const TimeOrDistRemindItemInfo &itemInfo, int16_t index)
|
||
{
|
||
itemInfo_ = itemInfo;
|
||
SetViewIndex(itemInfo.index);
|
||
// if (itemInfo.contentId == STR_ID_217) {
|
||
// content_.SetPosition(108, 36, 149, 50);
|
||
// content_.SetFont(TJD_VECTOR_FONT_FILENAME, 42);
|
||
// unit_.SetVisible(false);
|
||
// } else {
|
||
// content_.SetPosition(108, 39, 149, 50);
|
||
// content_.SetFont(TJD_DIN_MEDIUM_FONT_FILENAME, 42);
|
||
// unit_.SetVisible(true);
|
||
// }
|
||
content_.SetTextId(itemInfo_.contentId);
|
||
|
||
if (g_TimeReminder[TjdUiAppSportView::currentIconIndex_][itemInfo_.index] == true) {
|
||
switch_.SetSrc(selectRes_);
|
||
} else {
|
||
switch_.SetSrc(unSelectRes_);
|
||
}
|
||
}
|
||
|
||
void TimeOrDistRemindItemView::TimeRemindOnClickEventHandle(void)
|
||
{
|
||
if (g_TimeReminder[TjdUiAppSportView::currentIconIndex_][itemInfo_.index])
|
||
return;
|
||
|
||
OHOS::UIView *childView = static_cast<OHOS::UITransformList *>(GetParent())->GetChildrenHead();
|
||
while (childView != nullptr) {
|
||
static_cast<TimeOrDistRemindItemView *>(childView)->switch_.SetSrc(unSelectRes_);
|
||
childView = childView->GetNextSibling();
|
||
}
|
||
|
||
for (uint8_t i = 0; i < 7; i++) {
|
||
g_TimeReminder[TjdUiAppSportView::currentIconIndex_][i] = false;
|
||
}
|
||
|
||
g_TimeReminder[TjdUiAppSportView::currentIconIndex_][itemInfo_.index] =
|
||
!g_TimeReminder[TjdUiAppSportView::currentIconIndex_][itemInfo_.index];
|
||
if (g_TimeReminder[TjdUiAppSportView::currentIconIndex_][itemInfo_.index] == true) {
|
||
switch_.SetSrc(selectRes_);
|
||
} else {
|
||
switch_.SetSrc(unSelectRes_);
|
||
}
|
||
|
||
TimeRemindPickView::curSelectTimeIndex = itemInfo_.index;
|
||
}
|
||
|
||
void TimeOrDistRemindItemView::DistanceRemindOnClickEventHandle(void)
|
||
{
|
||
if (g_DistanceReminder[TjdUiAppSportView::currentIconIndex_][itemInfo_.index])
|
||
return;
|
||
|
||
OHOS::UIView *childView = static_cast<OHOS::UITransformList *>(GetParent())->GetChildrenHead();
|
||
while (childView != nullptr) {
|
||
static_cast<TimeOrDistRemindItemView *>(childView)->switch_.SetSrc(unSelectRes_);
|
||
childView = childView->GetNextSibling();
|
||
}
|
||
|
||
for (uint8_t i = 0; i < 6; i++) {
|
||
g_DistanceReminder[TjdUiAppSportView::currentIconIndex_][i] = false;
|
||
}
|
||
|
||
g_DistanceReminder[TjdUiAppSportView::currentIconIndex_][itemInfo_.index] =
|
||
!g_DistanceReminder[TjdUiAppSportView::currentIconIndex_][itemInfo_.index];
|
||
if (g_DistanceReminder[TjdUiAppSportView::currentIconIndex_][itemInfo_.index] == true) {
|
||
switch_.SetSrc(selectRes_);
|
||
} else {
|
||
switch_.SetSrc(unSelectRes_);
|
||
}
|
||
|
||
DistanceRemindPickView::curSelectDistanceIndex = itemInfo_.index;
|
||
}
|
||
|
||
bool TimeOrDistRemindItemView::OnClickEvent(const OHOS::ClickEvent &event)
|
||
{
|
||
if (itemInfo_.type == 0) {
|
||
TimeRemindOnClickEventHandle();
|
||
} else {
|
||
DistanceRemindOnClickEventHandle();
|
||
}
|
||
return true;
|
||
}
|
||
|
||
#pragma endregion
|
||
|
||
#pragma region 时间提醒区间选择
|
||
|
||
TimeRemindPickView::TimeRemindPickView()
|
||
{
|
||
SetPosition(0, 0, OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
|
||
SetDraggable(true);
|
||
SetOnDragListener(TjdUiAppSportPresenter::GetInstance());
|
||
|
||
// InitLabel(timeRemindTitle_, 28, 203, 17, "提醒");
|
||
timeRemindTitle_.SetFont(TJD_VECTOR_FONT_FILENAME, 28);
|
||
timeRemindTitle_.SetTextId(STR_ID_229);
|
||
// timeRemindTitle_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
|
||
timeRemindTitle_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
|
||
timeRemindTitle_.SetPosition(0, 17, 466, 37);
|
||
|
||
timeListItemInfo_.clear();
|
||
for (int i = 0; i < MAX_MIN_INDEX; ++i) {
|
||
timeListItemInfo_.push_back(g_pv_TimeRemindItemInfo[i]);
|
||
}
|
||
|
||
timeAdapterPtr_ = new TjdUITransformListGroupAdapter<TimeOrDistRemindItemInfo, TimeOrDistRemindItemView,
|
||
std::list<TimeOrDistRemindItemInfo>>(timeListItemInfo_);
|
||
timeListView_ = new TjdUITransformListGroup(timeAdapterPtr_);
|
||
timeListView_->AddCustomView(&timeRemindTitle_, TjdUITransformListGroup::CustomViewPos::TITLE);
|
||
timeListView_->SetTitleOffset(80);
|
||
|
||
Add(timeListView_);
|
||
}
|
||
|
||
void TimeRemindPickView::ShowView()
|
||
{
|
||
// TjdUiUtils::ScrollByTop(*this);
|
||
// timeItemViews_[curSelectTimeIndex]->checkBox_.SetState(OHOS::UICheckBox::UICheckBoxState::SELECTED);
|
||
timeListView_->RefreshList();
|
||
OHOS::FocusManager::GetInstance()->ClearFocus();
|
||
timeListView_->RequestFocus();
|
||
SetVisible(true);
|
||
// TjdUiUtils::ViewRequestFocus(*this);
|
||
}
|
||
void TimeRemindPickView::HideView()
|
||
{
|
||
for (uint8_t k = 0; k < MAX_MIN_INDEX; k++) {
|
||
if (g_TimeReminder[TjdUiAppSportView::currentIconIndex_][k])
|
||
g_pv_SportGoal[TjdUiAppSportView::currentIconIndex_].timeRemindGoal =
|
||
std::string(FontGlobalManager::GetInstance()->GetText(g_pv_TimeRemindItemInfo[k].contentId));
|
||
}
|
||
|
||
sql_fit_set_sport_time_remind_value(curSelectTimeIndex); // 数据保存到sql中
|
||
SetVisible(false);
|
||
}
|
||
|
||
TimeRemindPickView::~TimeRemindPickView()
|
||
{
|
||
RemoveAll();
|
||
|
||
if (timeAdapterPtr_ != nullptr) {
|
||
delete timeAdapterPtr_;
|
||
timeAdapterPtr_ = nullptr;
|
||
}
|
||
|
||
if (timeListView_ != nullptr) {
|
||
timeListView_->RemoveAll();
|
||
delete timeListView_;
|
||
timeListView_ = nullptr;
|
||
}
|
||
};
|
||
#pragma endregion
|
||
|
||
#pragma region 距离提醒区间选择
|
||
DistanceRemindPickView::DistanceRemindPickView()
|
||
{
|
||
SetPosition(0, 0, OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
|
||
SetDraggable(true);
|
||
SetOnDragListener(TjdUiAppSportPresenter::GetInstance());
|
||
|
||
// InitLabel(distRemindTitle_, 28, 203, 17, "提醒");
|
||
distRemindTitle_.SetFont(TJD_VECTOR_FONT_FILENAME, 28);
|
||
distRemindTitle_.SetTextId(STR_ID_229);
|
||
// distRemindTitle_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
|
||
distRemindTitle_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
|
||
distRemindTitle_.SetPosition(0, 17, 466, 37);
|
||
|
||
distanceListItemInfo_.clear();
|
||
for (int i = 0; i < MAX_DISTANCE_INDEX; ++i) {
|
||
distanceListItemInfo_.push_back(g_pv_DistanceRemindItemInfo[i]);
|
||
}
|
||
|
||
distanceAdapterPtr_ =
|
||
new TjdUITransformListGroupAdapter<TimeOrDistRemindItemInfo, TimeOrDistRemindItemView,
|
||
std::list<TimeOrDistRemindItemInfo>>(distanceListItemInfo_);
|
||
distanceListView_ = new TjdUITransformListGroup(distanceAdapterPtr_);
|
||
distanceListView_->AddCustomView(&distRemindTitle_, TjdUITransformListGroup::CustomViewPos::TITLE);
|
||
distanceListView_->SetTitleOffset(80);
|
||
|
||
Add(distanceListView_);
|
||
}
|
||
|
||
void DistanceRemindPickView::ShowView()
|
||
{
|
||
distanceListView_->RefreshList();
|
||
OHOS::FocusManager::GetInstance()->ClearFocus();
|
||
distanceListView_->RequestFocus();
|
||
SetVisible(true);
|
||
}
|
||
void DistanceRemindPickView::HideView()
|
||
{
|
||
// g_pv_SportGoal[TjdUiAppSportView::currentIconIndex_].distRemindGoal =
|
||
// std::string(g_pv_DistanceRemindItemInfo[curSelectDistanceIndex].content);
|
||
for (uint8_t k = 0; k < MAX_DISTANCE_INDEX; k++) {
|
||
if (g_DistanceReminder[TjdUiAppSportView::currentIconIndex_][k])
|
||
g_pv_SportGoal[TjdUiAppSportView::currentIconIndex_].distRemindGoal =
|
||
std::string(FontGlobalManager::GetInstance()->GetText(g_pv_DistanceRemindItemInfo[k].contentId));
|
||
}
|
||
SetVisible(false);
|
||
sql_fit_set_sport_dist_remind_value(curSelectDistanceIndex);
|
||
}
|
||
|
||
DistanceRemindPickView::~DistanceRemindPickView()
|
||
{
|
||
RemoveAll();
|
||
|
||
if (distanceAdapterPtr_ != nullptr) {
|
||
delete distanceAdapterPtr_;
|
||
distanceAdapterPtr_ = nullptr;
|
||
}
|
||
|
||
if (distanceListView_ != nullptr) {
|
||
distanceListView_->RemoveAll();
|
||
delete distanceListView_;
|
||
distanceListView_ = nullptr;
|
||
}
|
||
};
|
||
#pragma endregion
|
||
|
||
#pragma region 运动消息弹窗
|
||
// ----------------------------------------------------------------------------
|
||
static void popupTimerCallBack(void *data)
|
||
{
|
||
static_print_info("popupTimerCallBack\n");
|
||
if (popupTimer_ != nullptr) {
|
||
popupTimer_->Stop();
|
||
delete popupTimer_;
|
||
popupTimer_ = nullptr;
|
||
}
|
||
NotificationManager::GetInstance()->StopNotify();
|
||
// view.SetVisible(false);
|
||
}
|
||
|
||
// 运动消息弹窗
|
||
bool SportPopupWindowListener::OnClick(OHOS::UIView &view, const OHOS::ClickEvent &event)
|
||
{
|
||
static_print_info("sport popup window click\n");
|
||
if (popupTimer_ != nullptr) {
|
||
popupTimer_->Stop();
|
||
delete popupTimer_;
|
||
popupTimer_ = nullptr;
|
||
}
|
||
tjd_driver_motor_user_stop();
|
||
NotificationManager::GetInstance()->StopNotify();
|
||
view.SetVisible(false);
|
||
return true;
|
||
}
|
||
|
||
bool SportPopupWindowListener::OnKeyAct(OHOS::UIView &view, const OHOS::KeyEvent &event)
|
||
{
|
||
if (popupTimer_ != nullptr) {
|
||
popupTimer_->Stop();
|
||
delete popupTimer_;
|
||
popupTimer_ = nullptr;
|
||
}
|
||
|
||
if (!TjdUiCommonOnKeyListener::CheckIsExitEvent(event)) {
|
||
return true;
|
||
}
|
||
NotificationManager::GetInstance()->StopNotify();
|
||
return true;
|
||
}
|
||
|
||
SportPopupWindow::SportPopupWindow(PopupMsgType msgType, char *goal)
|
||
{
|
||
SetPosition(0, 0, OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
|
||
SetViewId("SportPopupWindow");
|
||
SetTouchable(true);
|
||
SetOnClickListener(&onclickListener_);
|
||
OHOS::RootView::GetInstance()->SetOnKeyActListener(&onkeyListener_);
|
||
|
||
std::ostringstream oss;
|
||
std::string goalStr;
|
||
static_print_info("===SportPopupWindow::SportPopupWindow\n");
|
||
auto imgInfo = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(
|
||
g_pv_Sport[TjdUiAppSportView::currentIconIndex_].imgIconResId, SPORT_IMAGE_BIN_PATH);
|
||
|
||
UIDrawImageScale(&sportIcon_, 183, 20, imgInfo, 0.6, 0.6, 30, 30);
|
||
|
||
switch (msgType) {
|
||
case SPORT_POPUP_MSG_TYPE_TIME:
|
||
case SPORT_POPUP_MSG_TYPE_DISTANCE:
|
||
case SPORT_POPUP_MSG_TYPE_CALORIES:
|
||
imgInfo = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_SPORT_ACHIEVE, SPORT_IMAGE_BIN_PATH);
|
||
UiDrawImage(&achieveIcon_, 151, 134, imgInfo);
|
||
|
||
// InitLabelHorCenter(tip_, 28, 333, 466, "达成目标");
|
||
tip_.SetFont(TJD_VECTOR_FONT_FILENAME, 28);
|
||
tip_.SetTextId(STR_ID_210);
|
||
tip_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
|
||
tip_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
|
||
tip_.SetPosition((OHOS::HORIZONTAL_RESOLUTION - tip_.GetWidth()) / 2, 333);
|
||
|
||
// InitLabelHorCenter(popupContent_, 50, 372, 466, goal, 0xFFEA28FF);
|
||
popupContent_.SetFont(TJD_VECTOR_FONT_FILENAME, 50);
|
||
popupContent_.SetText(goal);
|
||
popupContent_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_WRAP);
|
||
popupContent_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
|
||
popupContent_.SetPosition(50, 372, 366, 70);
|
||
popupContent_.SetTextColor(Color::GetColorFromRGBA(
|
||
static_cast<uint8_t>((0xFFEA28FF >> 24) & 0xFF), static_cast<uint8_t>((0xFFEA28FF >> 16) & 0xFF),
|
||
static_cast<uint8_t>((0xFFEA28FF >> 8) & 0xFF), static_cast<uint8_t>(0xFFEA28FF & 0xFF)));
|
||
|
||
Add(&tip_);
|
||
Add(&achieveIcon_);
|
||
break;
|
||
case SPORT_POPUP_MSG_TYPE_PER_DISTANCE:
|
||
// oss << "已运动" << goal << "m,\n请继续加油！";
|
||
oss << FontGlobalManager::GetInstance()->GetText(STR_ID_214) << goal << "m,"
|
||
<< FontGlobalManager::GetInstance()->GetText(STR_ID_215);
|
||
goalStr = oss.str();
|
||
imgInfo = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_SPORT_ENCOURAGE, SPORT_IMAGE_BIN_PATH);
|
||
UiDrawImage(&distanceIcon_, 171, 149, imgInfo);
|
||
// InitLabelHorCenter(popupContent_, 28, 311, 466, goalStr.c_str());
|
||
popupContent_.SetFont(TJD_VECTOR_FONT_FILENAME, 28);
|
||
popupContent_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_WRAP);
|
||
popupContent_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
|
||
popupContent_.SetPosition(50, 311, 366, 40);
|
||
popupContent_.SetText(goalStr.c_str());
|
||
|
||
Add(&distanceIcon_);
|
||
break;
|
||
case SPORT_POPUP_MSG_TYPE_PER_TIME:
|
||
// oss << "已运动" << goal << ",\n请继续加油！";
|
||
oss << FontGlobalManager::GetInstance()->GetText(STR_ID_214) << goal << ","
|
||
<< FontGlobalManager::GetInstance()->GetText(STR_ID_215);
|
||
goalStr = oss.str();
|
||
imgInfo = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_SPORT_ENCOURAGE, SPORT_IMAGE_BIN_PATH);
|
||
UiDrawImage(&timeIcon_, 171, 149, imgInfo);
|
||
// InitLabelHorCenter(popupContent_, 28, 311, 466, goalStr.c_str());
|
||
popupContent_.SetFont(TJD_VECTOR_FONT_FILENAME, 28);
|
||
popupContent_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_WRAP);
|
||
popupContent_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
|
||
popupContent_.SetPosition(50, 311, 366, 40);
|
||
popupContent_.SetText(goalStr.c_str());
|
||
|
||
Add(&timeIcon_);
|
||
break;
|
||
case SPORT_POPUP_MSG_TYPE_PER_HEARTRATE_TYPE_1:
|
||
case SPORT_POPUP_MSG_TYPE_PER_HEARTRATE_TYPE_2:
|
||
case SPORT_POPUP_MSG_TYPE_PER_HEARTRATE_TYPE_3:
|
||
case SPORT_POPUP_MSG_TYPE_PER_HEARTRATE_TYPE_4:
|
||
switch (msgType) {
|
||
case SPORT_POPUP_MSG_TYPE_PER_HEARTRATE_TYPE_1:
|
||
popupContent_.SetTextId(STR_ID_211);
|
||
imgInfo = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_SPORT_ICON_HR, SPORT_IMAGE_BIN_PATH);
|
||
break;
|
||
case SPORT_POPUP_MSG_TYPE_PER_HEARTRATE_TYPE_2:
|
||
popupContent_.SetTextId(STR_ID_212);
|
||
imgInfo = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_SPORT_ICON_HR, SPORT_IMAGE_BIN_PATH);
|
||
break;
|
||
case SPORT_POPUP_MSG_TYPE_PER_HEARTRATE_TYPE_3:
|
||
popupContent_.SetTextId(STR_ID_213);
|
||
imgInfo = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_SPORT_ICON_HR, SPORT_IMAGE_BIN_PATH);
|
||
break;
|
||
case SPORT_POPUP_MSG_TYPE_PER_HEARTRATE_TYPE_4:
|
||
popupContent_.SetTextId(STR_ID_216);
|
||
imgInfo = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_SPORT_ICON_HR_WARNING,
|
||
SPORT_IMAGE_BIN_PATH);
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
goalStr = oss.str();
|
||
UiDrawImage(&heartrateIcon_, 155, 127, imgInfo);
|
||
// InitLabelHorCenter(popupContent_, 28, 296, 466, goalStr.c_str());
|
||
popupContent_.SetFont(TJD_VECTOR_FONT_FILENAME, 28);
|
||
popupContent_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_WRAP);
|
||
popupContent_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
|
||
popupContent_.SetPosition(50, 296, 366, 40);
|
||
|
||
Add(&heartrateIcon_);
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
|
||
if (popupTimer_ == nullptr) {
|
||
popupTimer_ = new OHOS::GraphicTimer(5000, popupTimerCallBack, nullptr, false);
|
||
}
|
||
popupTimer_->Start();
|
||
|
||
motor_param_t motorParam = {.cycle1_on = 2000, .cycle1_off = 0, .cycle1_cnt = 1, .duty = 100};
|
||
tjd_driver_motor_user_start(&motorParam);
|
||
|
||
Add(&popupContent_);
|
||
Add(&sportIcon_);
|
||
}
|
||
#pragma endregion
|
||
|
||
#pragma region 运动结束提醒
|
||
static void finishiTimerCallBack(void *data)
|
||
{
|
||
static_print_info("finishiTimerCallBack\n");
|
||
if (finishTimer_ != nullptr) {
|
||
finishTimer_->Stop();
|
||
delete finishTimer_;
|
||
finishTimer_ = nullptr;
|
||
}
|
||
NotificationManager::GetInstance()->StopNotify();
|
||
// view.SetVisible(false);
|
||
}
|
||
|
||
bool SportFinishRemindOnclickListener::OnClick(OHOS::UIView &view, const OHOS::ClickEvent &event)
|
||
{
|
||
static_print_info("SportFinishRemindOnclickListener OnClick\n");
|
||
if (view.GetViewId() == "image_cancel") {
|
||
static_print_info("SportFinishRemindOnclickListener OnClick cancel\n");
|
||
view.GetParent()->SetVisible(false);
|
||
NotificationManager::GetInstance()->StopNotify();
|
||
} else if (view.GetViewId() == "image_confirm") {
|
||
static_print_info("SportFinishRemindOnclickListener OnClick confirm\n");
|
||
// view.GetParent()->SetVisible(false);
|
||
auto sportView = TjdUiAppSportView::GetInstance();
|
||
sportView->ShowTargetView(SPORT_END_DATA_VIEW);
|
||
NotificationManager::GetInstance()->StopNotify();
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool SportFinishRemindOnclickListener::OnKeyAct(OHOS::UIView &view, const OHOS::KeyEvent &event)
|
||
{
|
||
static_print_info("SportFinishRemindOnclickListener::OnKeyAct\n");
|
||
if (event.GetState() == OHOS::InputDevice::STATE_RELEASE) {
|
||
if (finishTimer_ != nullptr) {
|
||
finishTimer_->Stop();
|
||
delete finishTimer_;
|
||
finishTimer_ = nullptr;
|
||
}
|
||
NotificationManager::GetInstance()->StopNotify();
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
SportFinishRemindView::SportFinishRemindView(uint8_t time_stamp)
|
||
{
|
||
SetPosition(0, 0, OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
|
||
OHOS::RootView::GetInstance()->SetOnKeyActListener(&onkeyListener_);
|
||
|
||
std::string finalContent =
|
||
std::string("您已经") + std::to_string(time_stamp) + std::string("分钟未运动\n是否结束运动?");
|
||
InitLabelHorCenter(remindContent_, 34, 196, 466, finalContent.c_str());
|
||
|
||
auto image = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_CONFIRM_CANCEL_CANCEL,
|
||
CONFIRM_CANCEL_RES_BIN_PATH);
|
||
cancelImage_.SetPosition(103, 326);
|
||
if (image != nullptr) {
|
||
cancelImage_.SetSrc(image);
|
||
}
|
||
cancelImage_.SetTouchable(true);
|
||
cancelImage_.SetViewId("image_cancel");
|
||
cancelImage_.SetOnClickListener(&listener_);
|
||
|
||
image = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_CONFIRM_CANCEL_CONFIRM,
|
||
CONFIRM_CANCEL_RES_BIN_PATH);
|
||
confirmImage_.SetPosition(271, 326);
|
||
if (image != nullptr) {
|
||
confirmImage_.SetSrc(image);
|
||
}
|
||
confirmImage_.SetViewId("image_confirm");
|
||
confirmImage_.SetTouchable(true);
|
||
confirmImage_.SetOnClickListener(&listener_);
|
||
|
||
if (finishTimer_ == nullptr) {
|
||
finishTimer_ = new OHOS::GraphicTimer(5000, finishiTimerCallBack, nullptr, false);
|
||
}
|
||
finishTimer_->Start();
|
||
|
||
Add(&remindContent_);
|
||
Add(&cancelImage_);
|
||
Add(&confirmImage_);
|
||
}
|
||
|
||
SportFinishRemindView::~SportFinishRemindView()
|
||
{
|
||
static_print_info("SportFinishRemindView::~SportFinishRemindView\n");
|
||
if (finishTimer_ != nullptr) {
|
||
finishTimer_->Stop();
|
||
delete finishTimer_;
|
||
finishTimer_ = nullptr;
|
||
}
|
||
RemoveAll();
|
||
ImageCacheManager::GetInstance().UnloadAllInMultiRes(CONFIRM_CANCEL_RES_BIN_PATH);
|
||
};
|
||
#pragma endregion
|
||
|
||
#pragma region 运动目标页
|
||
#pragma endregion
|
||
|
||
#pragma region 运动目标页
|
||
#pragma endregion
|
||
|
||
#pragma region 运动目标页
|
||
#pragma endregion
|
||
|
||
} // namespace TJD
|