/*----------------------------------------------------------------------------
 * Copyright (c) TJD Technologies Co., Ltd. 2025. All rights reserved.
 *
 * Description: TjdUiAppPlayerView.cpp
 *
 * Author: luziquan@ss-tjd.com
 *
 * Create: 2024-06-07
 *--------------------------------------------------------------------------*/

#include "TjdUiAppPlayerView.h"
#include "TjdUiImageIds.h"
#include "TjdUiMultiLanguageExt.h"
#include "TjdUiUtils.h"
#include "common/image_cache_manager.h"
#include "ui_image_animator.h"
#include <iomanip>
#include <sstream>

namespace TJD {
#define MUSIC_IMAGE_BIN_PATH TJD_IMAGE_PATH "img_music.bin"
#define LOADING_IMAGE_BIN_PATH TJD_IMAGE_PATH "img_loading.bin"

static inline void SetRotateEnable(OHOS::UIScrollView &view) { TjdUiUtils::SetDefaultRollingEffect(view); }

static TjdUiAppPlayerView *g_playerView = nullptr;

bool PlayerUIScrollView::OnDragStartEvent(const OHOS::DragEvent &event)
{
    if (TjdUiAppPlayerView::GetInstance()->GetCurrentView() != PlayerViewIndex::PLAYER_VIEW) {
        return true;
    }

    isOnStart_ = true;
    return OHOS::UIScrollViewNested::OnDragStartEvent(event);
}

bool PlayerUIScrollView::OnDragEvent(const OHOS::DragEvent &event)
{
    if (!isOnStart_) {
        return true;
    }

    if (TjdUiAppPlayerView::GetInstance()->GetCurrentView() != PlayerViewIndex::PLAYER_VIEW) {
        return true;
    }
    return OHOS::UIScrollViewNested::OnDragEvent(event);
}

bool PlayerUIScrollView::OnDragEndEvent(const OHOS::DragEvent &event)
{
    if (!isOnStart_) {
        return true;
    }
    isOnStart_ = false;

    if (TjdUiAppPlayerView::GetInstance()->GetCurrentView() != PlayerViewIndex::PLAYER_VIEW) {
        return true;
    }
    return OHOS::UIScrollViewNested::OnDragEndEvent(event);
}

TjdUiAppPlayerView::TjdUiAppPlayerView() { g_playerView = this; }

TjdUiAppPlayerView::~TjdUiAppPlayerView() { g_playerView = nullptr; }

TjdUiAppPlayerView *TjdUiAppPlayerView::GetInstance(void) { return g_playerView; }

void TjdUiAppPlayerView::OnStart()
{
    InitImageInfo();

    if (mainView_ == nullptr) {
        mainView_ = new PlayerUIScrollView();
        mainView_->SetPosition(0, 0, OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
        // mainView_->SetOnDragListener(TjdUiAppPlayerPresenter::GetInstance());
    }

    InitTargetView(PlayerViewIndex::PLAYER_VIEW);

    AddViewToRootContainer(mainView_);
}

void TjdUiAppPlayerView::OnStop()
{
    RemoveAll();
    if (mainView_ != nullptr) {
        mainView_->RemoveAll();
        delete mainView_;
        mainView_ = nullptr;
    }
    for (int i = 0; i < PLAYER_UNKNOWN; i++) {
        if (viewManager_[i] == nullptr) {
            continue;
        }
        delete viewManager_[i];
        viewManager_[i] = nullptr;
    }
    delete[] musicStateAnimator_;
    OHOS::ImageCacheManager::GetInstance().UnloadAllInMultiRes(MUSIC_IMAGE_BIN_PATH);
}

OHOS::ImageAnimatorInfo *TjdUiAppPlayerView::GetImageAnimatorInfo(void) { return musicStateAnimator_; }

void TjdUiAppPlayerView::InitImageInfo()
{
    const int resId[] = {IMG_MUSIC_VOICE01, IMG_MUSIC_VOICE02, IMG_MUSIC_VOICE03};
    auto &image = OHOS::ImageCacheManager::GetInstance();
    image.LoadAllInMultiRes(MUSIC_IMAGE_BIN_PATH);
    const int size = sizeof(resId) / sizeof(resId[0]);
    musicStateAnimator_ = new OHOS::ImageAnimatorInfo[size];
    // 播放动效
    OHOS::ImageAnimatorInfo baseinfo = {nullptr, {383, 35}, 39, 37, OHOS::IMG_SRC_IMAGE_INFO};
    for (int i = 0; i < 3; i++) {
        musicStateAnimator_[i] = baseinfo;
        musicStateAnimator_[i].imageInfo = image.LoadOneInMultiRes(resId[i], MUSIC_IMAGE_BIN_PATH);
    }
}

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

    // clang-format off
    switch (index) {
    case PLAYER_VIEW:           viewManager_[index] = new PlayerMainView(); break;
    case MUSIC_LIST_VIEW:       viewManager_[index] = new PlayerListView(); break;
    case VOLUME_VIEW:           viewManager_[index] = new PlayerVolumeView(); break;
    case DEVICE_VIEW:           viewManager_[index] = new PlayerDeviceView(); break;
    case LOW_POWER_VIEW:        viewManager_[index] = new PlayerLowPowerView(); break;
    case SEARCH_LIST_VIEW:      viewManager_[index] = new PlayerSearchView(); break;
    case SEARCHING_VIEW:        viewManager_[index] = new PlayerWaitView(); break;
    case DEVICE_CONNECT_VIEW:   viewManager_[index] = new PlayerDeviceConnectView(); break;
    case CONNECT_SUCCESS_VIEW:  viewManager_[index] = new PlayerConnectSuccessView(); break;
    case CONNECT_FAIL_VIEW:     viewManager_[index] = new PlayerConnectFailView(); break;
    case CONNECT_APP_FAIL_VIEW: viewManager_[index] = new PlayerConnectAppFailView(); break;
    case DELETE_MUSIC_VIEW:     viewManager_[index] = new PlayerCaseDeleteEntryView(); 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 TjdUiAppPlayerView::ShowView(PlayerViewIndex showIndex)
{
    if (showIndex < 0 || showIndex >= PlayerViewIndex::PLAYER_UNKNOWN) {
        return;
    }
    InitTargetView(showIndex);

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

    if (viewManager_[showIndex] != nullptr) {
        viewManager_[showIndex]->ShowView();
    }

    currentViewIndex_ = showIndex;
}

#pragma region 支持缩放的Slider
class PlayerMainView::SliderAnimatorCallback : public OHOS::AnimatorCallback
{
public:
    virtual void Callback(UIView *view)
    {
        if (animator_->GetRunTime() >= animator_->GetTime()) {
            animator_->Stop();
            return;
        }
        auto *slider = dynamic_cast<OHOS::UISlider *>(view);
        if (slider == nullptr) {
            return;
        }
        int16_t knobSize =
            OHOS::EasingEquation::LinearEaseNone(startSize_, endSize_, animator_->GetRunTime(), animator_->GetTime());
        slider->SetKnobWidth(knobSize);
        slider->SetKnobRadius(knobSize >> 1);
        slider->Invalidate();
    }
    virtual void OnStop(UIView &view) {}
    void SetAnimator(OHOS::Animator *animator) { animator_ = animator; }
    void SetAnimatorSize(int16_t startSize, int16_t endSize)
    {
        startSize_ = startSize;
        endSize_ = endSize;
    }

private:
    OHOS::Animator *animator_{nullptr};
    int16_t startSize_{0};
    int16_t endSize_{0};
};

PlayerMainView::CustomSlider::~CustomSlider()
{
    if (sliderAnimatorCallback_ != nullptr) {
        delete sliderAnimatorCallback_;
        sliderAnimatorCallback_ = nullptr;
    }
    if (animator_ != nullptr) {
        delete animator_;
        animator_ = nullptr;
    }
}

bool PlayerMainView::CustomSlider::OnDragStartEvent(const OHOS::DragEvent &event)
{
    TjdUiAppPlayerPresenter::GetInstance()->IsDragSlider = true;
    StartAnimator(20, 30);
    return UISlider::OnDragStartEvent(event);
}

bool PlayerMainView::CustomSlider::OnDragEndEvent(const OHOS::DragEvent &event)
{
    TjdUiAppPlayerPresenter::GetInstance()->IsDragSlider = false;
    StartAnimator(30, 20);
    return UISlider::OnDragEndEvent(event);
}

void PlayerMainView::CustomSlider::StartAnimator(uint16_t startSize, uint16_t endSize)
{
    if (animator_ == nullptr) {
        sliderAnimatorCallback_ = new SliderAnimatorCallback();
        animator_ = new OHOS::Animator(sliderAnimatorCallback_, this, 100, true);
        sliderAnimatorCallback_->SetAnimator(animator_);
    }
    sliderAnimatorCallback_->SetAnimatorSize(startSize, endSize);
    animator_->Start();
}
#pragma endregion

#pragma region 方法转发
void TjdUiAppPlayerView::SyncLyric(const char *lyric)
{
    InitTargetView(PlayerViewIndex::PLAYER_VIEW);
    dynamic_cast<PlayerMainView *>(viewManager_[PlayerViewIndex::PLAYER_VIEW])->SetLyricText(lyric);
}

void TjdUiAppPlayerView::ChangedVolume(int32_t volume)
{
    InitTargetView(PlayerViewIndex::VOLUME_VIEW);
    dynamic_cast<PlayerVolumeView *>(viewManager_[PlayerViewIndex::VOLUME_VIEW])->SetVolume(volume);
}

void TjdUiAppPlayerView::SetCurrentMusicName(const char *musicName)
{
    InitTargetView(PlayerViewIndex::PLAYER_VIEW);
    dynamic_cast<PlayerMainView *>(viewManager_[PlayerViewIndex::PLAYER_VIEW])->SetMusicNameText(musicName);
}

void TjdUiAppPlayerView::SwitchPlayerButtonState(void)
{
    InitTargetView(PlayerViewIndex::PLAYER_VIEW);
    auto playerView = dynamic_cast<PlayerMainView *>(viewManager_[PlayerViewIndex::PLAYER_VIEW]);
    auto state = playerView->GetPlayerButtonState();
    state = state == OHOS::UICheckBox::UICheckBoxState::SELECTED ? OHOS::UICheckBox::UICheckBoxState::UNSELECTED
                                                                 : OHOS::UICheckBox::UICheckBoxState::SELECTED;
    playerView->SetPlayerButtonState(state);
}

void TjdUiAppPlayerView::SetPlayerButtonState(OHOS::UICheckBox::UICheckBoxState state)
{
    InitTargetView(PlayerViewIndex::PLAYER_VIEW);
    auto playerView = dynamic_cast<PlayerMainView *>(viewManager_[PlayerViewIndex::PLAYER_VIEW]);
    playerView->SetPlayerButtonState(state);
}

void TjdUiAppPlayerView::SetConnectDevice(OHOS::UICheckBox::UICheckBoxState state)
{
    InitTargetView(PlayerViewIndex::DEVICE_VIEW);
    dynamic_cast<PlayerDeviceView *>(viewManager_[PlayerViewIndex::DEVICE_VIEW])->SetHeadsetState(state);
}

OHOS::UICheckBox::UICheckBoxState TjdUiAppPlayerView::GetPlayerButtonState(void)
{
    InitTargetView(PlayerViewIndex::PLAYER_VIEW);
    auto playerView = dynamic_cast<PlayerMainView *>(viewManager_[PlayerViewIndex::PLAYER_VIEW]);
    return playerView->GetPlayerButtonState();
}

void TjdUiAppPlayerView::SetDeviceState(PlayerSource state, bool isConnectEarpod)
{
    InitTargetView(PlayerViewIndex::PLAYER_VIEW);
    InitTargetView(PlayerViewIndex::DEVICE_VIEW);
    dynamic_cast<PlayerDeviceView *>(viewManager_[PlayerViewIndex::DEVICE_VIEW])->SetDeviceType(state);
    dynamic_cast<PlayerMainView *>(viewManager_[PlayerViewIndex::PLAYER_VIEW])->SetDeviceType(state);
}

void TjdUiAppPlayerView::ChangedImage(int resId)
{
    InitTargetView(PlayerViewIndex::PLAYER_VIEW);
    dynamic_cast<PlayerMainView *>(viewManager_[PlayerViewIndex::PLAYER_VIEW])->ChangedImage(resId);
}

void TjdUiAppPlayerView::SetDeviceInfo(const char *name, bool connectState)
{
    InitTargetView(PlayerViewIndex::DEVICE_CONNECT_VIEW);
    dynamic_cast<PlayerDeviceConnectView *>(viewManager_[PlayerViewIndex::DEVICE_CONNECT_VIEW])
        ->SetDeviceInfo(name, connectState);
}

void TjdUiAppPlayerView::SetWaitViewInfo(uint16_t textId)
{
    InitTargetView(PlayerViewIndex::SEARCHING_VIEW);
    dynamic_cast<PlayerWaitView *>(viewManager_[PlayerViewIndex::SEARCHING_VIEW])->SetDesc(textId);
}

void TjdUiAppPlayerView::SetPlayingMusic(int16_t index, bool isPlaying)
{
    InitTargetView(PlayerViewIndex::MUSIC_LIST_VIEW);
    dynamic_cast<PlayerListView *>(viewManager_[PlayerViewIndex::MUSIC_LIST_VIEW])->SetTargetPlaying(index, isPlaying);
}

void TjdUiAppPlayerView::SetDeleteEntryDesc(const char *name)
{
    InitTargetView(PlayerViewIndex::DELETE_MUSIC_VIEW);
    dynamic_cast<PlayerCaseDeleteEntryView *>(viewManager_[PlayerViewIndex::DELETE_MUSIC_VIEW])->SetDesc(name);
}

void TjdUiAppPlayerView::RefrashMusicList(void)
{
    InitTargetView(PlayerViewIndex::MUSIC_LIST_VIEW);
    dynamic_cast<PlayerListView *>(viewManager_[PlayerViewIndex::MUSIC_LIST_VIEW])->RefrashView();
}

static std::string 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();
}

void TjdUiAppPlayerView::SetTime(int64_t curTime, uint64_t duration, bool dragging)
{
    InitTargetView(PlayerViewIndex::PLAYER_VIEW);
    auto mainView = dynamic_cast<PlayerMainView *>(viewManager_[PlayerViewIndex::PLAYER_VIEW]);
    if (mainView == nullptr) {
        return;
    }
    if (lastDuration_ != duration) {
        mainView->SetDurationText(ConvertToTimeFormat(duration).c_str());
        lastDuration_ = duration;
    }
    if (!presenter_->IsDragSlider) {
        mainView->SetCurTimeText(ConvertToTimeFormat(curTime).c_str());
        mainView->SetSliderValue(curTime * 100 / duration);
    }
    if (dragging) {
        mainView->SetCurTimeText(ConvertToTimeFormat(curTime).c_str());
    }
}
#pragma endregion

#pragma region 音乐主界面
PlayerMainView::PlayerMainView()
{
    auto &image = OHOS::ImageCacheManager::GetInstance();
    OHOS::ImageInfo *res = nullptr;

    Resize(OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
    if (OHOS::PageTransitionMgr::GetInstance().GetTopSlideBackImage() == nullptr) {
        SetOnDragListener(TjdUiAppPlayerPresenter::GetInstance());
    }

    title_.SetTextId(STR_ID_10);
    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);

    songPicture_.SetPosition(163, 72, 142, 142);
    res = image.LoadOneInMultiRes(IMG_MUSIC_MUSIC_BJ, MUSIC_IMAGE_BIN_PATH);
    songPicture_.SetSrc(res);

    musicName_.SetPosition(100, 224, 266, 38);
    musicName_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ELLIPSIS);
    musicName_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    musicName_.SetFont(TJD_VECTOR_FONT_FILENAME, 30);

    lyric_.SetPosition(70, 269, 327, 32);
    lyric_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_MARQUEE);
    lyric_.SetStyle(OHOS::STYLE_TEXT_OPA, OHOS::OPA_OPAQUE * 0.3);
    lyric_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    lyric_.SetRollSpeed(60);
    lyric_.SetFont(TJD_VECTOR_FONT_FILENAME, 24);

    imgbackGround_.SetPosition(0, 0, OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
    res = image.LoadOneInMultiRes(IMG_MUSIC_BJ, MUSIC_IMAGE_BIN_PATH);
    imgbackGround_.SetSrc(res);

    // 音乐列表
    musicList_.SetOnClickListener(TjdUiAppPlayerPresenter::GetInstance());
    musicList_.SetTouchable(true);
    musicList_.SetViewId(BTN_MUSIC_LIST_VIEW_ID);
    musicList_.SetAutoEnable(false);
    musicList_.SetResizeMode(OHOS::UIImageView::ImageResizeMode::CENTER);
    musicList_.SetPosition(391, 116, 48, 48);
    res = image.LoadOneInMultiRes(IMG_MUSIC_LIST, MUSIC_IMAGE_BIN_PATH);
    musicList_.SetSrc(res);

    // 上一首
    left_.SetOnClickListener(TjdUiAppPlayerPresenter::GetInstance());
    left_.SetTouchable(true);
    left_.SetViewId(BTN_LEFT_VIEW_ID);
    left_.SetAutoEnable(false);
    left_.SetResizeMode(OHOS::UIImageView::ImageResizeMode::CENTER);
    left_.SetPosition(107, 360, 58, 43);
    res = image.LoadOneInMultiRes(IMG_MUSIC_LEFT_ICON, MUSIC_IMAGE_BIN_PATH);
    left_.SetSrc(res);

    // 下一首
    right_.SetOnClickListener(TjdUiAppPlayerPresenter::GetInstance());
    right_.SetTouchable(true);
    right_.SetViewId(BTN_RIGHT_VIEW_ID);
    right_.SetAutoEnable(false);
    right_.SetResizeMode(OHOS::UIImageView::ImageResizeMode::CENTER);
    right_.SetPosition(301, 360, 58, 44);
    res = image.LoadOneInMultiRes(IMG_MUSIC_RIGHT_ICON, MUSIC_IMAGE_BIN_PATH);
    right_.SetSrc(res);

    // 连接
    connect_.SetOnClickListener(TjdUiAppPlayerPresenter::GetInstance());
    connect_.SetTouchable(true);
    connect_.SetViewId(BTN_CONNECT_VIEW_ID);
    connect_.SetAutoEnable(false);
    connect_.SetResizeMode(OHOS::UIImageView::ImageResizeMode::CENTER);
    connect_.SetPosition(415, 184, 45, 55);
    res = image.LoadOneInMultiRes(IMG_MUSIC_PHONE, MUSIC_IMAGE_BIN_PATH);
    connect_.SetSrc(res);

    // 循环
    loop_.SetOnClickListener(TjdUiAppPlayerPresenter::GetInstance());
    loop_.SetTouchable(true);
    loop_.SetViewId(BTN_LOOP_VIEW_ID);
    loop_.SetAutoEnable(false);
    loop_.SetResizeMode(OHOS::UIImageView::ImageResizeMode::CENTER);
    loop_.SetPosition(35, 117, 52, 47);
    res = image.LoadOneInMultiRes(IMG_MUSIC_RANDOM, MUSIC_IMAGE_BIN_PATH);
    loop_.SetSrc(res);

    // 音量
    volume_.SetOnClickListener(TjdUiAppPlayerPresenter::GetInstance());
    volume_.SetTouchable(true);
    volume_.SetViewId(BTN_VOLUME_VIEW_ID);
    volume_.SetAutoEnable(false);
    volume_.SetResizeMode(OHOS::UIImageView::ImageResizeMode::CENTER);
    volume_.SetPosition(6, 188, 54, 48);
    res = image.LoadOneInMultiRes(IMG_MUSIC_VOLUME, MUSIC_IMAGE_BIN_PATH);
    volume_.SetSrc(res);

    // 播放/暂停
    btnPlayer_.SetPosition(211, 355, 44, 50);
    btnPlayer_.SetViewId(BTN_START_VIEW_ID);
    btnPlayer_.SetStyleForState(OHOS::STYLE_BACKGROUND_OPA, OHOS::OPA_TRANSPARENT,
                                OHOS::UIButton::ButtonState::PRESSED);
    btnPlayer_.SetStyleForState(OHOS::STYLE_BACKGROUND_OPA, OHOS::OPA_TRANSPARENT,
                                OHOS::UIButton::ButtonState::RELEASED);
    btnPlayer_.SetOnClickListener(TjdUiAppPlayerPresenter::GetInstance());
    auto startRes = image.LoadOneInMultiRes(IMG_MUSIC_SUSPEND_ICON, MUSIC_IMAGE_BIN_PATH);
    auto startLightRes = image.LoadOneInMultiRes(IMG_MUSIC_SUSPEND_ICON_LIGHT, MUSIC_IMAGE_BIN_PATH);
    if (startRes != nullptr && startLightRes != nullptr) {
        btnPlayer_.SetImageSrc(startRes, startLightRes);
    }

    slider_.SetPosition(103, 307, 261, 36);
    slider_.SetValidWidth(slider_.GetWidth() - 32);
    slider_.SetValidHeight(6);
    slider_.SetKnobWidth(20);
    slider_.SetIntercept(true);
    slider_.SetKnobRadius((slider_.GetKnobWidth() >> 1));
    slider_.SetKnobColor(OHOS::Color::White());
    slider_.SetCapType(OHOS::CapType::CAP_ROUND);
    slider_.SetSliderColor(OHOS::Color::Gray(), OHOS::Color::White());
    slider_.SetSliderEventListener(TjdUiAppPlayerPresenter::GetInstance());

    curTime_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_WRAP);
    curTime_.SetPosition(41, 308, 57, 24);
    curTime_.SetText("00:00");
    curTime_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    curTime_.SetFont(TJD_DIN_MEDIUM_FONT_FILENAME, 24);

    duration_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_WRAP);
    duration_.SetPosition(366, 308, 57, 24);
    duration_.SetText("00:00");
    duration_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    duration_.SetFont(TJD_DIN_MEDIUM_FONT_FILENAME, 24);

    Add(&imgbackGround_);
    Add(&songPicture_);
    Add(&title_);
    Add(&musicName_);
    Add(&lyric_);
    Add(&btnPlayer_);
    Add(&musicList_);
    Add(&left_);
    Add(&right_);
    Add(&connect_);
    Add(&loop_);
    Add(&slider_);
    Add(&volume_);
    Add(&curTime_);
    Add(&duration_);
}

PlayerMainView::~PlayerMainView() { RemoveAll(); }

void PlayerMainView::SetPlayerButtonState(OHOS::UICheckBox::UICheckBoxState state)
{
    auto &image = OHOS::ImageCacheManager::GetInstance();
    OHOS::ImageInfo *defaultRes = nullptr;
    OHOS::ImageInfo *triggeredRes = nullptr;
    btnPlayerState_ = state;

    if (btnPlayerState_ == OHOS::UICheckBox::UICheckBoxState::SELECTED) {
        defaultRes = image.LoadOneInMultiRes(IMG_MUSIC_START_ICON, MUSIC_IMAGE_BIN_PATH);
        triggeredRes = image.LoadOneInMultiRes(IMG_MUSIC_START_ICON_LIGHT, MUSIC_IMAGE_BIN_PATH);
    } else {
        defaultRes = image.LoadOneInMultiRes(IMG_MUSIC_SUSPEND_ICON, MUSIC_IMAGE_BIN_PATH);
        triggeredRes = image.LoadOneInMultiRes(IMG_MUSIC_SUSPEND_ICON_LIGHT, MUSIC_IMAGE_BIN_PATH);
    }

    if (defaultRes != nullptr && triggeredRes != nullptr) {
        btnPlayer_.SetImageSrc(defaultRes, triggeredRes);
    }

    btnPlayer_.Invalidate();
}

void PlayerMainView::ChangedImage(int resId)
{
    OHOS::ImageInfo *res = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(resId, MUSIC_IMAGE_BIN_PATH);
    if (res != nullptr) {
        loop_.SetSrc(res);
    }
}

void PlayerMainView::SetDeviceType(PlayerSource state)
{
    musicList_.SetTouchable(state != PlayerSource::PLAYER_SOURCE_PHONE);
    musicList_.SetOpaScale(state != PlayerSource::PLAYER_SOURCE_PHONE ? OHOS::OPA_OPAQUE : 0.3 * OHOS::OPA_OPAQUE);

    slider_.SetTouchable(state != PlayerSource::PLAYER_SOURCE_PHONE);
    slider_.SetKnobStyle(OHOS::STYLE_BACKGROUND_OPA,
                         state != PlayerSource::PLAYER_SOURCE_PHONE ? OHOS::OPA_OPAQUE : 0.3 * OHOS::OPA_OPAQUE);
    slider_.SetOpaScale(state != PlayerSource::PLAYER_SOURCE_PHONE ? OHOS::OPA_OPAQUE : 0.3 * OHOS::OPA_OPAQUE);

    loop_.SetTouchable(state != PlayerSource::PLAYER_SOURCE_PHONE);
    loop_.SetOpaScale(state != PlayerSource::PLAYER_SOURCE_PHONE ? OHOS::OPA_OPAQUE : 0.3 * OHOS::OPA_OPAQUE);
}
#pragma endregion

#pragma region 音乐列表项
PlayersCaseView::PlayersCaseView()
{
    auto *imageAnimatorInfo = TjdUiAppPlayerView::GetInstance()->GetImageAnimatorInfo();
    auto &image = OHOS::ImageCacheManager::GetInstance();

    auto deleteRes = image.LoadOneInMultiRes(IMG_MUSIC_DELETE, MUSIC_IMAGE_BIN_PATH);
    Resize(122 + 450, 110);
    SetStyle(OHOS::STYLE_MARGIN_BOTTOM, 8);

    mainView_.SetViewId("play");
    mainView_.SetPosition(0, 0, 450, GetHeight());
    mainView_.SetStyle(OHOS::STYLE_BACKGROUND_OPA, 0XFF);
    mainView_.SetStyle(OHOS::STYLE_BACKGROUND_COLOR, 0XFF262626);
    mainView_.SetStyle(OHOS::STYLE_BORDER_RADIUS, GetHeight() / 2);
    mainView_.SetTouchable(true);
    mainView_.SetDraggable(true);

    leftHide_.SetPosition(0, 0, 0, 0);
    rightHide_.SetPosition(450 + 22 + 250, 0, 0, 0);

    deleteIcon_.SetPosition(450 + 22, 10, 100, 100);
    if (deleteRes != nullptr) {
        deleteIcon_.SetSrc(deleteRes);
    }
    deleteIcon_.SetTouchable(true);
    deleteIcon_.SetViewId("delete");

    name_.SetText(" ");
    name_.SetFont(TJD_VECTOR_FONT_FILENAME, 34);
    name_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_MARQUEE);
    name_.SetAlign(OHOS::TEXT_ALIGNMENT_LEFT, OHOS::TEXT_ALIGNMENT_CENTER);
    name_.SetPosition(43, 33, 320, 55);

    mainView_.Add(&name_);
    mainView_.Add(&imageAnimator_);

    imageAnimator_.SetPosition(383, 35, 39, 37);
    imageAnimator_.SetImageAnimatorSrc(imageAnimatorInfo, 3, 75);
    SetPlaying(false);

    Add(&mainView_);
    Add(&deleteIcon_);
    Add(&leftHide_);
    Add(&rightHide_);
}

PlayersCaseView::~PlayersCaseView()
{
    mainView_.RemoveAll();
    RemoveAll();
}

void PlayersCaseView::SetPlaying(bool isPlaying)
{
    imageAnimator_.SetVisible(isPlaying);
    if (isPlaying) {
        imageAnimator_.Start();
    } else {
        imageAnimator_.Stop();
    }
}

void PlayersCaseView::StartAnimator(uint16_t ACCLevel, int16_t dragDistanceX, int16_t dragDistanceY)
{
    UIScrollView::SetDragACCLevel(ACCLevel);
    UIScrollView::StartAnimator(dragDistanceX, dragDistanceY);
}

bool PlayersCaseView::OnDragStartEvent(const OHOS::DragEvent &event)
{
    TjdUiAppPlayerPresenter *presenter = TjdUiAppPlayerPresenter::GetInstance();
    if (presenter == nullptr) {
        return false;
    }
    auto direction = event.GetDragDirection();
    if (direction == OHOS::DragEvent::DIRECTION_LEFT_TO_RIGHT) {
        auto *lastView = static_cast<PlayersCaseView *>(TjdUiAppPlayerPresenter::GetInstance()->GetSelectView());
        if (lastView != nullptr && lastView != this) {
            lastView->StartAnimator(3, 466, 0);
        }
        TjdUiAppPlayerPresenter::GetInstance()->SetSelectView(this);
        OHOS::UIScrollView::OnDragEvent(event);
        startDrag = true;
        intercept = true;
    } else {
        startDrag = false;
        intercept = false;
    }
    return false;
}

bool PlayersCaseView::OnDragEvent(const OHOS::DragEvent &event)
{
    if (!startDrag) {
        return false;
    }
    OHOS::UIScrollView::OnDragEvent(event);
    return intercept;
}

bool PlayersCaseView::OnDragEndEvent(const OHOS::DragEvent &event)
{
    if (!startDrag) {
        startDrag = false;
        return false;
    }
    OHOS::Rect coor = deleteIcon_.GetRect();
    int16_t val = 480 - 22 - coor.GetLeft();
    if (val >= deleteIcon_.GetWidth() / 2) {
        auto scroll = (deleteIcon_.GetWidth() - val);
        StartAnimator(2, -466, 0);
    } else {
        auto scroll = -(deleteIcon_.GetWidth() - val);
        StartAnimator(2, 466, 0);
    }
    return intercept;
}
#pragma endregion

#pragma region 音乐列表容器
PlayersCaseViewGroup::PlayersCaseViewGroup(std::list<PlayerCaseInfo> *list)
{
    SetAutoSize(true);
    playersItemList_ = new std::list<PlayersCaseView *>();
    playerCaseList_ = list;
    clickListener_ = new PlayerListOnClickListener();

    int16_t startY = 0;
    for (auto &item : *playerCaseList_) {
        auto view = new PlayersCaseView();
        view->SetName(item.sliceId);
        view->SetViewIndex(item.index);
        view->SetPosition(0, startY);
        startY += view->GetHeight() + 8;
        view->SetOnClickListener(clickListener_);
        playersItemList_->emplace_back(view);
        Add(view);
    }
}

PlayersCaseViewGroup::~PlayersCaseViewGroup()
{
    RemoveAll();
    for (auto &item : *playersItemList_) {
        delete item;
    }
    if (clickListener_ != nullptr) {
        delete clickListener_;
        clickListener_ = nullptr;
    }
    delete playersItemList_;
    playersItemList_ = nullptr;
}

void PlayersCaseViewGroup::RefreshView(void)
{
    PlayersCaseView *view = nullptr;
    // 如果当前个数大于列表个数，删除多余的。
    while (playerCaseList_->size() > playersItemList_->size()) {
        view = new PlayersCaseView();
        if (playersItemList_->size() == 0) {
            view->SetPosition(0, 0);
        } else {
            view->SetPosition(0, playersItemList_->back()->GetY() + playersItemList_->back()->GetHeight() + 8);
        }
        view->SetViewIndex(playersItemList_->size());
        view->SetOnClickListener(clickListener_);
        playersItemList_->emplace_back(view);
        Add(view);
    }

    // 如果小于，删除多余的
    while (playerCaseList_->size() < playersItemList_->size()) {
        view = playersItemList_->back();
        playersItemList_->pop_back();
        Remove(view);
        delete view;
        if (playersItemList_->size() != 0) {
            view = playersItemList_->back();
        }
    }

    // 刷新数据
    auto itemIt = playersItemList_->begin();
    auto dataIt = playerCaseList_->begin();
    for (; itemIt != playersItemList_->end() && dataIt != playerCaseList_->end(); ++itemIt, ++dataIt) {
        (*itemIt)->SetName(dataIt->sliceId);
        (*itemIt)->SetViewIndex(dataIt->index);
        (*itemIt)->ScrollBy(466, 0);
    }
    SetHeight(playersItemList_->size() * (110 + 8));
}
#pragma endregion

#pragma region 音乐列表界面
PlayerListView::PlayerListView()
{
    Resize(OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
    SetOnDragListener(TjdUiAppPlayerPresenter::GetInstance());

    title_.SetTextId(STR_ID_10);
    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);

    SetRotateEnable(*this);

    listGroup_ = new PlayersCaseViewGroup(&PlayersListGroup::GetInstance()->GetCase());
    listGroup_->SetPosition(0, 173);

    const int16_t bottomY = (listGroup_->GetY() + listGroup_->GetHeight() + (OHOS::VERTICAL_RESOLUTION / 2)) - 110 / 2;
    bottomLine_.SetY(bottomY);
    bottomLine_.Invalidate();

    desc_.SetTextId(STR_ID_277);
    desc_.SetFont(TJD_VECTOR_FONT_FILENAME, 30);
    desc_.Resize(330, 330);
    desc_.SetPosition(68, 68);
    desc_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);

    desc_.SetVisible(false);
    topLine_.SetPosition(0, 0, 0, 0);

    Add(&title_);
    Add(listGroup_);
    Add(&topLine_);
    Add(&bottomLine_);
    Add(&desc_);
}

PlayerListView::~PlayerListView()
{
    if (listGroup_ != nullptr) {
        delete listGroup_;
        listGroup_ = nullptr;
    }
    RemoveAll();
}

void PlayerListView::ShowView()
{
    SetVisible(true);
    TjdUiUtils::ViewRequestFocus(*this);
}

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

void PlayerListView::SetTargetPlaying(int16_t index, bool isPlaying)
{
    std::list<PlayersCaseView *> *list = listGroup_->GetPlayersItemList();
    if (list == nullptr) {
        return;
    }
    for (auto &item : *list) {
        item->SetPlaying(isPlaying && item->GetViewIndex() == index);
    }
}

void PlayerListView::RefrashView()
{
    if (listGroup_ == nullptr) {
        return;
    }
    if (PlayersListGroup::GetInstance()->GetCase().size() == 0) {
        desc_.SetVisible(true);
        listGroup_->SetVisible(false);
    } else {
        desc_.SetVisible(false);
        listGroup_->SetVisible(true);
        listGroup_->RefreshView();
        const int16_t bottomY =
            (listGroup_->GetY() + listGroup_->GetHeight() + (OHOS::VERTICAL_RESOLUTION / 2)) - 110 / 2;
        bottomLine_.SetY(bottomY);
        bottomLine_.Invalidate();
    }
}
#pragma endregion

#pragma region 音量界面
PlayerVolumeView::PlayerVolumeView()
{
    auto &image = OHOS::ImageCacheManager::GetInstance();
    auto volumeRes = image.LoadOneInMultiRes(IMG_MUSIC_VOLUME_LIGHT, MUSIC_IMAGE_BIN_PATH);

    Resize(OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
    SetOnDragListener(TjdUiAppPlayerPresenter::GetInstance());

    sliderVolume_.SetPosition(173, 55, 120, 320);
    sliderVolume_.SetDirection(OHOS::UISlider::Direction::DIR_BOTTOM_TO_TOP);
    sliderVolume_.SetValidWidth(sliderVolume_.GetWidth());
    sliderVolume_.SetValidHeight(sliderVolume_.GetHeight());
    sliderVolume_.SetSliderColor(OHOS::Color::GetColorFromRGBA(0x66, 0x66, 0x66, 0x4C),
                                 OHOS::Color::GetColorFromRGBA(0x66, 0x66, 0x66, 0xff));
    sliderVolume_.SetSliderEventListener(TjdUiAppPlayerPresenter::GetInstance()->GetVolumeListener().get());
    sliderVolume_.SetValue(50);
    sliderVolume_.SetSliderRadius(32, 32);

    imgVolume_.SetPosition(216, 401, 34, 34);
    if (volumeRes != nullptr) {
        imgVolume_.SetSrc(volumeRes);
    }

    Add(&sliderVolume_);
    Add(&imgVolume_);
}

void PlayerVolumeView::ShowView()
{
    SetVisible(true);
    TjdUiUtils::ViewRequestFocus(sliderVolume_);
}

void PlayerVolumeView::HideView()
{
    SetVisible(false);
    sliderVolume_.ClearFocus();
}

#pragma endregion

#pragma region 设备界面
PlayerDeviceView::PlayerDeviceView()
{
    Resize(OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
    SetOnDragListener(TjdUiAppPlayerPresenter::GetInstance());

    auto &image = OHOS::ImageCacheManager::GetInstance();

    phoneItemInfo.deviceIndex = PlayerDeviceType::DEVICE_PHONE;
    phoneItemInfo.textId = STR_ID_265;
    phoneItemInfo.state = false;
    phoneItemInfo.active = true;
    phoneItemInfo.iconInfo = image.LoadOneInMultiRes(IMG_MUSIC_PHONE_COLOR, MUSIC_IMAGE_BIN_PATH);
    phoneItemInfo.selectInfo = image.LoadOneInMultiRes(IMG_MUSIC_ICON_SELECT, MUSIC_IMAGE_BIN_PATH);
    phoneItemInfo.unSelectInfo = image.LoadOneInMultiRes(IMG_MUSIC_ICON_NO, MUSIC_IMAGE_BIN_PATH);

    watchItemInfo.deviceIndex = PlayerDeviceType::DEVICE_WATCH;
    watchItemInfo.textId = STR_ID_266;
    watchItemInfo.state = true;
    watchItemInfo.active = true;
    watchItemInfo.iconInfo = image.LoadOneInMultiRes(IMG_MUSIC_CALL, MUSIC_IMAGE_BIN_PATH);
    watchItemInfo.selectInfo = image.LoadOneInMultiRes(IMG_MUSIC_ICON_SELECT, MUSIC_IMAGE_BIN_PATH);
    watchItemInfo.unSelectInfo = image.LoadOneInMultiRes(IMG_MUSIC_ICON_NO, MUSIC_IMAGE_BIN_PATH);

    // btItemInfo.deviceIndex = PlayerDeviceType::DEVICE_HEADSET;
    // btItemInfo.textId = STR_ID_267;
    // btItemInfo.state = false;
    // btItemInfo.active = true;
    // btItemInfo.selectInfo = image.LoadOneInMultiRes(IMG_MUSIC_OPEN, MUSIC_IMAGE_BIN_PATH);
    // btItemInfo.unSelectInfo = image.LoadOneInMultiRes(IMG_MUSIC_COLSE, MUSIC_IMAGE_BIN_PATH);

    deviceSelectInfoList.emplace_back(phoneItemInfo);
    deviceSelectInfoList.emplace_back(watchItemInfo);
    // deviceSelectInfoList.emplace_back(btItemInfo);

    deviceSelectListAdapter_ =
        new TjdUITransformListGroupAdapter<DeviceSelectListItemInfo, DeviceSelectListItemView,
                                           std::list<DeviceSelectListItemInfo>>(deviceSelectInfoList);
    deviceSelectList_ = new TjdUITransformListGroup(deviceSelectListAdapter_, "音乐");

    Add(deviceSelectList_);
}

PlayerDeviceView::~PlayerDeviceView()
{
    RemoveAll();
    if (deviceSelectList_ != nullptr) {
        deviceSelectList_->RemoveAll();
        delete deviceSelectList_;
        deviceSelectList_ = nullptr;
    }
    if (deviceSelectListAdapter_ != nullptr) {
        delete deviceSelectListAdapter_;
        deviceSelectListAdapter_ = nullptr;
    }
}

void PlayerDeviceView::SetHeadsetState(OHOS::UICheckBox::UICheckBoxState state)
{
    for (auto &item : deviceSelectInfoList) {
        if (item.deviceIndex == PlayerDeviceType::DEVICE_HEADSET) {
            item.state = state == OHOS::UICheckBox::UICheckBoxState::SELECTED;
            break;
        }
    }
    deviceSelectList_->RefreshList();
}

void PlayerDeviceView::SetDeviceType(PlayerSource state)
{
    for (auto &item : deviceSelectInfoList) {
        if (item.deviceIndex == PlayerDeviceType::DEVICE_PHONE) {
            item.state = state == PlayerSource::PLAYER_SOURCE_PHONE;
        } else if (item.deviceIndex == PlayerDeviceType::DEVICE_WATCH) {
            item.state = state == PlayerSource::PLAYER_SOURCE_WATCH;
        } else if (item.deviceIndex == PlayerDeviceType::DEVICE_HEADSET) {
            item.active = state == PlayerSource::PLAYER_SOURCE_WATCH;
        }
    }
    deviceSelectList_->RefreshList();
}

void PlayerDeviceView::ShowView()
{
    SetVisible(true);
    deviceSelectList_->RequestFocus();
}

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

#pragma region 连接列表界面
PlayerSearchView::PlayerSearchView()
{
    imageRes[0] = IMG_MUSIC_ICON01;
    imageRes[1] = IMG_MUSIC_ICON02;
    imageRes[2] = IMG_MUSIC_ICON03;
    auto &image = OHOS::ImageCacheManager::GetInstance();
    Resize(OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
    SetOnDragListener(TjdUiAppPlayerPresenter::GetInstance());
    auto searchRes = image.LoadOneInMultiRes(IMG_MUSIC_SEARCH, MUSIC_IMAGE_BIN_PATH);

    desc_.SetFont(TJD_VECTOR_FONT_FILENAME, 36);
    desc_.SetTextId(STR_ID_269);
    desc_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_WRAP);
    desc_.Resize(300, 300);
    desc_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    desc_.SetPosition(((GetWidth() - desc_.GetWidth()) >> 1), (GetHeight() - desc_.GetHeight()) >> 1);

    searchBtn_.SetPosition(187, 0, 92, 92);
    searchBtn_.SetViewId(BTN_SEARCH_VIEW_ID);
    searchBtn_.SetTouchable(true);
    searchBtn_.SetOnClickListener(TjdUiAppPlayerPresenter::GetInstance());
    searchBtn_.SetSrc(searchRes);

    listSearchBtn_.SetPosition(187, 0, 92, 92);
    listSearchBtn_.SetViewId(BTN_SEARCH_VIEW_ID);
    listSearchBtn_.SetTouchable(true);
    listSearchBtn_.SetOnClickListener(TjdUiAppPlayerPresenter::GetInstance());
    listSearchBtn_.SetSrc(searchRes);

    headsetListAdapter_ =
        new TjdUITransformListGroupAdapter<HeadsetListItemInfo, HeadsetListItemView, std::list<HeadsetListItemInfo>>(
            headsetInfoList);
    headsetList_ = new TjdUITransformListGroup(headsetListAdapter_);
    headsetList_->AddCustomView(&listSearchBtn_, TjdUITransformListGroup::CustomViewPos::BOTTOM);
    title_.SetTextId(STR_ID_268);
    title_.SetFont(TJD_VECTOR_FONT_FILENAME, 32);
    title_.Resize(200, 100);
    title_.SetX((headsetList_->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());
    headsetList_->AddCustomView(&title_, TjdUITransformListGroup::CustomViewPos::TITLE);
    headsetList_->SetTitleOffset(titleOffset_);
    headsetList_->RequestFocus();

    Add(&desc_);
    Add(&searchBtn_);
    Add(headsetList_);
}

PlayerSearchView::~PlayerSearchView()
{
    RemoveAll();
    if (headsetList_ != nullptr) {
        headsetList_->RemoveAll();
        delete headsetList_;
        headsetList_ = nullptr;
    }
    if (headsetListAdapter_ != nullptr) {
        delete headsetListAdapter_;
        headsetListAdapter_ = nullptr;
    }
}

void PlayerSearchView::ShowView()
{
    TjdUiAppPlayerPresenter *presenter = TjdUiAppPlayerPresenter::GetInstance();
    if (presenter->IsNeedUpdateHeadsetList) {
        RefreshList();
        presenter->IsNeedUpdateHeadsetList = false;
    }
    if (headsetInfoList.size() == 0) {
        desc_.SetVisible(true);
        searchBtn_.SetVisible(true);
        headsetList_->SetVisible(false);
    } else {
        desc_.SetVisible(false);
        searchBtn_.SetVisible(false);
        headsetList_->SetVisible(true);
    }
    SetVisible(true);
    headsetList_->RequestFocus();
}

void PlayerSearchView::HideView()
{
    SetVisible(false);
    headsetList_->ClearFocus();
}

void PlayerSearchView::RefreshList()
{
    auto &image = OHOS::ImageCacheManager::GetInstance();
    TjdUiAppPlayerPresenter *presenter = TjdUiAppPlayerPresenter::GetInstance();
    std::list<HeadsetInfo> &headsetInfo = presenter->GetHeadsetList();
    int index = 0;
    headsetInfoList.clear();
    HeadsetListItemInfo info;
    info.moreInfo = image.LoadOneInMultiRes(IMG_MUSIC_MORE, MUSIC_IMAGE_BIN_PATH);
    for (HeadsetInfo &item : headsetInfo) {
        info.headsetInfo = &item;
        info.iconInfo = image.LoadOneInMultiRes(imageRes[index++ % 3], MUSIC_IMAGE_BIN_PATH);
        headsetInfoList.emplace_back(info);
    }
    headsetList_->RefreshList();

    auto *transformList_ = headsetList_->GetTransformList();
    OHOS::UIView *head = transformList_->GetChildrenHead();
    if (head != nullptr) {
        int16_t headCenterY = head->GetRect().GetTop() + (head->GetHeight() >> 1);
        transformList_->ScrollBy((transformList_->GetHeight() >> 1) - headCenterY);
    }
}
#pragma endregion

#pragma region 低电量界面
PlayerLowPowerView::PlayerLowPowerView()
{
    Resize(OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
    SetOnDragListener(TjdUiAppPlayerPresenter::GetInstance());

    lowPowerLabel_.SetTextId(STR_ID_591);
    lowPowerLabel_.SetFont(TJD_VECTOR_FONT_FILENAME, 34);
    lowPowerLabel_.Resize(340, 100);
    lowPowerLabel_.SetX((GetWidth() >> 1) - (lowPowerLabel_.GetWidth() >> 1));
    lowPowerLabel_.SetY(120);
    lowPowerLabel_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_BOTTOM);

    desc_.SetTextId(STR_ID_592);
    desc_.SetFont(TJD_VECTOR_FONT_FILENAME, 34);
    desc_.Resize(340, 150);
    desc_.SetX((GetWidth() >> 1) - (desc_.GetWidth() >> 1));
    desc_.SetY(lowPowerLabel_.GetY() + lowPowerLabel_.GetHeight());
    desc_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_TOP);
    desc_.SetStyle(OHOS::STYLE_TEXT_OPA, OHOS::OPA_OPAQUE * 0.3);

    Add(&lowPowerLabel_);
    Add(&desc_);
}
#pragma endregion

#pragma region 等待界面
PlayerWaitView::PlayerWaitView()
{
    Resize(OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
    /* 动画页面不允许滑动 */
    SetIntercept(true);
    SetTouchable(false);

    const int waitAnimatorId[] = {
        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,
    };

    const int16_t animatorX = 178;
    const int16_t animatorY = 154;
    const int16_t animatorWidth = 121;
    const int16_t animatorHeight = 121;
    animator_.SetPosition(animatorX, animatorY, animatorWidth, animatorHeight);

    auto &imgManager = OHOS::ImageCacheManager::GetInstance();
    const int size = sizeof(waitAnimatorId) / sizeof(waitAnimatorId[0]);
    waitInfo_ = new OHOS::ImageAnimatorInfo[size];
    for (int i = 0; i < size; i++) {
        waitInfo_[i].imageInfo = imgManager.LoadOneInMultiRes(waitAnimatorId[i], LOADING_IMAGE_BIN_PATH);
        waitInfo_[i].pos = {animatorX, animatorY};
        waitInfo_[i].width = animatorWidth;
        waitInfo_[i].height = animatorHeight;
        waitInfo_[i].imageType = OHOS::IMG_SRC_IMAGE_INFO;
    }

    animator_.SetImageAnimatorSrc(waitInfo_, size, 100);

    desc_.SetTextId(STR_ID_273);
    desc_.SetFont(TJD_VECTOR_FONT_FILENAME, 34);
    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);

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

PlayerWaitView::~PlayerWaitView()
{
    if (waitInfo_ != nullptr) {
        delete[] waitInfo_;
        waitInfo_ = nullptr;
    }
    RemoveAll();
}

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

void PlayerWaitView::HideView()
{
    animator_.Stop();
    SetVisible(false);
}

void PlayerWaitView::SetDesc(uint16_t textId) { desc_.SetTextId(textId); }
#pragma endregion

#pragma region 设备连接界面
PlayerDeviceConnectView::PlayerDeviceConnectView()
{
    auto &imgManager = OHOS::ImageCacheManager::GetInstance();

    Resize(OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
    SetOnDragListener(TjdUiAppPlayerPresenter::GetInstance());

    title_.SetTextId(STR_ID_267);
    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);

    name_.SetFont(TJD_VECTOR_FONT_FILENAME, 42);
    name_.Resize(350, 50);
    name_.SetX((GetWidth() >> 1) - (name_.GetWidth() >> 1));
    name_.SetY(150);
    name_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    name_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_MARQUEE);

    connectState_.SetFont(TJD_VECTOR_FONT_FILENAME, 32);
    connectState_.Resize(350, 100);
    connectState_.SetX((GetWidth() >> 1) - (connectState_.GetWidth() >> 1));
    connectState_.SetY(name_.GetY() + name_.GetHeight());
    connectState_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_TOP);
    connectState_.SetStyle(OHOS::STYLE_TEXT_OPA, OHOS::OPA_OPAQUE * 0.3);

    connEnterButton_.SetPosition(271, 326, 92, 92);
    connEnterButton_.SetViewId(BTN_CONNECT_ENTER_VIEW_ID);
    connEnterButton_.SetTouchable(true);
    connEnterButton_.SetOnClickListener(TjdUiAppPlayerPresenter::GetInstance());
    connEnterButton_.SetSrc(imgManager.LoadOneInMultiRes(IMG_MUSIC_QUEDING, MUSIC_IMAGE_BIN_PATH));

    connCancelButton_.SetPosition(103, 326, 92, 92);
    connCancelButton_.SetViewId(BTN_CONNECT_CANCEL_VIEW_ID);
    connCancelButton_.SetTouchable(true);
    connCancelButton_.SetOnClickListener(TjdUiAppPlayerPresenter::GetInstance());
    connCancelButton_.SetSrc(imgManager.LoadOneInMultiRes(IMG_MUSIC_QUXIAO, MUSIC_IMAGE_BIN_PATH));

    unpairButton_.SetPosition(187, 352, 92, 92);
    unpairButton_.SetViewId(BTN_DEVICE_UNPAIR_VIEW_ID);
    unpairButton_.SetTouchable(true);
    unpairButton_.SetOnClickListener(TjdUiAppPlayerPresenter::GetInstance());
    unpairButton_.SetSrc(imgManager.LoadOneInMultiRes(IMG_MUSIC_QUXIAO, MUSIC_IMAGE_BIN_PATH));

    SetDeviceInfo("Tianjin pro", false);

    Add(&title_);
    Add(&name_);
    Add(&connectState_);
    Add(&connEnterButton_);
    Add(&connCancelButton_);
    Add(&unpairButton_);
}

void PlayerDeviceConnectView::SetDeviceInfo(const char *name, bool connectState)
{
    name_.SetText(name);
    connectState_.SetTextId(connectState ? STR_ID_589 : STR_ID_590);
    connEnterButton_.SetVisible(!connectState);
    connCancelButton_.SetVisible(!connectState);
    unpairButton_.SetVisible(connectState);
}
#pragma endregion

#pragma region 连接成功界面
PlayerConnectSuccessView::PlayerConnectSuccessView()
{
    Resize(OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
    SetOnDragListener(TjdUiAppPlayerPresenter::GetInstance());

    bg_.SetPosition(144, 140, 173, 154);
    bg_.SetSrc(OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_MUSIC_BLE_SUCC, MUSIC_IMAGE_BIN_PATH));

    title_.SetTextId(STR_ID_278);
    title_.SetFont(TJD_VECTOR_FONT_FILENAME, 32);
    title_.Resize(300, 140);
    title_.SetX((GetWidth() >> 1) - (title_.GetWidth() >> 1));
    title_.SetY(bg_.GetY() + bg_.GetHeight() + 10);
    title_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_TOP);

    Add(&title_);
    Add(&bg_);
}
#pragma endregion

#pragma region 连接失败界面
PlayerConnectFailView::PlayerConnectFailView()
{
    Resize(OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
    SetOnDragListener(TjdUiAppPlayerPresenter::GetInstance());

    bg_.SetPosition(144, 140, 173, 154);
    bg_.SetSrc(OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_MUSIC_BLE_FAIL, MUSIC_IMAGE_BIN_PATH));

    title_.SetTextId(STR_ID_279);
    title_.SetFont(TJD_VECTOR_FONT_FILENAME, 32);
    title_.Resize(300, 140);
    title_.SetX((GetWidth() >> 1) - (title_.GetWidth() >> 1));
    title_.SetY(bg_.GetY() + bg_.GetHeight() + 10);
    title_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_TOP);

    Add(&title_);
    Add(&bg_);
}
#pragma endregion

#pragma region 未连接界面
PlayerConnectAppFailView::PlayerConnectAppFailView()
{
    Resize(OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
    SetOnDragListener(TjdUiAppPlayerPresenter::GetInstance());

    bg_.SetPosition(144, 140, 173, 154);
    bg_.SetSrc(OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_MUSIC_BLE_FAIL, MUSIC_IMAGE_BIN_PATH));

    title_.SetTextId(STR_ID_557);
    title_.SetFont(TJD_VECTOR_FONT_FILENAME, 32);
    title_.Resize(300, 140);
    title_.SetX((GetWidth() >> 1) - (title_.GetWidth() >> 1));
    title_.SetY(bg_.GetY() + bg_.GetHeight() + 10);
    title_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_TOP);

    Add(&title_);
    Add(&bg_);
}
#pragma endregion

#pragma region 删除歌曲界面
PlayerCaseDeleteEntryView::PlayerCaseDeleteEntryView()
{
    auto &image = OHOS::ImageCacheManager::GetInstance();
    Resize(OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
    SetOnDragListener(TjdUiAppPlayerPresenter::GetInstance());

    title_.SetTextId(STR_ID_282);
    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);
    title_.SetStyle(OHOS::STYLE_TEXT_COLOR, 0XFFFF0000);

    name_.SetFont(TJD_VECTOR_FONT_FILENAME, 32);
    name_.Resize(350, 50);
    name_.SetX((GetWidth() >> 1) - (name_.GetWidth() >> 1));
    name_.SetY(150);
    name_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    name_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_MARQUEE);

    desc_.SetTextId(STR_ID_272);
    desc_.SetFont(TJD_VECTOR_FONT_FILENAME, 32);
    desc_.Resize(350, 100);
    desc_.SetX((GetWidth() >> 1) - (desc_.GetWidth() >> 1));
    desc_.SetY(name_.GetY() + name_.GetHeight());
    desc_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_TOP);

    btnCancel_.SetPosition(102, 326, 92, 92);
    btnCancel_.SetSrc(image.LoadOneInMultiRes(IMG_MUSIC_QUXIAO, MUSIC_IMAGE_BIN_PATH));
    btnCancel_.SetViewId(BTN_DELETE_CANCEL_MUSIC_VIEW_ID);
    btnCancel_.SetOnClickListener(TjdUiAppPlayerPresenter::GetInstance());
    btnCancel_.SetTouchable(true);

    btnEntry_.SetPosition(270, 326, 92, 92);
    btnEntry_.SetSrc(image.LoadOneInMultiRes(IMG_MUSIC_QUEDING, MUSIC_IMAGE_BIN_PATH));
    btnEntry_.SetViewId(BTN_DELETE_ENTRY_MUSIC_VIEW_ID);
    btnEntry_.SetOnClickListener(TjdUiAppPlayerPresenter::GetInstance());
    btnEntry_.SetTouchable(true);

    Add(&title_);
    Add(&name_);
    Add(&desc_);
    Add(&btnCancel_);
    Add(&btnEntry_);
}

void PlayerCaseDeleteEntryView::SetDesc(const char *date) { name_.SetText(date); }
#pragma endregion
} // namespace TJD