#include "TjdUiAppMainPageFavorite.h"
#include "NativeAbility.h"
#include "TjdUiAppListModel.h"
#include "TjdUiAppMainView.h"
#include "TjdUiAppSettingModel.h"
#include "TjdUiAppSettingView.h"
#include "TjdUiImageIds.h"
#include "TjdUiMultiLanguageExt.h"
#include "TjdUiScreenDrag.h"
#include "TjdUiSettingCenter.h"
#include "TjdUiUtils.h"
#include "common/image_cache_manager.h"
#include "common/key_code.h"
#include "dock/input_device.h"
#include "graphic_service.h"
#include "hal_tick.h"
#include "rtc_api.h"
#include "sql_fit.h"
#include "sql_setting.h"
#include "sql_weather.h"
#include "ui_screennotify.h"
#include <cstdio>
#include <iomanip>
#include <sstream>
#include <string>
#include <unordered_set>

using namespace OHOS;

namespace TJD {

#define APP_IMAGE_BIN_PATH TJD_IMAGE_PATH "img_menu_list.bin"
#define FAVORITE_IMAGE_BIN_PATH TJD_IMAGE_PATH "img_main_favorite.bin"
#define COMMON_IMAGE_BIN_PATH TJD_IMAGE_PATH "img_loading.bin"

static ImageAnimatorInfo g_imageAnimator1Info[3] = {};
constexpr int16_t MAIN_VIEW_BLANK_SIZE = 30;
constexpr uint8_t REBOUND_SIZE = 200;
// clang-format off
static inline int16_t HorizontalCenter(int16_t width, int16_t parentWidth) { return (parentWidth - width) / 2; }

static inline int16_t VerticalCenter(int16_t height, int16_t parentHeight) { return (parentHeight - height) / 2; }

static inline void InitLabelHorCenter(OHOS::UILabel &label, uint8_t size, int16_t y, int16_t target, const char *text)
{
    label.SetFont(TJD_VECTOR_FONT_FILENAME, size);
    label.SetText(text);
    label.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
    label.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    label.SetPosition(HorizontalCenter(label.GetWidth(), target), y);
}

static inline void InitLabelVerCenter(OHOS::UILabel &label, uint8_t size, int16_t x, int16_t target, const char *text)
{
    label.SetFont(TJD_VECTOR_FONT_FILENAME, size);
    label.SetText(text);
    label.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
    label.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    label.SetPosition(x, VerticalCenter(label.GetHeight(), target));
}

static inline void SetRotateEnable(OHOS::UIScrollView &view)
{
    view.SetThrowDrag(true);
    view.SetReboundSize(REBOUND_SIZE);
    view.SetYScrollBarVisible(true);
    view.SetSwipeACCLevel(10);
    view.SetDragACCLevel(15);
}
// clang-format on

typedef struct
{
    uint32_t hour;
    uint32_t minute;
    uint32_t second;
} simple_timer_t;

static uint32_t g_start_time = 0;
static uint32_t g_pause_time = 0;
static uint32_t g_simple_timer_sec_count = 0;
static bool g_timeKeepingIsStart = false;
static simple_timer_t g_simple_timer_time = {};

static uint32_t get_hal_tick_time()
{
    struct timespec time;
    clock_gettime(CLOCK_MONOTONIC, &time);
    return time.tv_sec * 1000 + time.tv_nsec / 1000000;
}

static void tjd_service_simple_timer_start(void)
{
    g_start_time += get_hal_tick_time() - g_pause_time;
    g_pause_time = 0;
}

static void tjd_service_simple_timer_pause(void) { g_pause_time = get_hal_tick_time(); }

static void tjd_service_simple_timer_stop(void)
{
    g_simple_timer_sec_count = 0;
    g_start_time = 0;
    g_pause_time = 0;
}

static uint32_t tjd_service_simple_timer_get_count(void)
{
    g_simple_timer_sec_count = get_hal_tick_time() - g_start_time;
    return g_simple_timer_sec_count / 1000;
}

const simple_timer_t *tjd_service_simple_timer_get_time(void)
{
    uint32_t curTime = tjd_service_simple_timer_get_count();
    g_simple_timer_time.hour = curTime / 3600;
    g_simple_timer_time.minute = (curTime % 3600) / 60;
    g_simple_timer_time.second = (curTime % 3600) % 60;
    return &g_simple_timer_time;
}

static std::list<FavoriteModel> g_favoriteModelList_;

#pragma region FavoritePresenter

class FavoritePresenter;
static FavoritePresenter *g_favoritePresenter = nullptr;
class FavoritePresenter : public OHOS::UIView::OnClickListener, public TjdUiScreenDragListener
{
public:
    FavoritePresenter();
    ~FavoritePresenter();
    static FavoritePresenter *GetInstance(void) { return g_favoritePresenter; }
    bool OnClick(OHOS::UIView &view, const OHOS::ClickEvent &event);
    bool OnDragStart(OHOS::UIView &view, const OHOS::DragEvent &event);
    bool OnDragEnd(OHOS::UIView &view, const OHOS::DragEvent &event);
    void ScreenDragEventCallback(OHOS::UIView &view, const OHOS::DragEvent &event)
    {
        auto favortiteView = TjdUiAppMainPageFavorite::GetInstance();
        if (favortiteView == nullptr) {
            return;
        }
        if (favortiteView->currentViewIndex_ == FavoriteViewIndex::SORT_VIEW_INDEX) {
            SelectEdit();
        } else if (favortiteView->currentViewIndex_ == FavoriteViewIndex::CHOOSE_TOP_MODEL_VIEW_INDEX) {
            favortiteView->ShowView(FavoriteViewIndex::SORT_VIEW_INDEX);
        }
    }
    void SetTopModelType(TopModelType type)
    {
        if (topModelType_ != type) {
            topModelType_ = type;
            isChange_ = true;
        }
    };
    bool IsPlaying()
    {
        auto playerModel = TjdUiAppPlayerModel::GetInstance();
        if (playerModel->GetPlayerCtr() == nullptr) {
            return false;
        }
        return playerModel->GetPlayerCtr()->IsPlaying();
    }
    TopModelType GetTopModelType() { return topModelType_; };
    void UpdateViewData();
    void StartJumpTimer(FavoriteViewIndex jumpView);
    void DeleteJumpTimer()
    {
        if (jumpTimerId_ != nullptr) {
            osTimerDelete(jumpTimerId_);
            jumpTimerId_ = nullptr;
        }
    }
    std::string &GetTemper() { return temper_; }
    uint16_t WeartherType() { return weartherType_; }
    std::string &GetHeartRate() { return heartRateStr_; }
    uint16_t GetHeartRateLevel() { return heartRateLevel_; }
    std::string &GetSpo2() { return spo2Str_; }
    uint16_t GetSpo2Level() { return spo2Level_; }
    std::string &GetSleepHourTime() { return sleepHourTime_; }
    std::string &GetSleepMinuteTime() { return sleepMinuteTime_; }
    uint16_t GetSleepLevel() { return sleepLevel_; }
    std::string &GetStepCount() { return stepCount_; }
    std::string &GetDistance() { return distance_; }
    std::string &GetCalorie() { return calorie_; }
    uint8_t GetHeartRateValue() { return heartRateValue_; }
    uint8_t GetSpo2Value() { return spo2Value_; }
    uint32_t GetStepProcess() { return stepProcess; }

    void SelectEdit(void)
    {
        if (isChange_) {
            isChange_ = false;
            TjdUiAppMainPageFavorite::GetInstance()->ShowView(FavoriteViewIndex::BREAK_VIEW_INDEX);
        } else {
            TjdUiAppMainPageFavorite::GetInstance()->ShowView(FavoriteViewIndex::MAIN_VIEW_INDEX);
        }
    }
    void SetSortIsChange(bool isChange) { isChange_ = isChange; }
    void SelectTopModelIndex(int32_t index) { topModelIndex_ = index; };
    int32_t GetTopModelIndex() { return topModelIndex_; }

private:
    void SelectTopModel(void)
    {
        if (TjdUiSettingCenter::GetInstance().IsConnectApp()) {
            if (topModelType_ == TopModelType::TOP_MODEL_WEATHER) {
                OHOS::NativeAbility::GetInstance().ChangeSlice(TJD_APP_VIEW_WEATHER);
            } else if (topModelType_ == TopModelType::TOP_MODEL_VOICE) {
                OHOS::NativeAbility::GetInstance().ChangeSlice(TJD_APP_VIEW_VOICE_ASSISTANT);
            }
        } else {
            TjdUiAppSettingModel::GetInstance()->SetShowConnectQrCode(true);
            OHOS::NativeAbility::GetInstance().ChangeSlice(TJD_APP_VIEW_SETTING_COMMON_CONNECT,
                                                           OHOS::TransitionType::TRANSITION_INVALID,
                                                           OHOS::gSliceDefaultPriority, true);
        }
    }
    bool isChange_{false};
    int32_t topModelIndex_{0};
    TopModelType topModelType_{TOP_MODEL_WEATHER};
    std::string temper_;
    uint16_t weartherType_;
    std::string heartRateStr_;
    uint16_t heartRateLevel_;
    uint8_t heartRateValue_;
    std::string spo2Str_;
    uint16_t spo2Level_;
    uint8_t spo2Value_;
    std::string sleepHourTime_;
    std::string sleepMinuteTime_;
    uint16_t sleepLevel_;
    std::string stepCount_;
    std::string distance_;
    std::string calorie_;
    uint32_t curDistance = 0;
    uint32_t totalDistance = 0;
    uint32_t stepProcess = 0;
    osTimerId_t jumpTimerId_{nullptr};
    // bool playerInit_{false};
    bool isPlayed_{false};
};

FavoritePresenter::FavoritePresenter() { g_favoritePresenter = this; }

FavoritePresenter::~FavoritePresenter()
{
    g_favoritePresenter = nullptr;
    /* 如果在副一屏播放过并且没有正在播放再退出页面，则析构音乐资源 */
    // if (isPlayed_ && !IsPlaying()) {
    auto playerModel = TjdUiAppPlayerModel::GetInstance();
    playerModel->PlayerStop();
    isPlayed_ = false;
    // }
}

bool FavoritePresenter::OnClick(OHOS::UIView &view, const OHOS::ClickEvent &event)
{
    std::string viewId = view.GetViewId();
    if (viewId.empty()) {
        return false;
    }
    TjdUiAppMainPageFavorite *favoriteView = TjdUiAppMainPageFavorite::GetInstance();
    if (favoriteView == nullptr) {
        return true;
    }
    auto playerModel = TjdUiAppPlayerModel::GetInstance();

    if (viewId == BTN_EDIT_VIEW_ID) { // 进入编辑按钮
        /* 进入编辑的时候备份 */
        favoriteView->BackupSortItemView();
        favoriteView->ShowView(FavoriteViewIndex::SORT_VIEW_INDEX);
    } else if (viewId == BTN_SORT_ENTER_VIEW_ID) { // 编辑按钮确认
        SelectEdit();
    } else if (viewId == BTN_WEATHER_VIEW_ID) { // 选择顶部模组
        favoriteView->ShowView(FavoriteViewIndex::CHOOSE_TOP_MODEL_VIEW_INDEX);
    } else if (viewId == BTN_TOP_MODEL_VIEW_ID) {
        SelectTopModel();
    } else if (viewId == BTN_TOP_MODEL_ENTER_VIEW_ID) {
        // 顶部模组选择确定
        SetTopModelType(static_cast<TopModelType>(topModelIndex_));
        favoriteView->ShowView(FavoriteViewIndex::SORT_VIEW_INDEX);
    } else if (viewId == BTN_SAVE_SORT_ENTER_VIEW_ID) {
        /* 保存排序 */
        auto favoriteModelList = favoriteView->GetFavoriteSortModelViewList();
        uint8_t sqlSortItem[FAVORITE_MODEL_MAX_NUM] = {0};
        int index = 0;
        for (auto &item : favoriteModelList) {
            sqlSortItem[index++] = static_cast<uint8_t>(item);
            if (index >= FAVORITE_MODEL_MAX_NUM) {
                break;
            }
        }
        sql_setting_set_favorite_sort(sqlSortItem);
        favoriteView->ShowView(FavoriteViewIndex::SETTING_WAIT_VIEW_INDEX);
        favoriteView->SetFavoriteModelList(favoriteModelList);
        StartJumpTimer(FavoriteViewIndex::MAIN_VIEW_INDEX);
    } else if (viewId == BTN_SAVE_SORT_CLOSE_VIEW_ID) {
        /* 取消保存排序 */
        favoriteView->ResetSortItemView();
        favoriteView->ShowView(FavoriteViewIndex::MAIN_VIEW_INDEX);
    } else if (viewId == BTN_PLAYER_LEFT_VIEW_ID) {
        playerModel->PreviousPlayout();
    } else if (viewId == BTN_PLAYER_RIGHT_VIEW_ID) {
        playerModel->LoopingPlayout();
    } else if (viewId == BTN_PLAYER_PLAY_VIEW_ID) {
        isPlayed_ = true;
        /* 初始化音频 */
        // if (playerInit_ == false) {
        //     PlayersListGroup::GetInstance()->SetUpListCase();
        //     playerModel->PlayerInit();
        //     playerModel->AudioInit();
        //     playerInit_ = true;
        // }
        bool isPlay = favoriteView->GetPlayerButtonState() == UICheckBox::UICheckBoxState::SELECTED;
        if (isPlay) {
            playerModel->PlayerStart();
        } else {
            if (playerModel->GetPlayerCtr().get() != nullptr) {
                playerModel->GetPlayerCtr()->Pause();
            }
        }
    } else if (viewId == BTN_TIME_OUT_BTN_ID) {
        favoriteView->ShowView(FavoriteViewIndex::MAIN_VIEW_INDEX);
    }
    return false;
}

bool FavoritePresenter::OnDragStart(OHOS::UIView &view, const DragEvent &event)
{
    if (event.GetDragDirection() == OHOS::DragEvent::DIRECTION_RIGHT_TO_LEFT ||
        event.GetDragDirection() == OHOS::DragEvent::DIRECTION_LEFT_TO_RIGHT) {
        TjdUiAppMainPageFavorite::GetInstance()->SetVerticalScroll(false);
    } else {
        TjdUiAppMainPageFavorite::GetInstance()->SetHorizonalScroll(false);
    }
    return TjdUiScreenDragListener::OnDragStart(view, event);
};

bool FavoritePresenter::OnDragEnd(OHOS::UIView &view, const OHOS::DragEvent &event)
{
    auto favortiteView = TjdUiAppMainPageFavorite::GetInstance();
    favortiteView->SetVerticalScroll(true);
    favortiteView->SetHorizonalScroll(true);
    if (favortiteView->currentViewIndex_ == FavoriteViewIndex::MAIN_VIEW_INDEX) {
        favortiteView->SetViewSetIntercept(false);
    }
    return TjdUiScreenDragListener::OnDragEnd(view, event);
}

static std::string AssertZero(int32_t value)
{
    if (value == 0) {
        return "-";
    }
    return std::to_string(value);
}

static std::string AssertFloatValueToZero(float value)
{
    if (value == 0) {
        return "-";
    }

    std::ostringstream oss;
    oss << std::fixed << std::setprecision(2) << value;
    return oss.str();
}

void FavoritePresenter::UpdateViewData()
{
    auto type = static_cast<WeatherInfo>(sql_weather_get_forecast_protocol_value(0));
    // clang-format off
    switch (type) {
    case WeatherInfo::SQL_SUNNY:            weartherType_ = STR_ID_253;break;
    case WeatherInfo::SQL_PARTLY_CLOUDY:    weartherType_ = STR_ID_254;break;
    case WeatherInfo::SQL_CLOUDY:           weartherType_ = STR_ID_255;break;
    case WeatherInfo::SQL_LIGHT_RAIN:       weartherType_ = STR_ID_256;break;
    case WeatherInfo::SQL_MODERATE_RAIN:    weartherType_ = STR_ID_257;break;
    case WeatherInfo::SQL_HEAVY_RAIN:       weartherType_ = STR_ID_258;break;
    case WeatherInfo::SQL_SHOWER:           weartherType_ = STR_ID_259;break;
    case WeatherInfo::SQL_THUNDERSTORM:     weartherType_ = STR_ID_260;break;
    case WeatherInfo::SQL_SNOWY:            weartherType_ = STR_ID_261;break;
    case WeatherInfo::SQL_FOGGY:            weartherType_ = STR_ID_262;break;
    case WeatherInfo::SQL_DUSTSTORM:        weartherType_ = STR_ID_263;break;
    case WeatherInfo::SQL_TYPHOON:          weartherType_ = STR_ID_264;break;
    default:                                weartherType_ = STR_ID_253;break;
    }
    // clang-format on
    struct rtc_time time;
    tjd_driver_rtc_get_ops()->get_rtc_time(&time);

    auto temperMax = AssertZero(sql_weather_get_forecast_temperature_max(0));
    auto temperMin = AssertZero(sql_weather_get_forecast_temperature_min(0));
    if (temperMin != "-" && temperMin != "-") {
        temper_ = temperMin + "°C-" + temperMax + "°C";
    } else {
        temper_ = "-";
    }

    heartRateStr_ = AssertZero(sql_fit_get_last_hr(time.tm_wday));
    heartRateValue_ = sql_fit_get_last_hr(time.tm_wday);
    switch (heartRateValue_) {
    case 40 ... 69:
        heartRateLevel_ = STR_ID_604;
        break;
    case 70 ... 120:
        heartRateLevel_ = STR_ID_605;
        break;
    case 121 ... 140:
        heartRateLevel_ = STR_ID_606;
        break;
    default:
        heartRateLevel_ = STR_ID_607;
        break;
    }

    spo2Str_ = AssertZero(sql_fit_get_spo2_curdata(time.tm_wday));
    spo2Value_ = sql_fit_get_spo2_curdata(time.tm_wday);
    switch (spo2Value_) {
    case 90 ... 100:
        spo2Level_ = STR_ID_608;
        break;
    default:
        spo2Level_ = STR_ID_607;
        break;
    }

    uint32_t sleepMin;
    if (time.tm_wday == 0)
        sleepMin = sql_fit_get_total_sleep_daydata(6).mins_total;
    else
        sleepMin = sql_fit_get_total_sleep_daydata(time.tm_wday - 1).mins_total;
    int sleepHour = (int)(sleepMin / 60);
    int sleepMinute = (int)(sleepMin % 60);

    switch (sleepHour) {
    case 6 ... 9:
        sleepLevel_ = STR_ID_609;
        break;
    case 3 ... 5:
        sleepLevel_ = STR_ID_610;
        break;
    default:
        sleepLevel_ = STR_ID_607;
        break;
    }

    sleepHourTime_ = AssertZero(sleepHour);
    sleepMinuteTime_ = AssertZero(sleepMinute);
    if (sleepMinuteTime_ != "-") {
        std::ostringstream oss;
        oss << std::setw(2) << std::setfill('0') << sleepMinuteTime_;
        sleepMinuteTime_ = oss.str();
    } else {
        sleepMinuteTime_ = "--";
    }

    stepCount_ = AssertZero(sql_fit_get_day_step(time.tm_wday));
    curDistance = sql_fit_get_day_distance(time.tm_wday);
    totalDistance = sql_fit_get_goalStepNum_data();
    stepProcess = curDistance / totalDistance * 100 >= 100 ? 100 : curDistance / totalDistance * 100;
    distance_ = AssertFloatValueToZero(curDistance / 1000.0f);
    calorie_ = AssertZero(sql_fit_get_day_calorie(time.tm_wday));
}

void FavoritePresenter::StartJumpTimer(FavoriteViewIndex jumpView)
{
    if (jumpTimerId_ == nullptr) {
        jumpTimerId_ = osTimerNew(
            [](void *arg) {
                FavoriteViewIndex jumpView = static_cast<FavoriteViewIndex>(reinterpret_cast<intptr_t>(arg));
                GraphicService::GetInstance()->PostGraphicEvent([jumpView]() {
                    TjdUiAppMainPageFavorite *favoriteView = TjdUiAppMainPageFavorite::GetInstance();
                    FavoritePresenter *presenter = FavoritePresenter::GetInstance();
                    if (favoriteView == nullptr) {
                        return;
                    }
                    favoriteView->ShowView(jumpView);
                    presenter->DeleteJumpTimer();
                });
            },
            osTimerOnce, reinterpret_cast<void *>(static_cast<intptr_t>(jumpView)), nullptr);
        if (jumpTimerId_ == nullptr) {
            return;
        }
    }

    int32_t ret = osTimerStart(jumpTimerId_, 2000);
    if (ret != 0) {
        return;
    }
}

class FavoriteAppOnClickListener : public OHOS::UIView::OnClickListener
{
public:
    FavoriteAppOnClickListener(std::function<bool(OHOS::UIView &view, const OHOS::ClickEvent &event)> onClick)
        : onClick_(onClick)
    {}
    bool OnClick(OHOS::UIView &view, const OHOS::ClickEvent &event)
    {
        if (onClick_ != nullptr) {
            return onClick_(view, event);
        }
        return false;
    }

private:
    std::function<bool(OHOS::UIView &view, const OHOS::ClickEvent &event)> onClick_;
};

#pragma endregion

#pragma region 排序子项
SortItemView::SortItemView(int16_t y, int16_t index, uint16_t textId, OHOS::UIView::OnClickListener *listener)
{
    auto &images = OHOS::ImageCacheManager::GetInstance();
    textId_ = textId;
    SetPosition(8, y, 450, 110);
    SetStyle(STYLE_BACKGROUND_OPA, 0xff);
    SetStyle(STYLE_BORDER_RADIUS, 55);
    SetStyle(STYLE_BACKGROUND_COLOR, 0xff262626);
    SetViewIndex(index);

    up_.SetTouchable(true);
    up_.SetOnClickListener(listener);
    up_.SetPosition(293, 32, 46, 46);
    up_.SetViewId(BTN_UP_VIEW_ID);

    if (index == 0) {
        up_.SetSrc(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_UP1, FAVORITE_IMAGE_BIN_PATH));
    } else {
        up_.SetSrc(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_UP, FAVORITE_IMAGE_BIN_PATH));
    }

    down_.SetTouchable(true);
    down_.SetOnClickListener(listener);
    down_.SetPosition(360, 32, 46, 46);
    down_.SetViewId(BTN_DOWN_VIEW_ID);
    if (index == 4) {
        down_.SetSrc(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_DOWN1, FAVORITE_IMAGE_BIN_PATH));
    } else {
        down_.SetSrc(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_DOWN, FAVORITE_IMAGE_BIN_PATH));
    }

    name_.SetTextId(textId_);
    name_.SetFont(TJD_VECTOR_FONT_FILENAME, 34);
    name_.Resize(220, GetHeight());
    name_.SetPosition(51, 0);
    name_.SetLineBreakMode(UILabel::LINE_BREAK_MARQUEE);
    name_.SetAlign(OHOS::TEXT_ALIGNMENT_LEFT, OHOS::TEXT_ALIGNMENT_CENTER);

    Add(&name_);
    Add(&up_);
    Add(&down_);
}
#pragma endregion

#pragma region 总界面
static TjdUiAppMainPageFavorite *g_favoritePage = nullptr;

TjdUiAppMainPageFavorite::TjdUiAppMainPageFavorite()
{
    SetPosition(0, 0, HORIZONTAL_RESOLUTION, VERTICAL_RESOLUTION);
    g_favoritePresenter = new FavoritePresenter();
    FavoritePresenter::GetInstance()->UpdateViewData();
    g_favoritePage = this;
}

TjdUiAppMainPageFavorite::~TjdUiAppMainPageFavorite()
{
    UnLoad();

    auto view = dynamic_cast<FavoriteMainView *>(viewManager_[FavoriteViewIndex::MAIN_VIEW_INDEX]);
    if (view != nullptr) {
        view->musicModel_.StopAnimator();
    }

    if (g_favoritePage != nullptr) {
        delete g_favoritePresenter;
        g_favoritePresenter = nullptr;
    }
    tjd_service_simple_timer_stop();
    g_timeKeepingIsStart = false;
}

TjdUiAppMainPageFavorite *TjdUiAppMainPageFavorite::GetInstance(void) { return g_favoritePage; }

static void BleConnectStateEvent(bool isConnect)
{
    auto favortiteView = TjdUiAppMainPageFavorite::GetInstance();
    if (favortiteView == nullptr) {
        return;
    }
    favortiteView->BleStateChanged(isConnect);
}

void TjdUiAppMainPageFavorite::PreLoad(void)
{
    if (!viewiInitStatus) {
        InitView();
        TjdCardId pageid = TjdUiAppMainView::GetInstance()->GetHorCurrentCard();
        if (pageid == TjdCardId::TJD_CARD_FAVORITE) {
            auto view = dynamic_cast<FavoriteMainView *>(viewManager_[FavoriteViewIndex::MAIN_VIEW_INDEX]);
            if (view != nullptr) {
                TjdUiUtils::ViewRequestFocus(*view);
            }
        }
        viewiInitStatus = true;
        TjdUiSettingCenter::GetInstance().RegisterBleConnectStateCallback(BleConnectStateEvent);
    }
}

bool TjdUiAppMainPageFavorite::OnKeyEvent(const OHOS::KeyEvent &event)
{
    uint8_t state = event.GetState();
    OHOS::ZliteKeyCode keyId = static_cast<OHOS::ZliteKeyCode>(event.GetKeyId());
    if (state != OHOS::InputDevice::STATE_RELEASE || keyId != ZliteKeyCode::ZLITE_KEY_TJD_RIGHTUP) {
        return true;
    }
    auto presenter = FavoritePresenter::GetInstance();
    if (presenter == nullptr) {
        return true;
    }
    if (currentViewIndex_ == FavoriteViewIndex::MAIN_VIEW_INDEX) {
        if (viewManager_[currentViewIndex_])
            viewManager_[currentViewIndex_]->ClearFocus();
        return false;
    } else if (currentViewIndex_ == FavoriteViewIndex::SORT_VIEW_INDEX) {
        presenter->SelectEdit();
    } else if (currentViewIndex_ == FavoriteViewIndex::CHOOSE_TOP_MODEL_VIEW_INDEX) {
        ShowView(FavoriteViewIndex::SORT_VIEW_INDEX);
    }
    return true;
}

void TjdUiAppMainPageFavorite::UnLoad(void)
{
    TjdUiSettingCenter::GetInstance().UnregisterBleConnectStateCallback(BleConnectStateEvent);
    set_back_to_home_interval(5);
    if (viewiInitStatus) {
        ImageCacheManager::GetInstance().UnloadAllInMultiRes(APP_IMAGE_BIN_PATH);
        ImageCacheManager::GetInstance().UnloadAllInMultiRes(FAVORITE_IMAGE_BIN_PATH);
        ImageCacheManager::GetInstance().UnloadAllInMultiRes(COMMON_IMAGE_BIN_PATH);
        RemoveAll();

        if (viewManager_[currentViewIndex_])
            viewManager_[currentViewIndex_]->ClearFocus();

        if (mainView_ != nullptr) {
            mainView_->RemoveAll();
            delete mainView_;
            mainView_ = nullptr;
        }

        for (int i = 0; i < FavoriteViewIndex::FAVORITE_UNKNOWN; i++) {
            if (viewManager_[i] != nullptr) {
                delete viewManager_[i];
                viewManager_[i] = nullptr;
            }
        }

        viewiInitStatus = false;
    }
}

bool TjdUiAppMainPageFavorite::InitView(void)
{
    uint32_t startTime = OHOS::HALTick::GetInstance().GetTime();
    uint32_t end = 0;
    ImageCacheManager::GetInstance().LoadAllInMultiRes(FAVORITE_IMAGE_BIN_PATH);
    ImageCacheManager::GetInstance().LoadAllInMultiRes(COMMON_IMAGE_BIN_PATH);
    end = OHOS::HALTick::GetInstance().GetElapseTime(startTime);
    static_print_debug("LoadAllInMultiRes time %d", end);

    mainView_ = new OHOS::UIScrollView();
    mainView_->SetPosition(0, 0, OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);

    g_favoriteModelList_.clear();
    uint8_t sqlSortItem[FAVORITE_MODEL_MAX_NUM] = {0};
    sql_setting_get_favorite_sort(sqlSortItem);
    // 判断sqlSortItem是否有重复
    bool isRepeat = false;
    std::unordered_set<uint8_t> sqlSortItemSet;
    for (int i = 0; i < FAVORITE_MODEL_MAX_NUM; i++) {
        if (sqlSortItemSet.find(sqlSortItem[i]) != sqlSortItemSet.end()) {
            isRepeat = true;
            break;
        }
        sqlSortItemSet.insert(sqlSortItem[i]);
    }
    if (isRepeat) {
        sqlSortItem[0] = FavoriteModel::MUSIC_MODEL;
        sqlSortItem[1] = FavoriteModel::HEALTH_MODEL;
        sqlSortItem[2] = FavoriteModel::SLEEP_MODEL;
        sqlSortItem[3] = FavoriteModel::MOTION_MODEL;
        sqlSortItem[4] = FavoriteModel::TIMEKEEPING_MODEL;
    }

    for (int i = 0; i < FAVORITE_MODEL_MAX_NUM; i++) {
        g_favoriteModelList_.push_back({static_cast<FavoriteModel>(sqlSortItem[i])});
    }

    Add(mainView_);
    ShowView(FavoriteViewIndex::MAIN_VIEW_INDEX);
    end = OHOS::HALTick::GetInstance().GetElapseTime(startTime);
    static_print_debug("TjdUiAppMainPageFavorite::InitView time %d", end);
    return true;
}

void TjdUiAppMainPageFavorite::ScrollBegin(bool isActive)
{
    if (viewManager_[currentViewIndex_])
        viewManager_[currentViewIndex_]->ClearFocus();
}

void TjdUiAppMainPageFavorite::ScrollEnd(bool isActive)
{
    auto presenter = FavoritePresenter::GetInstance();
    if (presenter == nullptr) {
        return;
    }
    presenter->UpdateViewData();
    if (isActive) {
        auto mainView = dynamic_cast<FavoriteMainView *>(viewManager_[FavoriteViewIndex::MAIN_VIEW_INDEX]);
        if (mainView == nullptr) {
            return;
        }
        TjdUiUtils::ViewRequestFocus(*mainView);
        TjdUiAppMainPageFavorite::GetInstance()->FavoriteClockTick();

        // if (playerInit_ == false) {
        auto playerModel = TjdUiAppPlayerModel::GetInstance();
        PlayersListGroup::GetInstance()->SetUpListCase();
        playerModel->PlayerInit();
        // playerInit_ = true;
        // }
        mainView->musicModel_.UpdateInfo(playerModel);
    }
}

void TjdUiAppMainPageFavorite::FavoriteClockTick(void)
{
    struct rtc_time time;
    tjd_driver_rtc_get_ops()->get_rtc_time(&time);
    auto mainView = dynamic_cast<FavoriteMainView *>(viewManager_[FavoriteViewIndex::MAIN_VIEW_INDEX]);
    if (mainView == nullptr) {
        return;
    } // VIEW在Presenter后创建，有空针风险。
    char timeStr[6];
    sprintf(timeStr, "%02d:%02d", time.tm_hour, time.tm_min);
    mainView->time_.SetText(timeStr);
    mainView->timekeepingModel_.AddTimekeeping();

    if (HALTick::GetInstance().GetElapseTime(mainView->startTime_) >= 1000) {
        mainView->UpdateData(); // 1s更新一次数据
        mainView->startTime_ = HALTick::GetInstance().GetTime();
    }

    auto playerModel = TjdUiAppPlayerModel::GetInstance();
    bool isPlay = GetPlayerButtonState() == UICheckBox::UICheckBoxState::SELECTED;
    if (isPlay) {
        mainView->musicModel_.UpdateInfo(playerModel);
    }
}

void TjdUiAppMainPageFavorite::SetViewSetIntercept(bool isIntercept) { SetIntercept(isIntercept); }

OHOS::UICheckBox::UICheckBoxState TjdUiAppMainPageFavorite::GetPlayerButtonState()
{
    auto mainView = dynamic_cast<FavoriteMainView *>(viewManager_[FavoriteViewIndex::MAIN_VIEW_INDEX]);
    if (mainView == nullptr) {
        return OHOS::UICheckBox::UICheckBoxState::UNSELECTED;
    }
    return mainView->GetMusicModelPlayState();
}

void TjdUiAppMainPageFavorite::BleStateChanged(bool isConnect)
{
    auto mainView = dynamic_cast<FavoriteMainView *>(viewManager_[FavoriteViewIndex::MAIN_VIEW_INDEX]);
    if (mainView == nullptr) {
        return;
    }
    if (isConnect) {
        mainView->topModel_.SetType(FavoritePresenter::GetInstance()->GetTopModelType());
    } else {
        mainView->topModel_.SetType(TopModelType::TOP_MODEL_DISCONNECTED);
    }
}

static int FindTargetResource(uint16_t app)
{
    TjdUiAppListModel &appListModel = TjdUiAppListModel::GetInstance();
    const TjdAppItem *appList = appListModel.GetApplistItems();
    if (appList == nullptr) {
        return 0;
    }
    for (uint8_t i = 0; i < appListModel.GetAppListNum(); i++) {
        if (appList[i].appItem.id == app) {
            return appList[i].resId;
        }
    }
    return 0;
}

void TjdUiAppMainPageFavorite::InitTargetView(FavoriteViewIndex index)
{
    if (viewManager_[index] != nullptr) {
        return;
    }

    // clang-format off
    switch (index) {
    case MAIN_VIEW_INDEX:               viewManager_[index] = new FavoriteMainView(); break;
    case SORT_VIEW_INDEX:               viewManager_[index] = new FavoriteSortModelView(); break;
    case CHOOSE_TOP_MODEL_VIEW_INDEX:   viewManager_[index] = new FavoriteChooseTopModelView(); break;
    case BREAK_VIEW_INDEX:              viewManager_[index] = new FavoriteBreakView(); break;
    case SETTING_WAIT_VIEW_INDEX:       viewManager_[index] = new FavoriteSettingWaitView(); break;
    case TIME_OUT_VIEW:                 viewManager_[index] = new TimeOutView(); break;
    default: break;
    }
    // clang-format on

    if (viewManager_[index] == nullptr) {
        return;
    }

    viewManager_[index]->SetPosition(0, 0);
    viewManager_[index]->SetVisible(false);
    mainView_->Add(viewManager_[index]);
}

void TjdUiAppMainPageFavorite::ShowView(FavoriteViewIndex showIndex)
{
    if (showIndex < 0 || showIndex >= FavoriteViewIndex::FAVORITE_UNKNOWN) {
        return;
    }
    InitTargetView(showIndex);

    if (currentViewIndex_ >= 0 && currentViewIndex_ < FavoriteViewIndex::FAVORITE_UNKNOWN &&
        viewManager_[currentViewIndex_] != nullptr) {
        viewManager_[currentViewIndex_]->HideView();
    }

    if (showIndex != FavoriteViewIndex::MAIN_VIEW_INDEX) {
        SetViewSetIntercept(true);
    }
    if (viewManager_[showIndex] != nullptr) {
        viewManager_[showIndex]->ShowView();
    }

    currentViewIndex_ = showIndex;
}

void TjdUiAppMainPageFavorite::SetFavoriteModelList(std::list<FavoriteModel> &favoriteModelList)
{
    g_favoriteModelList_.clear();
    for (auto &item : favoriteModelList) {
        g_favoriteModelList_.emplace_back(item);
    }
}

std::list<FavoriteModel> &TjdUiAppMainPageFavorite::GetFavoriteModelList() { return g_favoriteModelList_; }

std::list<FavoriteModel> &TjdUiAppMainPageFavorite::GetFavoriteSortModelViewList()
{
    auto sortView = dynamic_cast<FavoriteSortModelView *>(viewManager_[FavoriteViewIndex::SORT_VIEW_INDEX]);
    if (sortView == nullptr) {
        return g_favoriteModelList_;
    }
    return sortView->GetModelSortList();
}

void TjdUiAppMainPageFavorite::SetHorizonalScroll(bool isHorizonal)
{
    dynamic_cast<FavoriteMainView *>(viewManager_[FavoriteViewIndex::MAIN_VIEW_INDEX])
        ->SetHorizontalScrollState(isHorizonal);
}

void TjdUiAppMainPageFavorite::SetVerticalScroll(bool isVertical)
{
    dynamic_cast<FavoriteMainView *>(viewManager_[FavoriteViewIndex::MAIN_VIEW_INDEX])
        ->SetVerticalScrollState(isVertical);
}

void TjdUiAppMainPageFavorite::BackupSortItemView()
{
    backupTopModelType_ = FavoritePresenter::GetInstance()->GetTopModelType();
}

void TjdUiAppMainPageFavorite::ResetSortItemView()
{
    FavoritePresenter::GetInstance()->SetTopModelType(backupTopModelType_);
}
#pragma endregion

#pragma region 模组

#pragma region 顶部模组
FavoriteTopModel::FavoriteTopModel()
{
    listener_ = new FavoriteAppOnClickListener([](OHOS::UIView &view, const OHOS::ClickEvent &event) -> bool {
        int sliceId = view.GetViewIndex();
        if (sliceId == 0) {
            OHOS::NativeAbility::GetInstance().ChangeSlice(TJD_APP_VIEW_LIST);
            return false;
        }
        OHOS::NativeAbility::GetInstance().ChangeSlice(sliceId);
        return false;
    });
    ImageCacheManager &imgManager = ImageCacheManager::GetInstance();

    Resize(366, 343);
    topModel_.SetPosition(0, 0, 366, 126);
    bg_.SetPosition(0, 0, 366, 126);

    SetType(FavoritePresenter::GetInstance()->GetTopModelType());

    topModelAppList_.resize(6);
    std::list<uint16_t> &sliceData = OHOS::NativeAbility::GetInstance().GetRecentAppsList();
    std::vector<uint16_t> result;
    // 从链表尾部（最新）向头部遍历
    auto rit = sliceData.rbegin(); // 反向迭代器
    for (int i = 0; i < 5 && rit != sliceData.rend(); ++i, ++rit) {
        result.push_back(*rit);
    }

    int arrIndex = 0;
    std::unordered_set<uint16_t> existingItems;
    for (auto item : result) {
        if (existingItems.find(item) == existingItems.end()) {
            topModelAppList_[arrIndex++] = item;
            existingItems.insert(item);
            if (arrIndex >= 5) {
                break;
            }
        }
    }

    // 如果前 5 个位置未填满，使用 tmpAppid 填充
    const uint16_t tmpAppid[5] = {TJD_APP_VIEW_HR, TJD_APP_VIEW_SPO2, TJD_APP_VIEW_SPORT, TJD_APP_VIEW_SLEEP,
                                  TJD_APP_VIEW_WEATHER};

    for (int i = 0; i < 5 && arrIndex < 5; ++i) {
        uint16_t addAppid = tmpAppid[i];
        if (existingItems.find(addAppid) == existingItems.end()) {
            topModelAppList_[arrIndex++] = addAppid;
            existingItems.insert(addAppid);
        }
    }
    /* 最后添加0，第6位的0是固定的 */
    topModelAppList_.emplace_back(0);

    topModel_.SetViewId(BTN_TOP_MODEL_VIEW_ID);
    topModel_.SetTouchable(true);
    topModel_.SetOnClickListener(FavoritePresenter::GetInstance());
    topModel_.Add(&bg_);
    topModel_.Add(&topModelIcon_);
    topModel_.Add(&descOne_);
    topModel_.Add(&descTwo_);
    Add(&topModel_);

    float targetSize = 88.0f;
    int16_t startX = 32;
    int16_t startY = 19 + 126;
    int16_t widthInterval = 28;
    int16_t heightInterval = 14;
    // 添加6个应用，每个应用占用88*88的区域，每三个应用换行
    OHOS::ImageInfo *imgInfo = nullptr;
    for (int i = 0; i < 6; ++i) {
        OHOS::UIImageView &appView = appIcon_[i];
        appView.SetPosition(startX + (i % 3) * (targetSize + widthInterval),
                            startY + (i / 3) * (targetSize + heightInterval), targetSize, targetSize);
        appView.SetViewIndex(topModelAppList_[i]);
        appView.SetTouchable(true);
        appView.SetOnClickListener(listener_);
        if (topModelAppList_[i] == 0) {
            imgInfo = imgManager.LoadOneInMultiRes(IMG_MAIN_FAVORITE_MORE, FAVORITE_IMAGE_BIN_PATH);
        } else {
            imgInfo = imgManager.LoadOneInMultiRes(FindTargetResource(topModelAppList_[i]), APP_IMAGE_BIN_PATH);
        }
        if (i < 5) {
            appView.Scale({targetSize / imgInfo->header.width, targetSize / imgInfo->header.width}, {0, 0});
        }
        if (imgInfo != nullptr) {
            appView.SetSrc(imgInfo);
        }
        Add(&appView);
    }
}

FavoriteTopModel::~FavoriteTopModel()
{
    RemoveAll();
    topModel_.RemoveAll();
    // topModelAppList_.clear();
    delete listener_;
}

void FavoriteTopModel::SetType(TopModelType type)
{
    switch (type) {
    case TOP_MODEL_DISCONNECTED:
        SetDisconnectType();
        break;
    case TOP_MODEL_WEATHER:
        SetWeatherType();
        break;
    case TOP_MODEL_VOICE:
        SetVoiceType();
        break;
    default:
        break;
    }
}

uint16_t FavoriteTopModel::GetGreeting(int hour)
{
    if (hour > 5 && hour <= 8) {
        return STR_ID_620;
    } else if (hour > 8 && hour <= 11) {
        return STR_ID_621;
    } else if (hour > 11 && hour <= 13) {
        return STR_ID_622;
    } else if (hour > 13 && hour <= 18) {
        return STR_ID_623;
    } else {
        return STR_ID_624;
    }
}

void FavoriteTopModel::SetDisconnectType()
{
    OHOS::ImageCacheManager &images = OHOS::ImageCacheManager::GetInstance();
    bg_.SetSrc(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_BJ_CONNECTION, FAVORITE_IMAGE_BIN_PATH));
    topModelIcon_.SetPosition(34, 38, 48, 48);
    topModelIcon_.SetSrc(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_TISHI, FAVORITE_IMAGE_BIN_PATH));
    descOne_.SetTextId(STR_ID_625);
    descOne_.SetFont(TJD_VECTOR_FONT_FILENAME, 34);
    descOne_.SetPosition(100, 42, 230, 45);
    descOne_.SetLineBreakMode(UILabel::LINE_BREAK_MARQUEE);
    descOne_.SetAlign(OHOS::TEXT_ALIGNMENT_LEFT, OHOS::TEXT_ALIGNMENT_CENTER);
    descOne_.SetVisible(true);
    descTwo_.SetVisible(false);
}

void FavoriteTopModel::SetWeatherType()
{
    OHOS::ImageCacheManager &images = OHOS::ImageCacheManager::GetInstance();
    bg_.SetSrc(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_BJ_WEATHER, FAVORITE_IMAGE_BIN_PATH));
    topModelIcon_.SetPosition(53, 20, 88, 88);
    topModelIcon_.SetSrc(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_W_02, FAVORITE_IMAGE_BIN_PATH));
    descOne_.SetTextId(FavoritePresenter::GetInstance()->WeartherType());
    descOne_.SetFont(TJD_VECTOR_FONT_FILENAME, 28);
    descOne_.Resize(180, (topModel_.GetHeight() >> 1));
    descOne_.SetPosition(topModelIcon_.GetX() + topModelIcon_.GetWidth() + 10, 0);
    descOne_.SetLineBreakMode(UILabel::LINE_BREAK_MARQUEE);
    descOne_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_BOTTOM);
    descTwo_.SetText(FavoritePresenter::GetInstance()->GetTemper().c_str());
    descTwo_.SetFont(TJD_VECTOR_FONT_FILENAME, 28);
    descTwo_.Resize(180, (topModel_.GetHeight() >> 1));
    descTwo_.SetPosition(descOne_.GetX(), (topModel_.GetHeight() >> 1));
    descTwo_.SetLineBreakMode(UILabel::LINE_BREAK_MARQUEE);
    descTwo_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_TOP);
    descTwo_.SetStyle(OHOS::STYLE_TEXT_OPA, OHOS::OPA_OPAQUE);
    descOne_.SetVisible(true);
    descTwo_.SetVisible(true);
}

void FavoriteTopModel::SetVoiceType()
{
    OHOS::ImageCacheManager &images = OHOS::ImageCacheManager::GetInstance();
    rtc_time time;
    tjd_driver_rtc_get_ops()->get_rtc_time(&time);
    bg_.SetSrc(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_BJ_VOICE, FAVORITE_IMAGE_BIN_PATH));
    topModelIcon_.SetPosition(46, 15, 90, 90);
    topModelIcon_.SetSrc(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_ICON_VOICE, FAVORITE_IMAGE_BIN_PATH));
    descOne_.SetTextId(GetGreeting(time.tm_hour));
    descOne_.SetFont(TJD_VECTOR_FONT_FILENAME, 36);
    descOne_.Resize(180, (topModel_.GetHeight() >> 1));
    descOne_.SetPosition(topModelIcon_.GetX() + topModelIcon_.GetWidth() + 10, 0);
    descOne_.SetLineBreakMode(UILabel::LINE_BREAK_MARQUEE);
    descOne_.SetAlign(OHOS::TEXT_ALIGNMENT_LEFT, OHOS::TEXT_ALIGNMENT_BOTTOM);
    descTwo_.SetTextId(STR_ID_86);
    descTwo_.SetFont(TJD_VECTOR_FONT_FILENAME, 30);
    descTwo_.Resize(180, (topModel_.GetHeight() >> 1));
    descTwo_.SetPosition(descOne_.GetX(), (topModel_.GetHeight() >> 1));
    descTwo_.SetLineBreakMode(UILabel::LINE_BREAK_MARQUEE);
    descTwo_.SetAlign(OHOS::TEXT_ALIGNMENT_LEFT, OHOS::TEXT_ALIGNMENT_TOP);
    descTwo_.SetStyle(OHOS::STYLE_TEXT_OPA, OHOS::OPA_OPAQUE * 0.3);
    descOne_.SetVisible(true);
    descTwo_.SetVisible(true);
}
#pragma endregion

#pragma region 音乐模组
FavoriteMusicModel::FavoriteMusicModel()
{
    auto &images = OHOS::ImageCacheManager::GetInstance();
    Resize(400, 180);
    lrcParser_ = new LrcParser();

    const int animatorRes[3] = {IMG_MAIN_FAVORITE_BEAT_DT_01_10, IMG_MAIN_FAVORITE_BEAT_DT_02_10,
                                IMG_MAIN_FAVORITE_BEAT_DT_03_10};
    OHOS::ImageAnimatorInfo baseinfo = {nullptr, {324, 33}, 43, 28, OHOS::IMG_SRC_IMAGE_INFO};
    for (int i = 0; i < 3; ++i) {
        g_imageAnimator1Info[i] = baseinfo;
        g_imageAnimator1Info[i].imageInfo =
            ImageCacheManager::GetInstance().LoadOneInMultiRes(animatorRes[i], FAVORITE_IMAGE_BIN_PATH);
    }

    imageAnimator_.SetPosition(324, 33, 43, 28);
    imageAnimator_.SetImageAnimatorSrc(g_imageAnimator1Info, 3, 100);
    imageAnimator_.SetTimeOfPause(100);
    imageAnimator_.Start();
    // SetStyle(STYLE_BACKGROUND_OPA, 0xff);
    // SetStyle(STYLE_BACKGROUND_COLOR, 0xff262626);
    // SetStyle(STYLE_BORDER_RADIUS, 63);
    musicBg_.SetPosition(0, 0, 400, 180);
    musicBg_.SetSrc(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_BJ_MUSIC, FAVORITE_IMAGE_BIN_PATH));

    musicIcon_.SetPosition(43, 15, 25, 25);
    musicIcon_.SetSrc(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_MUSIC, FAVORITE_IMAGE_BIN_PATH));

    song_.SetFont(TJD_VECTOR_FONT_FILENAME, 20);
    song_.SetText("...");
    song_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
    song_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    song_.SetPosition(83, 15, 111, 19);
    song_.SetStyle(STYLE_TEXT_COLOR, 0xFF265CFD);

    lyric_.SetFont(TJD_VECTOR_FONT_FILENAME, 24);
    lyric_.SetText("...");
    lyric_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_MARQUEE);
    lyric_.SetAlign(OHOS::TEXT_ALIGNMENT_LEFT, OHOS::TEXT_ALIGNMENT_CENTER);
    lyric_.SetPosition(43, 55, 250, 36);

    currentTime_.SetFont(TJD_D_DIN_PRO_MEDIUM_FONT_FILENAME, 18);
    currentTime_.SetText("00:32");
    currentTime_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
    currentTime_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    currentTime_.SetPosition(41, 95, 40, 14);
    currentTime_.SetStyle(STYLE_TEXT_OPA, OHOS::OPA_OPAQUE * 0.6);

    totalTime_.SetFont(TJD_D_DIN_PRO_MEDIUM_FONT_FILENAME, 18);
    totalTime_.SetText("04:16");
    totalTime_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
    totalTime_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    totalTime_.SetPosition(329, 95, 37, 14);
    totalTime_.SetStyle(STYLE_TEXT_OPA, OHOS::OPA_OPAQUE * 0.6);

    progress_.SetPosition(90, 101, 221, 20);
    progress_.SetStyle(STYLE_BACKGROUND_OPA, 0);
    progress_.SetStyle(STYLE_BORDER_RADIUS, 6);
    progress_.SetValidWidth(220);
    progress_.SetValidHeight(4);
    progress_.SetKnobWidth(20);
    progress_.SetSliderColor(Color::GetColorFromRGBA(78, 86, 111, 0xff), Color::GetColorFromRGBA(255, 255, 255, 0xff));
    progress_.SetKnobImage(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_KNODE, FAVORITE_IMAGE_BIN_PATH));
    progress_.SetValue(60);
    progress_.SetTouchable(false);

    leftIcon_.SetPosition(82, 139, 48, 51);
    leftIcon_.SetSrc(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_L, FAVORITE_IMAGE_BIN_PATH));
    leftIcon_.SetTouchable(true);
    leftIcon_.SetViewId(BTN_PLAYER_LEFT_VIEW_ID);
    leftIcon_.SetOnClickListener(FavoritePresenter::GetInstance());
    leftIcon_.SetAutoEnable(false);
    leftIcon_.SetResizeMode(OHOS::UIImageView::ImageResizeMode::CENTER);

    rightIcon_.SetPosition(334, 139, 45, 51);
    rightIcon_.SetSrc(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_R, FAVORITE_IMAGE_BIN_PATH));
    rightIcon_.SetTouchable(true);
    rightIcon_.SetViewId(BTN_PLAYER_RIGHT_VIEW_ID);
    rightIcon_.SetOnClickListener(FavoritePresenter::GetInstance());
    rightIcon_.SetAutoEnable(false);
    rightIcon_.SetResizeMode(OHOS::UIImageView::ImageResizeMode::CENTER);

    playIcon_.SetPosition(185, 130, 30, 34);
    playIcon_.SetImages(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_PAUSE, FAVORITE_IMAGE_BIN_PATH),
                        images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_START, FAVORITE_IMAGE_BIN_PATH));
    playIcon_.SetTouchable(true);
    playIcon_.SetViewId(BTN_PLAYER_PLAY_VIEW_ID);
    playIcon_.SetOnClickListener(FavoritePresenter::GetInstance());

    Add(&musicBg_);
    Add(&musicIcon_);
    Add(&playIcon_);
    Add(&leftIcon_);
    Add(&rightIcon_);
    Add(&song_);
    Add(&lyric_);
    Add(&progress_);
    Add(&totalTime_);
    Add(&currentTime_);
    Add(&imageAnimator_);
}

void FavoriteMusicModel::StopAnimator(void) { imageAnimator_.Stop(); }

void FavoriteMusicModel::UpdateInfo(TjdUiAppPlayerModel *playerModel)
{
    if (playerModel == nullptr) {
        return;
    }

    std::string musicName = PlayersListGroup::GetInstance()->GetCase(playerModel->GetCurrentIndex());
    if (musicName.empty()) {
        return;
    }
    song_.SetText(musicName.c_str());

    std::string path = TJD_FS_DIR_MUSIC;
    std::string pureName = musicName.substr(0, musicName.rfind("."));
    path += "/";
    path += pureName;
    path += ".lrc";

    lrcParser_->parseLrc(path.c_str());

    // 获取歌曲当前播放时间
    uint64_t totalTime = playerModel->GetDuration();
    uint64_t curTime = playerModel->GetCurrentPosition();

    currentTime_.SetText(ConvertToTimeFormat(curTime).c_str());
    totalTime_.SetText(ConvertToTimeFormat(totalTime).c_str());

    if (totalTime == 0)
        progress_.SetValue(4);
    else
        progress_.SetValue(static_cast<int>(curTime * 100 / totalTime));

    if (curTime > (uint64_t)(lrcParser_->duration() + 1000)) {
        return;
    }

    if (lrcParser_->seek(curTime)) {
        LyricPacket data = lrcParser_->readPacket();
        if (data.isEmpty()) {
            return;
        }
        if (lrc_ == data.lyric) {
            return;
        }
        lyric_.SetText(data.lyric.c_str());
        lrc_ = data.lyric;
    }
}

std::string FavoriteMusicModel::ConvertToTimeFormat(uint64_t Seconds)
{
    uint64_t minutes = Seconds / 1000 / 60; // 计算分钟数
    uint64_t seconds = Seconds / 1000 % 60; // 计算剩余的秒数

    // 使用setw设置宽度，setfill设置填充字符，确保分钟和秒都是两位数
    std::stringstream ss;
    ss << std::setw(2) << std::setfill('0') << minutes << ":" << std::setw(2) << std::setfill('0') << seconds;
    return ss.str();
}
#pragma endregion

#pragma region 健康模组
FavoriteHealthModel::FavoriteHealthModel()
{
    auto &images = OHOS::ImageCacheManager::GetInstance();

    Resize(400, 378);

    healthModel_.SetPosition(0, 0, 400, 180);
    bloodOxygenModel_.SetPosition(0, 198, 400, 180);

    healthBg_.SetPosition(0, 0, 400, 180);
    healthBg_.SetSrc(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_BJ_HR, FAVORITE_IMAGE_BIN_PATH));

    healthIcon_.SetPosition(41, 16, 28, 23);
    healthIcon_.SetSrc(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_HR_ICON, FAVORITE_IMAGE_BIN_PATH));

    healthValue_.SetFont(TJD_DIN_MEDIUM_FONT_FILENAME, 42);
    healthValue_.SetText("100");
    healthValue_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
    healthValue_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    healthValue_.SetPosition(42, 52 - 12, 61, 32);

    healthUnit_.SetFont(TJD_D_DIN_PRO_REGULAR_FONT_FILENAME, 30);
    healthUnit_.SetText("bpm");
    healthUnit_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
    healthUnit_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    healthUnit_.SetPosition(112, 58, 51, 26);
    healthUnit_.SetStyle(STYLE_TEXT_OPA, OHOS::OPA_OPAQUE * 0.3);

    healthLevel_.SetFont(TJD_VECTOR_FONT_FILENAME, 24);
    healthLevel_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
    healthLevel_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    healthLevel_.SetPosition(226, 61 - 12, 51, 26);
    healthLevel_.SetStyle(STYLE_TEXT_OPA, OHOS::OPA_OPAQUE * 0.3);

    healthTitle_.SetFont(TJD_D_DIN_PRO_MEDIUM_FONT_FILENAME, 18);
    healthTitle_.SetText("HEART RATE");
    healthTitle_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
    healthTitle_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    healthTitle_.SetPosition(83, 23, 93, 14);
    healthTitle_.SetStyle(STYLE_TEXT_COLOR, 0XFFEA3D35);
    healthTitle_.SetStyle(STYLE_TEXT_OPA, OHOS::OPA_OPAQUE * 0.8);

    healthPic_.SetPosition(25, 97, 350, 60);
    healthPic_.SetSrc(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_HR_PICTURE, FAVORITE_IMAGE_BIN_PATH));

    healthModel_.Add(&healthBg_);
    healthModel_.Add(&healthIcon_);
    healthModel_.Add(&healthValue_);
    healthModel_.Add(&healthUnit_);
    healthModel_.Add(&healthLevel_);
    healthModel_.Add(&healthPic_);
    healthModel_.Add(&healthTitle_);

    spo2Bg_.SetPosition(0, 0, 400, 180);
    spo2Bg_.SetSrc(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_BJ_SPO2, FAVORITE_IMAGE_BIN_PATH));

    spo2Icon_.SetPosition(40, 12, 30, 30);
    spo2Icon_.SetSrc(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_SPO2_ICON, FAVORITE_IMAGE_BIN_PATH));

    spo2Value_.SetFont(TJD_DIN_MEDIUM_FONT_FILENAME, 42);
    spo2Value_.SetText("96");
    spo2Value_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
    spo2Value_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    spo2Value_.SetPosition(42, 50 - 12, 41, 32);

    spo2Unit_.SetFont(TJD_D_DIN_PRO_REGULAR_FONT_FILENAME, 30);
    spo2Unit_.SetText("%");
    spo2Unit_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
    spo2Unit_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    spo2Unit_.SetPosition(98, 61, 51, 26);
    spo2Unit_.SetStyle(STYLE_TEXT_OPA, OHOS::OPA_OPAQUE * 0.3);

    spo2Level_.SetFont(TJD_VECTOR_FONT_FILENAME, 24);
    spo2Level_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
    spo2Level_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    spo2Level_.SetPosition(141, 59 - 12, 51, 26);
    spo2Level_.SetStyle(STYLE_TEXT_OPA, OHOS::OPA_OPAQUE * 0.3);

    spo2Title_.SetFont(TJD_D_DIN_PRO_MEDIUM_FONT_FILENAME, 18);
    spo2Title_.SetText("BLOOD OXYGEN");
    spo2Title_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
    spo2Title_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    spo2Title_.SetPosition(83, 23, 118, 14);
    spo2Title_.SetStyle(STYLE_TEXT_COLOR, 0XFFEA3D35);
    spo2Title_.SetStyle(STYLE_TEXT_OPA, OHOS::OPA_OPAQUE * 0.8);

    spo2Pic_.SetPosition(25, 97, 350, 60);
    spo2Pic_.SetSrc(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_SPO2_PICTURE, FAVORITE_IMAGE_BIN_PATH));

    bloodOxygenModel_.Add(&spo2Bg_);
    bloodOxygenModel_.Add(&spo2Icon_);
    bloodOxygenModel_.Add(&spo2Value_);
    bloodOxygenModel_.Add(&spo2Unit_);
    bloodOxygenModel_.Add(&spo2Level_);
    bloodOxygenModel_.Add(&spo2Title_);
    bloodOxygenModel_.Add(&spo2Pic_);

    Add(&healthModel_);
    Add(&bloodOxygenModel_);
}
#pragma endregion

#pragma region 睡眠模组
FavoriteSleepModel::FavoriteSleepModel()
{
    auto &images = OHOS::ImageCacheManager::GetInstance();

    Resize(400, 180);

    sleepBg_.SetPosition(0, 0, 400, 180);
    sleepBg_.SetSrc(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_BJ_SLEEP, FAVORITE_IMAGE_BIN_PATH));

    sleepIcon_.SetPosition(41, 19, 27, 22);
    sleepIcon_.SetSrc(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_SLEEP_ICON, FAVORITE_IMAGE_BIN_PATH));

    sleepTitle_.SetFont(TJD_D_DIN_PRO_MEDIUM_FONT_FILENAME, 18);
    sleepTitle_.SetText("SLEEP");
    sleepTitle_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
    sleepTitle_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    sleepTitle_.SetPosition(78, 23, 93, 14);
    sleepTitle_.SetStyle(STYLE_TEXT_COLOR, 0XFF7119FF);
    sleepTitle_.SetStyle(STYLE_TEXT_OPA, OHOS::OPA_OPAQUE * 0.8);

    sleepHourValue_.SetFont(TJD_DIN_MEDIUM_FONT_FILENAME, 42);
    sleepHourValue_.SetText("--");
    sleepHourValue_.SetPosition(41, 50, 41, 32);
    sleepHourValue_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
    sleepHourValue_.SetAlign(OHOS::TEXT_ALIGNMENT_RIGHT, OHOS::TEXT_ALIGNMENT_CENTER);
    InitLabelVerCenter(sleepHourUnit_, 30, sleepHourValue_.GetX() + sleepHourValue_.GetWidth() + 6, GetHeight(), "h");
    sleepHourUnit_.SetFont(TJD_D_DIN_PRO_REGULAR_FONT_FILENAME, 30);
    sleepHourUnit_.SetY(66);

    sleepMinValue_.SetFont(TJD_DIN_MEDIUM_FONT_FILENAME, 42);
    sleepMinValue_.SetText("--");
    sleepMinValue_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
    sleepMinValue_.SetAlign(OHOS::TEXT_ALIGNMENT_RIGHT, OHOS::TEXT_ALIGNMENT_CENTER);
    sleepMinValue_.SetPosition(107, 50, 42, 32);
    InitLabelVerCenter(sleepMinUnit_, 30, sleepMinValue_.GetX() + sleepMinValue_.GetWidth() + 10, GetHeight(), "m");
    sleepMinUnit_.SetFont(TJD_D_DIN_PRO_REGULAR_FONT_FILENAME, 30);
    sleepMinUnit_.SetY(66);

    sleepLevel_.SetFont(TJD_VECTOR_FONT_FILENAME, 24);
    sleepLevel_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
    sleepLevel_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    sleepLevel_.SetPosition(195, 59, 142, 23);
    sleepLevel_.SetStyle(STYLE_TEXT_OPA, OHOS::OPA_OPAQUE * 0.3);

    sleepPic_.SetPosition(51, 108, 297, 38);
    sleepPic_.SetSrc(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_SLEEP_PICTURE, FAVORITE_IMAGE_BIN_PATH));

    Add(&sleepBg_);
    Add(&sleepTitle_);
    Add(&sleepIcon_);
    Add(&sleepHourValue_);
    Add(&sleepHourUnit_);
    Add(&sleepMinValue_);
    Add(&sleepMinUnit_);
    Add(&sleepLevel_);
    Add(&sleepPic_);
}
#pragma endregion

#pragma region 运动模组
FavoriteMotionModel::FavoriteMotionModel()
{
    auto &images = OHOS::ImageCacheManager::GetInstance();

    Resize(400, 576);

    motionModel_.SetPosition(0, 0, 400, 180);
    distanceModel_.SetPosition(0, 198, 400, 180);
    calorieModel_.SetPosition(0, 396, 400, 180);

    motionBg_.SetPosition(0, 0, 400, 180);
    motionBg_.SetSrc(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_BJ_STEP, FAVORITE_IMAGE_BIN_PATH));

    motionIcon_.SetPosition(40, 15, 21, 24);
    motionIcon_.SetSrc(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_STEP_ICON, FAVORITE_IMAGE_BIN_PATH));

    motionStepValue_.SetFont(TJD_DIN_MEDIUM_FONT_FILENAME, 42);
    motionStepValue_.SetText("18800");
    motionStepValue_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
    motionStepValue_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    motionStepValue_.SetPosition(42, 50, 41, 32);

    motionProcess_.SetFont(TJD_VECTOR_FONT_FILENAME, 24);
    motionProcess_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
    motionProcess_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    motionProcess_.SetPosition(163, 59, 145, 23);
    motionProcess_.SetStyle(STYLE_TEXT_OPA, OHOS::OPA_OPAQUE * 0.3);

    motionTitle_.SetFont(TJD_D_DIN_PRO_MEDIUM_FONT_FILENAME, 18);
    motionTitle_.SetText("STEPS");
    motionTitle_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
    motionTitle_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    motionTitle_.SetPosition(79, 23, 48, 14);
    motionTitle_.SetStyle(STYLE_TEXT_COLOR, 0XFF02952F);
    // motionTitle_.SetStyle(STYLE_TEXT_OPA, OHOS::OPA_OPAQUE * 0.8);

    auto progressBgRes =
        ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_MAIN_FAVORITE_RECTANGLE, FAVORITE_IMAGE_BIN_PATH);
    motionProgressBg_.SetPosition(40, 117, 322, 24);
    if (progressBgRes != nullptr) {
        motionProgressBg_.SetSrc(progressBgRes);
    }

    auto knodeRes =
        ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_MAIN_FAVORITE_PROGRESS, FAVORITE_IMAGE_BIN_PATH);
    motionProgress_.SetPosition(40, 116, 322, 24);
    motionProgress_.SetStyle(STYLE_BACKGROUND_OPA, 0);
    motionProgress_.SetStyle(STYLE_BORDER_RADIUS, 6);
    motionProgress_.SetValidWidth(303);
    motionProgress_.SetValidHeight(3);
    motionProgress_.SetKnobWidth(24);
    motionProgress_.SetSliderColor(Color::GetColorFromRGBA(0, 177, 36, 51), Color::GetColorFromRGBA(0, 177, 55, 0xff));
    // motionProgress_.SetKnobStyle(STYLE_BACKGROUND_COLOR, 0xff3299FE);
    // motionProgress_.SetKnobRadius(12);
    motionProgress_.SetKnobStyle(STYLE_BORDER_WIDTH, 2);
    motionProgress_.SetKnobImage(knodeRes);
    motionProgress_.SetValue(60);
    motionProgress_.SetTouchable(false);

    motionModel_.Add(&motionBg_);
    motionModel_.Add(&motionIcon_);
    motionModel_.Add(&motionProgressBg_);
    motionModel_.Add(&motionProcess_);
    motionModel_.Add(&motionStepValue_);
    motionModel_.Add(&motionProgress_);
    motionModel_.Add(&motionTitle_);
    //===================================================================================//distanceModel_
    distanceBg_.SetPosition(0, 0, 400, 180);
    distanceBg_.SetSrc(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_BJ_DIS, FAVORITE_IMAGE_BIN_PATH));

    distanceIcon_.SetPosition(39, 11, 26, 29);
    distanceIcon_.SetSrc(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_JULI_ICON, FAVORITE_IMAGE_BIN_PATH));

    distanceTitle_.SetFont(TJD_D_DIN_PRO_MEDIUM_FONT_FILENAME, 18);
    distanceTitle_.SetText("DISTANCE");
    distanceTitle_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
    distanceTitle_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    distanceTitle_.SetPosition(79, 23, 118, 14);
    distanceTitle_.SetStyle(STYLE_TEXT_COLOR, 0XFF00C989);
    distanceTitle_.SetStyle(STYLE_TEXT_OPA, OHOS::OPA_OPAQUE * 0.8);

    distanceValue_.SetFont(TJD_DIN_MEDIUM_FONT_FILENAME, 42);
    distanceValue_.SetText("36.6");
    distanceValue_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
    distanceValue_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    distanceValue_.SetPosition(42, 48, 76, 32);

    distanceUnit_.SetFont(TJD_D_DIN_PRO_REGULAR_FONT_FILENAME, 30);
    distanceUnit_.SetText("km");
    distanceUnit_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
    distanceUnit_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    distanceUnit_.SetPosition(150, 58, 35, 21);
    distanceUnit_.SetStyle(STYLE_TEXT_OPA, OHOS::OPA_OPAQUE * 0.3);

    distancePic_.SetPosition(64, 97, 269, 61);
    distancePic_.SetSrc(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_DISTANCE_PICTURE, FAVORITE_IMAGE_BIN_PATH));

    distanceModel_.Add(&distanceBg_);
    distanceModel_.Add(&distanceIcon_);
    distanceModel_.Add(&distanceValue_);
    distanceModel_.Add(&distanceTitle_);
    distanceModel_.Add(&distanceUnit_);
    distanceModel_.Add(&distancePic_);

    //===================================================================================//calorieModel_
    calorieBg_.SetPosition(0, 0, 400, 180);
    calorieBg_.SetSrc(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_BJ_CAL, FAVORITE_IMAGE_BIN_PATH));

    calorieIcon_.SetPosition(41, 15, 21, 23);
    calorieIcon_.SetSrc(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_KCAL_ICON, FAVORITE_IMAGE_BIN_PATH));

    calorieTitle_.SetFont(TJD_D_DIN_PRO_MEDIUM_FONT_FILENAME, 18);
    calorieTitle_.SetText("KCAL");
    calorieTitle_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
    calorieTitle_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    calorieTitle_.SetPosition(79, 23, 41, 14);
    calorieTitle_.SetStyle(STYLE_TEXT_COLOR, 0XFFFF751C);

    calorieValue_.SetFont(TJD_DIN_MEDIUM_FONT_FILENAME, 42);
    calorieValue_.SetText("1230");
    calorieValue_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
    calorieValue_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    calorieValue_.SetPosition(45, 49, 83, 32);

    calorieUnit_.SetFont(TJD_D_DIN_PRO_REGULAR_FONT_FILENAME, 30);
    calorieUnit_.SetText("kcal");
    calorieUnit_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
    calorieUnit_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    calorieUnit_.SetPosition(136, 59, 50, 22);
    calorieUnit_.SetStyle(STYLE_TEXT_OPA, OHOS::OPA_OPAQUE * 0.3);

    calorieLevel_.SetFont(TJD_VECTOR_FONT_FILENAME, 24);
    calorieLevel_.SetTextId(STR_ID_617);
    calorieLevel_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
    calorieLevel_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    calorieLevel_.SetPosition(206, 58, 95, 23);
    calorieLevel_.SetStyle(STYLE_TEXT_OPA, OHOS::OPA_OPAQUE * 0.3);

    caloriePic_.SetPosition(41, 106, 311, 52);
    caloriePic_.SetSrc(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_KCAL_PICTURE, FAVORITE_IMAGE_BIN_PATH));

    // InitLabelVerCenter(calorieValue_, 28, 151, 80, "1080");
    // InitLabelVerCenter(calorieUnit_, 28, 228, 80, "kcal");
    calorieModel_.Add(&calorieBg_);
    calorieModel_.Add(&calorieIcon_);
    calorieModel_.Add(&calorieValue_);
    calorieModel_.Add(&calorieUnit_);
    calorieModel_.Add(&calorieLevel_);
    calorieModel_.Add(&calorieTitle_);
    calorieModel_.Add(&caloriePic_);

    Add(&motionModel_);
    Add(&distanceModel_);
    Add(&calorieModel_);
}
#pragma endregion

#pragma region 秒表模组
FavoriteTimekeepingModel::FavoriteTimekeepingModel()
{
    auto &images = OHOS::ImageCacheManager::GetInstance();

    Resize(400, 180);
    SetTouchable(true);

    stopwatchBg_.SetPosition(0, 0, 400, 180);
    stopwatchBg_.SetSrc(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_BJ_STOP_WATCH, FAVORITE_IMAGE_BIN_PATH));

    startIcon_.SetPosition(22, 110, 46, 46);
    startIcon_.SetImages(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_PAUSE_MID, FAVORITE_IMAGE_BIN_PATH),
                         images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_START_MID, FAVORITE_IMAGE_BIN_PATH));
    startIcon_.SetTouchable(false);

    icon_.SetPosition(41, 17, 23, 24);
    icon_.SetSrc(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_STOPWATCH_ICON, FAVORITE_IMAGE_BIN_PATH));

    stopwatchTitle_.SetFont(TJD_D_DIN_PRO_MEDIUM_FONT_FILENAME, 18);
    stopwatchTitle_.SetText("STOPWATCH");
    stopwatchTitle_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
    stopwatchTitle_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    stopwatchTitle_.SetPosition(78, 23, 94, 14);
    stopwatchTitle_.SetStyle(STYLE_TEXT_COLOR, 0XFF00CE4F);
    stopwatchTitle_.SetStyle(STYLE_TEXT_OPA, OHOS::OPA_OPAQUE * 0.8);

    title_.SetFont(TJD_DIN_MEDIUM_FONT_FILENAME, 42);
    title_.SetText("30");
    title_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
    title_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    title_.SetPosition(43, 53, 41, 32);

    stopwatchUnit_.SetFont(TJD_VECTOR_FONT_FILENAME, 24);
    stopwatchUnit_.SetTextId(STR_ID_618);
    stopwatchUnit_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
    stopwatchUnit_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    stopwatchUnit_.SetPosition(92, 62, 119, 23);
    stopwatchUnit_.SetStyle(STYLE_TEXT_OPA, OHOS::OPA_OPAQUE * 0.3);

    time_.SetFont(TJD_DIN_MEDIUM_FONT_FILENAME, 60);
    time_.SetText("00:00:00");
    time_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
    time_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    time_.SetPosition(HorizontalCenter(time_.GetWidth(), 400), 88);

    if (g_timeKeepingIsStart) {
        startIcon_.SetState(OHOS::UICheckBox::UICheckBoxState::SELECTED);
        AddTimekeeping();
    }

    stopIcon_.SetPosition(334, 110, 46, 46);
    stopIcon_.SetSrc(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_END, FAVORITE_IMAGE_BIN_PATH));
    stopIcon_.SetTouchable(false);

    Add(&stopwatchBg_);
    Add(&startIcon_);
    Add(&icon_);
    Add(&title_);
    Add(&time_);
    Add(&stopIcon_);
    Add(&stopwatchTitle_);
    Add(&stopwatchUnit_);
}

void FavoriteTimekeepingModel::AddTimekeeping()
{
    if (g_timeKeepingIsStart == false) {
        return;
    }
    const simple_timer_t *timerTime = tjd_service_simple_timer_get_time();
    std::ostringstream oss;
    oss << std::setw(2) << std::setfill('0') << timerTime->hour << ":" << std::setw(2) << std::setfill('0')
        << timerTime->minute << ":" << std::setw(2) << std::setfill('0') << timerTime->second;
    timeStr_ = oss.str();
    time_.SetText(timeStr_.c_str());

    if (timerTime->hour == 0 && timerTime->minute == 30 && timerTime->second == 0) {
        StopTimekeeping();
        auto favortiteView = TjdUiAppMainPageFavorite::GetInstance();
        favortiteView->ShowView(FavoriteViewIndex::TIME_OUT_VIEW);
    }
}

void FavoriteTimekeepingModel::StopTimekeeping()
{
    g_timeKeepingIsStart = false;
    time_.SetText("00:00:00");
    startIcon_.SetState(OHOS::UICheckBox::UICheckBoxState::UNSELECTED, false);
}

bool FavoriteTimekeepingModel::OnClickEvent(const OHOS::ClickEvent &event)
{
    auto touchX = event.GetCurrentPos().x; // 获取点击的x坐标
    auto x = GetX();                       // 获取当前控件的x坐标
    auto width = GetWidth();               // 获取当前控件的宽度

    // 计算左边1/4和右边1/4的边界
    auto leftQuarter = x + width / 4;
    auto rightQuarter = x + 3 * width / 4;

    if (touchX < leftQuarter) {
        startIcon_.OnClickEvent(event);
        g_timeKeepingIsStart = startIcon_.GetState() == OHOS::UICheckBox::UICheckBoxState::SELECTED;
        if (g_timeKeepingIsStart) {
            tjd_service_simple_timer_start();
        } else {
            tjd_service_simple_timer_pause();
        }
    } else if (touchX > rightQuarter) {
        StopTimekeeping();
        tjd_service_simple_timer_stop();
    }
    return UIView::OnClickEvent(event);
}

TimeOutView::TimeOutView()
{
    auto &images = OHOS::ImageCacheManager::GetInstance();
    SetPosition(0, 0, OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);

    timeOut_.SetTextId(STR_ID_619);
    timeOut_.SetFont(TJD_VECTOR_FONT_FILENAME, 36);
    timeOut_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    timeOut_.SetPosition(68, 68, 330, 330);
    timeOut_.SetStyle(OHOS::STYLE_BACKGROUND_COLOR, 0xff00ff00);
    timeOut_.SetStyle(OHOS::STYLE_BACKGROUND_OPA, 0xff);

    enterIcon_.SetPosition(77, 378, 312, 88);
    enterIcon_.SetSrc(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_BJ, FAVORITE_IMAGE_BIN_PATH));
    enterIcon_.SetTouchable(true);
    enterIcon_.SetViewId(BTN_TIME_OUT_BTN_ID);
    enterIcon_.SetOnClickListener(FavoritePresenter::GetInstance());

    Add(&timeOut_);
    Add(&enterIcon_);
}

#pragma endregion

#pragma endregion

#pragma region 主页面
FavoriteMainView::FavoriteMainView()
{
    SetPosition(0, 0, OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
    SetScrollBlankSize(MAIN_VIEW_BLANK_SIZE);
    SetRotateEnable(*this);
    SetHorizontalScrollState(false);
    SetOnDragListener(FavoritePresenter::GetInstance());

    struct rtc_time time;
    tjd_driver_rtc_get_ops()->get_rtc_time(&time);
    std::ostringstream oss;
    oss << std::setfill('0') << std::setw(2) << time.tm_hour << ":" << std::setw(2) << time.tm_min;
    std::string timeStr = oss.str();
    InitLabelHorCenter(time_, 42, 27, OHOS::HORIZONTAL_RESOLUTION, timeStr.c_str());
    Add(&time_);

    topModel_.SetPosition(50, 102);
    Add(&topModel_);
    Add(&musicModel_);
    Add(&healthModel_);
    Add(&sleepModel_);
    Add(&motionModel_);
    Add(&timekeepingModel_);

    btnEdit_.SetStyle(STYLE_BACKGROUND_COLOR, 0xff242424);
    btnEdit_.SetStyle(STYLE_BACKGROUND_OPA, 0xff);
    btnEdit_.SetStyle(STYLE_BORDER_RADIUS, 33);
    btnEdit_.SetPosition(123, 2057 + 40, 220, 66);
    btnEdit_.SetTouchable(true);
    btnEdit_.SetViewId(BTN_EDIT_VIEW_ID);
    btnEdit_.SetOnClickListener(FavoritePresenter::GetInstance());

    editDesc_.SetFont(TJD_VECTOR_FONT_FILENAME, 36);
    editDesc_.SetTextId(STR_ID_69);
    editDesc_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
    editDesc_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    editDesc_.SetPosition(HorizontalCenter(editDesc_.GetWidth(), btnEdit_.GetWidth()),
                          VerticalCenter(editDesc_.GetHeight(), btnEdit_.GetHeight()));
    editDesc_.SetStyle(STYLE_TEXT_COLOR, 0XFF00b136);
    btnEdit_.Add(&editDesc_);

    Add(&btnEdit_);
    int setY = btnEdit_.GetY() + 233;
    hide_.SetPosition(50, setY, 0, 0);
    Add(&hide_);
}

void FavoriteMainView::ShowView()
{
    startTime_ = HALTick::GetInstance().GetTime();
    set_back_to_home_interval(5);
    auto presenter = FavoritePresenter::GetInstance();
    if (TjdUiSettingCenter::GetInstance().IsConnectApp()) {
        topModel_.SetType(FavoritePresenter::GetInstance()->GetTopModelType());
    } else {
        topModel_.SetType(TopModelType::TOP_MODEL_DISCONNECTED);
    }
    SetMusicModelPlayState(presenter->IsPlaying() ? OHOS::UICheckBox::UICheckBoxState::SELECTED
                                                  : OHOS::UICheckBox::UICheckBoxState::UNSELECTED);
    UpdateData();
    ScrollBy(0, GetHeight());
    SetModelSort(TjdUiAppMainPageFavorite::GetInstance()->GetFavoriteModelList());
    SetVisible(true);

    TjdCardId pageid = TjdUiAppMainView::GetInstance()->GetHorCurrentCard();
    if (pageid == TjdCardId::TJD_CARD_FAVORITE) {
        TjdUiUtils::ViewRequestFocus(*this);
    }
}

void FavoriteMainView::HideView()
{
    SetVisible(false);
    ClearFocus();
}

void FavoriteMainView::SetModelSort(std::list<FavoriteModel> &favoriteModelList)
{
    bool isFirst = true;
    int16_t startY = topModel_.GetY() + 336 + 12;
    for (auto it = favoriteModelList.begin(); it != favoriteModelList.end(); it++) {
        // clang-format off
        UIView *view = nullptr;
        switch (*it) {
        case FavoriteModel::MUSIC_MODEL:        view = &musicModel_;        break;
        case FavoriteModel::HEALTH_MODEL:       view = &healthModel_;       break;
        case FavoriteModel::SLEEP_MODEL:        view = &sleepModel_;        break;
        case FavoriteModel::MOTION_MODEL:       view = &motionModel_;       break;
        case FavoriteModel::TIMEKEEPING_MODEL:  view = &timekeepingModel_;  break;
        default: break;
        }
        // clang-format on
        if (isFirst) {
            startY += (46 - 12);
            isFirst = false;
        }
        if (view != nullptr) {
            view->SetPosition(33, startY);
            startY += view->GetHeight() + 22;
        }
    }
}

void FavoriteMainView::UpdateData()
{
    auto favoritePresenter = FavoritePresenter::GetInstance();
    if (favoritePresenter == nullptr) {
        return;
    }
    healthModel_.healthValue_.SetText(favoritePresenter->GetHeartRate().c_str());
    healthModel_.healthLevel_.SetTextId(favoritePresenter->GetHeartRateLevel());

    healthModel_.spo2Value_.SetText(favoritePresenter->GetSpo2().c_str());
    healthModel_.spo2Level_.SetTextId(favoritePresenter->GetSpo2Level());

    sleepModel_.sleepHourValue_.SetText(favoritePresenter->GetSleepHourTime().c_str());
    sleepModel_.sleepMinValue_.SetText(favoritePresenter->GetSleepMinuteTime().c_str());
    sleepModel_.sleepLevel_.SetTextId(favoritePresenter->GetSleepLevel());

    motionModel_.motionStepValue_.SetText(favoritePresenter->GetStepCount().c_str());
    motionModel_.motionProgress_.SetValue(favoritePresenter->GetStepProcess()); // 步数进度条
    motionModel_.motionProcess_.SetText((std::string(OHOS::FontGlobalManager::GetInstance()->GetText(STR_ID_616)) +
                                         std::to_string(favoritePresenter->GetStepProcess()) + std::string("%"))
                                            .c_str()); // 步数进度条
    motionModel_.distanceValue_.SetText(favoritePresenter->GetDistance().c_str());
    motionModel_.calorieValue_.SetText(favoritePresenter->GetCalorie().c_str());
}

OHOS::UICheckBox::UICheckBoxState FavoriteMainView::GetMusicModelPlayState() { return musicModel_.GetPlayState(); }

void FavoriteMainView::SetMusicModelPlayState(OHOS::UICheckBox::UICheckBoxState state)
{
    musicModel_.SetPlayState(state);
}
#pragma endregion

#pragma region 排序界面
FavoriteSortModelView::FavoriteSortModelView()
{
    itemName_[FavoriteModel::MUSIC_MODEL] = STR_ID_627;
    itemName_[FavoriteModel::HEALTH_MODEL] = STR_ID_628;
    itemName_[FavoriteModel::SLEEP_MODEL] = STR_ID_629;
    itemName_[FavoriteModel::MOTION_MODEL] = STR_ID_630;
    itemName_[FavoriteModel::TIMEKEEPING_MODEL] = STR_ID_631;

    auto &images = OHOS::ImageCacheManager::GetInstance();
    SetPosition(0, 0, OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
    SetScrollBlankSize(MAIN_VIEW_BLANK_SIZE);
    SetRotateEnable(*this);
    SetHorizontalScrollState(false);
    SetOnDragListener(FavoritePresenter::GetInstance());
    SetReboundSize(0);

    title_.SetTextId(STR_ID_88);
    title_.SetFont(TJD_VECTOR_FONT_FILENAME, 32);
    title_.Resize(200, 100);
    title_.SetX((GetWidth() >> 1) - (title_.GetWidth() >> 1));
    title_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    Add(&title_);

    topIcon_.SetPosition(272, 32, 60, 60);
    topIcon_.SetSrc(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_TOP, FAVORITE_IMAGE_BIN_PATH));

    topModel_.SetViewId(BTN_WEATHER_VIEW_ID);
    topModel_.SetPosition(50, 85, 366, 126);
    topModel_.SetStyle(STYLE_BACKGROUND_OPA, 0xff);
    topModel_.SetStyle(STYLE_BORDER_RADIUS, 63);
    topModel_.SetStyle(STYLE_BACKGROUND_COLOR, 0xff262626);
    topModel_.SetTouchable(true);
    topModel_.SetOnClickListener(FavoritePresenter::GetInstance());

    topModelDesc_.SetTextId(STR_ID_626);
    topModelDesc_.SetFont(TJD_VECTOR_FONT_FILENAME, 34);
    topModelDesc_.Resize(180, (topModel_.GetHeight() >> 1));
    topModelDesc_.SetPosition(51, 0);
    topModelDesc_.SetLineBreakMode(UILabel::LINE_BREAK_MARQUEE);
    topModelDesc_.SetAlign(OHOS::TEXT_ALIGNMENT_LEFT, OHOS::TEXT_ALIGNMENT_BOTTOM);

    topModelValue_.SetTextId(STR_ID_11);
    topModelValue_.SetFont(TJD_VECTOR_FONT_FILENAME, 28);
    topModelValue_.Resize(180, (topModel_.GetHeight() >> 1));
    topModelValue_.SetPosition(topModelDesc_.GetX(), (topModel_.GetHeight() >> 1));
    topModelValue_.SetLineBreakMode(UILabel::LINE_BREAK_MARQUEE);
    topModelValue_.SetAlign(OHOS::TEXT_ALIGNMENT_LEFT, OHOS::TEXT_ALIGNMENT_TOP);
    topModelValue_.SetStyle(OHOS::STYLE_TEXT_OPA, OHOS::OPA_OPAQUE * 0.5);

    topModel_.Add(&topIcon_);
    topModel_.Add(&topModelDesc_);
    topModel_.Add(&topModelValue_);
    Add(&topModel_);

    /* 初始化时用全局 */
    int startY = 219;
    int index = 0;
    for (auto item : g_favoriteModelList_) {
        sortItemView_[index] = new SortItemView(startY, index, itemName_[item], this);
        startY += 118;
        Add(sortItemView_[index]);
        ++index;
    }

    btnEnter_.SetPosition(77, 958, 312, 88);
    btnEnter_.SetSrc(ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_MAIN_FAVORITE_BJ, FAVORITE_IMAGE_BIN_PATH));
    btnEnter_.SetTouchable(true);
    btnEnter_.SetViewId(BTN_SORT_ENTER_VIEW_ID);
    btnEnter_.SetOnClickListener(FavoritePresenter::GetInstance());

    Add(&btnEnter_);
}

FavoriteSortModelView::~FavoriteSortModelView()
{
    RemoveAll();
    for (int i = 0; i < FavoriteModel::MODEL_COUNT; ++i) {
        if (sortItemView_[i] != nullptr) {
            delete sortItemView_[i];
            sortItemView_[i] = nullptr;
        }
    }
    topModel_.RemoveAll();
}

void FavoriteSortModelView::ShowView()
{
    auto presenter = FavoritePresenter::GetInstance();
    if (presenter == nullptr) {
        return;
    }
    set_back_to_home_interval(0xffffffff);
    /* 拷贝一份排序 */
    modelSortList_.clear();
    for (auto &item : g_favoriteModelList_) {
        modelSortList_.emplace_back(item);
    }
    ScrollBy(0, 1413);
    switch (presenter->GetTopModelType()) {
    case TopModelType::TOP_MODEL_VOICE:
        topModelValue_.SetTextId(STR_ID_614);
        break;
    default:
        topModelValue_.SetTextId(STR_ID_11);
        break;
    }
    int index = 0;
    for (auto item : modelSortList_) {
        sortItemView_[index]->SetItemName(itemName_[item]);
        ++index;
    }
    SetReboundSize(0);
    SetVisible(true);
    TjdUiUtils::ViewRequestFocus(*this);
}

void FavoriteSortModelView::HideView()
{
    SetVisible(false);
    ClearFocus();
}

bool FavoriteSortModelView::OnClick(OHOS::UIView &view, const OHOS::ClickEvent &event)
{
    auto presenter = FavoritePresenter::GetInstance();
    if (presenter == nullptr) {
        return false;
    }
    std::string viewId = view.GetViewId();
    if (viewId.empty()) {
        return false;
    }
    int16_t index = view.GetParent()->GetViewIndex();
    if (viewId == BTN_UP_VIEW_ID) { // 上移
        if (index == 0) {
            return true;
        }
        SortItem(index, true);
        presenter->SetSortIsChange(true);
    } else if (viewId == BTN_DOWN_VIEW_ID) { // 下移
        if (index == 4) {
            return true;
        }
        SortItem(index, false);
        presenter->SetSortIsChange(true);
    }
    return true;
}

void FavoriteSortModelView::SortItem(int index, bool isUp)
{
    auto curIt = modelSortList_.begin();
    std::advance(curIt, index);
    std::function<void(SortItemView *, SortItemView *)> swapItem = [](SortItemView *curItem, SortItemView *targetItem) {
        auto text = curItem->GetItemName();
        curItem->SetItemName(targetItem->GetItemName());
        targetItem->SetItemName(text);
    };
    if (isUp) {
        swapItem(sortItemView_[index], sortItemView_[index - 1]);
        auto preIt = std::prev(curIt);
        std::iter_swap(curIt, preIt);
    } else {
        swapItem(sortItemView_[index], sortItemView_[index + 1]);
        auto nextIt = std::next(curIt);
        std::iter_swap(curIt, nextIt);
    }
}
#pragma endregion

#pragma region 顶部排序页面
TopModelItemView::TopModelItemView(const TopModelItemInfo &itemInfo)
{
    auto &images = OHOS::ImageCacheManager::GetInstance();
    Resize(450, 128);
    SetTouchable(true);
    SetStyle(OHOS::STYLE_BACKGROUND_OPA, 0xff);
    SetStyle(OHOS::STYLE_BORDER_RADIUS, 64);
    SetStyle(OHOS::STYLE_BACKGROUND_COLOR, 0xff202020);
    SetViewIndex(itemInfo.index);

    name_.SetFont(TJD_VECTOR_FONT_FILENAME, 42);
    name_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_STRETCH);
    name_.SetAlign(OHOS::TEXT_ALIGNMENT_LEFT, OHOS::TEXT_ALIGNMENT_CENTER);
    name_.SetHeight(GetHeight());
    name_.SetX(42);

    selectRes_ = images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_ICON_SELECT, FAVORITE_IMAGE_BIN_PATH);
    unSelectRes_ = images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_ICON_NO, FAVORITE_IMAGE_BIN_PATH);

    switch_.SetPosition(382, 44, 40, 40);
    switch_.SetTouchable(false);
    switch_.SetSrc(selectRes_);

    Add(&name_);
    Add(&switch_);
}

void TopModelItemView::RefreshItem(const TopModelItemInfo &itemInfo, int16_t index)
{
    itemInfo_ = itemInfo;
    name_.SetTextId(itemInfo.name);

    int32_t selectIndex = FavoritePresenter::GetInstance()->GetTopModelType();
    if (itemInfo.index == selectIndex) {
        switch_.SetSrc(selectRes_);
    } else {
        switch_.SetSrc(unSelectRes_);
    }
}

bool TopModelItemView::OnClickEvent(const OHOS::ClickEvent &event)
{
    FavoritePresenter::GetInstance()->SelectTopModelIndex(itemInfo_.index);
    OHOS::UIView *childView = static_cast<OHOS::UITransformList *>(GetParent())->GetChildrenHead();
    while (childView != nullptr) {
        static_cast<TopModelItemView *>(childView)->switch_.SetSrc(unSelectRes_);
        childView = childView->GetNextSibling();
    }

    if (switch_.GetImageInfo()->resId == selectRes_->resId) {
        switch_.SetSrc(unSelectRes_);
    } else {
        switch_.SetSrc(selectRes_);
    }
    switch_.Invalidate();
    return true;
}

FavoriteChooseTopModelView::FavoriteChooseTopModelView()
{
    auto &images = OHOS::ImageCacheManager::GetInstance();
    auto selectRes = images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_ICON_SELECT, FAVORITE_IMAGE_BIN_PATH);
    auto unSelectRes = images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_ICON_NO, FAVORITE_IMAGE_BIN_PATH);

    Resize(OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
    SetOnDragListener(FavoritePresenter::GetInstance());
    SetHorizontalScrollState(false);

    infoList_.push_back({TopModelType::TOP_MODEL_WEATHER, STR_ID_613});
    infoList_.push_back({TopModelType::TOP_MODEL_VOICE, STR_ID_612});

    enterIcon_.SetPosition(77, 378, 312, 88);
    enterIcon_.SetTouchable(true);
    enterIcon_.SetViewId(BTN_TOP_MODEL_ENTER_VIEW_ID);
    enterIcon_.SetOnClickListener(FavoritePresenter::GetInstance());
    enterIcon_.SetSrc(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_BJ, FAVORITE_IMAGE_BIN_PATH));

    title_.SetTextId(STR_ID_88);
    title_.SetFont(TJD_VECTOR_FONT_FILENAME, 32);
    title_.Resize(200, 100);
    title_.SetX((GetWidth() >> 1) - (title_.GetWidth() >> 1));
    title_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    auto titleOffset_ = ((OHOS::Screen::GetInstance().GetHeight() >> 1) - (128 >> 1) - 17 - title_.GetHeight());
    adapter_ =
        new TjdUITransformListGroupAdapter<TopModelItemInfo, TopModelItemView, std::list<TopModelItemInfo>>(infoList_);
    listGroup_ = new TjdUITransformListGroup(adapter_);
    Add(listGroup_);
    listGroup_->AddCustomView(&title_, TjdUITransformListGroup::CustomViewPos::TITLE);
    listGroup_->SetTitleOffset(titleOffset_);

    Add(&title_);
    Add(&enterIcon_);
}

void FavoriteChooseTopModelView::ShowView()
{
    SetVisible(true);
    listGroup_->RequestFocus();
}

void FavoriteChooseTopModelView::HideView()
{
    listGroup_->ClearFocus();
    SetVisible(false);
}
#pragma endregion

#pragma region 设置提示页面
FavoriteBreakView::FavoriteBreakView()
{
    auto &images = OHOS::ImageCacheManager::GetInstance();
    Resize(OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
    SetHorizontalScrollState(false);

    desc_.SetTextId(STR_ID_90);
    desc_.SetFont(TJD_VECTOR_FONT_FILENAME, 34);
    desc_.Resize(300, 200);
    desc_.SetX((GetWidth() >> 1) - (desc_.GetWidth() >> 1));
    desc_.SetY(120);
    desc_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);

    btnCancel_.SetPosition(103, 326, 92, 92);
    btnCancel_.SetTouchable(true);
    btnCancel_.SetViewId(BTN_SAVE_SORT_CLOSE_VIEW_ID);
    btnCancel_.SetOnClickListener(FavoritePresenter::GetInstance());
    btnCancel_.SetSrc(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_QUXIAO, FAVORITE_IMAGE_BIN_PATH));

    btnOK_.SetPosition(271, 326, 92, 92);
    btnOK_.SetTouchable(true);
    btnOK_.SetViewId(BTN_SAVE_SORT_ENTER_VIEW_ID);
    btnOK_.SetOnClickListener(FavoritePresenter::GetInstance());
    btnOK_.SetSrc(images.LoadOneInMultiRes(IMG_MAIN_FAVORITE_QUEDING, FAVORITE_IMAGE_BIN_PATH));

    Add(&desc_);
    Add(&btnCancel_);
    Add(&btnOK_);
}
#pragma endregion

#pragma region 等待页面
FavoriteSettingWaitView::FavoriteSettingWaitView()
{
    const int WaitAnimatorId[11] = {
        IMG_LOADING_LOADING_01_06, IMG_LOADING_LOADING_02_06, IMG_LOADING_LOADING_03_06, IMG_LOADING_LOADING_04_06,
        IMG_LOADING_LOADING_05_06, IMG_LOADING_LOADING_06_06, IMG_LOADING_LOADING_07_06, IMG_LOADING_LOADING_08_06,
        IMG_LOADING_LOADING_09_06, IMG_LOADING_LOADING_10_06, IMG_LOADING_LOADING_11_06,
    };
    auto &imgManager = OHOS::ImageCacheManager::GetInstance();
    imgManager.LoadAllInMultiRes(COMMON_IMAGE_BIN_PATH);
    for (int i = 0; i < 11; i++) {
        waitInfo_[i].imageInfo = imgManager.LoadOneInMultiRes(WaitAnimatorId[i], COMMON_IMAGE_BIN_PATH);
        waitInfo_[i].pos = {174, 135};
        waitInfo_[i].width = 121;
        waitInfo_[i].height = 121;
        waitInfo_[i].imageType = OHOS::IMG_SRC_IMAGE_INFO;
    }

    Resize(OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);

    /* 动画页面不允许滑动 */
    SetIntercept(true);

    animator_.SetPosition(150, 113, 166, 164);

    desc_.SetTextId(STR_ID_89);
    desc_.SetFont(TJD_VECTOR_FONT_FILENAME, 36);
    desc_.Resize(340, 150);
    desc_.SetX((GetWidth() >> 1) - (desc_.GetWidth() >> 1));
    desc_.SetY(animator_.GetY() + animator_.GetHeight() + 30);
    desc_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_TOP);

    animator_.SetImageAnimatorSrc(waitInfo_, 11, 100);
    animator_.Start();

    Add(&animator_);
    Add(&desc_);
}

FavoriteSettingWaitView::~FavoriteSettingWaitView()
{
    animator_.Stop();
    OHOS::ImageCacheManager::GetInstance().UnloadAllInMultiRes(COMMON_IMAGE_BIN_PATH);
    RemoveAll();
}

void FavoriteSettingWaitView::ShowView()
{
    animator_.Start();
    SetVisible(true);
}

void FavoriteSettingWaitView::HideView()
{
    animator_.Stop();
    SetVisible(false);
}
#pragma endregion

} // namespace TJD