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 "window_helper.h"
19 #include "wm_common_inner.h"
20 #include "wm_common.h"
21 namespace OHOS {
22 namespace Rosen {
23 namespace {
24 constexpr HiviewDFX::HiLogLabel LABEL = {LOG_CORE, HILOG_DOMAIN_WINDOW, "WindowTestUtils"};
25 constexpr uint32_t EDGE_INTERVAL = 48;
26 constexpr uint32_t MID_INTERVAL = 24;
27 }
28
29 Rect WindowTestUtils::displayRect_ = {0, 0, 0, 0};
30 Rect WindowTestUtils::statusBarRect_ = {0, 0, 0, 0};
31 Rect WindowTestUtils::naviBarRect_ = {0, 0, 0, 0};
32 Rect WindowTestUtils::customAppRect_ = {0, 0, 0, 0};
33 Rect WindowTestUtils::limitDisplayRect_ = {0, 0, 0, 0};
34 Rect WindowTestUtils::dockWindowRect_ = {0, 0, 0, 0};
35 SplitRects WindowTestUtils::splitRects_ = {
36 .primaryRect = {0, 0, 0, 0},
37 .secondaryRect = {0, 0, 0, 0},
38 .dividerRect = {0, 0, 0, 0},
39 };
40 Rect WindowTestUtils::singleTileRect_ = {0, 0, 0, 0};
41 std::vector<Rect> WindowTestUtils::doubleTileRects_ = std::vector<Rect>(2);
42 std::vector<Rect> WindowTestUtils::tripleTileRects_ = std::vector<Rect>(3);
43 AvoidArea WindowTestUtils::systemAvoidArea_ = {};
44
45 bool WindowTestUtils::isVerticalDisplay_ = false;
46
CreateTestWindow(const TestWindowInfo & info)47 sptr<Window> WindowTestUtils::CreateTestWindow(const TestWindowInfo& info)
48 {
49 sptr<WindowOption> option = new WindowOption();
50 option->SetWindowRect(info.rect);
51 option->SetWindowType(info.type);
52 option->SetWindowMode(info.mode);
53 option->SetFocusable(info.focusable_);
54 option->SetRequestedOrientation(info.orientation_);
55 if (info.parentId != INVALID_WINDOW_ID) {
56 option->SetParentId(info.parentId);
57 }
58 if (info.needAvoid) {
59 option->AddWindowFlag(WindowFlag::WINDOW_FLAG_NEED_AVOID);
60 } else {
61 option->RemoveWindowFlag(WindowFlag::WINDOW_FLAG_NEED_AVOID);
62 }
63 if (info.parentLimit) {
64 option->AddWindowFlag(WindowFlag::WINDOW_FLAG_PARENT_LIMIT);
65 } else {
66 option->RemoveWindowFlag(WindowFlag::WINDOW_FLAG_PARENT_LIMIT);
67 }
68 if (info.forbidSplitMove) {
69 option->AddWindowFlag(WindowFlag::WINDOW_FLAG_FORBID_SPLIT_MOVE);
70 } else {
71 option->RemoveWindowFlag(WindowFlag::WINDOW_FLAG_FORBID_SPLIT_MOVE);
72 }
73 if (info.showWhenLocked) {
74 option->AddWindowFlag(WindowFlag::WINDOW_FLAG_SHOW_WHEN_LOCKED);
75 } else {
76 option->RemoveWindowFlag(WindowFlag::WINDOW_FLAG_SHOW_WHEN_LOCKED);
77 }
78 sptr<Window> window = Window::Create(info.name, option);
79 return window;
80 }
81
CreateDockWindow()82 sptr<Window> WindowTestUtils::CreateDockWindow()
83 {
84 TestWindowInfo info = {
85 .name = "dockWindow",
86 .rect = dockWindowRect_,
87 .type = WindowType::WINDOW_TYPE_LAUNCHER_DOCK,
88 .mode = WindowMode::WINDOW_MODE_FLOATING,
89 .needAvoid = false,
90 .parentLimit = false,
91 .parentId = INVALID_WINDOW_ID,
92 };
93 return CreateTestWindow(info);
94 }
95
CreateStatusBarWindow()96 sptr<Window> WindowTestUtils::CreateStatusBarWindow()
97 {
98 TestWindowInfo info = {
99 .name = "statusBar",
100 .rect = statusBarRect_,
101 .type = WindowType::WINDOW_TYPE_STATUS_BAR,
102 .mode = WindowMode::WINDOW_MODE_FLOATING,
103 .needAvoid = false,
104 .parentLimit = false,
105 .parentId = INVALID_WINDOW_ID,
106 };
107 return CreateTestWindow(info);
108 }
109
CreateNavigationBarWindow()110 sptr<Window> WindowTestUtils::CreateNavigationBarWindow()
111 {
112 TestWindowInfo info = {
113 .name = "naviBar",
114 .rect = naviBarRect_,
115 .type = WindowType::WINDOW_TYPE_NAVIGATION_BAR,
116 .mode = WindowMode::WINDOW_MODE_FLOATING,
117 .needAvoid = false,
118 .parentLimit = false,
119 .parentId = INVALID_WINDOW_ID,
120 };
121 return CreateTestWindow(info);
122 }
123
CreateWindowScene()124 sptr<WindowScene> WindowTestUtils::CreateWindowScene()
125 {
126 sptr<IWindowLifeCycle> listener = nullptr;
127 std::shared_ptr<AbilityRuntime::AbilityContext> abilityContext = nullptr;
128
129 sptr<WindowScene> scene = new WindowScene();
130 scene->Init(0, abilityContext, listener);
131 return scene;
132 }
133
GetDefaultFloatingRect(const sptr<Window> & window)134 Rect WindowTestUtils::GetDefaultFloatingRect(const sptr<Window>& window)
135 {
136 limitDisplayRect_ = displayRect_;
137 UpdateSplitRects(window);
138 constexpr uint32_t half = 2;
139 constexpr float ratio = DEFAULT_ASPECT_RATIO; // 0.67: default height/width ratio
140 float vpr = GetVirtualPixelRatio(0);
141
142 /*
143 * Calculate default width and height, if width or height is
144 * smaller than minWidth or minHeight, use the minimum limits
145 */
146 uint32_t defaultW = std::max(static_cast<uint32_t>(displayRect_.width_ * ratio),
147 static_cast<uint32_t>(MIN_FLOATING_WIDTH * vpr));
148 uint32_t defaultH = std::max(static_cast<uint32_t>(displayRect_.height_ * ratio),
149 static_cast<uint32_t>(MIN_FLOATING_HEIGHT * vpr));
150 // calculate default x and y
151 Rect resRect = {0, 0, defaultW, defaultH};
152 if (defaultW <= limitDisplayRect_.width_ && defaultH <= limitDisplayRect_.height_) {
153 int32_t centerPosX = limitDisplayRect_.posX_ + static_cast<int32_t>(limitDisplayRect_.width_ / half);
154 resRect.posX_ = centerPosX - static_cast<int32_t>(defaultW / half);
155
156 int32_t centerPosY = limitDisplayRect_.posY_ + static_cast<int32_t>(limitDisplayRect_.height_ / half);
157 resRect.posY_ = centerPosY - static_cast<int32_t>(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_ = {0, displayRect_.height_ * (1 - barRatio), displayRect_.width_, displayRect_.height_ * barRatio};
217 customAppRect_ = {
218 displayRect_.width_ * spaceRation,
219 displayRect_.height_ * spaceRation,
220 displayRect_.width_ * DEFAULT_ASPECT_RATIO,
221 displayRect_.height_ * DEFAULT_ASPECT_RATIO
222 };
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 WLOGFI("maxNum: %{public}d", maxNum);
251 return maxNum;
252 }
253
InitTileWindowRects(const sptr<Window> & window)254 void WindowTestUtils::InitTileWindowRects(const sptr<Window>& window)
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 UpdateSplitRects(window);
263
264 uint32_t minFloatingW = static_cast<uint32_t>(MIN_FLOATING_WIDTH * virtualPixelRatio);
265 uint32_t minFloatingH = static_cast<uint32_t>(MIN_FLOATING_HEIGHT * virtualPixelRatio);
266 uint32_t w = std::max(static_cast<uint32_t>(displayRect_.width_ * ratio), minFloatingW);
267 uint32_t h = std::max(static_cast<uint32_t>(displayRect_.height_ * ratio), minFloatingH);
268 w = w > limitDisplayRect_.width_ ? limitDisplayRect_.width_ : w;
269 h = h > limitDisplayRect_.height_ ? limitDisplayRect_.height_ : h;
270 int x = limitDisplayRect_.posX_ + ((limitDisplayRect_.width_ - w) / half);
271 int y = limitDisplayRect_.posY_ + ((limitDisplayRect_.height_ - h) / half);
272 singleTileRect_ = { x, y, w, h };
273 WLOGFI("singleRect_: %{public}d %{public}d %{public}d %{public}d", x, y, w, h);
274 x = edgeInterval;
275 w = (limitDisplayRect_.width_ - edgeInterval * half - midInterval) / half;
276 // calc doubleRect
277 doubleTileRects_[0] = {x, y, w, h};
278 doubleTileRects_[1] = {x + w + midInterval, y, w, h};
279 WLOGFI("doubleRects_: %{public}d %{public}d %{public}d %{public}d", x, y, w, h);
280 // calc tripleRect
281 w = (limitDisplayRect_.width_ - edgeInterval * half - midInterval * half) / 3; // 3 is triple rects num
282 tripleTileRects_[0] = {x, y, w, h};
283 tripleTileRects_[1] = {x + w + midInterval, y, w, h};
284 tripleTileRects_[2] = {x + w * half + midInterval * half, y, w, h}; // 2 is third index
285 WLOGFI("tripleRects_: %{public}d %{public}d %{public}d %{public}d", x, y, w, h);
286 }
287
RectEqualTo(const sptr<Window> & window,const Rect & r)288 bool WindowTestUtils::RectEqualTo(const sptr<Window>& window, const Rect& r)
289 {
290 usleep(100000); // 100000us
291 Rect l = window->GetRect();
292 bool res = ((l.posX_ == r.posX_) && (l.posY_ == r.posY_) && (l.width_ == r.width_) && (l.height_ == r.height_));
293 if (!res) {
294 WLOGFE("GetLayoutRect: %{public}d %{public}d %{public}d %{public}d, " \
295 "Expect: %{public}d %{public}d %{public}d %{public}d", l.posX_, l.posY_, l.width_, l.height_,
296 r.posX_, r.posY_, r.width_, r.height_);
297 }
298 return res;
299 }
300
RectEqualToRect(const Rect & l,const Rect & r)301 bool WindowTestUtils::RectEqualToRect(const Rect& l, const Rect& r)
302 {
303 bool res = ((l.posX_ == r.posX_) && (l.posY_ == r.posY_) && (l.width_ == r.width_) && (l.height_ == r.height_));
304 if (!res) {
305 WLOGFE("GetLayoutRect: %{public}d %{public}d %{public}d %{public}d, " \
306 "Expect: %{public}d %{public}d %{public}d %{public}d", l.posX_, l.posY_, l.width_, l.height_,
307 r.posX_, r.posY_, r.width_, r.height_);
308 }
309 return res;
310 }
311
GetAvoidPosType(const Rect & rect)312 AvoidPosType WindowTestUtils::GetAvoidPosType(const Rect& rect)
313 {
314 auto display = DisplayManager::GetInstance().GetDisplayById(0);
315 if (display == nullptr) {
316 WLOGFE("GetAvoidPosType fail. Get display fail. displayId: 0");
317 return AvoidPosType::AVOID_POS_UNKNOWN;
318 }
319 auto displayInfo = display->GetDisplayInfo();
320 Rect displayRect = {displayInfo->GetOffsetX(), displayInfo->GetOffsetY(), displayInfo->GetWidth(),
321 displayInfo->GetHeight()};
322 return WindowHelper::GetAvoidPosType(rect, displayRect);
323 }
324
InitSplitRects()325 bool WindowTestUtils::InitSplitRects()
326 {
327 auto display = DisplayManager::GetInstance().GetDisplayById(0);
328 if (display == nullptr) {
329 WLOGFE("GetDefaultDisplay: failed!");
330 return false;
331 }
332 WLOGFI("GetDefaultDisplay: id %{public}" PRIu64", w %{public}d, h %{public}d, fps %{public}u",
333 display->GetId(), display->GetWidth(), display->GetHeight(), display->GetRefreshRate());
334
335 Rect displayRect = {0, 0, display->GetWidth(), display->GetHeight()};
336 displayRect_ = displayRect;
337 limitDisplayRect_ = displayRect;
338
339 float virtualPixelRatio = WindowTestUtils::GetVirtualPixelRatio(0);
340 uint32_t dividerWidth = static_cast<uint32_t>(DIVIDER_WIDTH * virtualPixelRatio);
341
342 if (displayRect_.width_ < displayRect_.height_) {
343 isVerticalDisplay_ = true;
344 }
345 if (isVerticalDisplay_) {
346 splitRects_.dividerRect = { 0,
347 static_cast<uint32_t>((displayRect_.height_ - dividerWidth) * DEFAULT_SPLIT_RATIO),
348 displayRect_.width_,
349 dividerWidth, };
350 } else {
351 splitRects_.dividerRect = { static_cast<uint32_t>((displayRect_.width_ - dividerWidth) * DEFAULT_SPLIT_RATIO),
352 0,
353 dividerWidth,
354 displayRect_.height_ };
355 }
356 return true;
357 }
358
UpdateSplitRects(const sptr<Window> & window)359 void WindowTestUtils::UpdateSplitRects(const sptr<Window>& window)
360 {
361 std::unique_ptr<WindowTestUtils> testUtils = std::make_unique<WindowTestUtils>();
362 testUtils->avoidArea_ = systemAvoidArea_;
363 testUtils->UpdateLimitDisplayRect(testUtils->avoidArea_.leftRect_);
364 testUtils->UpdateLimitDisplayRect(testUtils->avoidArea_.topRect_);
365 testUtils->UpdateLimitDisplayRect(testUtils->avoidArea_.rightRect_);
366 testUtils->UpdateLimitDisplayRect(testUtils->avoidArea_.bottomRect_);
367
368 if (isVerticalDisplay_) {
369 splitRects_.dividerRect.posY_ = limitDisplayRect_.posY_ +
370 static_cast<uint32_t>((limitDisplayRect_.height_ - splitRects_.dividerRect.height_) * DEFAULT_SPLIT_RATIO);
371 testUtils->UpdateLimitSplitRects(splitRects_.dividerRect.posY_);
372 } else {
373 splitRects_.dividerRect.posX_ = limitDisplayRect_.posX_ +
374 static_cast<uint32_t>((limitDisplayRect_.width_ - splitRects_.dividerRect.width_) * DEFAULT_SPLIT_RATIO);
375 testUtils->UpdateLimitSplitRects(splitRects_.dividerRect.posX_);
376 }
377 }
378
UpdateLimitDisplayRect(const Rect & avoidRect)379 void WindowTestUtils::UpdateLimitDisplayRect(const Rect& avoidRect)
380 {
381 if (((avoidRect.posX_ == 0) && (avoidRect.posY_ == 0) &&
382 (avoidRect.width_ == 0) && (avoidRect.height_ == 0))) {
383 return;
384 }
385 auto avoidPosType = GetAvoidPosType(avoidRect);
386 int32_t offsetH = 0;
387 int32_t offsetW = 0;
388 switch (avoidPosType) {
389 case AvoidPosType::AVOID_POS_TOP:
390 offsetH = avoidRect.posY_ + avoidRect.height_ - limitDisplayRect_.posY_;
391 limitDisplayRect_.posY_ += offsetH;
392 limitDisplayRect_.height_ -= offsetH;
393 break;
394 case AvoidPosType::AVOID_POS_BOTTOM:
395 offsetH = limitDisplayRect_.posY_ + limitDisplayRect_.height_ - avoidRect.posY_;
396 limitDisplayRect_.height_ -= offsetH;
397 break;
398 case AvoidPosType::AVOID_POS_LEFT:
399 offsetW = avoidRect.posX_ + avoidRect.width_ - limitDisplayRect_.posX_;
400 limitDisplayRect_.posX_ += offsetW;
401 limitDisplayRect_.width_ -= offsetW;
402 break;
403 case AvoidPosType::AVOID_POS_RIGHT:
404 offsetW = limitDisplayRect_.posX_ + limitDisplayRect_.width_ - avoidRect.posX_;
405 limitDisplayRect_.width_ -= offsetW;
406 break;
407 default:
408 WLOGFE("invalid avoidPosType: %{public}d", avoidPosType);
409 }
410 }
411
UpdateLimitSplitRects(int32_t divPos)412 void WindowTestUtils::UpdateLimitSplitRects(int32_t divPos)
413 {
414 std::unique_ptr<WindowTestUtils> testUtils = std::make_unique<WindowTestUtils>();
415 if (isVerticalDisplay_) {
416 splitRects_.dividerRect.posY_ = divPos;
417
418 splitRects_.primaryRect.posX_ = displayRect_.posX_;
419 splitRects_.primaryRect.posY_ = displayRect_.posY_;
420 splitRects_.primaryRect.height_ = divPos;
421 splitRects_.primaryRect.width_ = displayRect_.width_;
422
423 splitRects_.secondaryRect.posX_ = displayRect_.posX_;
424 splitRects_.secondaryRect.posY_ = splitRects_.dividerRect.posY_ + splitRects_.dividerRect.height_;
425 splitRects_.secondaryRect.height_ = displayRect_.height_ - splitRects_.secondaryRect.posY_;
426 splitRects_.secondaryRect.width_ = displayRect_.width_;
427 } else {
428 splitRects_.dividerRect.posX_ = divPos;
429
430 splitRects_.primaryRect.posX_ = displayRect_.posX_;
431 splitRects_.primaryRect.posY_ = displayRect_.posY_;
432 splitRects_.primaryRect.width_ = divPos;
433 splitRects_.primaryRect.height_ = displayRect_.height_;
434
435 splitRects_.secondaryRect.posX_ = splitRects_.dividerRect.posX_ + splitRects_.dividerRect.width_;
436 splitRects_.secondaryRect.posY_ = displayRect_.posY_;
437 splitRects_.secondaryRect.width_ = displayRect_.width_ - splitRects_.secondaryRect.posX_;
438 splitRects_.secondaryRect.height_ = displayRect_.height_;
439 }
440
441 testUtils->UpdateLimitSplitRect(splitRects_.primaryRect);
442 testUtils->UpdateLimitSplitRect(splitRects_.secondaryRect);
443 }
444
UpdateLimitSplitRect(Rect & limitSplitRect)445 void WindowTestUtils::UpdateLimitSplitRect(Rect& limitSplitRect)
446 {
447 Rect curLimitRect = limitSplitRect;
448 limitSplitRect.posX_ = std::max(limitDisplayRect_.posX_, curLimitRect.posX_);
449 limitSplitRect.posY_ = std::max(limitDisplayRect_.posY_, curLimitRect.posY_);
450 limitSplitRect.width_ = std::min(limitDisplayRect_.posX_ + limitDisplayRect_.width_,
451 curLimitRect.posX_ + curLimitRect.width_) -
452 limitSplitRect.posX_;
453 limitSplitRect.height_ = std::min(limitDisplayRect_.posY_ + limitDisplayRect_.height_,
454 curLimitRect.posY_ + curLimitRect.height_) -
455 limitSplitRect.posY_;
456 }
457
GetVirtualPixelRatio(DisplayId displayId)458 float WindowTestUtils::GetVirtualPixelRatio(DisplayId displayId)
459 {
460 auto display = DisplayManager::GetInstance().GetDisplayById(displayId);
461 if (display == nullptr) {
462 WLOGFE("GetVirtualPixel fail. Get display fail. displayId:%{public}" PRIu64", use Default vpr:1.0", displayId);
463 return 1.0; // Use DefaultVPR 1.0
464 }
465
466 float virtualPixelRatio = display->GetVirtualPixelRatio();
467 if (virtualPixelRatio == 0.0) {
468 WLOGFE("GetVirtualPixel fail. vpr is 0.0. displayId:%{public}" PRIu64", use Default vpr:1.0", displayId);
469 return 1.0; // Use DefaultVPR 1.0
470 }
471
472 WLOGFI("GetVirtualPixel success. displayId:%{public}" PRIu64", vpr:%{public}f", displayId, virtualPixelRatio);
473 return virtualPixelRatio;
474 }
475 } // namespace ROSEN
476 } // namespace OHOS
477