1051 lines
39 KiB
C++
1051 lines
39 KiB
C++
#include "TjdUiAppAlbumView.h"
|
||
#include "NativeAbility.h"
|
||
#include "TjdUiAppAlbumPresenter.h"
|
||
#include "TjdUiAppMainView.h"
|
||
#include "TjdUiMemManage.h"
|
||
#include "TjdUiMultiLanguageExt.h"
|
||
#include "TjdUiScreenManage.h"
|
||
#include "common/image_cache_manager.h"
|
||
#include "graphic_service.h"
|
||
#include "mem_api.h"
|
||
#include "sys_config.h"
|
||
#include <iomanip>
|
||
#include <iostream>
|
||
#include <sstream>
|
||
#include <string>
|
||
|
||
#define ENABLE_PRINT_INFO 1
|
||
#define ENABLE_DEBUG 0
|
||
|
||
#if ENABLE_PRINT_INFO
|
||
#define static_print_info(...) sys_ui_log_i(__VA_ARGS__) // 一般信息打印宏控制
|
||
#define static_print_warn(...) sys_ui_log_w(__VA_ARGS__) // 警告信息打印一般常开
|
||
#define static_print_error(...) sys_ui_log_e(__VA_ARGS__) // 错误信息打印一般常开
|
||
#if ENABLE_DEBUG
|
||
#define static_print_debug(...) sys_ui_log_d(__VA_ARGS__) // 调试信息打印
|
||
#else
|
||
#define static_print_debug(...)
|
||
#endif
|
||
#else
|
||
#define static_print_info(...)
|
||
#define static_print_warn(...)
|
||
#define static_print_error(...)
|
||
#define static_print_debug(...)
|
||
#endif
|
||
|
||
using namespace OHOS;
|
||
|
||
static constexpr int16_t VIDEO_WIDTH = HORIZONTAL_RESOLUTION;
|
||
static constexpr int16_t VIDEO_HEIGHT = VERTICAL_RESOLUTION;
|
||
static constexpr int16_t STRIDE_ALIGNMENT_VALUE = 128;
|
||
static constexpr int16_t BUFFER_QUEUE_SIZE = 3;
|
||
static constexpr int16_t JPEG_HEIGHT_DIVISOR = 2;
|
||
static constexpr int16_t JPEG_WIDTH_BYTE_ALIGNMENT = 128;
|
||
static constexpr int16_t JPEG_HEIGHT_BYTE_ALIGNMENT = 16;
|
||
static constexpr int16_t USEC_TO_MILLI = 1000;
|
||
static constexpr int16_t TIME_CONVERT = 60; // sec to min, and min to hor
|
||
static constexpr int16_t TEXT_BUFFER_SIEZ = 20;
|
||
static constexpr int16_t TEXT_FONT_SIEZ = 40;
|
||
static constexpr int16_t MAX_SCROLL_DIS = 1000;
|
||
static constexpr int16_t VIDEO_FORWARD_BACKWARD_TIME = 5000;
|
||
|
||
namespace TJD {
|
||
#define ALBUM_LOADING_IMAGE_BIN_PATH TJD_IMAGE_PATH "img_loading.bin"
|
||
|
||
#ifndef WAIT_ANIMATOR_COUNT
|
||
#define WAIT_ANIMATOR_COUNT 11
|
||
#endif
|
||
static OHOS::ImageAnimatorInfo g_pv_waitInfo_[WAIT_ANIMATOR_COUNT];
|
||
static void WaitAnimatorImageInfo()
|
||
{
|
||
const int waitAnimatorId[WAIT_ANIMATOR_COUNT] = {
|
||
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(ALBUM_LOADING_IMAGE_BIN_PATH);
|
||
for (int i = 0; i < WAIT_ANIMATOR_COUNT; i++) {
|
||
g_pv_waitInfo_[i].imageInfo = imgManager.LoadOneInMultiRes(waitAnimatorId[i], ALBUM_LOADING_IMAGE_BIN_PATH);
|
||
g_pv_waitInfo_[i].pos = {174, 135};
|
||
g_pv_waitInfo_[i].width = 121;
|
||
g_pv_waitInfo_[i].height = 121;
|
||
g_pv_waitInfo_[i].imageType = OHOS::IMG_SRC_IMAGE_INFO;
|
||
}
|
||
}
|
||
|
||
static void WaitAnimatorImageInfoUnload()
|
||
{
|
||
OHOS::ImageCacheManager::GetInstance().UnloadAllInMultiRes(ALBUM_LOADING_IMAGE_BIN_PATH);
|
||
}
|
||
|
||
static inline int16_t HorizontalCenter(int16_t width, int16_t parentWidth) { return (parentWidth - width) / 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 std::string millisecondsToTimeString(long milliseconds)
|
||
{
|
||
int seconds = milliseconds / 1000; // 毫秒转换为秒
|
||
int hours = seconds / 3600; // 秒转换为小时
|
||
int minutes = (seconds % 3600) / 60; // 秒中剩余的部分转换为分钟
|
||
int secs = seconds % 60; // 剩余的就是秒
|
||
|
||
// 使用std::ostringstream来构建字符串
|
||
std::ostringstream oss;
|
||
oss << std::setfill('0') << std::setw(2) << hours << ":" << std::setfill('0') << std::setw(2) << minutes << ":"
|
||
<< std::setfill('0') << std::setw(2) << secs;
|
||
|
||
return oss.str(); // 返回构建好的字符串
|
||
}
|
||
|
||
static void WaitAlbumVideoStart(void *param)
|
||
{
|
||
AlbumVideoOnClickListener *listener = static_cast<AlbumVideoOnClickListener *>(param);
|
||
listener->LoadVideoStart();
|
||
}
|
||
|
||
static void AlbumVideoTimerCallback(void *param)
|
||
{
|
||
AlbumVideoOnClickListener *listener = static_cast<AlbumVideoOnClickListener *>(param);
|
||
GraphicService::GetInstance()->PostGraphicEvent(std::bind(WaitAlbumVideoStart, listener));
|
||
}
|
||
|
||
static void SettingTimerCallback(void *param)
|
||
{
|
||
GraphicService::GetInstance()->PostGraphicEvent(std::bind(
|
||
[](void *param) {
|
||
auto presenter = static_cast<TjdUiAppAlbumPresenter *>(param);
|
||
presenter->isSetSucc = false;
|
||
NativeAbility::GetInstance().ChangeSlice(TJD_APP_VIEW_MAIN);
|
||
},
|
||
param));
|
||
}
|
||
|
||
AlbumVideoOnClickListener::AlbumVideoOnClickListener(AlbumVideoPlayer *player, OHOS::UILabel *totalTime,
|
||
OHOS::Animator *animator)
|
||
: player_(player), totalTime_(totalTime), animator_(animator)
|
||
{
|
||
timer_ = new GraphicTimer(100, AlbumVideoTimerCallback, this, true);
|
||
}
|
||
|
||
AlbumVideoOnClickListener::~AlbumVideoOnClickListener()
|
||
{
|
||
player_ = nullptr;
|
||
totalTime_ = nullptr;
|
||
animator_ = nullptr;
|
||
if (timer_ != nullptr) {
|
||
delete timer_;
|
||
timer_ = nullptr;
|
||
}
|
||
}
|
||
|
||
void AlbumVideoOnClickListener::PauseResumeButtonSwitch(AlbumIconType icon)
|
||
{
|
||
for (int i = 0; i < ALBUM_BUTTON_NUM; i++) {
|
||
if (player_->buttonArray_[i]->GetViewId() == std::string(PAUSE_RESUME_BUTTON)) {
|
||
ImageInfo *imageinfo = TjdUiAppAlbumPresenter::GetInstance()->GetAlbumIcon(icon);
|
||
player_->buttonArray_[i]->SetImageSrc(imageinfo, imageinfo);
|
||
player_->buttonArray_[i]->Invalidate();
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
void AlbumVideoOnClickListener::VideoForward(void)
|
||
{
|
||
if (player_->isPlayed_ || player_->isPause_) {
|
||
int64_t time = 0;
|
||
player_->GetCurrentPosition(&time);
|
||
static_print_debug("player_->GetCurrentPosition: %d\n", time);
|
||
time += VIDEO_FORWARD_BACKWARD_TIME;
|
||
time = time > player_->GetDurationTime() ? player_->GetDurationTime() : time;
|
||
player_->SeekVideoPlay(time);
|
||
animator_->SetRunTime(time);
|
||
}
|
||
}
|
||
|
||
void AlbumVideoOnClickListener::VideoBackward(void)
|
||
{
|
||
if (player_->isPlayed_ || player_->isPause_) {
|
||
int64_t time = 0;
|
||
player_->GetCurrentPosition(&time);
|
||
static_print_debug("player_->GetCurrentPosition: %d\n", time);
|
||
time -= VIDEO_FORWARD_BACKWARD_TIME;
|
||
time = time < 0 ? 0 : time;
|
||
player_->SeekVideoPlay(time);
|
||
animator_->SetRunTime(time);
|
||
}
|
||
}
|
||
|
||
void AlbumVideoOnClickListener::LoadVideoStart(void)
|
||
{
|
||
static_print_debug("AlbumVideoOnClickListener::LoadVideoStart\n");
|
||
if (player_->isPlayed_) {
|
||
int64_t time = player_->GetDurationTime();
|
||
animator_->SetTime(time);
|
||
totalTime_->SetText(millisecondsToTimeString(time).c_str());
|
||
animator_->Start();
|
||
timer_->Stop();
|
||
}
|
||
}
|
||
|
||
void AlbumVideoOnClickListener::SetVideoWallPaper(void)
|
||
{
|
||
player_->PauseVideoPlay();
|
||
animator_->Pause();
|
||
PauseResumeButtonSwitch(ALBUM_RESUME);
|
||
TjdUiAppAlbumView::GetInstance()->isEnterFromVideo_ = true;
|
||
TjdUiAppAlbumView::GetInstance()->ShowPhotoView(TjdUiAppAlbumPresenter::GetInstance()->currentView);
|
||
}
|
||
|
||
#define SCREEN_AUTO_OFF_TIME (1000 * 60 * 60)
|
||
bool AlbumVideoOnClickListener::OnClick(UIView &view, const ClickEvent &event)
|
||
{
|
||
int32_t ret = 0;
|
||
if (player_ == nullptr) {
|
||
static_print_error("AlbumVideoOnClickListener::%s player_ is nullptr!", __func__);
|
||
return true;
|
||
}
|
||
if (animator_ == nullptr) {
|
||
static_print_error("AlbumVideoOnClickListener::%s animator_ is nullptr!", __func__);
|
||
return true;
|
||
}
|
||
static_print_info("AlbumVideoOnClickListener::%s viewid: %s", __func__, view.GetViewId());
|
||
if (view.GetViewId() == std::string(PAUSE_RESUME_BUTTON)) {
|
||
if (player_->isExited_ || !player_->isEntered_) {
|
||
ret = player_->StartVideoPlay();
|
||
timer_->Start();
|
||
PauseResumeButtonSwitch(ALBUM_PAUSE);
|
||
TjdUiScreenManage::SetScreenKeepOnTimeout(SCREEN_AUTO_OFF_TIME);
|
||
return true;
|
||
}
|
||
if (player_->isPause_) {
|
||
ret = player_->ResumeVideoPlay();
|
||
animator_->Resume();
|
||
if (ret == 0) {
|
||
PauseResumeButtonSwitch(ALBUM_PAUSE);
|
||
}
|
||
} else {
|
||
ret = player_->PauseVideoPlay();
|
||
animator_->Pause();
|
||
if (ret == 0) {
|
||
PauseResumeButtonSwitch(ALBUM_RESUME);
|
||
}
|
||
}
|
||
} else if (view.GetViewId() == std::string(FORWARD_BUTTON)) {
|
||
VideoForward();
|
||
} else if (view.GetViewId() == std::string(BACKWARD_BUTTON)) {
|
||
VideoBackward();
|
||
} else if (view.GetViewId() == std::string(WALLPAPER_BUTTON)) {
|
||
SetVideoWallPaper();
|
||
}
|
||
return true;
|
||
}
|
||
|
||
void AlbumVideoAnimatorCallback::Callback(OHOS::UIView *view)
|
||
{
|
||
UNUSED(view);
|
||
if (videoAnimator_ == nullptr) {
|
||
static_print_error("AlbumVideoAnimatorCallback::%s animator is nullptr, please call SetAnimator first");
|
||
return;
|
||
}
|
||
|
||
// uint32_t runTime = videoAnimator_->GetRunTime();
|
||
int64_t runTime = 0;
|
||
TjdUiAppAlbumView::GetInstance()->GetVideoPlayer()->GetCurrentPosition(&runTime);
|
||
if (abs(runTime - lastTime) < 1000) {
|
||
return;
|
||
}
|
||
static_print_debug("TjdUiAppAlbumView::GetInstance()->GetVideoPlayer()->GetCurrentPosition %d\n", runTime);
|
||
lastTime = runTime;
|
||
curlabel_->SetText(millisecondsToTimeString(runTime).c_str());
|
||
|
||
uint8_t present = ((float)runTime / videoAnimator_->GetTime()) * 100;
|
||
static_print_debug("present: %d%%", present);
|
||
present = present > 98 ? 98 : present;
|
||
slider_->SetValue(present);
|
||
}
|
||
|
||
void AlbumVideoAnimatorCallback::OnStop(OHOS::UIView &view)
|
||
{
|
||
UNUSED(view);
|
||
ImageInfo *imageinfo = TjdUiAppAlbumPresenter::GetInstance()->GetAlbumIcon(ALBUM_RESUME);
|
||
button_->SetImageSrc(imageinfo, imageinfo);
|
||
button_->Invalidate();
|
||
curlabel_->SetText(millisecondsToTimeString(0).c_str());
|
||
totallabel_->SetText(millisecondsToTimeString(0).c_str());
|
||
slider_->SetValue(2);
|
||
lastTime = 0;
|
||
TjdUiScreenManage::ResetScreenKeepOnTimeout();
|
||
}
|
||
|
||
bool AlbumVideoAnimatorCallback::SetAnimator(OHOS::Animator *animator)
|
||
{
|
||
if (animator == nullptr) {
|
||
static_print_error("AlbumVideoAnimatorCallback::%s animator is nullptr", __func__);
|
||
return false;
|
||
}
|
||
videoAnimator_ = animator;
|
||
return true;
|
||
}
|
||
|
||
bool AlbumUIScrollView::OnDragStartEvent(const OHOS::DragEvent &event)
|
||
{
|
||
if (TjdUiAppAlbumPresenter::GetInstance()->GetCurrentView() != ALBUM_LIST_VIEW) {
|
||
return true;
|
||
}
|
||
isOnStart_ = true;
|
||
return OHOS::UIScrollViewNested::OnDragStartEvent(event);
|
||
}
|
||
|
||
bool AlbumUIScrollView::OnDragEvent(const OHOS::DragEvent &event)
|
||
{
|
||
if (!isOnStart_) {
|
||
return true;
|
||
}
|
||
|
||
if (TjdUiAppAlbumPresenter::GetInstance()->GetCurrentView() != ALBUM_LIST_VIEW) {
|
||
return true;
|
||
}
|
||
return OHOS::UIScrollViewNested::OnDragEvent(event);
|
||
}
|
||
|
||
bool AlbumUIScrollView::OnDragEndEvent(const OHOS::DragEvent &event)
|
||
{
|
||
if (!isOnStart_) {
|
||
return true;
|
||
}
|
||
isOnStart_ = false;
|
||
|
||
if (TjdUiAppAlbumPresenter::GetInstance()->GetCurrentView() != ALBUM_LIST_VIEW) {
|
||
return true;
|
||
}
|
||
return OHOS::UIScrollViewNested::OnDragEndEvent(event);
|
||
}
|
||
|
||
static TjdUiAppAlbumView *g_pv_UiAppAlbumView = nullptr;
|
||
|
||
TjdUiAppAlbumView::TjdUiAppAlbumView()
|
||
{
|
||
g_pv_UiAppAlbumView = this;
|
||
static_print_info("TjdUiAppAlbumView::%s", __func__);
|
||
}
|
||
|
||
TjdUiAppAlbumView::~TjdUiAppAlbumView()
|
||
{
|
||
static_print_info("TjdUiAppAlbumView::%s", __func__);
|
||
g_pv_UiAppAlbumView = nullptr;
|
||
|
||
if (setTimer_ != nullptr) {
|
||
setTimer_->Stop();
|
||
delete setTimer_;
|
||
setTimer_ = nullptr;
|
||
}
|
||
if (jumpTimerId_ != nullptr) {
|
||
osTimerDelete(jumpTimerId_);
|
||
jumpTimerId_ = nullptr;
|
||
}
|
||
if (contentList_ != nullptr) {
|
||
contentList_->ClearFocus();
|
||
delete contentList_;
|
||
contentList_ = nullptr;
|
||
}
|
||
if (listAdapter_ != nullptr) {
|
||
delete listAdapter_;
|
||
listAdapter_ = nullptr;
|
||
}
|
||
if (videoPlay_ != nullptr) {
|
||
delete videoPlay_;
|
||
videoPlay_ = nullptr;
|
||
}
|
||
if (clickListener != nullptr) {
|
||
delete clickListener;
|
||
clickListener = nullptr;
|
||
}
|
||
if (videoAnimator_ != nullptr) {
|
||
videoAnimator_->Stop();
|
||
delete videoAnimator_;
|
||
videoAnimator_ = nullptr;
|
||
}
|
||
if (animatorCallback_ != nullptr) {
|
||
delete animatorCallback_;
|
||
animatorCallback_ = nullptr;
|
||
}
|
||
if (setWaitAnimator_ != nullptr) {
|
||
delete setWaitAnimator_;
|
||
setWaitAnimator_ = nullptr;
|
||
}
|
||
TjdUiMemManage::DeleteChildren(containerAll_);
|
||
}
|
||
|
||
TjdUiAppAlbumView *TjdUiAppAlbumView::GetInstance(void) { return g_pv_UiAppAlbumView; }
|
||
|
||
void TjdUiAppAlbumView::OnStart()
|
||
{
|
||
static_print_info("TjdUiAppAlbumView::%s", __func__);
|
||
|
||
if (containerAll_ == nullptr) {
|
||
containerAll_ = new AlbumUIScrollView();
|
||
containerAll_->SetViewId("containerAll_");
|
||
containerAll_->SetPosition(0, 0, HORIZONTAL_RESOLUTION, VERTICAL_RESOLUTION);
|
||
containerAll_->SetStyle(STYLE_BACKGROUND_OPA, 0);
|
||
// containerAll_->SetOnDragListener(presenter_);
|
||
}
|
||
|
||
groupList_[ALBUM_LIST_VIEW] = ListViewInit();
|
||
groupList_[ALBUM_PHOTO_VIEW] = PhotoViewInit();
|
||
groupList_[ALBUM_VIDEO_VIEW] = VideoViewInit();
|
||
groupList_[ALBUM_SETTING_VIEW] = SettingViewInit();
|
||
|
||
containerAll_->Add(groupList_[ALBUM_LIST_VIEW]);
|
||
containerAll_->Add(groupList_[ALBUM_PHOTO_VIEW]);
|
||
containerAll_->Add(groupList_[ALBUM_VIDEO_VIEW]);
|
||
containerAll_->Add(groupList_[ALBUM_SETTING_VIEW]);
|
||
|
||
ShowListView(presenter_->currentView);
|
||
AddViewToRootContainer(containerAll_);
|
||
}
|
||
|
||
void TjdUiAppAlbumView::OnStop()
|
||
{
|
||
static_print_info("TjdUiAppAlbumView::%s", __func__);
|
||
listContainer_->Remove(contentList_);
|
||
settingContainer_->Remove(setWaitAnimator_);
|
||
}
|
||
|
||
OHOS::UIScrollViewNested *TjdUiAppAlbumView::ListViewInit(void)
|
||
{
|
||
static_print_debug("TjdUiAppAlbumView::%s", __func__);
|
||
listContainer_ = new UIScrollViewNested();
|
||
listContainer_->SetPosition(0, 0, HORIZONTAL_RESOLUTION, VERTICAL_RESOLUTION);
|
||
if (OHOS::PageTransitionMgr::GetInstance().GetTopSlideBackImage() == nullptr) {
|
||
listContainer_->SetOnDragListener(TjdUiAppAlbumPresenter::GetInstance());
|
||
}
|
||
|
||
UILabelExt *noneLabel = new UILabelExt();
|
||
noneLabel->SetPosition(99, 192, 267, 50);
|
||
noneLabel->SetViewId(NONE_ALBUM_LABEL);
|
||
// noneLabel->SetText("请前往APP\n相册同步");
|
||
noneLabel->SetTextId(STR_ID_325);
|
||
noneLabel->SetLineBreakMode(UILabel::LINE_BREAK_WRAP);
|
||
noneLabel->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
|
||
noneLabel->SetFont(TJD_VECTOR_FONT_FILENAME, 36);
|
||
listContainer_->Add(noneLabel);
|
||
|
||
listAdapter_ = new TjdAlbumAdapter();
|
||
presenter_->GetAlbumModel()->GetAllFiles(&GetAdapterList());
|
||
|
||
contentList_ = new UIListNested(UIList::VERTICAL);
|
||
contentList_->SetViewId("contentList_");
|
||
contentList_->SetPosition(0, 0);
|
||
contentList_->Resize(HORIZONTAL_RESOLUTION, VERTICAL_RESOLUTION);
|
||
contentList_->SetScrollBlankSize((VERTICAL_RESOLUTION - ALBUM_ITEM_H) / 2);
|
||
contentList_->SetSelectPosition((VERTICAL_RESOLUTION / 2)); // middle position
|
||
contentList_->SetThrowDrag(true);
|
||
contentList_->EnableAutoAlign(true);
|
||
contentList_->SetElastic(true);
|
||
contentList_->SetStartIndex(0);
|
||
contentList_->SetSwipeACCLevel(10); // 0-255
|
||
contentList_->SetDragACCLevel(8); // 5: drag acceleration
|
||
contentList_->SetReboundSize(contentList_->GetHeight() >> 1);
|
||
contentList_->SetScrollStateListener(presenter_);
|
||
contentList_->SetMaxScrollDistance(MAX_SCROLL_DIS);
|
||
contentList_->SetYScrollBarVisible(true);
|
||
|
||
listContainer_->Add(contentList_);
|
||
|
||
return listContainer_;
|
||
}
|
||
|
||
OHOS::UIScrollView *TjdUiAppAlbumView::PhotoViewInit(void)
|
||
{
|
||
static_print_debug("TjdUiAppAlbumView::%s", __func__);
|
||
photoContainer_ = new UIScrollView();
|
||
photoContainer_->SetPosition(0, 0, HORIZONTAL_RESOLUTION, VERTICAL_RESOLUTION);
|
||
photoContainer_->SetVisible(false);
|
||
photoContainer_->SetOnDragListener(TjdUiAppAlbumPresenter::GetInstance());
|
||
|
||
selectedPhoto_ = new UIImageView();
|
||
selectedPhoto_->SetPosition(0, 0, HORIZONTAL_RESOLUTION, VERTICAL_RESOLUTION);
|
||
selectedPhoto_->SetViewId(SELECTED_PHOTO_IMAGE);
|
||
selectedPhoto_->SetAutoEnable(false);
|
||
selectedPhoto_->SetResizeMode(UIImageView::FILL);
|
||
photoContainer_->Add(selectedPhoto_);
|
||
|
||
UIImageView *settingButton = new UIImageView();
|
||
settingButton->SetPosition(77, 378, 312, 88);
|
||
settingButton->SetViewId(SET_WALLPAPER_BUTTON);
|
||
settingButton->SetTouchable(true);
|
||
settingButton->SetSrc(
|
||
ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_ALBUM_Z_SETTING_BG, ALBUM_IMAGE_BIN_PATH));
|
||
settingButton->SetOnClickListener(presenter_);
|
||
photoContainer_->Add(settingButton);
|
||
|
||
UILabelExt *lbSetDial = new UILabelExt();
|
||
lbSetDial->SetFont(TJD_VECTOR_FONT_FILENAME, 30);
|
||
lbSetDial->SetTextId(STR_ID_565);
|
||
lbSetDial->SetViewId("lbSetDial");
|
||
// lbSetDial->SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
|
||
lbSetDial->SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
|
||
lbSetDial->SetPosition(0, 407, 466, 40);
|
||
photoContainer_->Add(lbSetDial);
|
||
|
||
UIButton *button1 = new UIButton();
|
||
button1->SetPosition(103, 326, 92, 92);
|
||
button1->SetViewId(SET_CANCEL_BUTTON);
|
||
ImageInfo *imageinfo = TjdUiAppAlbumPresenter::GetInstance()->GetAlbumIcon(ALBUM_CANCEL);
|
||
button1->SetImageSrc(imageinfo, imageinfo);
|
||
button1->SetVisible(false);
|
||
button1->SetStyle(STYLE_BACKGROUND_OPA, 0);
|
||
button1->SetOnClickListener(presenter_);
|
||
photoContainer_->Add(button1);
|
||
|
||
UIButton *button2 = new UIButton();
|
||
button2->SetPosition(271, 326, 92, 92);
|
||
button2->SetViewId(SET_CONFIRM_BUTTON);
|
||
button2->SetStyle(STYLE_BACKGROUND_OPA, 0);
|
||
imageinfo = TjdUiAppAlbumPresenter::GetInstance()->GetAlbumIcon(ALBUM_CONFIRM);
|
||
button2->SetImageSrc(imageinfo, imageinfo);
|
||
button2->SetVisible(false);
|
||
button2->SetOnClickListener(presenter_);
|
||
photoContainer_->Add(button2);
|
||
|
||
UILabelExt *label = new UILabelExt();
|
||
label->SetPosition(0, 214, 466, 50);
|
||
label->SetViewId(SET_WALLPAPER_LABEL);
|
||
// label->SetText("是否设置为表盘?");//409
|
||
label->SetTextId(STR_ID_409);
|
||
// label->SetLineBreakMode(UILabel::LINE_BREAK_ADAPT);
|
||
label->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
|
||
label->SetFont(TJD_VECTOR_FONT_FILENAME, 36);
|
||
label->SetVisible(false);
|
||
photoContainer_->Add(label);
|
||
|
||
return photoContainer_;
|
||
}
|
||
|
||
OHOS::UIScrollView *TjdUiAppAlbumView::VideoViewInit(void)
|
||
{
|
||
static_print_debug("TjdUiAppAlbumView::%s", __func__);
|
||
videoContainer_ = new UIScrollView();
|
||
videoContainer_->SetPosition(0, 0, HORIZONTAL_RESOLUTION, VERTICAL_RESOLUTION);
|
||
videoContainer_->SetVisible(false);
|
||
videoContainer_->SetOnDragListener(TjdUiAppAlbumPresenter::GetInstance());
|
||
|
||
surfaceView_ = new AlbumSurfaceView();
|
||
surfaceView_->SetViewId("sur");
|
||
surfaceView_->SetPosition(0, 0, VIDEO_WIDTH, VIDEO_HEIGHT);
|
||
surfaceView_->SetStyle(STYLE_BACKGROUND_COLOR, Color::Black().full);
|
||
colorKey_.full = 0xff3184d7;
|
||
surfaceView_->SetSurfaceColorkey(colorKey_);
|
||
videoContainer_->Add(surfaceView_);
|
||
|
||
playContainer_ = new UIScrollView();
|
||
playContainer_->SetPosition(0, 271, HORIZONTAL_RESOLUTION, VERTICAL_RESOLUTION - 271);
|
||
playContainer_->SetStyle(STYLE_BACKGROUND_OPA, 0);
|
||
videoContainer_->Add(playContainer_);
|
||
|
||
int screenWidth = 466;
|
||
int buttonWidth = 100;
|
||
int spacing = 10;
|
||
int totalWidth = 4 * buttonWidth + 3 * spacing;
|
||
int startX = (screenWidth - totalWidth) / 2;
|
||
for (int i = 0; i < ALBUM_BUTTON_NUM; i++) {
|
||
buttonArray_[i] = new UIButton();
|
||
int buttonX = startX + i * (buttonWidth + spacing);
|
||
buttonArray_[i]->SetPosition(buttonX, 0, 100, 70);
|
||
buttonArray_[i]->SetStyle(STYLE_BACKGROUND_OPA, 0);
|
||
buttonArray_[i]->SetStyleForState(STYLE_BACKGROUND_OPA, 0, UIButton::PRESSED);
|
||
buttonArray_[i]->SetImagePosition((buttonArray_[i]->GetWidth() - 50) / 2,
|
||
(buttonArray_[i]->GetHeight() - 50) / 2);
|
||
}
|
||
|
||
buttonArray_[0]->SetViewId(BACKWARD_BUTTON);
|
||
ImageInfo *imageinfo = TjdUiAppAlbumPresenter::GetInstance()->GetAlbumIcon(ALBUM_BACKWARD);
|
||
buttonArray_[0]->SetImageSrc(imageinfo, imageinfo);
|
||
buttonArray_[1]->SetViewId(PAUSE_RESUME_BUTTON);
|
||
imageinfo = TjdUiAppAlbumPresenter::GetInstance()->GetAlbumIcon(ALBUM_RESUME);
|
||
buttonArray_[1]->SetImageSrc(imageinfo, imageinfo);
|
||
buttonArray_[2]->SetViewId(FORWARD_BUTTON);
|
||
imageinfo = TjdUiAppAlbumPresenter::GetInstance()->GetAlbumIcon(ALBUM_FORWARD);
|
||
buttonArray_[2]->SetImageSrc(imageinfo, imageinfo);
|
||
buttonArray_[3]->SetViewId(WALLPAPER_BUTTON);
|
||
imageinfo = TjdUiAppAlbumPresenter::GetInstance()->GetAlbumIcon(ALBUM_WALLPAPER);
|
||
buttonArray_[3]->SetImageSrc(imageinfo, imageinfo);
|
||
|
||
videoSlider_ = new UISlider();
|
||
videoSlider_->SetPosition(73, 367 - 271, 320, 20);
|
||
videoSlider_->SetStyle(STYLE_BORDER_RADIUS, 29);
|
||
videoSlider_->SetValidWidth(320);
|
||
videoSlider_->SetValidHeight(14);
|
||
videoSlider_->SetValue(2);
|
||
videoSlider_->SetKnobWidth(14);
|
||
videoSlider_->SetKnobRadius(7);
|
||
videoSlider_->SetForegroundStyle(STYLE_BACKGROUND_OPA, 0xff);
|
||
videoSlider_->SetCapType(CAP_ROUND);
|
||
videoSlider_->SetKnobStyle(STYLE_BACKGROUND_COLOR, 0xff00E345);
|
||
videoSlider_->SetSliderColor(Color::GetColorFromRGBA(0, 45, 14, 0xff), Color::GetColorFromRGBA(0, 227, 29, 0xff));
|
||
playContainer_->Add(videoSlider_);
|
||
|
||
UILabel *slashLabel = new UILabel();
|
||
slashLabel->SetPosition(234, 407 - 271);
|
||
slashLabel->SetText("/");
|
||
slashLabel->SetLineBreakMode(UILabel::LINE_BREAK_ADAPT);
|
||
slashLabel->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
|
||
slashLabel->SetFont(TJD_VECTOR_FONT_FILENAME, TJD_FONT_SIZE_24);
|
||
playContainer_->Add(slashLabel);
|
||
|
||
videoTotalTime_ = new UILabel();
|
||
videoTotalTime_->SetPosition(244, 407 - 271);
|
||
videoTotalTime_->SetText("00:00:00");
|
||
videoTotalTime_->SetLineBreakMode(UILabel::LINE_BREAK_ADAPT);
|
||
videoTotalTime_->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
|
||
videoTotalTime_->SetFont(TJD_VECTOR_FONT_FILENAME, TJD_FONT_SIZE_24);
|
||
playContainer_->Add(videoTotalTime_);
|
||
|
||
videoCurTime_ = new UILabel();
|
||
videoCurTime_->SetPosition(141, 407 - 271, 93, 23);
|
||
videoCurTime_->SetText("00:00:00");
|
||
videoCurTime_->SetLineBreakMode(UILabel::LINE_BREAK_ADAPT);
|
||
videoCurTime_->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
|
||
videoCurTime_->SetFont(TJD_VECTOR_FONT_FILENAME, TJD_FONT_SIZE_24);
|
||
playContainer_->Add(videoCurTime_);
|
||
|
||
Surface *surface = surfaceView_->GetSurface();
|
||
surface->SetStrideAlignment(STRIDE_ALIGNMENT_VALUE);
|
||
surface->SetWidthAndHeight(VIDEO_WIDTH, VIDEO_HEIGHT);
|
||
surface->SetQueueSize(BUFFER_QUEUE_SIZE);
|
||
surface->SetFormat(PIXEL_FMT_YCBCR_420_SP);
|
||
|
||
// jpeg decoder output buffer size calculation formula
|
||
int32_t ySize = ALIGN_BYTE(VIDEO_WIDTH, JPEG_WIDTH_BYTE_ALIGNMENT) * VIDEO_HEIGHT;
|
||
int32_t uvSize = ALIGN_BYTE(VIDEO_WIDTH, JPEG_WIDTH_BYTE_ALIGNMENT) *
|
||
ALIGN_BYTE(VIDEO_HEIGHT, JPEG_HEIGHT_BYTE_ALIGNMENT) / JPEG_HEIGHT_DIVISOR;
|
||
int32_t bufferSize = ySize + uvSize;
|
||
surface->SetSize(bufferSize);
|
||
|
||
videoPlay_ = new AlbumVideoPlayer(surface, buttonArray_, "", false);
|
||
videoPlay_->SetVideoPlayLoop(false);
|
||
videoPlay_->SetSyncExitMode(true);
|
||
|
||
animatorCallback_ = new AlbumVideoAnimatorCallback(videoCurTime_, videoTotalTime_, videoSlider_, buttonArray_[1]);
|
||
videoAnimator_ = new Animator(animatorCallback_, nullptr, 0, false);
|
||
animatorCallback_->SetAnimator(videoAnimator_);
|
||
|
||
clickListener = new AlbumVideoOnClickListener(videoPlay_, videoTotalTime_, videoAnimator_);
|
||
|
||
for (int i = 0; i < ALBUM_BUTTON_NUM; i++) {
|
||
buttonArray_[i]->SetOnClickListener(clickListener);
|
||
playContainer_->Add(buttonArray_[i]);
|
||
}
|
||
|
||
return videoContainer_;
|
||
}
|
||
|
||
OHOS::UIScrollView *TjdUiAppAlbumView::SettingViewInit(void)
|
||
{
|
||
static_print_debug("TjdUiAppAlbumView::%s", __func__);
|
||
isSetWallPaperFail_ = false;
|
||
|
||
if (settingContainer_ != nullptr) {
|
||
settingContainer_->SetVisible(false);
|
||
settingContainer_->GetChildById(SET_SUCC_IMAGE)->SetVisible(false);
|
||
settingContainer_->GetChildById(SET_FAIL_IMAGE)->SetVisible(false);
|
||
settingContainer_->GetChildById(SET_SUCC_LABEL)->SetVisible(false);
|
||
settingContainer_->GetChildById(SET_FAIL_LABEL)->SetVisible(false);
|
||
settingContainer_->GetChildById(SET_RESET_BUTTON)->SetVisible(false);
|
||
return settingContainer_;
|
||
}
|
||
|
||
settingContainer_ = new UIScrollView();
|
||
settingContainer_->SetPosition(0, 0, HORIZONTAL_RESOLUTION, VERTICAL_RESOLUTION);
|
||
settingContainer_->SetVisible(false);
|
||
settingContainer_->SetOnDragListener(TjdUiAppAlbumPresenter::GetInstance());
|
||
|
||
setWaitAnimator_ = new AlbumWaitView();
|
||
settingContainer_->Add(setWaitAnimator_);
|
||
|
||
UIImageView *imageView1 = new UIImageView();
|
||
imageView1->SetPosition(151, 118, 166, 164);
|
||
imageView1->SetViewId(SET_SUCC_IMAGE);
|
||
ImageInfo *imageinfo = TjdUiAppAlbumPresenter::GetInstance()->GetAlbumIcon(ALBUM_SET_SUCC);
|
||
imageView1->SetSrc(imageinfo);
|
||
imageView1->SetVisible(false);
|
||
settingContainer_->Add(imageView1);
|
||
|
||
UIImageView *imageView2 = new UIImageView();
|
||
imageView2->SetPosition(153, 119, 170, 168);
|
||
imageView2->SetViewId(SET_FAIL_IMAGE);
|
||
imageinfo = TjdUiAppAlbumPresenter::GetInstance()->GetAlbumIcon(ALBUM_SET_FALSE);
|
||
imageView2->SetSrc(imageinfo);
|
||
imageView2->SetVisible(false);
|
||
settingContainer_->Add(imageView2);
|
||
|
||
UILabelExt *setSucc = new UILabelExt();
|
||
setSucc->SetPosition(161, 310, 127, 31);
|
||
setSucc->SetViewId(SET_SUCC_LABEL);
|
||
// setSucc->SetText("设置成功");
|
||
setSucc->SetTextId(STR_ID_327);
|
||
setSucc->SetLineBreakMode(UILabel::LINE_BREAK_ADAPT);
|
||
setSucc->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_TOP);
|
||
setSucc->SetFont(TJD_VECTOR_FONT_FILENAME, 36);
|
||
setSucc->SetVisible(false);
|
||
settingContainer_->Add(setSucc);
|
||
|
||
UILabelExt *setFail = new UILabelExt();
|
||
setFail->SetPosition(0, 310, 466, 47);
|
||
setFail->SetViewId(SET_FAIL_LABEL);
|
||
// setFail->SetText("设置失败");
|
||
setFail->SetTextId(STR_ID_566);
|
||
// setFail->SetLineBreakMode(UILabel::LINE_BREAK_ADAPT);
|
||
setFail->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
|
||
setFail->SetFont(TJD_VECTOR_FONT_FILENAME, 36);
|
||
setFail->SetVisible(false);
|
||
settingContainer_->Add(setFail);
|
||
|
||
UIButton *resetButton = new UIButton();
|
||
resetButton->SetPosition(187, 352, 92, 92);
|
||
resetButton->SetStyle(STYLE_BACKGROUND_OPA, 0);
|
||
resetButton->SetViewId(SET_RESET_BUTTON);
|
||
resetButton->SetStyle(STYLE_BORDER_RADIUS, 0);
|
||
imageinfo = TjdUiAppAlbumPresenter::GetInstance()->GetAlbumIcon(ALBUM_RESET);
|
||
resetButton->SetImageSrc(imageinfo, imageinfo);
|
||
resetButton->SetVisible(false);
|
||
resetButton->SetOnClickListener(presenter_);
|
||
settingContainer_->Add(resetButton);
|
||
|
||
setTimer_ = new GraphicTimer(2000, SettingTimerCallback, presenter_);
|
||
|
||
return settingContainer_;
|
||
}
|
||
|
||
bool TjdUiAppAlbumView::ChangeView(AlbumView view, AlbumView hideView)
|
||
{
|
||
if (view >= ALBUM_VIEW_MAX || hideView >= ALBUM_VIEW_MAX) {
|
||
return false;
|
||
}
|
||
|
||
if (viewMapper_[view] == nullptr || viewMapper_[hideView] == nullptr) {
|
||
return false;
|
||
}
|
||
|
||
(GetInstance()->*viewMapper_[view])(hideView);
|
||
return true;
|
||
}
|
||
|
||
void TjdUiAppAlbumView::ResetListPosition()
|
||
{
|
||
if (contentList_ == nullptr) {
|
||
return;
|
||
}
|
||
auto head = contentList_->GetChildrenHead();
|
||
while (head != nullptr) {
|
||
auto item = dynamic_cast<TjdAlbumItemView *>(head);
|
||
item->GetScrollView().ScrollBy(DELECT_ICON_INTERVAL + DELECT_ICON_W, 0);
|
||
head = head->GetNextSibling();
|
||
}
|
||
RefreshListView();
|
||
}
|
||
|
||
void TjdUiAppAlbumView::RefreshListView(void)
|
||
{
|
||
if (GetAdapterList().size() > 0) {
|
||
contentList_->SetVisible(true);
|
||
listContainer_->GetChildById(NONE_ALBUM_LABEL)->SetVisible(false);
|
||
} else {
|
||
contentList_->SetVisible(false);
|
||
listContainer_->GetChildById(NONE_ALBUM_LABEL)->SetVisible(true);
|
||
}
|
||
}
|
||
|
||
void TjdUiAppAlbumView::EnterWallPaperSet(bool value)
|
||
{
|
||
if (value) {
|
||
isEnterWallPaperSet_ = true;
|
||
photoContainer_->GetChildById(SELECTED_PHOTO_IMAGE)->SetStyle(STYLE_IMAGE_OPA, 102);
|
||
photoContainer_->GetChildById(SET_WALLPAPER_BUTTON)->SetVisible(false);
|
||
photoContainer_->GetChildById("lbSetDial")->SetVisible(false);
|
||
photoContainer_->GetChildById(SET_CONFIRM_BUTTON)->SetVisible(true);
|
||
photoContainer_->GetChildById(SET_CANCEL_BUTTON)->SetVisible(true);
|
||
photoContainer_->GetChildById(SET_WALLPAPER_LABEL)->SetVisible(true);
|
||
} else {
|
||
isEnterWallPaperSet_ = false;
|
||
photoContainer_->GetChildById(SELECTED_PHOTO_IMAGE)->SetStyle(STYLE_IMAGE_OPA, 255);
|
||
photoContainer_->GetChildById(SET_WALLPAPER_BUTTON)->SetVisible(true);
|
||
photoContainer_->GetChildById("lbSetDial")->SetVisible(true);
|
||
photoContainer_->GetChildById(SET_CONFIRM_BUTTON)->SetVisible(false);
|
||
photoContainer_->GetChildById(SET_CANCEL_BUTTON)->SetVisible(false);
|
||
photoContainer_->GetChildById(SET_WALLPAPER_LABEL)->SetVisible(false);
|
||
}
|
||
RootView::GetInstance()->Invalidate();
|
||
}
|
||
|
||
void TjdUiAppAlbumView::EnterSetFail(bool value)
|
||
{
|
||
if (value) {
|
||
isSetWallPaperFail_ = true;
|
||
setWaitAnimator_->HideView();
|
||
settingContainer_->GetChildById(SET_FAIL_IMAGE)->SetVisible(true);
|
||
settingContainer_->GetChildById(SET_FAIL_LABEL)->SetVisible(true);
|
||
settingContainer_->GetChildById(SET_RESET_BUTTON)->SetVisible(true);
|
||
} else {
|
||
isSetWallPaperFail_ = false;
|
||
setWaitAnimator_->ShowView();
|
||
StartJumpTimer();
|
||
AlbumItem *itemPtr = listAdapter_->GetListItem(presenter_->GetSelectedListId());
|
||
presenter_->TaskProcess(itemPtr);
|
||
settingContainer_->GetChildById(SET_FAIL_IMAGE)->SetVisible(false);
|
||
settingContainer_->GetChildById(SET_FAIL_LABEL)->SetVisible(false);
|
||
settingContainer_->GetChildById(SET_RESET_BUTTON)->SetVisible(false);
|
||
}
|
||
settingContainer_->Invalidate();
|
||
}
|
||
|
||
void TjdUiAppAlbumView::EnterSetSucc(void)
|
||
{
|
||
setWaitAnimator_->HideView();
|
||
settingContainer_->GetChildById(SET_SUCC_IMAGE)->SetVisible(true);
|
||
settingContainer_->GetChildById(SET_SUCC_LABEL)->SetVisible(true);
|
||
settingContainer_->Invalidate();
|
||
setTimer_->Start();
|
||
}
|
||
|
||
void TjdUiAppAlbumView::StartJumpTimer()
|
||
{
|
||
if (jumpTimerId_ == nullptr) {
|
||
jumpTimerId_ = osTimerNew(
|
||
[](void *arg) {
|
||
GraphicService::GetInstance()->PostGraphicEvent(
|
||
[]() { TjdUiAppAlbumView::GetInstance()->JumpTimerCallback(); });
|
||
},
|
||
osTimerPeriodic, nullptr, nullptr);
|
||
if (jumpTimerId_ == nullptr) {
|
||
return;
|
||
}
|
||
} else {
|
||
static_print_error("StartJumpTimer: jumpTimerId_ is not null");
|
||
}
|
||
|
||
int32_t ret = osTimerStart(jumpTimerId_, 500);
|
||
if (ret != 0) {
|
||
return;
|
||
}
|
||
}
|
||
|
||
void TjdUiAppAlbumView::StopJumpTimer()
|
||
{
|
||
if (jumpTimerId_ == nullptr) {
|
||
return;
|
||
}
|
||
|
||
int32_t ret = osTimerStop(jumpTimerId_);
|
||
if (ret != 0) {
|
||
static_print_error("TjdUiAppAlbumView::StopJumpTimer timer fail");
|
||
return;
|
||
}
|
||
}
|
||
|
||
void TjdUiAppAlbumView::JumpTimerCallback()
|
||
{
|
||
static_print_debug("TjdUiAppAlbumView::JumpTimerCallback count:%d", jumpTimerCount_);
|
||
if (++jumpTimerCount_ > 20) { // 10s后都没有收到设置成功，设置失败
|
||
jumpTimerCount_ = 0;
|
||
EnterSetFail(true);
|
||
StopJumpTimer();
|
||
return;
|
||
} else if (presenter_->isSetSucc) {
|
||
jumpTimerCount_ = 0;
|
||
EnterSetSucc();
|
||
StopJumpTimer();
|
||
return;
|
||
}
|
||
}
|
||
|
||
void TjdUiAppAlbumView::DeleteAlbumItemFromList(uint8_t index)
|
||
{
|
||
TjdUiAppAlbumModel::GetInstance().DeleteFile(listAdapter_->GetListItem(index)->type,
|
||
listAdapter_->GetListItem(index)->path);
|
||
listAdapter_->DeleteListItem(index);
|
||
contentList_->RefreshList();
|
||
ResetListPosition();
|
||
}
|
||
|
||
bool TjdUiAppAlbumView::ShowListView(AlbumView hideView)
|
||
{
|
||
if (groupList_[hideView] == nullptr) {
|
||
static_print_error("TjdUiAppAlbumView::%s: groupList_ is nullptr", __func__);
|
||
return false;
|
||
}
|
||
groupList_[hideView]->SetVisible(false);
|
||
if (hideView == ALBUM_VIDEO_VIEW) {
|
||
if (!videoPlay_->isEntered_) {
|
||
static_print_debug("TjdUiAppAlbumView::%s video is not played", __func__);
|
||
} else {
|
||
for (int i = 0; i < ALBUM_BUTTON_NUM; i++) {
|
||
if (videoPlay_->buttonArray_[i]->GetViewId() == std::string(PAUSE_RESUME_BUTTON)) {
|
||
ImageInfo *imageinfo = TjdUiAppAlbumPresenter::GetInstance()->GetAlbumIcon(ALBUM_RESUME);
|
||
videoPlay_->buttonArray_[i]->SetImageSrc(imageinfo, imageinfo);
|
||
videoPlay_->buttonArray_[i]->Invalidate();
|
||
break;
|
||
}
|
||
}
|
||
videoTotalTime_->SetText("00:00:00");
|
||
videoAnimator_->Stop();
|
||
videoPlay_->StopVideoPlay();
|
||
}
|
||
}
|
||
if (groupList_[AlbumView::ALBUM_LIST_VIEW] == nullptr) {
|
||
static_print_error("TjdUiAppAlbumView::%s: groupList_ is nullptr", __func__);
|
||
return false;
|
||
}
|
||
|
||
RefreshListView();
|
||
if (contentList_ != nullptr && presenter_->firstEnter_) {
|
||
contentList_->RequestFocus();
|
||
contentList_->SetRotateFactor(1.0);
|
||
}
|
||
|
||
groupList_[AlbumView::ALBUM_LIST_VIEW]->SetVisible(true);
|
||
groupList_[AlbumView::ALBUM_LIST_VIEW]->Invalidate();
|
||
presenter_->currentView = ALBUM_LIST_VIEW;
|
||
return true;
|
||
}
|
||
|
||
bool TjdUiAppAlbumView::ShowPhotoView(AlbumView hideView)
|
||
{
|
||
if (groupList_[hideView] == nullptr) {
|
||
static_print_error("TjdUiAppAlbumView::%s: groupList_ is nullptr", __func__);
|
||
return false;
|
||
}
|
||
groupList_[hideView]->SetVisible(false);
|
||
if (hideView == ALBUM_LIST_VIEW) {
|
||
contentList_->ClearFocus();
|
||
}
|
||
|
||
if (groupList_[AlbumView::ALBUM_PHOTO_VIEW] == nullptr) {
|
||
static_print_error("TjdUiAppAlbumView::%s: groupList_ is nullptr", __func__);
|
||
return false;
|
||
}
|
||
AlbumItem *itemPtr = listAdapter_->GetListItem(presenter_->GetSelectedListId());
|
||
selectedPhoto_->SetSrc(itemPtr->path);
|
||
groupList_[AlbumView::ALBUM_PHOTO_VIEW]->SetVisible(true);
|
||
groupList_[AlbumView::ALBUM_PHOTO_VIEW]->Invalidate();
|
||
presenter_->currentView = ALBUM_PHOTO_VIEW;
|
||
return true;
|
||
}
|
||
|
||
bool TjdUiAppAlbumView::ShowVideoView(AlbumView hideView)
|
||
{
|
||
if (groupList_[hideView] == nullptr) {
|
||
static_print_error("TjdUiAppAlbumView::%s: groupList_ is nullptr", __func__);
|
||
return false;
|
||
}
|
||
groupList_[hideView]->SetVisible(false);
|
||
if (hideView == ALBUM_LIST_VIEW) {
|
||
contentList_->ClearFocus();
|
||
}
|
||
|
||
AlbumItem *itemPtr = listAdapter_->GetListItem(presenter_->GetSelectedListId());
|
||
std::string uri = itemPtr->path;
|
||
surfaceView_->SetPreview(uri);
|
||
uri = uri.substr(0, uri.rfind('.') + 1) + "mp4";
|
||
videoPlay_->SetUri(uri);
|
||
if (groupList_[AlbumView::ALBUM_VIDEO_VIEW] == nullptr) {
|
||
static_print_error("TjdUiAppAlbumView::%s: groupList_ is nullptr", __func__);
|
||
return false;
|
||
}
|
||
groupList_[AlbumView::ALBUM_VIDEO_VIEW]->SetVisible(true);
|
||
groupList_[AlbumView::ALBUM_VIDEO_VIEW]->Invalidate();
|
||
presenter_->currentView = ALBUM_VIDEO_VIEW;
|
||
return true;
|
||
}
|
||
|
||
bool TjdUiAppAlbumView::ShowSettingView(AlbumView hideView)
|
||
{
|
||
if (groupList_[hideView] == nullptr) {
|
||
static_print_error("TjdUiAppAlbumView::%s: groupList_ is nullptr", __func__);
|
||
return false;
|
||
}
|
||
groupList_[hideView]->SetVisible(false);
|
||
|
||
if (groupList_[AlbumView::ALBUM_SETTING_VIEW] == nullptr) {
|
||
static_print_error("TjdUiAppAlbumView::%s: groupList_ is nullptr", __func__);
|
||
return false;
|
||
}
|
||
setWaitAnimator_->ShowView();
|
||
AlbumItem *itemPtr = listAdapter_->GetListItem(presenter_->GetSelectedListId());
|
||
StartJumpTimer();
|
||
presenter_->TaskProcess(itemPtr);
|
||
groupList_[AlbumView::ALBUM_SETTING_VIEW]->SetVisible(true);
|
||
groupList_[AlbumView::ALBUM_SETTING_VIEW]->Invalidate();
|
||
presenter_->currentView = ALBUM_SETTING_VIEW;
|
||
return true;
|
||
}
|
||
|
||
AlbumWaitView::AlbumWaitView()
|
||
{
|
||
Resize(OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
|
||
|
||
animator_.SetPosition(150, 113, 166, 164);
|
||
// InitLabelHorCenter(desc_, 34, 287, 466, "设置中，请稍后...");
|
||
desc_.SetFont(TJD_VECTOR_FONT_FILENAME, 34);
|
||
desc_.SetTextId(STR_ID_330);
|
||
desc_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
|
||
desc_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
|
||
desc_.SetPosition(HorizontalCenter(desc_.GetWidth(), 466), 287);
|
||
|
||
WaitAnimatorImageInfo();
|
||
animator_.SetImageAnimatorSrc(g_pv_waitInfo_, 11, 100);
|
||
// animator_.Start();
|
||
|
||
Add(&animator_);
|
||
Add(&desc_);
|
||
}
|
||
|
||
AlbumWaitView::~AlbumWaitView()
|
||
{
|
||
animator_.Stop();
|
||
WaitAnimatorImageInfoUnload();
|
||
RemoveAll();
|
||
}
|
||
|
||
void AlbumWaitView::ShowView()
|
||
{
|
||
animator_.Start();
|
||
SetVisible(true);
|
||
}
|
||
|
||
void AlbumWaitView::HideView()
|
||
{
|
||
animator_.Stop();
|
||
SetVisible(false);
|
||
}
|
||
|
||
void AlbumSurfaceView::SetPreview(std::string res)
|
||
{
|
||
ImageInfo *imgInfo;
|
||
if (lastRes_ == "") {
|
||
imgInfo = ImageCacheManager::GetInstance().LoadSingleRes(res);
|
||
UILiteSurfaceView::SetPreview(imgInfo);
|
||
lastRes_ = res;
|
||
} else {
|
||
ImageCacheManager::GetInstance().UnloadSingleRes(lastRes_);
|
||
imgInfo = ImageCacheManager::GetInstance().LoadSingleRes(res);
|
||
UILiteSurfaceView::SetPreview(imgInfo);
|
||
lastRes_ = res;
|
||
}
|
||
}
|
||
|
||
void AlbumSurfaceView::UnsetPreview()
|
||
{
|
||
ImageCacheManager::GetInstance().UnloadSingleRes(lastRes_);
|
||
lastRes_ = "";
|
||
}
|
||
|
||
} // namespace TJD
|