1 /*
2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "window_test_utils.h"
17 #include <ability_context.h>
18 #include "display_manager_proxy.h"
19 #include "window_helper.h"
20 #include "wm_common.h"
21 #include "wm_common_inner.h"
22 namespace OHOS {
23 namespace Rosen {
24 namespace {
25 constexpr HiviewDFX::HiLogLabel LABEL = { LOG_CORE, HILOG_DOMAIN_WINDOW, "WindowTestUtils" };
26 constexpr uint32_t EDGE_INTERVAL = 48;
27 constexpr uint32_t MID_INTERVAL = 24;
28 } // namespace
29
30 Rect WindowTestUtils::displayRect_ = { 0, 0, 0, 0 };
31 Rect WindowTestUtils::statusBarRect_ = { 0, 0, 0, 0 };
32 Rect WindowTestUtils::naviBarRect_ = { 0, 0, 0, 0 };
33 Rect WindowTestUtils::customAppRect_ = { 0, 0, 0, 0 };
34 Rect WindowTestUtils::limitDisplayRect_ = { 0, 0, 0, 0 };
35 Rect WindowTestUtils::dockWindowRect_ = { 0, 0, 0, 0 };
36 SplitRects WindowTestUtils::splitRects_ = {
37 .primaryRect = { 0, 0, 0, 0 },
38 .secondaryRect = { 0, 0, 0, 0 },
39 .dividerRect = { 0, 0, 0, 0 },
40 };
41 Rect WindowTestUtils::singleTileRect_ = { 0, 0, 0, 0 };
42 std::vector<Rect> WindowTestUtils::doubleTileRects_ = std::vector<Rect>(2);
43 std::vector<Rect> WindowTestUtils::tripleTileRects_ = std::vector<Rect>(3);
44 AvoidArea WindowTestUtils::systemAvoidArea_ = {};
45
46 bool WindowTestUtils::isVerticalDisplay_ = false;
47
CreateTestWindow(const TestWindowInfo & info)48 sptr<Window> WindowTestUtils::CreateTestWindow(const TestWindowInfo& info)
49 {
50 sptr<WindowOption> option = new WindowOption();
51 option->SetWindowRect(info.rect);
52 option->SetWindowType(info.type);
53 option->SetWindowMode(info.mode);
54 option->SetFocusable(info.focusable_);
55 option->SetRequestedOrientation(info.orientation_);
56 if (info.parentId != INVALID_WINDOW_ID) {
57 option->SetParentId(info.parentId);
58 }
59 if (info.needAvoid) {
60 option->AddWindowFlag(WindowFlag::WINDOW_FLAG_NEED_AVOID);
61 } else {
62 option->RemoveWindowFlag(WindowFlag::WINDOW_FLAG_NEED_AVOID);
63 }
64 if (info.parentLimit) {
65 option->AddWindowFlag(WindowFlag::WINDOW_FLAG_PARENT_LIMIT);
66 } else {
67 option->RemoveWindowFlag(WindowFlag::WINDOW_FLAG_PARENT_LIMIT);
68 }
69 if (info.forbidSplitMove) {
70 option->AddWindowFlag(WindowFlag::WINDOW_FLAG_FORBID_SPLIT_MOVE);
71 } else {
72 option->RemoveWindowFlag(WindowFlag::WINDOW_FLAG_FORBID_SPLIT_MOVE);
73 }
74 if (info.showWhenLocked) {
75 option->AddWindowFlag(WindowFlag::WINDOW_FLAG_SHOW_WHEN_LOCKED);
76 } else {
77 option->RemoveWindowFlag(WindowFlag::WINDOW_FLAG_SHOW_WHEN_LOCKED);
78 }
79 sptr<Window> window = Window::Create(info.name, option);
80 return window;
81 }
82
CreateDockWindow()83 sptr<Window> WindowTestUtils::CreateDockWindow()
84 {
85 TestWindowInfo info = {
86 .name = "dockWindow",
87 .rect = dockWindowRect_,
88 .type = WindowType::WINDOW_TYPE_LAUNCHER_DOCK,
89 .mode = WindowMode::WINDOW_MODE_FLOATING,
90 .needAvoid = false,
91 .parentLimit = false,
92 .parentId = INVALID_WINDOW_ID,
93 };
94 return CreateTestWindow(info);
95 }
96
CreateStatusBarWindow()97 sptr<Window> WindowTestUtils::CreateStatusBarWindow()
98 {
99 TestWindowInfo info = {
100 .name = "statusBar",
101 .rect = statusBarRect_,
102 .type = WindowType::WINDOW_TYPE_STATUS_BAR,
103 .mode = WindowMode::WINDOW_MODE_FLOATING,
104 .needAvoid = false,
105 .parentLimit = false,
106 .parentId = INVALID_WINDOW_ID,
107 };
108 return CreateTestWindow(info);
109 }
110
CreateNavigationBarWindow()111 sptr<Window> WindowTestUtils::CreateNavigationBarWindow()
112 {
113 TestWindowInfo info = {
114 .name = "naviBar",
115 .rect = naviBarRect_,
116 .type = WindowType::WINDOW_TYPE_NAVIGATION_BAR,
117 .mode = WindowMode::WINDOW_MODE_FLOATING,
118 .needAvoid = false,
119 .parentLimit = false,
120 .parentId = INVALID_WINDOW_ID,
121 };
122 return CreateTestWindow(info);
123 }
124
CreateWindowScene()125 sptr<WindowScene> WindowTestUtils::CreateWindowScene()
126 {
127 sptr<IWindowLifeCycle> listener = nullptr;
128 std::shared_ptr<AbilityRuntime::AbilityContext> abilityContext = nullptr;
129
130 sptr<WindowScene> scene = new WindowScene();
131 scene->Init(0, abilityContext, listener);
132 return scene;
133 }
134
GetDefaultFloatingRect(const sptr<Window> & window,bool avoid)135 Rect WindowTestUtils::GetDefaultFloatingRect(const sptr<Window>& window, bool avoid)
136 {
137 limitDisplayRect_ = displayRect_;
138 if (avoid) {
139 UpdateSplitRects(window);
140 }
141 constexpr uint32_t half = 2;
142 constexpr float ratio = DEFAULT_ASPECT_RATIO; // 0.67: default height/width ratio
143 float vpr = GetVirtualPixelRatio(0);
144
145 /*
146 * Calculate default width and height, if width or height is
147 * smaller than minWidth or minHeight, use the minimum limits
148 */
149 uint32_t defaultW =
150 std::max(static_cast<uint32_t>(displayRect_.width_ * ratio), static_cast<uint32_t>(MIN_FLOATING_WIDTH * vpr));
151 uint32_t defaultH =
152 std::max(static_cast<uint32_t>(displayRect_.height_ * ratio), static_cast<uint32_t>(MIN_FLOATING_HEIGHT * vpr));
153 // calculate default x and y
154 Rect resRect = { 0, 0, defaultW, defaultH };
155 if (defaultW <= limitDisplayRect_.width_ && defaultH <= limitDisplayRect_.height_) {
156 resRect.posX_ = limitDisplayRect_.posX_ + static_cast<int32_t>((limitDisplayRect_.width_ - defaultW) / half);
157 resRect.posY_ = limitDisplayRect_.posY_ + static_cast<int32_t>((limitDisplayRect_.height_ - defaultH) / half);
158 }
159
160 return resRect;
161 }
162
CalcLimitedRect(const Rect & rect,float virtualPixelRatio)163 Rect WindowTestUtils::CalcLimitedRect(const Rect& rect, float virtualPixelRatio)
164 {
165 constexpr uint32_t maxLimitLen = 2560;
166 constexpr int32_t maxPosRemain = 48;
167 uint32_t minFloatingW = static_cast<uint32_t>(MIN_FLOATING_WIDTH * virtualPixelRatio);
168 uint32_t minFloatingH = static_cast<uint32_t>(MIN_FLOATING_HEIGHT * virtualPixelRatio);
169 Rect resRect = {
170 std::min(std::max(rect.posX_, maxPosRemain - static_cast<int32_t>(rect.width_)),
171 static_cast<int32_t>(displayRect_.width_) - maxPosRemain),
172 std::min(std::max(rect.posY_, maxPosRemain), static_cast<int32_t>(displayRect_.height_) - maxPosRemain),
173 std::min(std::max(minFloatingW, rect.width_), maxLimitLen),
174 std::min(std::max(minFloatingH, rect.height_), maxLimitLen),
175 };
176 return resRect;
177 }
178
GetFloatingLimitedRect(const Rect & rect,float virtualPixelRatio)179 Rect WindowTestUtils::GetFloatingLimitedRect(const Rect& rect, float virtualPixelRatio)
180 {
181 uint32_t minFloatingW = static_cast<uint32_t>(MIN_FLOATING_WIDTH * virtualPixelRatio);
182 uint32_t minFloatingH = static_cast<uint32_t>(MIN_FLOATING_HEIGHT * virtualPixelRatio);
183 Rect resRect = {
184 rect.posX_,
185 rect.posY_,
186 std::max(minFloatingW, rect.width_),
187 std::max(minFloatingH, rect.height_),
188 };
189 return resRect;
190 }
191
GetDecorateRect(const Rect & rect,float virtualPixelRatio)192 Rect WindowTestUtils::GetDecorateRect(const Rect& rect, float virtualPixelRatio)
193 {
194 uint32_t winFrameW = static_cast<uint32_t>(WINDOW_FRAME_WIDTH * virtualPixelRatio);
195 uint32_t winTitleBarH = static_cast<uint32_t>(WINDOW_TITLE_BAR_HEIGHT * virtualPixelRatio);
196
197 Rect resRect;
198 resRect.posX_ = rect.posX_;
199 resRect.posY_ = rect.posY_;
200 resRect.width_ = rect.width_ + winFrameW + winFrameW;
201 resRect.height_ = rect.height_ + winTitleBarH + winFrameW;
202 return resRect;
203 }
204
InitByDisplayRect(const Rect & displayRect)205 void WindowTestUtils::InitByDisplayRect(const Rect& displayRect)
206 {
207 const float barRatio = 0.07;
208 const float spaceRation = 0.125;
209 displayRect_ = displayRect;
210 limitDisplayRect_ = displayRect;
211 if (displayRect_.width_ < displayRect_.height_) {
212 isVerticalDisplay_ = true;
213 }
214 statusBarRect_ = { 0, 0, displayRect_.width_, displayRect_.height_ * barRatio };
215 naviBarRect_ = { 0, displayRect_.height_ * (1 - barRatio), displayRect_.width_, displayRect_.height_ * barRatio };
216 dockWindowRect_ = {
217 0, displayRect_.height_ * (1 - barRatio), displayRect_.width_, displayRect_.height_ * barRatio
218 };
219 customAppRect_ = { displayRect_.width_ * spaceRation,
220 displayRect_.height_ * spaceRation,
221 displayRect_.width_ * DEFAULT_ASPECT_RATIO,
222 displayRect_.height_ * DEFAULT_ASPECT_RATIO };
223 }
224
CreatePointerEvent(int32_t posX,int32_t posY,uint32_t pointerId,int32_t pointerAction)225 std::shared_ptr<MMI::PointerEvent> WindowTestUtils::CreatePointerEvent(int32_t posX, int32_t posY, uint32_t pointerId,
226 int32_t pointerAction)
227 {
228 MMI::PointerEvent::PointerItem pointerItem;
229 pointerItem.SetPointerId(pointerId);
230 pointerItem.SetDisplayX(posX);
231 pointerItem.SetDisplayY(posY);
232
233 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
234 pointerEvent->AddPointerItem(pointerItem);
235 pointerEvent->SetPointerId(pointerId);
236 pointerEvent->SetPointerAction(pointerAction);
237 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
238 return pointerEvent;
239 }
240
GetMaxTileWinNum()241 uint32_t WindowTestUtils::GetMaxTileWinNum()
242 {
243 float virtualPixelRatio = GetVirtualPixelRatio(0);
244 constexpr uint32_t half = 2;
245 uint32_t edgeIntervalVp = static_cast<uint32_t>(EDGE_INTERVAL * half * virtualPixelRatio);
246 uint32_t midIntervalVp = static_cast<uint32_t>(MID_INTERVAL * virtualPixelRatio);
247 uint32_t minFloatingW = static_cast<uint32_t>(MIN_FLOATING_WIDTH * virtualPixelRatio);
248 uint32_t drawableW = limitDisplayRect_.width_ - edgeIntervalVp + midIntervalVp;
249 uint32_t maxNum = static_cast<uint32_t>(drawableW / (minFloatingW + midIntervalVp));
250 WLOGI("maxNum: %{public}d", maxNum);
251 return maxNum;
252 }
253
InitTileWindowRects(const sptr<Window> & window,bool avoid)254 void WindowTestUtils::InitTileWindowRects(const sptr<Window>& window, bool avoid)
255 {
256 float virtualPixelRatio = GetVirtualPixelRatio(0);
257 uint32_t edgeInterval = static_cast<uint32_t>(EDGE_INTERVAL * virtualPixelRatio); // 48 is edge interval
258 uint32_t midInterval = static_cast<uint32_t>(MID_INTERVAL * virtualPixelRatio); // 24 is mid interval
259 constexpr float ratio = DEFAULT_ASPECT_RATIO;
260 constexpr int half = 2;
261 limitDisplayRect_ = displayRect_;
262 if (avoid) {
263 UpdateSplitRects(window);
264 }
265
266 uint32_t minFloatingW = static_cast<uint32_t>(MIN_FLOATING_WIDTH * virtualPixelRatio);
267 uint32_t minFloatingH = static_cast<uint32_t>(MIN_FLOATING_HEIGHT * virtualPixelRatio);
268 uint32_t w = std::max(static_cast<uint32_t>(displayRect_.width_ * ratio), minFloatingW);
269 uint32_t h = std::max(static_cast<uint32_t>(displayRect_.height_ * ratio), minFloatingH);
270 w = w > limitDisplayRect_.width_ ? limitDisplayRect_.width_ : w;
271 h = h > limitDisplayRect_.height_ ? limitDisplayRect_.height_ : h;
272 int x = limitDisplayRect_.posX_ + ((limitDisplayRect_.width_ - w) / half);
273 int y = limitDisplayRect_.posY_ + ((limitDisplayRect_.height_ - h) / half);
274 singleTileRect_ = { x, y, w, h };
275 WLOGI("singleRect_: %{public}d %{public}d %{public}d %{public}d", x, y, w, h);
276 x = edgeInterval;
277 w = (limitDisplayRect_.width_ - edgeInterval * half - midInterval) / half;
278 // calc doubleRect
279 doubleTileRects_[0] = { x, y, w, h };
280 doubleTileRects_[1] = { x + w + midInterval, y, w, h };
281 WLOGI("doubleRects_: %{public}d %{public}d %{public}d %{public}d", x, y, w, h);
282 // calc tripleRect
283 w = (limitDisplayRect_.width_ - edgeInterval * half - midInterval * half) / 3; // 3 is triple rects num
284 tripleTileRects_[0] = { x, y, w, h };
285 tripleTileRects_[1] = { x + w + midInterval, y, w, h };
286 tripleTileRects_[2] = { x + w * half + midInterval * half, y, w, h }; // 2 is third index
287 WLOGI("tripleRects_: %{public}d %{public}d %{public}d %{public}d", x, y, w, h);
288 }
289
RectEqualTo(const sptr<Window> & window,const Rect & r)290 bool WindowTestUtils::RectEqualTo(const sptr<Window>& window, const Rect& r)
291 {
292 usleep(100000); // 100000us
293 Rect l = window->GetRect();
294 bool res = ((l.posX_ == r.posX_) && (l.posY_ == r.posY_) && (l.width_ == r.width_) && (l.height_ == r.height_));
295 if (!res) {
296 WLOGFE(
297 "GetLayoutRect: %{public}d %{public}d %{public}d %{public}d, "
298 "Expect: %{public}d %{public}d %{public}d %{public}d",
299 l.posX_,
300 l.posY_,
301 l.width_,
302 l.height_,
303 r.posX_,
304 r.posY_,
305 r.width_,
306 r.height_);
307 }
308 return res;
309 }
310
RectEqualToRect(const Rect & l,const Rect & r)311 bool WindowTestUtils::RectEqualToRect(const Rect& l, const Rect& r)
312 {
313 bool res = ((l.posX_ == r.posX_) && (l.posY_ == r.posY_) && (l.width_ == r.width_) && (l.height_ == r.height_));
314 if (!res) {
315 WLOGFE(
316 "GetLayoutRect: %{public}d %{public}d %{public}d %{public}d, "
317 "Expect: %{public}d %{public}d %{public}d %{public}d",
318 l.posX_,
319 l.posY_,
320 l.width_,
321 l.height_,
322 r.posX_,
323 r.posY_,
324 r.width_,
325 r.height_);
326 }
327 return res;
328 }
329
GetAvoidPosType(const Rect & rect)330 AvoidPosType WindowTestUtils::GetAvoidPosType(const Rect& rect)
331 {
332 auto display = DisplayManager::GetInstance().GetDisplayById(0);
333 if (display == nullptr) {
334 WLOGFE("GetAvoidPosType fail. Get display fail. displayId: 0");
335 return AvoidPosType::AVOID_POS_UNKNOWN;
336 }
337 auto displayInfo = display->GetDisplayInfo();
338 Rect displayRect = {
339 displayInfo->GetOffsetX(), displayInfo->GetOffsetY(), displayInfo->GetWidth(), displayInfo->GetHeight()
340 };
341 return WindowHelper::GetAvoidPosType(rect, displayRect);
342 }
343
InitSplitRects()344 bool WindowTestUtils::InitSplitRects()
345 {
346 auto display = DisplayManager::GetInstance().GetDisplayById(0);
347 if (display == nullptr) {
348 WLOGFE("GetDefaultDisplay: failed!");
349 return false;
350 }
351 WLOGI("GetDefaultDisplay: id %{public}" PRIu64 ", w %{public}d, h %{public}d, fps %{public}u",
352 display->GetId(),
353 display->GetWidth(),
354 display->GetHeight(),
355 display->GetRefreshRate());
356
357 Rect displayRect = { 0, 0, display->GetWidth(), display->GetHeight() };
358 displayRect_ = displayRect;
359 limitDisplayRect_ = displayRect;
360
361 float virtualPixelRatio = WindowTestUtils::GetVirtualPixelRatio(0);
362 uint32_t dividerWidth = static_cast<uint32_t>(DIVIDER_WIDTH * virtualPixelRatio);
363
364 if (displayRect_.width_ < displayRect_.height_) {
365 isVerticalDisplay_ = true;
366 }
367 if (isVerticalDisplay_) {
368 splitRects_.dividerRect = {
369 0,
370 static_cast<uint32_t>((displayRect_.height_ - dividerWidth) * DEFAULT_SPLIT_RATIO),
371 displayRect_.width_,
372 dividerWidth,
373 };
374 } else {
375 splitRects_.dividerRect = { static_cast<uint32_t>((displayRect_.width_ - dividerWidth) * DEFAULT_SPLIT_RATIO),
376 0,
377 dividerWidth,
378 displayRect_.height_ };
379 }
380 return true;
381 }
382
UpdateSplitRects(const sptr<Window> & window)383 void WindowTestUtils::UpdateSplitRects(const sptr<Window>& window)
384 {
385 std::unique_ptr<WindowTestUtils> testUtils = std::make_unique<WindowTestUtils>();
386 testUtils->avoidArea_ = systemAvoidArea_;
387 testUtils->UpdateLimitDisplayRect(testUtils->avoidArea_.leftRect_);
388 testUtils->UpdateLimitDisplayRect(testUtils->avoidArea_.topRect_);
389 testUtils->UpdateLimitDisplayRect(testUtils->avoidArea_.rightRect_);
390 testUtils->UpdateLimitDisplayRect(testUtils->avoidArea_.bottomRect_);
391
392 if (isVerticalDisplay_) {
393 splitRects_.dividerRect.posY_ =
394 limitDisplayRect_.posY_ +
395 static_cast<uint32_t>((limitDisplayRect_.height_ - splitRects_.dividerRect.height_) * DEFAULT_SPLIT_RATIO);
396 testUtils->UpdateLimitSplitRects(splitRects_.dividerRect.posY_);
397 } else {
398 splitRects_.dividerRect.posX_ =
399 limitDisplayRect_.posX_ +
400 static_cast<uint32_t>((limitDisplayRect_.width_ - splitRects_.dividerRect.width_) * DEFAULT_SPLIT_RATIO);
401 testUtils->UpdateLimitSplitRects(splitRects_.dividerRect.posX_);
402 }
403 }
404
UpdateLimitDisplayRect(const Rect & avoidRect)405 void WindowTestUtils::UpdateLimitDisplayRect(const Rect& avoidRect)
406 {
407 if (((avoidRect.posX_ == 0) && (avoidRect.posY_ == 0) && (avoidRect.width_ == 0) && (avoidRect.height_ == 0))) {
408 return;
409 }
410 auto avoidPosType = GetAvoidPosType(avoidRect);
411 int32_t offsetH = 0;
412 int32_t offsetW = 0;
413 switch (avoidPosType) {
414 case AvoidPosType::AVOID_POS_TOP:
415 offsetH = avoidRect.posY_ + avoidRect.height_ - limitDisplayRect_.posY_;
416 limitDisplayRect_.posY_ += offsetH;
417 limitDisplayRect_.height_ -= offsetH;
418 break;
419 case AvoidPosType::AVOID_POS_BOTTOM:
420 offsetH = limitDisplayRect_.posY_ + limitDisplayRect_.height_ - avoidRect.posY_;
421 limitDisplayRect_.height_ -= offsetH;
422 break;
423 case AvoidPosType::AVOID_POS_LEFT:
424 offsetW = avoidRect.posX_ + avoidRect.width_ - limitDisplayRect_.posX_;
425 limitDisplayRect_.posX_ += offsetW;
426 limitDisplayRect_.width_ -= offsetW;
427 break;
428 case AvoidPosType::AVOID_POS_RIGHT:
429 offsetW = limitDisplayRect_.posX_ + limitDisplayRect_.width_ - avoidRect.posX_;
430 limitDisplayRect_.width_ -= offsetW;
431 break;
432 default:
433 WLOGFE("invalid avoidPosType: %{public}d", avoidPosType);
434 }
435 }
436
UpdateLimitSplitRects(int32_t divPos)437 void WindowTestUtils::UpdateLimitSplitRects(int32_t divPos)
438 {
439 std::unique_ptr<WindowTestUtils> testUtils = std::make_unique<WindowTestUtils>();
440 if (isVerticalDisplay_) {
441 splitRects_.dividerRect.posY_ = divPos;
442
443 splitRects_.primaryRect.posX_ = displayRect_.posX_;
444 splitRects_.primaryRect.posY_ = displayRect_.posY_;
445 splitRects_.primaryRect.height_ = divPos;
446 splitRects_.primaryRect.width_ = displayRect_.width_;
447
448 splitRects_.secondaryRect.posX_ = displayRect_.posX_;
449 splitRects_.secondaryRect.posY_ = splitRects_.dividerRect.posY_ + splitRects_.dividerRect.height_;
450 splitRects_.secondaryRect.height_ = displayRect_.height_ - splitRects_.secondaryRect.posY_;
451 splitRects_.secondaryRect.width_ = displayRect_.width_;
452 } else {
453 splitRects_.dividerRect.posX_ = divPos;
454
455 splitRects_.primaryRect.posX_ = displayRect_.posX_;
456 splitRects_.primaryRect.posY_ = displayRect_.posY_;
457 splitRects_.primaryRect.width_ = divPos;
458 splitRects_.primaryRect.height_ = displayRect_.height_;
459
460 splitRects_.secondaryRect.posX_ = splitRects_.dividerRect.posX_ + splitRects_.dividerRect.width_;
461 splitRects_.secondaryRect.posY_ = displayRect_.posY_;
462 splitRects_.secondaryRect.width_ = displayRect_.width_ - splitRects_.secondaryRect.posX_;
463 splitRects_.secondaryRect.height_ = displayRect_.height_;
464 }
465
466 testUtils->UpdateLimitSplitRect(splitRects_.primaryRect);
467 testUtils->UpdateLimitSplitRect(splitRects_.secondaryRect);
468 }
469
UpdateLimitSplitRect(Rect & limitSplitRect)470 void WindowTestUtils::UpdateLimitSplitRect(Rect& limitSplitRect)
471 {
472 Rect curLimitRect = limitSplitRect;
473 limitSplitRect.posX_ = std::max(limitDisplayRect_.posX_, curLimitRect.posX_);
474 limitSplitRect.posY_ = std::max(limitDisplayRect_.posY_, curLimitRect.posY_);
475 limitSplitRect.width_ =
476 std::min(limitDisplayRect_.posX_ + limitDisplayRect_.width_, curLimitRect.posX_ + curLimitRect.width_) -
477 limitSplitRect.posX_;
478 limitSplitRect.height_ =
479 std::min(limitDisplayRect_.posY_ + limitDisplayRect_.height_, curLimitRect.posY_ + curLimitRect.height_) -
480 limitSplitRect.posY_;
481 }
482
GetVirtualPixelRatio(DisplayId displayId)483 float WindowTestUtils::GetVirtualPixelRatio(DisplayId displayId)
484 {
485 auto display = DisplayManager::GetInstance().GetDisplayById(displayId);
486 if (display == nullptr) {
487 WLOGFE("GetVirtualPixel fail. Get display fail. displayId:%{public}" PRIu64 ", use Default vpr:1.0", displayId);
488 return 1.0; // Use DefaultVPR 1.0
489 }
490
491 float virtualPixelRatio = display->GetVirtualPixelRatio();
492 if (virtualPixelRatio == 0.0) {
493 WLOGFE("GetVirtualPixel fail. vpr is 0.0. displayId:%{public}" PRIu64 ", use Default vpr:1.0", displayId);
494 return 1.0; // Use DefaultVPR 1.0
495 }
496
497 WLOGI("GetVirtualPixel success. displayId:%{public}" PRIu64 ", vpr:%{public}f", displayId, virtualPixelRatio);
498 return virtualPixelRatio;
499 }
500 } // namespace Rosen
501 } // namespace OHOS
502