1 /*
2 * Copyright (c) 2021-2023 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 "rs_screen_manager.h"
17
18 #include "hgm_core.h"
19 #include "pipeline/rs_display_render_node.h"
20 #include "pipeline/rs_main_thread.h"
21 #include "pipeline/rs_hardware_thread.h"
22 #include "platform/common/rs_log.h"
23 #include "vsync_sampler.h"
24 #include <parameter.h>
25 #include <parameters.h>
26 #include "param/sys_param.h"
27 #include "common/rs_optional_trace.h"
28 #include "rs_trace.h"
29
30 namespace OHOS {
31 namespace Rosen {
32 #ifdef RS_SUBSCRIBE_SENSOR_ENABLE
33 namespace {
34 constexpr float ANGLE_MIN_VAL = 0.0F;
35 constexpr float ANGLE_MAX_VAL = 180.0F;
36 constexpr int32_t SENSOR_SUCCESS = 0;
37 constexpr int32_t POSTURE_INTERVAL = 4000000;
38 constexpr uint16_t SENSOR_EVENT_FIRST_DATA = 0;
39 constexpr float HALF_FOLDED_MAX_THRESHOLD = 140.0F;
40 constexpr float OPEN_HALF_FOLDED_MIN_THRESHOLD = 25.0F;
41 constexpr uint32_t WAIT_FOR_ACTIVE_SCREEN_ID_TIMEOUT = 1000;
42 constexpr uint32_t MAX_VIRTUAL_SCREEN_NUM = 64;
43 constexpr uint32_t MAX_VIRTUAL_SCREEN_WIDTH = 65536;
44 constexpr uint32_t MAX_VIRTUAL_SCREEN_HEIGHT = 65536;
SensorPostureDataCallback(SensorEvent * event)45 void SensorPostureDataCallback(SensorEvent *event)
46 {
47 OHOS::Rosen::CreateOrGetScreenManager()->HandlePostureData(event);
48 }
49 } // namespace
50 #endif
51 using namespace HiviewDFX;
52 namespace impl {
53 std::once_flag RSScreenManager::createFlag_;
54 sptr<OHOS::Rosen::RSScreenManager> RSScreenManager::instance_ = nullptr;
55
GetInstance()56 sptr<OHOS::Rosen::RSScreenManager> RSScreenManager::GetInstance() noexcept
57 {
58 std::call_once(createFlag_, []() {
59 instance_ = new RSScreenManager();
60 });
61
62 return instance_;
63 }
64
RSScreenManager()65 RSScreenManager::RSScreenManager()
66 {
67 }
68
~RSScreenManager()69 RSScreenManager::~RSScreenManager() noexcept
70 {
71 }
72
Init()73 bool RSScreenManager::Init() noexcept
74 {
75 composer_ = HdiBackend::GetInstance();
76 #ifdef RS_SUBSCRIBE_SENSOR_ENABLE
77 isFoldScreenFlag_ = system::GetParameter("const.window.foldscreen.type", "") != "";
78 #endif
79 if (composer_ == nullptr) {
80 RS_LOGE("RSScreenManager %{public}s: Failed to get composer.", __func__);
81 return false;
82 }
83
84 if (composer_->RegScreenHotplug(&RSScreenManager::OnHotPlug, this) != 0) {
85 RS_LOGE("RSScreenManager %{public}s: Failed to register OnHotPlug Func to composer.", __func__);
86 return false;
87 }
88
89 if (composer_->RegScreenRefresh(&RSScreenManager::OnRefresh, this) != 0) {
90 RS_LOGE("RSScreenManager %{public}s: Failed to register OnRefresh Func to composer.", __func__);
91 }
92
93 if (composer_->RegHwcDeadListener(&RSScreenManager::OnHwcDead, this) != 0) {
94 RS_LOGE("RSScreenManager %{public}s: Failed to register OnHwcDead Func to composer.", __func__);
95 return false;
96 }
97
98 if (composer_->RegScreenVBlankIdleCallback(&RSScreenManager::OnScreenVBlankIdle, this) != 0) {
99 RS_LOGW("RSScreenManager %{public}s: Not support register OnScreenVBlankIdle Func to composer.", __func__);
100 }
101
102 // call ProcessScreenHotPlugEvents() for primary screen immediately in main thread.
103 ProcessScreenHotPlugEvents();
104
105 #ifdef RS_SUBSCRIBE_SENSOR_ENABLE
106 if (isFoldScreenFlag_) {
107 RegisterSensorCallback();
108 }
109 #endif
110 RS_LOGI("RSScreenManager Init succeed");
111 return true;
112 }
113
114 #ifdef RS_SUBSCRIBE_SENSOR_ENABLE
RegisterSensorCallback()115 void RSScreenManager::RegisterSensorCallback()
116 {
117 user.callback = SensorPostureDataCallback;
118 int32_t subscribeRet;
119 int32_t setBatchRet;
120 int32_t activateRet;
121 int tryCnt = 0;
122 constexpr int tryLimit = 5; // 5 times failure limit
123 do {
124 subscribeRet = SubscribeSensor(SENSOR_TYPE_ID_POSTURE, &user);
125 RS_LOGI("RSScreenManager RegisterSensorCallback, subscribeRet: %{public}d", subscribeRet);
126 setBatchRet = SetBatch(SENSOR_TYPE_ID_POSTURE, &user, POSTURE_INTERVAL, POSTURE_INTERVAL);
127 RS_LOGI("RSScreenManager RegisterSensorCallback, setBatchRet: %{public}d", setBatchRet);
128 activateRet = ActivateSensor(SENSOR_TYPE_ID_POSTURE, &user);
129 RS_LOGI("RSScreenManager RegisterSensorCallback, activateRet: %{public}d", activateRet);
130 if (subscribeRet != SENSOR_SUCCESS || setBatchRet != SENSOR_SUCCESS || activateRet != SENSOR_SUCCESS) {
131 RS_LOGE("RSScreenManager RegisterSensorCallback failed.");
132 usleep(1000); // wait 1000 us for next try
133 tryCnt++;
134 }
135 } while (tryCnt <= tryLimit && (subscribeRet != SENSOR_SUCCESS || setBatchRet != SENSOR_SUCCESS ||
136 activateRet != SENSOR_SUCCESS));
137 if (tryCnt <= tryLimit) {
138 RS_LOGI("RSScreenManager RegisterSensorCallback success.");
139 }
140 }
141
UnRegisterSensorCallback()142 void RSScreenManager::UnRegisterSensorCallback()
143 {
144 int32_t deactivateRet = DeactivateSensor(SENSOR_TYPE_ID_POSTURE, &user);
145 int32_t unsubscribeRet = UnsubscribeSensor(SENSOR_TYPE_ID_POSTURE, &user);
146 if (deactivateRet == SENSOR_SUCCESS && unsubscribeRet == SENSOR_SUCCESS) {
147 RS_LOGI("RSScreenManager UnRegisterSensorCallback success.");
148 }
149 }
150
HandlePostureData(const SensorEvent * const event)151 void RSScreenManager::HandlePostureData(const SensorEvent * const event)
152 {
153 if (event == nullptr) {
154 RS_LOGI("SensorEvent is nullptr.");
155 return;
156 }
157 if (event[SENSOR_EVENT_FIRST_DATA].data == nullptr) {
158 RS_LOGI("SensorEvent[0].data is nullptr.");
159 return;
160 }
161 if (event[SENSOR_EVENT_FIRST_DATA].dataLen < sizeof(PostureData)) {
162 RS_LOGI("SensorEvent dataLen less than posture data size.");
163 return;
164 }
165 PostureData *postureData = reinterpret_cast<PostureData *>(event[SENSOR_EVENT_FIRST_DATA].data);
166 float angle = (*postureData).angle;
167 if (std::isless(angle, ANGLE_MIN_VAL) || std::isgreater(angle, ANGLE_MAX_VAL)) {
168 RS_LOGD("Invalid angle value, angle is %{public}f.", angle);
169 return;
170 }
171 RS_LOGD("angle vlaue in PostureData is: %{public}f.", angle);
172 HandleSensorData(angle);
173 }
174
HandleSensorData(float angle)175 void RSScreenManager::HandleSensorData(float angle)
176 {
177 std::unique_lock<std::mutex> lock(activeScreenIdAssignedMutex_);
178 FoldState foldState = TransferAngleToScreenState(angle);
179 if (foldState == FoldState::FOLDED) {
180 activeScreenId_ = externalScreenId_;
181 } else {
182 activeScreenId_ = innerScreenId_;
183 }
184 isPostureSensorDataHandled_ = true;
185 HgmCore::Instance().SetActiveScreenId(activeScreenId_);
186 activeScreenIdAssignedCV_.notify_one();
187 }
188
TransferAngleToScreenState(float angle)189 FoldState RSScreenManager::TransferAngleToScreenState(float angle)
190 {
191 if (std::isless(angle, ANGLE_MIN_VAL)) {
192 return FoldState::FOLDED;
193 }
194 if (std::isgreaterequal(angle, HALF_FOLDED_MAX_THRESHOLD)) {
195 return FoldState::EXPAND;
196 }
197 FoldState state;
198 if (std::islessequal(angle, OPEN_HALF_FOLDED_MIN_THRESHOLD)) {
199 state = FoldState::FOLDED;
200 } else {
201 state = FoldState::EXPAND;
202 }
203 return state;
204 }
205
GetActiveScreenId()206 ScreenId RSScreenManager::GetActiveScreenId()
207 {
208 std::unique_lock<std::mutex> lock(activeScreenIdAssignedMutex_);
209 if (!isFoldScreenFlag_) {
210 return INVALID_SCREEN_ID;
211 }
212 if (isPostureSensorDataHandled_) {
213 isFirstTimeToGetActiveScreenId_ = false;
214 UnRegisterSensorCallback();
215 RS_LOGI("RSScreenManager activeScreenId: %{public}" PRIu64 " ", activeScreenId_);
216 return activeScreenId_;
217 }
218 activeScreenIdAssignedCV_.wait_until(lock, std::chrono::system_clock::now() +
219 std::chrono::milliseconds(WAIT_FOR_ACTIVE_SCREEN_ID_TIMEOUT), [this]() {
220 return isPostureSensorDataHandled_;
221 });
222 if (isFirstTimeToGetActiveScreenId_) {
223 isFirstTimeToGetActiveScreenId_ = false;
224 UnRegisterSensorCallback();
225 }
226 RS_LOGI("RSScreenManager activeScreenId: %{public}" PRIu64 " ", activeScreenId_);
227 return activeScreenId_;
228 }
229 #else
GetActiveScreenId()230 ScreenId RSScreenManager::GetActiveScreenId()
231 {
232 return INVALID_SCREEN_ID;
233 }
234 #endif
235
IsAllScreensPowerOff() const236 bool RSScreenManager::IsAllScreensPowerOff() const
237 {
238 std::lock_guard<std::mutex> lock(mutex_);
239 if (screenPowerStatus_.empty()) {
240 return false;
241 }
242 for (const auto &[id, powerStatus] : screenPowerStatus_) {
243 auto iter = screens_.find(id);
244 if (iter != screens_.end() && iter->second->IsVirtual()) {
245 continue;
246 }
247 // we also need to consider the AOD mode(POWER_STATUS_SUSPEND)
248 if (powerStatus != ScreenPowerStatus::POWER_STATUS_OFF &&
249 powerStatus != ScreenPowerStatus::POWER_STATUS_SUSPEND) {
250 return false;
251 }
252 }
253 return true;
254 }
255
256 #ifdef USE_VIDEO_PROCESSING_ENGINE
GetScreenBrightnessNits(ScreenId id) const257 float RSScreenManager::GetScreenBrightnessNits(ScreenId id) const
258 {
259 constexpr float DEFAULT_SCREEN_LIGHT_NITS = 500.0;
260 constexpr float DEFAULT_SCREEN_LIGHT_MAX_NITS = 1200.0;
261 constexpr int32_t DEFAULT_SCREEN_LIGHT_MAX_LEVEL = 255;
262
263 float screenBrightnessNits = DEFAULT_SCREEN_LIGHT_NITS;
264
265 RSScreenType screenType;
266 if (GetScreenType(id, screenType) != SUCCESS) {
267 RS_LOGW("RSScreenManager::GetScreenBrightnessNits GetScreenType fail.");
268 return screenBrightnessNits;
269 }
270
271 if (screenType == VIRTUAL_TYPE_SCREEN) {
272 return screenBrightnessNits;
273 }
274
275 int32_t backLightLevel = GetScreenBacklight(id);
276 if (backLightLevel <= 0) {
277 return screenBrightnessNits;
278 }
279
280 return DEFAULT_SCREEN_LIGHT_MAX_NITS * backLightLevel / DEFAULT_SCREEN_LIGHT_MAX_LEVEL;
281 }
282 #endif
283
ForceRefreshOneFrameIfNoRNV()284 void RSScreenManager::ForceRefreshOneFrameIfNoRNV()
285 {
286 auto mainThread = RSMainThread::Instance();
287 if (mainThread != nullptr && !mainThread->IsRequestedNextVSync()) {
288 RS_TRACE_NAME("No RNV, ForceRefreshOneFrame");
289 mainThread->PostTask([mainThread]() {
290 mainThread->SetDirtyFlag();
291 });
292 mainThread->RequestNextVSync();
293 }
294 }
295
OnHotPlug(std::shared_ptr<HdiOutput> & output,bool connected,void * data)296 void RSScreenManager::OnHotPlug(std::shared_ptr<HdiOutput> &output, bool connected, void *data)
297 {
298 if (output == nullptr) {
299 RS_LOGE("RSScreenManager %{public}s: output is nullptr.", __func__);
300 return;
301 }
302
303 RSScreenManager *screenManager = nullptr;
304 if (data != nullptr) {
305 screenManager = static_cast<RSScreenManager *>(data);
306 } else {
307 screenManager = static_cast<RSScreenManager *>(RSScreenManager::GetInstance().GetRefPtr());
308 }
309
310 if (screenManager == nullptr) {
311 RS_LOGE("RSScreenManager %{public}s: Failed to find RSScreenManager instance.", __func__);
312 return;
313 }
314
315 screenManager->OnHotPlugEvent(output, connected);
316 }
317
OnHotPlugEvent(std::shared_ptr<HdiOutput> & output,bool connected)318 void RSScreenManager::OnHotPlugEvent(std::shared_ptr<HdiOutput> &output, bool connected)
319 {
320 {
321 std::lock_guard<std::mutex> lock(mutex_);
322 pendingHotPlugEvents_.emplace_back(ScreenHotPlugEvent{output, connected});
323 }
324
325 // This func would be called in main thread first time immediately after calling composer_->RegScreenHotplug,
326 // but at this time the RSMainThread object would not be ready to handle this, so we need to call
327 // ProcessScreenHotPlugEvents() after this func in RSScreenManager::Init().
328
329 // Normally, this func would be called in hdi's hw-ipc threads(but sometimes in main thread, maybe),
330 // so we should notify the RSMainThread to postTask to call ProcessScreenHotPlugEvents().
331 auto mainThread = RSMainThread::Instance();
332 if (mainThread == nullptr) {
333 return;
334 }
335 mainThread->RequestNextVSync();
336 }
337
OnRefresh(ScreenId id,void * data)338 void RSScreenManager::OnRefresh(ScreenId id, void *data)
339 {
340 RSScreenManager *screenManager = nullptr;
341 if (data != nullptr) {
342 screenManager = static_cast<RSScreenManager *>(data);
343 } else {
344 screenManager = static_cast<RSScreenManager *>(RSScreenManager::GetInstance().GetRefPtr());
345 }
346
347 if (screenManager == nullptr) {
348 RS_LOGE("RSScreenManager %{public}s: Failed to find RSScreenManager instance.", __func__);
349 return;
350 }
351 screenManager->OnRefreshEvent(id);
352 }
353
OnRefreshEvent(ScreenId id)354 void RSScreenManager::OnRefreshEvent(ScreenId id)
355 {
356 auto mainThread = RSMainThread::Instance();
357 if (mainThread == nullptr) {
358 return;
359 }
360 mainThread->PostTask([mainThread]() {
361 mainThread->SetForceUpdateUniRenderFlag(true);
362 mainThread->RequestNextVSync();
363 });
364 }
365
OnHwcDead(void * data)366 void RSScreenManager::OnHwcDead(void *data)
367 {
368 RS_LOGW("RSScreenManager %{public}s: The composer_host is already dead.", __func__);
369 RSScreenManager *screenManager = static_cast<RSScreenManager *>(RSScreenManager::GetInstance().GetRefPtr());
370 if (screenManager == nullptr) {
371 RS_LOGE("RSScreenManager %{public}s: Failed to find RSScreenManager instance.", __func__);
372 return;
373 }
374
375 // Automatically recover when composer host dies.
376 screenManager->CleanAndReinit();
377 }
378
OnHwcDeadEvent()379 void RSScreenManager::OnHwcDeadEvent()
380 {
381 std::lock_guard<std::mutex> lock(mutex_);
382 for (const auto &[id, screen] : screens_) {
383 if (screen) {
384 // In sceneboard, we should not notify the WMS to remove node from RSTree
385 if (screen->IsVirtual()) {
386 continue;
387 } else {
388 RSHardwareThread::Instance().ClearFrameBuffers(screen->GetOutput());
389 }
390 }
391 }
392 isHwcDead_ = true;
393 screens_.clear();
394 defaultScreenId_ = INVALID_SCREEN_ID;
395 }
396
OnScreenVBlankIdle(uint32_t devId,uint64_t ns,void * data)397 void RSScreenManager::OnScreenVBlankIdle(uint32_t devId, uint64_t ns, void *data)
398 {
399 RSScreenManager *screenManager = static_cast<RSScreenManager *>(RSScreenManager::GetInstance().GetRefPtr());
400 if (screenManager == nullptr) {
401 RS_LOGE("RSScreenManager %{public}s: Failed to find RSScreenManager instance.", __func__);
402 return;
403 }
404 screenManager->OnScreenVBlankIdleEvent(devId, ns);
405 }
406
OnScreenVBlankIdleEvent(uint32_t devId,uint64_t ns)407 void RSScreenManager::OnScreenVBlankIdleEvent(uint32_t devId, uint64_t ns)
408 {
409 std::lock_guard<std::mutex> lock(mutex_);
410 ScreenId screenId = ToScreenId(devId);
411 if (screens_.count(screenId) == 0) {
412 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, screenId);
413 return;
414 }
415 RSHardwareThread::Instance().PostTask([screenId, ns]() {
416 RSHardwareThread::Instance().OnScreenVBlankIdleCallback(screenId, ns);
417 });
418 }
419
CleanAndReinit()420 void RSScreenManager::CleanAndReinit()
421 {
422 RSScreenManager *screenManager = static_cast<RSScreenManager *>(RSScreenManager::GetInstance().GetRefPtr());
423 if (screenManager == nullptr) {
424 RS_LOGE("RSScreenManager %{public}s: Failed to find RSScreenManager instance.", __func__);
425 return;
426 }
427
428 auto renderType = RSUniRenderJudgement::GetUniRenderEnabledType();
429 if (renderType != UniRenderEnabledType::UNI_RENDER_ENABLED_FOR_ALL) {
430 auto mainThread = RSMainThread::Instance();
431 if (mainThread == nullptr) {
432 RS_LOGE("RSScreenManager %{public}s: Reinit failed, get RSMainThread failed.", __func__);
433 return;
434 }
435 mainThread->PostTask([screenManager, this]() {
436 screenManager->OnHwcDeadEvent();
437 if (!composer_) {
438 RS_LOGE("RSScreenManager %{public}s: Failed to get composer.", __func__);
439 return;
440 }
441 composer_->ResetDevice();
442 if (!screenManager->Init()) {
443 RS_LOGE("RSScreenManager %{public}s: Reinit failed, screenManager init failed in mainThread.",
444 __func__);
445 return;
446 }
447 });
448 } else {
449 RSHardwareThread::Instance().PostTask([screenManager, this]() {
450 RS_LOGW("RSScreenManager %{public}s: clean and reinit in hardware thread.", __func__);
451 screenManager->OnHwcDeadEvent();
452 if (!composer_) {
453 RS_LOGE("RSScreenManager %{public}s: Failed to get composer.", __func__);
454 return;
455 }
456 composer_->ResetDevice();
457 if (!screenManager->Init()) {
458 RS_LOGE("RSScreenManager %{public}s: Reinit failed, screenManager init failed in HardwareThread.",
459 __func__);
460 return;
461 }
462 });
463 }
464 }
465
TrySimpleProcessHotPlugEvents()466 bool RSScreenManager::TrySimpleProcessHotPlugEvents()
467 {
468 std::lock_guard<std::mutex> lock(mutex_);
469 if (!isHwcDead_ && pendingHotPlugEvents_.empty() && connectedIds_.empty()) {
470 mipiCheckInFirstHotPlugEvent_ = true;
471 return true;
472 }
473 return false;
474 }
475
ProcessScreenHotPlugEvents()476 void RSScreenManager::ProcessScreenHotPlugEvents()
477 {
478 std::lock_guard<std::mutex> lock(mutex_);
479 for (auto &event : pendingHotPlugEvents_) {
480 if (event.connected) {
481 ProcessScreenConnectedLocked(event.output);
482 AddScreenToHgm(event.output);
483 } else {
484 ProcessScreenDisConnectedLocked(event.output);
485 RemoveScreenFromHgm(event.output);
486 }
487 }
488 for (auto id : connectedIds_) {
489 for (auto &cb : screenChangeCallbacks_) {
490 if (!isHwcDead_) {
491 cb->OnScreenChanged(id, ScreenEvent::CONNECTED);
492 continue;
493 }
494 }
495 auto screenIt = screens_.find(id);
496 if (screenIt == screens_.end() || screenIt->second == nullptr) {
497 continue;
498 }
499 auto screenCorrectionIt = screenCorrection_.find(id);
500 auto screenBacklightIt = screenBacklight_.find(id);
501 auto screenPowerStatusIt = screenPowerStatus_.find(id);
502 if (screenCorrectionIt != screenCorrection_.end()) {
503 screenIt->second->SetScreenCorrection(screenCorrectionIt->second);
504 }
505 if (screenBacklightIt != screenBacklight_.end() && (screenPowerStatusIt == screenPowerStatus_.end() ||
506 screenPowerStatusIt->second == ScreenPowerStatus::POWER_STATUS_ON)) {
507 screenIt->second->SetScreenBacklight(screenBacklightIt->second);
508 auto mainThread = RSMainThread::Instance();
509 mainThread->PostTask([mainThread]() {
510 mainThread->SetDirtyFlag();
511 });
512 mainThread->ForceRefreshForUni();
513 }
514 }
515 isHwcDead_ = false;
516 mipiCheckInFirstHotPlugEvent_ = true;
517 pendingHotPlugEvents_.clear();
518 connectedIds_.clear();
519 }
520
AddScreenToHgm(std::shared_ptr<HdiOutput> & output)521 void RSScreenManager::AddScreenToHgm(std::shared_ptr<HdiOutput> &output)
522 {
523 if (output == nullptr) {
524 RS_LOGE("RSScreenManager %{public}s: output is nullptr.", __func__);
525 return;
526 }
527 RS_LOGI("RSScreenManager AddScreenToHgm");
528 auto &hgmCore = OHOS::Rosen::HgmCore::Instance();
529 ScreenId thisId = ToScreenId(output->GetScreenId());
530 auto screensIt = screens_.find(thisId);
531 if (screensIt == screens_.end()) {
532 RS_LOGE("RSScreenManager invalid screen id, screen not found : %{public}" PRIu64 "", thisId);
533 return;
534 }
535
536 int32_t initModeId = 0;
537 if (screensIt->second == nullptr) {
538 RS_LOGW("AddScreenToHgm:screen %{public}" PRIu64 " not found", thisId);
539 return;
540 }
541 const auto &screen = screensIt->second;
542 auto initMode = screen->GetActiveMode();
543 if (!initMode) {
544 RS_LOGE("RSScreenManager failed to get initial mode");
545 } else {
546 initModeId = initMode->id;
547 }
548 const auto &capability = screen->GetCapability();
549 ScreenSize screenSize = {screen->Width(), screen->Height(), capability.phyWidth, capability.phyHeight};
550 RS_LOGD_IF(DEBUG_SCREEN, "RSScreenManager add screen: w * h: [%{public}u * %{public}u], capability w * h: "
551 "[%{public}u * %{public}u]", screen->Width(), screen->Height(), capability.phyWidth, capability.phyHeight);
552 if (hgmCore.AddScreen(thisId, initModeId, screenSize)) {
553 RS_LOGW("RSScreenManager failed to add screen : %{public}" PRIu64 "", thisId);
554 return;
555 }
556 hgmCore.SetActiveScreenId(thisId);
557
558 // for each supported mode, use the index as modeId to add the detailed mode to hgm
559 int32_t modeId = 0;
560 auto supportedModes = screen->GetSupportedModes();
561 for (auto mode = supportedModes.begin(); mode != supportedModes.end(); ++mode) {
562 if (hgmCore.AddScreenInfo(thisId, (*mode).width, (*mode).height,
563 (*mode).freshRate, modeId)) {
564 RS_LOGW("RSScreenManager failed to add a screen profile to the screen : %{public}" PRIu64 "", thisId);
565 }
566 modeId++;
567 }
568 }
569
RemoveScreenFromHgm(std::shared_ptr<HdiOutput> & output)570 void RSScreenManager::RemoveScreenFromHgm(std::shared_ptr<HdiOutput> &output)
571 {
572 if (output == nullptr) {
573 RS_LOGE("RSScreenManager %{public}s: output is nullptr.", __func__);
574 return;
575 }
576
577 RS_LOGI("RSScreenManager RemoveScreenFromHgm");
578 auto &hgmCore = OHOS::Rosen::HgmCore::Instance();
579 ScreenId id = ToScreenId(output->GetScreenId());
580 RS_LOGD_IF(DEBUG_SCREEN, "RSScreenManager remove screen, id: %{public}" PRIu64 "", id);
581 if (hgmCore.RemoveScreen(id)) {
582 RS_LOGW("RSScreenManager failed to remove screen : %{public}" PRIu64 "", id);
583 }
584 }
585
ProcessScreenConnectedLocked(std::shared_ptr<HdiOutput> & output)586 void RSScreenManager::ProcessScreenConnectedLocked(std::shared_ptr<HdiOutput> &output)
587 {
588 if (output == nullptr) {
589 RS_LOGE("RSScreenManager %{public}s: output is nullptr.", __func__);
590 return;
591 }
592
593 bool isVirtual = false;
594 ScreenId id = ToScreenId(output->GetScreenId());
595 RS_LOGI("RSScreenManager %{public}s The screen for id %{public}" PRIu64 " connected.", __func__, id);
596
597 auto it = screens_.find(id);
598 if (it != screens_.end() && it->second != nullptr) {
599 RS_LOGW("RSScreenManager %{public}s The screen for id %{public}" PRIu64 " already existed.", __func__, id);
600
601 // [PLANNING]: should we erase it and create a new one?
602 for (auto &cb : screenChangeCallbacks_) {
603 cb->OnScreenChanged(id, ScreenEvent::DISCONNECTED);
604 }
605 screens_.erase(it);
606 RS_LOGI("The screen for id %{public}" PRIu64 " already existed, remove the orignal one.", id);
607 }
608
609 screens_[id] = std::make_unique<RSScreen>(id, isVirtual, output, nullptr);
610
611 auto vsyncSampler = CreateVSyncSampler();
612 if (vsyncSampler != nullptr) {
613 auto renderType = RSUniRenderJudgement::GetUniRenderEnabledType();
614 if (renderType != UniRenderEnabledType::UNI_RENDER_ENABLED_FOR_ALL) {
615 vsyncSampler->RegSetScreenVsyncEnabledCallback([this, id](bool enabled) {
616 auto mainThread = RSMainThread::Instance();
617 if (mainThread == nullptr) {
618 RS_LOGE("SetScreenVsyncEnabled:%{public}d failed, get RSMainThread failed", enabled);
619 return;
620 }
621 mainThread->PostTask([this, id, enabled]() {
622 auto screensIt = screens_.find(id);
623 if (screensIt == screens_.end() || screensIt->second == nullptr) {
624 RS_LOGE("SetScreenVsyncEnabled:%{public}d failed, screen %{public}" PRIu64 " not found",
625 enabled, id);
626 return;
627 }
628 screensIt->second->SetScreenVsyncEnabled(enabled);
629 });
630 });
631 } else {
632 vsyncSampler->RegSetScreenVsyncEnabledCallback([this, id](bool enabled) {
633 RSHardwareThread::Instance().PostTask([this, id, enabled]() {
634 auto screensIt = screens_.find(id);
635 if (screensIt == screens_.end() || screensIt->second == nullptr) {
636 RS_LOGE("SetScreenVsyncEnabled:%{public}d failed, screen %{public}" PRIu64 " not found",
637 enabled, id);
638 return;
639 }
640 screensIt->second->SetScreenVsyncEnabled(enabled);
641 });
642 });
643 }
644 } else {
645 RS_LOGE("RegSetScreenVsyncEnabledCallback failed, vsyncSampler is null");
646 }
647
648 if (screens_[id]->GetCapability().type == GraphicInterfaceType::GRAPHIC_DISP_INTF_MIPI) {
649 if (!mipiCheckInFirstHotPlugEvent_) {
650 defaultScreenId_ = id;
651 }
652 mipiCheckInFirstHotPlugEvent_ = true;
653 } else if (defaultScreenId_ == INVALID_SCREEN_ID) {
654 defaultScreenId_ = id;
655 }
656
657 RS_LOGI("RSScreenManager %{public}s: A new screen(id %{public}" PRIu64 ") connected.", __func__, id);
658 connectedIds_.emplace_back(id);
659 #ifdef RS_SUBSCRIBE_SENSOR_ENABLE
660 if (isFoldScreenFlag_ && id != 0) {
661 externalScreenId_ = id;
662 }
663 #endif
664 }
665
ProcessScreenDisConnectedLocked(std::shared_ptr<HdiOutput> & output)666 void RSScreenManager::ProcessScreenDisConnectedLocked(std::shared_ptr<HdiOutput> &output)
667 {
668 ScreenId id = ToScreenId(output->GetScreenId());
669 RS_LOGD_IF(DEBUG_SCREEN, "RSScreenManager process screen disconnected, id: %{public}" PRIu64 "", id);
670 auto screensIt = screens_.find(id);
671 if (screensIt == screens_.end()) {
672 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64, __func__, id);
673 } else {
674 for (auto &cb : screenChangeCallbacks_) {
675 cb->OnScreenChanged(id, ScreenEvent::DISCONNECTED);
676 }
677 screens_.erase(screensIt);
678 RS_LOGI("RSScreenManager %{public}s: Screen(id %{public}" PRIu64 ") disconnected.", __func__, id);
679 }
680 screenPowerStatus_.erase(id);
681 screenBacklight_.erase(id);
682 screenCorrection_.erase(id);
683 if (id == defaultScreenId_) {
684 HandleDefaultScreenDisConnectedLocked();
685 }
686 }
687
688 // If the previous primary screen disconnected, we traversal the left screens
689 // and find the first physical screen to be the default screen.
690 // If there was no physical screen left, we set the first screen as default, no matter what type it is.
691 // At last, if no screen left, we set Default Screen Id to INVALID_SCREEN_ID.
HandleDefaultScreenDisConnectedLocked()692 void RSScreenManager::HandleDefaultScreenDisConnectedLocked()
693 {
694 defaultScreenId_ = INVALID_SCREEN_ID;
695 for (const auto &[id, screen] : screens_) {
696 if (screen == nullptr) {
697 RS_LOGW("HandleDefaultScreenDisConnectedLocked:screen %{public}" PRIu64 " not found", id);
698 continue;
699 }
700 if (!screen->IsVirtual()) {
701 defaultScreenId_ = id;
702 break;
703 }
704 }
705
706 if (defaultScreenId_ == INVALID_SCREEN_ID) {
707 if (!screens_.empty()) {
708 defaultScreenId_ = screens_.cbegin()->first;
709 }
710 }
711 }
712
713 // if SetVirtualScreenSurface success, force a refresh of one frame, avoiding prolong black screen
ForceRefreshOneFrame() const714 void RSScreenManager::ForceRefreshOneFrame() const
715 {
716 auto mainThread = RSMainThread::Instance();
717 if (mainThread != nullptr) {
718 mainThread->PostTask([mainThread]() {
719 mainThread->SetDirtyFlag();
720 });
721 mainThread->ForceRefreshForUni();
722 }
723 }
724
SetDefaultScreenId(ScreenId id)725 void RSScreenManager::SetDefaultScreenId(ScreenId id)
726 {
727 std::lock_guard<std::mutex> lock(mutex_);
728 defaultScreenId_ = id;
729 }
730
SetScreenMirror(ScreenId id,ScreenId toMirror)731 void RSScreenManager::SetScreenMirror(ScreenId id, ScreenId toMirror)
732 {
733 std::lock_guard<std::mutex> lock(mutex_);
734
735 auto screensIt = screens_.find(id);
736 if (screensIt == screens_.end() || screensIt->second == nullptr) {
737 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
738 return;
739 }
740
741 screensIt->second->SetMirror(toMirror);
742 }
743
GenerateVirtualScreenIdLocked()744 ScreenId RSScreenManager::GenerateVirtualScreenIdLocked()
745 {
746 if (!freeVirtualScreenIds_.empty()) {
747 ScreenId id = freeVirtualScreenIds_.front();
748 freeVirtualScreenIds_.pop();
749 return id;
750 }
751
752 // The left 32 bits is for virtual screen id.
753 return (static_cast<ScreenId>(virtualScreenCount_++) << 32) | 0xffffffffu;
754 }
755
ReuseVirtualScreenIdLocked(ScreenId id)756 void RSScreenManager::ReuseVirtualScreenIdLocked(ScreenId id)
757 {
758 freeVirtualScreenIds_.push(id);
759 }
760
GetVirtualScreenResolutionLocked(ScreenId id,RSVirtualScreenResolution & virtualScreenResolution) const761 void RSScreenManager::GetVirtualScreenResolutionLocked(ScreenId id,
762 RSVirtualScreenResolution& virtualScreenResolution) const
763 {
764 auto screensIt = screens_.find(id);
765 if (screensIt == screens_.end() || screensIt->second == nullptr) {
766 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
767 return;
768 }
769 const auto& screen = screensIt->second;
770 virtualScreenResolution.SetVirtualScreenWidth(static_cast<uint32_t>(screen->Width()));
771 virtualScreenResolution.SetVirtualScreenHeight(static_cast<uint32_t>(screen->Height()));
772 }
773
GetScreenActiveModeLocked(ScreenId id,RSScreenModeInfo & screenModeInfo) const774 void RSScreenManager::GetScreenActiveModeLocked(ScreenId id, RSScreenModeInfo& screenModeInfo) const
775 {
776 auto screensIt = screens_.find(id);
777 if (screensIt == screens_.end() || screensIt->second == nullptr) {
778 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
779 return;
780 }
781 const auto& screen = screensIt->second;
782 auto modeInfo = screen->GetActiveMode();
783 if (!modeInfo) {
784 RS_LOGE("RSScreenManager %{public}s: Failed to get active mode for screen %{public}" PRIu64 ".", __func__, id);
785 return;
786 }
787
788 screenModeInfo.SetScreenWidth(modeInfo->width);
789 screenModeInfo.SetScreenHeight(modeInfo->height);
790 screenModeInfo.SetScreenRefreshRate(modeInfo->freshRate);
791 screenModeInfo.SetScreenModeId(screen->GetActiveModePosByModeId(modeInfo->id));
792 }
793
GetScreenSupportedModesLocked(ScreenId id) const794 std::vector<RSScreenModeInfo> RSScreenManager::GetScreenSupportedModesLocked(ScreenId id) const
795 {
796 std::vector<RSScreenModeInfo> screenSupportedModes;
797 auto screensIt = screens_.find(id);
798 if (screensIt == screens_.end() || screensIt->second == nullptr) {
799 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
800 return screenSupportedModes;
801 }
802
803 const auto& displaySupportedModes = screensIt->second->GetSupportedModes();
804 screenSupportedModes.resize(displaySupportedModes.size());
805 for (decltype(displaySupportedModes.size()) idx = 0; idx < displaySupportedModes.size(); ++idx) {
806 screenSupportedModes[idx].SetScreenWidth(displaySupportedModes[idx].width);
807 screenSupportedModes[idx].SetScreenHeight(displaySupportedModes[idx].height);
808 screenSupportedModes[idx].SetScreenRefreshRate(displaySupportedModes[idx].freshRate);
809 screenSupportedModes[idx].SetScreenModeId(displaySupportedModes[idx].id);
810 }
811 return screenSupportedModes;
812 }
813
GetScreenCapabilityLocked(ScreenId id) const814 RSScreenCapability RSScreenManager::GetScreenCapabilityLocked(ScreenId id) const
815 {
816 RSScreenCapability screenCapability;
817 auto screensIt = screens_.find(id);
818 if (screensIt == screens_.end() || screensIt->second == nullptr) {
819 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
820 return screenCapability;
821 }
822 const auto& screen = screensIt->second;
823 if (screen->IsVirtual()) {
824 RS_LOGW("RSScreenManager %{public}s: only name attribute is valid for virtual screen.", __func__);
825 screenCapability.SetName(screen->Name());
826 return screenCapability;
827 }
828
829 const auto& capability = screen->GetCapability();
830 std::vector<RSScreenProps> props;
831 uint32_t propCount = capability.propertyCount;
832 props.resize(propCount);
833 for (uint32_t propIndex = 0; propIndex < propCount; propIndex++) {
834 props[propIndex] = RSScreenProps(capability.props[propIndex].name, capability.props[propIndex].propId,
835 capability.props[propIndex].value);
836 }
837 screenCapability.SetName(capability.name);
838 screenCapability.SetType(static_cast<ScreenInterfaceType>(capability.type));
839 screenCapability.SetPhyWidth(capability.phyWidth);
840 screenCapability.SetPhyHeight(capability.phyHeight);
841 screenCapability.SetSupportLayers(capability.supportLayers);
842 screenCapability.SetVirtualDispCount(capability.virtualDispCount);
843 screenCapability.SetSupportWriteBack(capability.supportWriteBack);
844 screenCapability.SetProps(props);
845 return screenCapability;
846 }
847
GetScreenPowerStatusLocked(ScreenId id) const848 ScreenPowerStatus RSScreenManager::GetScreenPowerStatusLocked(ScreenId id) const
849 {
850 auto screensIt = screens_.find(id);
851 if (screensIt == screens_.end() || screensIt->second == nullptr) {
852 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
853 return INVALID_POWER_STATUS;
854 }
855
856 ScreenPowerStatus status = static_cast<ScreenPowerStatus>(screensIt->second->GetPowerStatus());
857 return status;
858 }
859
GetScreenCorrectionLocked(ScreenId id) const860 ScreenRotation RSScreenManager::GetScreenCorrectionLocked(ScreenId id) const
861 {
862 auto screensIt = screens_.find(id);
863 if (screensIt == screens_.end() || screensIt->second == nullptr) {
864 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
865 return ScreenRotation::INVALID_SCREEN_ROTATION;
866 }
867
868 ScreenRotation screenRotation = screensIt->second->GetScreenCorrection();
869 return screenRotation;
870 }
871
GetAllScreenIds() const872 std::vector<ScreenId> RSScreenManager::GetAllScreenIds() const
873 {
874 std::lock_guard<std::mutex> lock(mutex_);
875 std::vector<ScreenId> ids;
876 for (auto iter = screens_.begin(); iter != screens_.end(); ++iter) {
877 ids.emplace_back(iter->first);
878 }
879 return ids;
880 }
881
CreateVirtualScreen(const std::string & name,uint32_t width,uint32_t height,sptr<Surface> surface,ScreenId mirrorId,int32_t flags,std::vector<NodeId> whiteList)882 ScreenId RSScreenManager::CreateVirtualScreen(
883 const std::string &name,
884 uint32_t width,
885 uint32_t height,
886 sptr<Surface> surface,
887 ScreenId mirrorId,
888 int32_t flags,
889 std::vector<NodeId> whiteList)
890 {
891 std::lock_guard<std::mutex> lock(mutex_);
892
893 if (currentVirtualScreenNum_ >= MAX_VIRTUAL_SCREEN_NUM) {
894 RS_LOGW("RSScreenManager %{public}s: virtual screens num %{public}" PRIu32" has reached the maximum limit!",
895 __func__, currentVirtualScreenNum_);
896 return INVALID_SCREEN_ID;
897 }
898 if (width > MAX_VIRTUAL_SCREEN_WIDTH || height > MAX_VIRTUAL_SCREEN_HEIGHT) {
899 RS_LOGW("RSScreenManager %{public}s: width %{public}" PRIu32" or height %{public}" PRIu32" has reached"
900 " the maximum limit!", __func__, width, height);
901 return INVALID_SCREEN_ID;
902 }
903 if (surface != nullptr) {
904 uint64_t surfaceId = surface->GetUniqueId();
905 for (auto &[_, screen] : screens_) {
906 if (screen == nullptr || !screen->IsVirtual()) {
907 continue;
908 }
909 auto screenSurface = screen->GetProducerSurface();
910 if (screenSurface == nullptr) {
911 continue;
912 }
913 if (screenSurface->GetUniqueId() == surfaceId) {
914 RS_LOGW("RSScreenManager %{public}s: surface %{public}" PRIu64 " is used, create virtual"
915 " screen failed!", __func__, surfaceId);
916 return INVALID_SCREEN_ID;
917 }
918 }
919 } else {
920 RS_LOGD("RSScreenManager %{public}s: surface is nullptr.", __func__);
921 }
922
923 VirtualScreenConfigs configs;
924 ScreenId newId = GenerateVirtualScreenIdLocked();
925 configs.id = newId;
926 configs.mirrorId = mirrorId;
927 configs.name = name;
928 configs.width = width;
929 configs.height = height;
930 configs.surface = surface;
931 configs.flags = flags;
932 configs.whiteList = std::unordered_set<NodeId>(whiteList.begin(), whiteList.end());
933
934 screens_[newId] = std::make_unique<RSScreen>(configs);
935 ++currentVirtualScreenNum_;
936 RS_LOGD("RSScreenManager %{public}s: create virtual screen(id %{public}" PRIu64 ").", __func__, newId);
937 return newId;
938 }
939
GetCastScreenBlackList(std::unordered_set<uint64_t> & screenBlackList)940 void RSScreenManager::GetCastScreenBlackList(std::unordered_set<uint64_t>& screenBlackList)
941 {
942 std::lock_guard<std::mutex> lock(blackListMutex_);
943 screenBlackList = castScreenBlackLists_;
944 }
945
SetCastScreenBlackList(std::unordered_set<uint64_t> & screenBlackList)946 void RSScreenManager::SetCastScreenBlackList(std::unordered_set<uint64_t>& screenBlackList)
947 {
948 std::lock_guard<std::mutex> lock(blackListMutex_);
949 castScreenBlackLists_ = screenBlackList;
950 }
951
SetVirtualScreenBlackList(ScreenId id,const std::vector<uint64_t> & blackList)952 int32_t RSScreenManager::SetVirtualScreenBlackList(ScreenId id, const std::vector<uint64_t>& blackList)
953 {
954 std::unordered_set<NodeId> screenBlackList(blackList.begin(), blackList.end());
955 if (id == INVALID_SCREEN_ID) {
956 RS_LOGD("RSScreenManager %{public}s: CastScreenBlackLists.", __func__);
957 SetCastScreenBlackList(screenBlackList);
958 return SUCCESS;
959 }
960 std::lock_guard<std::mutex> lock(mutex_);
961 auto virtualScreen = screens_.find(id);
962 if (virtualScreen == screens_.end()) {
963 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
964 return SCREEN_NOT_FOUND;
965 } else {
966 if (virtualScreen->second != nullptr) {
967 virtualScreen->second->SetBlackList(screenBlackList);
968 } else {
969 RS_LOGW("RSScreenManager %{public}s: Null screen for id %{public}" PRIu64 ".", __func__, id);
970 return SCREEN_NOT_FOUND;
971 }
972 }
973 ScreenId mainId = GetDefaultScreenId();
974 if (mainId != id) {
975 auto mainScreen = screens_.find(mainId);
976 if (mainScreen == screens_.end()) {
977 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, mainId);
978 return SCREEN_NOT_FOUND;
979 } else {
980 if (mainScreen->second != nullptr) {
981 mainScreen->second->SetBlackList(screenBlackList);
982 } else {
983 RS_LOGW("RSScreenManager %{public}s: Null screen for id %{public}" PRIu64 ".", __func__, mainId);
984 return SCREEN_NOT_FOUND;
985 }
986 }
987 }
988 return SUCCESS;
989 }
990
AddVirtualScreenBlackList(ScreenId id,const std::vector<uint64_t> & blackList)991 int32_t RSScreenManager::AddVirtualScreenBlackList(ScreenId id, const std::vector<uint64_t>& blackList)
992 {
993 std::lock_guard<std::mutex> lock(mutex_);
994 if (id == INVALID_SCREEN_ID) {
995 RS_LOGI("RSScreenManager %{public}s: Cast screen blacklists", __func__);
996 for (auto& list : blackList) {
997 castScreenBlackLists_.emplace(list);
998 }
999 return SUCCESS;
1000 }
1001 auto virtualScreen = screens_.find(id);
1002 if (virtualScreen == screens_.end() || virtualScreen->second == nullptr) {
1003 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
1004 return SCREEN_NOT_FOUND;
1005 }
1006 RS_LOGI("RSScreenManager %{public}s: Record screen blacklists for id %{public}" PRIu64 ".", __func__, id);
1007 virtualScreen->second->AddBlackList(blackList);
1008
1009 ScreenId mainId = GetDefaultScreenId();
1010 if (mainId != id) {
1011 auto mainScreen = screens_.find(mainId);
1012 if (mainScreen == screens_.end() || mainScreen->second == nullptr) {
1013 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, mainId);
1014 return SCREEN_NOT_FOUND;
1015 }
1016 mainScreen->second->AddBlackList(blackList);
1017 }
1018 return SUCCESS;
1019 }
1020
RemoveVirtualScreenBlackList(ScreenId id,const std::vector<uint64_t> & blackList)1021 int32_t RSScreenManager::RemoveVirtualScreenBlackList(ScreenId id, const std::vector<uint64_t>& blackList)
1022 {
1023 std::lock_guard<std::mutex> lock(mutex_);
1024 if (id == INVALID_SCREEN_ID) {
1025 RS_LOGI("RSScreenManager %{public}s: Cast screen blacklists", __func__);
1026 for (auto& list : blackList) {
1027 auto it = castScreenBlackLists_.find(list);
1028 if (it == castScreenBlackLists_.end()) {
1029 continue;
1030 }
1031 castScreenBlackLists_.erase(it);
1032 }
1033 return SUCCESS;
1034 }
1035 auto virtualScreen = screens_.find(id);
1036 if (virtualScreen == screens_.end() || virtualScreen->second == nullptr) {
1037 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
1038 return SCREEN_NOT_FOUND;
1039 }
1040 RS_LOGI("RSScreenManager %{public}s: Record screen blacklists for id %{public}" PRIu64 ".", __func__, id);
1041 virtualScreen->second->RemoveBlackList(blackList);
1042
1043 ScreenId mainId = GetDefaultScreenId();
1044 if (mainId != id) {
1045 auto mainScreen = screens_.find(mainId);
1046 if (mainScreen == screens_.end() || mainScreen->second == nullptr) {
1047 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, mainId);
1048 return SCREEN_NOT_FOUND;
1049 }
1050 mainScreen->second->RemoveBlackList(blackList);
1051 }
1052 return SUCCESS;
1053 }
1054
SetVirtualScreenSecurityExemptionList(ScreenId id,const std::vector<uint64_t> & securityExemptionList)1055 int32_t RSScreenManager::SetVirtualScreenSecurityExemptionList(
1056 ScreenId id,
1057 const std::vector<uint64_t>& securityExemptionList)
1058 {
1059 if (id == INVALID_SCREEN_ID) {
1060 RS_LOGD("RSScreenManager %{public}s: INVALID_SCREEN_ID.", __func__);
1061 return INVALID_ARGUMENTS;
1062 }
1063 std::lock_guard<std::mutex> lock(mutex_);
1064 auto virtualScreen = screens_.find(id);
1065 if (virtualScreen == screens_.end()) {
1066 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
1067 return SCREEN_NOT_FOUND;
1068 }
1069
1070 if (virtualScreen->second == nullptr) {
1071 RS_LOGW("RSScreenManager %{public}s: Null screen for id %{public}" PRIu64 ".", __func__, id);
1072 return SCREEN_NOT_FOUND;
1073 }
1074 if (!(virtualScreen->second->IsVirtual())) {
1075 RS_LOGW("RSScreenManager %{public}s: not virtual screen for id %{public}" PRIu64 ".", __func__, id);
1076 return INVALID_ARGUMENTS;
1077 }
1078 virtualScreen->second->SetSecurityExemptionList(securityExemptionList);
1079 for (const auto& exemption : securityExemptionList) {
1080 RS_LOGD("RSScreenManager %{public}s: virtual screen(id %{public}" PRIu64 "), nodeId %{public}" PRIu64 ".",
1081 __func__, id, exemption);
1082 }
1083 return SUCCESS;
1084 }
1085
GetVirtualScreenSecurityExemptionList(ScreenId id) const1086 const std::vector<uint64_t> RSScreenManager::GetVirtualScreenSecurityExemptionList(ScreenId id) const
1087 {
1088 std::lock_guard<std::mutex> lock(mutex_);
1089 auto virtualScreen = screens_.find(id);
1090 if (virtualScreen == screens_.end()) {
1091 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
1092 return {};
1093 }
1094
1095 if (virtualScreen->second == nullptr) {
1096 RS_LOGW("RSScreenManager %{public}s: Null screen for id %{public}" PRIu64 ".", __func__, id);
1097 return {};
1098 }
1099 return virtualScreen->second->GetSecurityExemptionList();
1100 }
1101
SetCastScreenEnableSkipWindow(ScreenId id,bool enable)1102 int32_t RSScreenManager::SetCastScreenEnableSkipWindow(ScreenId id, bool enable)
1103 {
1104 std::lock_guard<std::mutex> lock(mutex_);
1105 auto virtualScreen = screens_.find(id);
1106 if (virtualScreen == screens_.end()) {
1107 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
1108 return SCREEN_NOT_FOUND;
1109 } else {
1110 if (virtualScreen->second != nullptr) {
1111 virtualScreen->second->SetCastScreenEnableSkipWindow(enable);
1112 return SUCCESS;
1113 } else {
1114 RS_LOGW("RSScreenManager %{public}s: Null screen for id %{public}" PRIu64 ".", __func__, id);
1115 return SCREEN_NOT_FOUND;
1116 }
1117 }
1118 }
1119
GetCastScreenEnableSkipWindow(ScreenId id)1120 bool RSScreenManager::GetCastScreenEnableSkipWindow(ScreenId id)
1121 {
1122 std::lock_guard<std::mutex> lock(mutex_);
1123 auto virtualScreen = screens_.find(id);
1124 if (virtualScreen == screens_.end()) {
1125 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
1126 return false;
1127 } else {
1128 if (virtualScreen->second != nullptr) {
1129 return virtualScreen->second->GetCastScreenEnableSkipWindow();
1130 } else {
1131 RS_LOGW("RSScreenManager %{public}s: Null screen for id %{public}" PRIu64 ".", __func__, id);
1132 return false;
1133 }
1134 }
1135 }
1136
GetVirtualScreenBlackList(ScreenId id)1137 std::unordered_set<NodeId> RSScreenManager::GetVirtualScreenBlackList(ScreenId id)
1138 {
1139 std::lock_guard<std::mutex> lock(mutex_);
1140 auto virtualScreen = screens_.find(id);
1141 if (virtualScreen == screens_.end()) {
1142 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
1143 return {};
1144 } else {
1145 if (virtualScreen->second != nullptr) {
1146 return virtualScreen->second->GetBlackList();
1147 } else {
1148 RS_LOGW("RSScreenManager %{public}s: Null screen for id %{public}" PRIu64 ".", __func__, id);
1149 return {};
1150 }
1151 }
1152 }
1153
SetVirtualScreenSurface(ScreenId id,sptr<Surface> surface)1154 int32_t RSScreenManager::SetVirtualScreenSurface(ScreenId id, sptr<Surface> surface)
1155 {
1156 std::lock_guard<std::mutex> lock(mutex_);
1157 auto screensIt = screens_.find(id);
1158 if (screensIt == screens_.end() || screensIt->second == nullptr || surface == nullptr) {
1159 return SCREEN_NOT_FOUND;
1160 }
1161 uint64_t surfaceId = surface->GetUniqueId();
1162 for (auto &[screenId, screen] : screens_) {
1163 if (screen == nullptr) {
1164 RS_LOGW("SetVirtualScreenSurface:screen %{public}" PRIu64 " not found", screenId);
1165 continue;
1166 }
1167 if (!screen->IsVirtual() || screenId == id) {
1168 continue;
1169 }
1170 auto screenSurface = screen->GetProducerSurface();
1171 if (screenSurface == nullptr) {
1172 continue;
1173 }
1174 if (screenSurface->GetUniqueId() == surface->GetUniqueId()) {
1175 RS_LOGE("RSScreenManager %{public}s: surface %{public}" PRIu64 " is used, set surface failed!",
1176 __func__, surfaceId);
1177 return SURFACE_NOT_UNIQUE;
1178 }
1179 }
1180 screensIt->second->SetProducerSurface(surface);
1181 RS_LOGD("RSScreenManager %{public}s: set virtual screen surface success!", __func__);
1182 RS_OPTIONAL_TRACE_NAME("RSScreenManager::SetVirtualScreenSurface, ForceRefreshOneFrame.");
1183 ForceRefreshOneFrame();
1184 return SUCCESS;
1185 }
1186
GetAndResetVirtualSurfaceUpdateFlag(ScreenId id) const1187 bool RSScreenManager::GetAndResetVirtualSurfaceUpdateFlag(ScreenId id) const
1188 {
1189 std::lock_guard<std::mutex> lock(mutex_);
1190 auto virtualScreen = screens_.find(id);
1191 if (virtualScreen == screens_.end()) {
1192 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
1193 return false;
1194 }
1195 if (virtualScreen->second != nullptr) {
1196 return virtualScreen->second->GetAndResetVirtualSurfaceUpdateFlag();
1197 } else {
1198 RS_LOGW("RSScreenManager %{public}s: Null screen for id %{public}" PRIu64 ".", __func__, id);
1199 return false;
1200 }
1201 }
1202
RemoveVirtualScreen(ScreenId id)1203 void RSScreenManager::RemoveVirtualScreen(ScreenId id)
1204 {
1205 std::lock_guard<std::mutex> lock(mutex_);
1206
1207 RemoveVirtualScreenLocked(id);
1208 }
1209
RemoveVirtualScreenLocked(ScreenId id)1210 void RSScreenManager::RemoveVirtualScreenLocked(ScreenId id)
1211 {
1212 auto screensIt = screens_.find(id);
1213 if (screensIt == screens_.end()) {
1214 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
1215 return;
1216 }
1217
1218 screens_.erase(screensIt);
1219 --currentVirtualScreenNum_;
1220
1221 // Update other screens' mirrorId.
1222 for (auto &[id, screen] : screens_) {
1223 if (screen == nullptr) {
1224 RS_LOGW("RemoveVirtualScreenLocked:screen %{public}" PRIu64 " not found", id);
1225 continue;
1226 }
1227 if (screen->MirrorId() == id) {
1228 screen->SetMirror(INVALID_SCREEN_ID);
1229 }
1230 }
1231 RS_LOGD("RSScreenManager %{public}s: remove virtual screen(id %{public}" PRIu64 ").", __func__, id);
1232
1233 ReuseVirtualScreenIdLocked(id);
1234
1235 disableRenderControlScreens_.erase(id);
1236 }
1237
SetScreenActiveMode(ScreenId id,uint32_t modeId)1238 void RSScreenManager::SetScreenActiveMode(ScreenId id, uint32_t modeId)
1239 {
1240 std::lock_guard<std::mutex> lock(mutex_);
1241
1242 auto screensIt = screens_.find(id);
1243 if (screensIt == screens_.end() || screensIt->second == nullptr) {
1244 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
1245 return;
1246 }
1247 screensIt->second->SetActiveMode(modeId);
1248 }
1249
SetVirtualScreenResolution(ScreenId id,uint32_t width,uint32_t height)1250 int32_t RSScreenManager::SetVirtualScreenResolution(ScreenId id, uint32_t width, uint32_t height)
1251 {
1252 std::lock_guard<std::mutex> lock(mutex_);
1253
1254 if (width > MAX_VIRTUAL_SCREEN_WIDTH || height > MAX_VIRTUAL_SCREEN_HEIGHT) {
1255 RS_LOGW("RSScreenManager %{public}s: width %{public}" PRIu32" or height %{public}" PRIu32" has reached"
1256 " the maximum limit!", __func__, width, height);
1257 return INVALID_ARGUMENTS;
1258 }
1259 auto screensIt = screens_.find(id);
1260 if (screensIt == screens_.end() || screensIt->second == nullptr) {
1261 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
1262 return SCREEN_NOT_FOUND;
1263 }
1264 screensIt->second->SetResolution(width, height);
1265 RS_LOGD("RSScreenManager %{public}s: set virtual screen resolution success", __func__);
1266 RS_OPTIONAL_TRACE_NAME("RSScreenManager::SetVirtualScreenResolution, ForceRefreshOneFrame.");
1267 ForceRefreshOneFrame();
1268 return SUCCESS;
1269 }
1270
SetRogScreenResolution(ScreenId id,uint32_t width,uint32_t height)1271 int32_t RSScreenManager::SetRogScreenResolution(ScreenId id, uint32_t width, uint32_t height)
1272 {
1273 std::lock_guard<std::mutex> lock(mutex_);
1274
1275 auto screensIt = screens_.find(id);
1276 if (screensIt == screens_.end() || screensIt->second == nullptr) {
1277 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
1278 return SCREEN_NOT_FOUND;
1279 }
1280 screensIt->second->SetRogResolution(width, height);
1281 return SUCCESS;
1282 }
1283
SetScreenPowerStatus(ScreenId id,ScreenPowerStatus status)1284 void RSScreenManager::SetScreenPowerStatus(ScreenId id, ScreenPowerStatus status)
1285 {
1286 std::lock_guard<std::mutex> lock(mutex_);
1287
1288 auto screensIt = screens_.find(id);
1289 if (screensIt == screens_.end() || screensIt->second == nullptr) {
1290 RS_LOGW("[UL_POWER]RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
1291 return;
1292 }
1293 screensIt->second->SetPowerStatus(static_cast<uint32_t>(status));
1294
1295 /*
1296 * If app adds the first frame when power on the screen, delete the code
1297 */
1298 if (status == ScreenPowerStatus::POWER_STATUS_ON ||
1299 status == ScreenPowerStatus::POWER_STATUS_ON_ADVANCED) {
1300 auto mainThread = RSMainThread::Instance();
1301 if (mainThread == nullptr) {
1302 return;
1303 }
1304 mainThread->PostTask([mainThread]() {
1305 mainThread->SetDirtyFlag();
1306 mainThread->SetScreenPowerOnChanged(true);
1307 });
1308 if (screenPowerStatus_.count(id) == 0 ||
1309 screenPowerStatus_[id] == ScreenPowerStatus::POWER_STATUS_OFF ||
1310 screenPowerStatus_[id] == ScreenPowerStatus::POWER_STATUS_OFF_FAKE ||
1311 screenPowerStatus_[id] == ScreenPowerStatus::POWER_STATUS_OFF_ADVANCED) {
1312 mainThread->ForceRefreshForUni();
1313 } else {
1314 mainThread->RequestNextVSync();
1315 }
1316
1317 RS_LOGD("[UL_POWER]RSScreenManager %{public}s: PowerStatus %{public}d, request a frame", __func__, status);
1318 }
1319 screenPowerStatus_[id] = status;
1320 }
1321
SetVirtualMirrorScreenCanvasRotation(ScreenId id,bool canvasRotation)1322 bool RSScreenManager::SetVirtualMirrorScreenCanvasRotation(ScreenId id, bool canvasRotation)
1323 {
1324 std::lock_guard<std::mutex> lock(mutex_);
1325
1326 auto screensIt = screens_.find(id);
1327 if (screensIt == screens_.end() || screensIt->second == nullptr) {
1328 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
1329 return false;
1330 }
1331
1332 RS_LOGD("RSScreenManager %{public}s: canvasRotation: %{public}d", __func__, canvasRotation);
1333
1334 return screensIt->second->SetVirtualMirrorScreenCanvasRotation(canvasRotation);
1335 }
1336
SetVirtualMirrorScreenScaleMode(ScreenId id,ScreenScaleMode scaleMode)1337 bool RSScreenManager::SetVirtualMirrorScreenScaleMode(ScreenId id, ScreenScaleMode scaleMode)
1338 {
1339 std::lock_guard<std::mutex> lock(mutex_);
1340
1341 auto screensIt = screens_.find(id);
1342 if (screensIt == screens_.end() || screensIt->second == nullptr) {
1343 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
1344 return false;
1345 }
1346
1347 RS_LOGD("RSScreenManager %{public}s: scaleMode: %{public}d", __func__, scaleMode);
1348
1349 return screensIt->second->SetVirtualMirrorScreenScaleMode(scaleMode);
1350 }
1351
GetVirtualScreenResolution(ScreenId id,RSVirtualScreenResolution & virtualScreenResolution) const1352 void RSScreenManager::GetVirtualScreenResolution(ScreenId id, RSVirtualScreenResolution& virtualScreenResolution) const
1353 {
1354 std::lock_guard<std::mutex> lock(mutex_);
1355
1356 GetVirtualScreenResolutionLocked(id, virtualScreenResolution);
1357 }
1358
GetScreenActiveMode(ScreenId id,RSScreenModeInfo & screenModeInfo) const1359 void RSScreenManager::GetScreenActiveMode(ScreenId id, RSScreenModeInfo& screenModeInfo) const
1360 {
1361 std::lock_guard<std::mutex> lock(mutex_);
1362
1363 GetScreenActiveModeLocked(id, screenModeInfo);
1364 }
1365
GetScreenSupportedModes(ScreenId id) const1366 std::vector<RSScreenModeInfo> RSScreenManager::GetScreenSupportedModes(ScreenId id) const
1367 {
1368 std::lock_guard<std::mutex> lock(mutex_);
1369
1370 return GetScreenSupportedModesLocked(id);
1371 }
1372
GetScreenCapability(ScreenId id) const1373 RSScreenCapability RSScreenManager::GetScreenCapability(ScreenId id) const
1374 {
1375 std::lock_guard<std::mutex> lock(mutex_);
1376
1377 return GetScreenCapabilityLocked(id);
1378 }
1379
GetScreenPowerStatus(ScreenId id) const1380 ScreenPowerStatus RSScreenManager::GetScreenPowerStatus(ScreenId id) const
1381 {
1382 std::lock_guard<std::mutex> lock(mutex_);
1383
1384 return GetScreenPowerStatusLocked(id);
1385 }
1386
GetScreenCorrection(ScreenId id) const1387 ScreenRotation RSScreenManager::GetScreenCorrection(ScreenId id) const
1388 {
1389 std::lock_guard<std::mutex> lock(mutex_);
1390
1391 return GetScreenCorrectionLocked(id);
1392 }
1393
GetScreenData(ScreenId id) const1394 RSScreenData RSScreenManager::GetScreenData(ScreenId id) const
1395 {
1396 std::lock_guard<std::mutex> lock(mutex_);
1397 RSScreenData screenData;
1398 if (screens_.count(id) == 0) {
1399 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
1400 return screenData;
1401 }
1402 RSScreenCapability capability = GetScreenCapabilityLocked(id);
1403 RSScreenModeInfo activeMode;
1404 GetScreenActiveModeLocked(id, activeMode);
1405 std::vector<RSScreenModeInfo> supportModes = GetScreenSupportedModesLocked(id);
1406 ScreenPowerStatus powerStatus = GetScreenPowerStatusLocked(id);
1407 screenData.SetCapability(capability);
1408 screenData.SetActivityModeInfo(activeMode);
1409 screenData.SetSupportModeInfo(supportModes);
1410 screenData.SetPowerStatus(powerStatus);
1411 return screenData;
1412 }
1413
ResizeVirtualScreen(ScreenId id,uint32_t width,uint32_t height)1414 int32_t RSScreenManager::ResizeVirtualScreen(ScreenId id, uint32_t width, uint32_t height)
1415 {
1416 std::lock_guard<std::mutex> lock(mutex_);
1417
1418 if (width > MAX_VIRTUAL_SCREEN_WIDTH || height > MAX_VIRTUAL_SCREEN_HEIGHT) {
1419 RS_LOGW("RSScreenManager %{public}s: width %{public}" PRIu32" or height %{public}" PRIu32" has reached"
1420 " the maximum limit!", __func__, width, height);
1421 return INVALID_ARGUMENTS;
1422 }
1423 auto screensIt = screens_.find(id);
1424 if (screensIt == screens_.end() || screensIt->second == nullptr) {
1425 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
1426 return SCREEN_NOT_FOUND;
1427 }
1428 screensIt->second->ResizeVirtualScreen(width, height);
1429 RS_LOGI("RSScreenManager %{public}s: resize virtual screen success, width:%{public}u, height:%{public}u",
1430 __func__, width, height);
1431
1432 return SUCCESS;
1433 }
1434
GetScreenBacklight(ScreenId id) const1435 int32_t RSScreenManager::GetScreenBacklight(ScreenId id) const
1436 {
1437 return GetScreenBacklightLocked(id);
1438 }
1439
GetScreenBacklightLocked(ScreenId id) const1440 int32_t RSScreenManager::GetScreenBacklightLocked(ScreenId id) const
1441 {
1442 std::shared_ptr<OHOS::Rosen::RSScreen> screen = nullptr;
1443 {
1444 std::lock_guard<std::mutex> lock(mutex_);
1445 auto screensIt = screens_.find(id);
1446 if (screensIt == screens_.end() || screensIt->second == nullptr) {
1447 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
1448 return INVALID_BACKLIGHT_VALUE;
1449 }
1450 screen = screensIt->second;
1451 }
1452 int32_t level = screen->GetScreenBacklight();
1453 return level;
1454 }
1455
SetScreenBacklight(ScreenId id,uint32_t level)1456 void RSScreenManager::SetScreenBacklight(ScreenId id, uint32_t level)
1457 {
1458 std::shared_ptr<OHOS::Rosen::RSScreen> screen = nullptr;
1459 {
1460 std::lock_guard<std::mutex> lock(mutex_);
1461 auto screensIt = screens_.find(id);
1462 if (screensIt == screens_.end() || screensIt->second == nullptr) {
1463 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
1464 return;
1465 }
1466 screenBacklight_[id] = level;
1467 screen = screensIt->second;
1468 }
1469 screen->SetScreenBacklight(level);
1470 }
1471
QueryDefaultScreenInfo() const1472 ScreenInfo RSScreenManager::QueryDefaultScreenInfo() const
1473 {
1474 std::lock_guard<std::mutex> lock(mutex_);
1475 return QueryScreenInfoLocked(defaultScreenId_);
1476 }
1477
QueryScreenInfo(ScreenId id) const1478 ScreenInfo RSScreenManager::QueryScreenInfo(ScreenId id) const
1479 {
1480 std::lock_guard<std::mutex> lock(mutex_);
1481 return QueryScreenInfoLocked(id);
1482 }
1483
QueryScreenInfoLocked(ScreenId id) const1484 ScreenInfo RSScreenManager::QueryScreenInfoLocked(ScreenId id) const
1485 {
1486 ScreenInfo info;
1487 auto screensIt = screens_.find(id);
1488 if (screensIt == screens_.end()) {
1489 RS_LOGD("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
1490 return info;
1491 }
1492
1493 const auto &screen = screensIt->second;
1494 if (!screen) {
1495 RS_LOGE("RSScreenManager::QueryScreenInfo screen %{public}" PRIu64 " has no info.", id);
1496 return info;
1497 }
1498 info.id = id;
1499 info.width = screen->Width();
1500 info.height = screen->Height();
1501 info.phyWidth = screen->PhyWidth() ? screen->PhyWidth() : screen->Width();
1502 info.phyHeight = screen->PhyHeight() ? screen->PhyHeight() : screen->Height();
1503 auto ret = screen->GetScreenColorGamut(info.colorGamut);
1504 if (ret != StatusCode::SUCCESS) {
1505 info.colorGamut = COLOR_GAMUT_SRGB;
1506 }
1507
1508 if (!screen->IsEnable()) {
1509 info.state = ScreenState::DISABLED;
1510 } else if (!screen->IsVirtual()) {
1511 info.state = ScreenState::HDI_OUTPUT_ENABLE;
1512 } else {
1513 info.state = ScreenState::SOFTWARE_OUTPUT_ENABLE;
1514 }
1515 info.skipFrameInterval = screen->GetScreenSkipFrameInterval();
1516 screen->GetPixelFormat(info.pixelFormat);
1517 screen->GetScreenHDRFormat(info.hdrFormat);
1518 info.whiteList = screen->GetWhiteList();
1519 return info;
1520 }
1521
GetCanvasRotation(ScreenId id) const1522 bool RSScreenManager::GetCanvasRotation(ScreenId id) const
1523 {
1524 std::lock_guard<std::mutex> lock(mutex_);
1525
1526 auto screensIt = screens_.find(id);
1527 if (screensIt == screens_.end() || screensIt->second == nullptr) {
1528 RS_LOGD("RSScreenManager::GetCanvasRotation: There is no screen for id %{public}" PRIu64 ".", id);
1529 return false;
1530 }
1531 return screensIt->second->GetCanvasRotation();
1532 }
1533
GetScaleMode(ScreenId id) const1534 ScreenScaleMode RSScreenManager::GetScaleMode(ScreenId id) const
1535 {
1536 std::lock_guard<std::mutex> lock(mutex_);
1537
1538 auto screensIt = screens_.find(id);
1539 if (screensIt == screens_.end() || screensIt->second == nullptr) {
1540 RS_LOGD("RSScreenManager::GetScaleMode: There is no screen for id %{public}" PRIu64 ".", id);
1541 return ScreenScaleMode::INVALID_MODE;
1542 }
1543 auto scaleModeDFX = static_cast<ScreenScaleMode>(
1544 RSSystemProperties::GetVirtualScreenScaleModeDFX());
1545 // Support mode can be configured for maintenance and testing before
1546 // upper layer application adaptation
1547 const auto& scaleMode = (scaleModeDFX == ScreenScaleMode::INVALID_MODE) ?
1548 screensIt->second->GetScaleMode() : scaleModeDFX;
1549 return scaleMode;
1550 }
1551
GetProducerSurface(ScreenId id) const1552 sptr<Surface> RSScreenManager::GetProducerSurface(ScreenId id) const
1553 {
1554 std::lock_guard<std::mutex> lock(mutex_);
1555
1556 auto screensIt = screens_.find(id);
1557 if (screensIt == screens_.end() || screensIt->second == nullptr) {
1558 RS_LOGD("RSScreenManager::GetProducerSurface: There is no screen for id %{public}" PRIu64 ".", id);
1559 return nullptr;
1560 }
1561 return screensIt->second->GetProducerSurface();
1562 }
1563
GetOutput(ScreenId id) const1564 std::shared_ptr<HdiOutput> RSScreenManager::GetOutput(ScreenId id) const
1565 {
1566 std::lock_guard<std::mutex> lock(mutex_);
1567
1568 auto screensIt = screens_.find(id);
1569 if (screensIt == screens_.end() || screensIt->second == nullptr) {
1570 RS_LOGW("RSScreenManager::GetOutput: There is no screen for id %{public}" PRIu64 ".", id);
1571 return nullptr;
1572 }
1573 return screensIt->second->GetOutput();
1574 }
1575
AddScreenChangeCallback(const sptr<RSIScreenChangeCallback> & callback)1576 int32_t RSScreenManager::AddScreenChangeCallback(const sptr<RSIScreenChangeCallback> &callback)
1577 {
1578 if (callback == nullptr) {
1579 RS_LOGE("RSScreenManager %{public}s: callback is NULL.", __func__);
1580 return INVALID_ARGUMENTS;
1581 }
1582
1583 std::lock_guard<std::mutex> lock(mutex_);
1584 // when the callback first registered, maybe there were some physical screens already connected,
1585 // so notify to remote immediately.
1586 for (const auto &[id, screen] : screens_) {
1587 if (screen == nullptr) {
1588 RS_LOGW("AddScreenChangeCallback:screen %{public}" PRIu64 " not found", id);
1589 continue;
1590 }
1591 if (!screen->IsVirtual()) {
1592 callback->OnScreenChanged(id, ScreenEvent::CONNECTED);
1593 }
1594 }
1595 screenChangeCallbacks_.push_back(callback);
1596 RS_LOGD("RSScreenManager %{public}s: add a remote callback succeed.", __func__);
1597 return SUCCESS;
1598 }
1599
RemoveScreenChangeCallback(const sptr<RSIScreenChangeCallback> & callback)1600 void RSScreenManager::RemoveScreenChangeCallback(const sptr<RSIScreenChangeCallback> &callback)
1601 {
1602 std::lock_guard<std::mutex> lock(mutex_);
1603 for (auto it = screenChangeCallbacks_.begin(); it != screenChangeCallbacks_.end(); it++) {
1604 if (*it == callback) {
1605 screenChangeCallbacks_.erase(it);
1606 RS_LOGD("RSScreenManager %{public}s: remove a remote callback succeed.", __func__);
1607 break;
1608 }
1609 }
1610 }
1611
DisplayDump(std::string & dumpString)1612 void RSScreenManager::DisplayDump(std::string& dumpString)
1613 {
1614 std::lock_guard<std::mutex> lock(mutex_);
1615 int32_t index = 0;
1616 for (const auto &[id, screen] : screens_) {
1617 if (screen == nullptr) {
1618 continue;
1619 }
1620 screen->DisplayDump(index, dumpString);
1621 index++;
1622 }
1623 }
1624
SurfaceDump(std::string & dumpString)1625 void RSScreenManager::SurfaceDump(std::string& dumpString)
1626 {
1627 std::lock_guard<std::mutex> lock(mutex_);
1628 int32_t index = 0;
1629 for (const auto &[id, screen] : screens_) {
1630 if (screen == nullptr) {
1631 continue;
1632 }
1633 screen->SurfaceDump(index, dumpString);
1634 index++;
1635 }
1636 }
1637
FpsDump(std::string & dumpString,std::string & arg)1638 void RSScreenManager::FpsDump(std::string& dumpString, std::string& arg)
1639 {
1640 std::lock_guard<std::mutex> lock(mutex_);
1641 int32_t index = 0;
1642 dumpString += "\n-- The recently fps records info of screens:\n";
1643 for (const auto &[id, screen] : screens_) {
1644 if (screen == nullptr) {
1645 continue;
1646 }
1647 screen->FpsDump(index, dumpString, arg);
1648 index++;
1649 }
1650 }
1651
ClearFpsDump(std::string & dumpString,std::string & arg)1652 void RSScreenManager::ClearFpsDump(std::string& dumpString, std::string& arg)
1653 {
1654 std::lock_guard<std::mutex> lock(mutex_);
1655 int32_t index = 0;
1656 dumpString += "\n-- Clear fps records info of screens:\n";
1657 for (const auto &[id, screen] : screens_) {
1658 if (screen == nullptr) {
1659 RS_LOGW("ClearFpsDump:screen %{public}" PRIu64 " not found", id);
1660 continue;
1661 }
1662 screen->ClearFpsDump(index, dumpString, arg);
1663 index++;
1664 }
1665 }
1666
ClearFrameBufferIfNeed()1667 void RSScreenManager::ClearFrameBufferIfNeed()
1668 {
1669 RSHardwareThread::Instance().PostTask([this]() {
1670 std::lock_guard<std::mutex> lock(mutex_);
1671 for (const auto& [id, screen] : screens_) {
1672 if (!screen || !screen->GetOutput()) {
1673 continue;
1674 }
1675 if (screen->GetOutput()->GetBufferCacheSize() > 0) {
1676 RSHardwareThread::Instance().ClearFrameBuffers(screen->GetOutput());
1677 }
1678 }
1679 });
1680 }
1681
SetScreenConstraint(ScreenId id,uint64_t timestamp,ScreenConstraintType type)1682 int32_t RSScreenManager::SetScreenConstraint(ScreenId id, uint64_t timestamp, ScreenConstraintType type)
1683 {
1684 frameId_++;
1685 auto screensIt = screens_.find(id);
1686 if (screensIt == screens_.end() || screensIt->second == nullptr) {
1687 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
1688 return StatusCode::SCREEN_NOT_FOUND;
1689 }
1690 RS_TRACE_NAME_FMT("SetScreenConstraint frameId:%lu timestamp:%lu type:%d", frameId_, timestamp, type);
1691 return screensIt->second->SetScreenConstraint(frameId_, timestamp, type);
1692 }
1693
HitchsDump(std::string & dumpString,std::string & arg)1694 void RSScreenManager::HitchsDump(std::string& dumpString, std::string& arg)
1695 {
1696 std::lock_guard<std::mutex> lock(mutex_);
1697 int32_t index = 0;
1698 dumpString += "\n-- The recently window hitchs records info of screens:\n";
1699 for (const auto &[id, screen] : screens_) {
1700 if (screen == nullptr) {
1701 continue;
1702 }
1703 screen->HitchsDump(index, dumpString, arg);
1704 index++;
1705 }
1706 }
1707
GetScreenSupportedColorGamutsLocked(ScreenId id,std::vector<ScreenColorGamut> & mode) const1708 int32_t RSScreenManager::GetScreenSupportedColorGamutsLocked(ScreenId id, std::vector<ScreenColorGamut>& mode) const
1709 {
1710 auto screensIt = screens_.find(id);
1711 if (screensIt == screens_.end() || screensIt->second == nullptr) {
1712 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
1713 return StatusCode::SCREEN_NOT_FOUND;
1714 }
1715 return screensIt->second->GetScreenSupportedColorGamuts(mode);
1716 }
1717
GetScreenSupportedMetaDataKeysLocked(ScreenId id,std::vector<ScreenHDRMetadataKey> & keys) const1718 int32_t RSScreenManager::GetScreenSupportedMetaDataKeysLocked(
1719 ScreenId id, std::vector<ScreenHDRMetadataKey>& keys) const
1720 {
1721 auto screensIt = screens_.find(id);
1722 if (screensIt == screens_.end() || screensIt->second == nullptr) {
1723 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
1724 return StatusCode::SCREEN_NOT_FOUND;
1725 }
1726 return screensIt->second->GetScreenSupportedMetaDataKeys(keys);
1727 }
1728
GetScreenColorGamutLocked(ScreenId id,ScreenColorGamut & mode) const1729 int32_t RSScreenManager::GetScreenColorGamutLocked(ScreenId id, ScreenColorGamut& mode) const
1730 {
1731 auto screensIt = screens_.find(id);
1732 if (screensIt == screens_.end() || screensIt->second == nullptr) {
1733 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
1734 return StatusCode::SCREEN_NOT_FOUND;
1735 }
1736 return screensIt->second->GetScreenColorGamut(mode);
1737 }
1738
SetScreenColorGamutLocked(ScreenId id,int32_t modeIdx)1739 int32_t RSScreenManager::SetScreenColorGamutLocked(ScreenId id, int32_t modeIdx)
1740 {
1741 auto screensIt = screens_.find(id);
1742 if (screensIt == screens_.end() || screensIt->second == nullptr) {
1743 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
1744 return StatusCode::SCREEN_NOT_FOUND;
1745 }
1746 return screensIt->second->SetScreenColorGamut(modeIdx);
1747 }
1748
SetScreenGamutMapLocked(ScreenId id,ScreenGamutMap mode)1749 int32_t RSScreenManager::SetScreenGamutMapLocked(ScreenId id, ScreenGamutMap mode)
1750 {
1751 auto screensIt = screens_.find(id);
1752 if (screensIt == screens_.end() || screensIt->second == nullptr) {
1753 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
1754 return StatusCode::SCREEN_NOT_FOUND;
1755 }
1756 RS_OPTIONAL_TRACE_NAME("RSScreenManager::SetScreenGamutMapLocked, ForceRefreshOneFrame.");
1757 ForceRefreshOneFrame();
1758 return screensIt->second->SetScreenGamutMap(mode);
1759 }
1760
SetScreenCorrectionLocked(ScreenId id,ScreenRotation screenRotation)1761 int32_t RSScreenManager::SetScreenCorrectionLocked(ScreenId id, ScreenRotation screenRotation)
1762 {
1763 auto screensIt = screens_.find(id);
1764 if (screensIt == screens_.end() || screensIt->second == nullptr) {
1765 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
1766 return StatusCode::SCREEN_NOT_FOUND;
1767 }
1768 screensIt->second->SetScreenCorrection(screenRotation);
1769 screenCorrection_[id] = screenRotation;
1770 return StatusCode::SUCCESS;
1771 }
1772
GetScreenGamutMapLocked(ScreenId id,ScreenGamutMap & mode) const1773 int32_t RSScreenManager::GetScreenGamutMapLocked(ScreenId id, ScreenGamutMap &mode) const
1774 {
1775 auto screensIt = screens_.find(id);
1776 if (screensIt == screens_.end() || screensIt->second == nullptr) {
1777 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
1778 return StatusCode::SCREEN_NOT_FOUND;
1779 }
1780 return screensIt->second->GetScreenGamutMap(mode);
1781 }
1782
GetScreenHDRCapabilityLocked(ScreenId id,RSScreenHDRCapability & screenHdrCapability) const1783 int32_t RSScreenManager::GetScreenHDRCapabilityLocked(ScreenId id, RSScreenHDRCapability& screenHdrCapability) const
1784 {
1785 auto screensIt = screens_.find(id);
1786 if (screensIt == screens_.end() || screensIt->second == nullptr) {
1787 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
1788 return StatusCode::SCREEN_NOT_FOUND;
1789 }
1790 GraphicHDRCapability hdrCapability = screensIt->second->GetHDRCapability();
1791 std::vector<ScreenHDRFormat> hdrFormats;
1792 uint32_t formatCount = hdrCapability.formatCount;
1793 hdrFormats.resize(formatCount);
1794 for (uint32_t index = 0; index < formatCount; index++) {
1795 hdrFormats[index] = static_cast<ScreenHDRFormat>(hdrCapability.formats[index]);
1796 }
1797 screenHdrCapability.SetMaxLum(hdrCapability.maxLum);
1798 screenHdrCapability.SetMaxAverageLum(hdrCapability.maxAverageLum);
1799 screenHdrCapability.SetMinLum(hdrCapability.minLum);
1800 screenHdrCapability.SetHdrFormats(hdrFormats);
1801 return StatusCode::SUCCESS;
1802 }
1803
GetScreenTypeLocked(ScreenId id,RSScreenType & type) const1804 int32_t RSScreenManager::GetScreenTypeLocked(ScreenId id, RSScreenType& type) const
1805 {
1806 auto screensIt = screens_.find(id);
1807 if (screensIt == screens_.end() || screensIt->second == nullptr) {
1808 RS_LOGD("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
1809 return StatusCode::SCREEN_NOT_FOUND;
1810 }
1811
1812 type = screensIt->second->GetScreenType();
1813 return StatusCode::SUCCESS;
1814 }
1815
SetScreenSkipFrameIntervalLocked(ScreenId id,uint32_t skipFrameInterval)1816 int32_t RSScreenManager::SetScreenSkipFrameIntervalLocked(ScreenId id, uint32_t skipFrameInterval)
1817 {
1818 auto screensIt = screens_.find(id);
1819 if (screensIt == screens_.end() || screensIt->second == nullptr) {
1820 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
1821 return StatusCode::SCREEN_NOT_FOUND;
1822 }
1823 RSScreenModeInfo screenModeInfo;
1824 // use the refresh rate of the physical screen as the maximum refresh rate
1825 GetScreenActiveModeLocked(defaultScreenId_, screenModeInfo);
1826 // guaranteed screen refresh rate at least 1
1827 if (skipFrameInterval == 0 || (skipFrameInterval > screenModeInfo.GetScreenRefreshRate())) {
1828 return INVALID_ARGUMENTS;
1829 }
1830 screensIt->second->SetScreenSkipFrameInterval(skipFrameInterval);
1831 RS_LOGD("RSScreenManager %{public}s: screen(id %" PRIu64 "), skipFrameInterval(%d).",
1832 __func__, id, skipFrameInterval);
1833 return StatusCode::SUCCESS;
1834 }
1835
GetPixelFormatLocked(ScreenId id,GraphicPixelFormat & pixelFormat) const1836 int32_t RSScreenManager::GetPixelFormatLocked(ScreenId id, GraphicPixelFormat& pixelFormat) const
1837 {
1838 auto screensIt = screens_.find(id);
1839 if (screensIt == screens_.end() || screensIt->second == nullptr) {
1840 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
1841 return StatusCode::SCREEN_NOT_FOUND;
1842 }
1843 return screensIt->second->GetPixelFormat(pixelFormat);
1844 }
1845
SetPixelFormatLocked(ScreenId id,GraphicPixelFormat pixelFormat)1846 int32_t RSScreenManager::SetPixelFormatLocked(ScreenId id, GraphicPixelFormat pixelFormat)
1847 {
1848 auto screensIt = screens_.find(id);
1849 if (screensIt == screens_.end() || screensIt->second == nullptr) {
1850 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
1851 return StatusCode::SCREEN_NOT_FOUND;
1852 }
1853 return screensIt->second->SetPixelFormat(pixelFormat);
1854 }
1855
GetScreenSupportedHDRFormatsLocked(ScreenId id,std::vector<ScreenHDRFormat> & hdrFormats) const1856 int32_t RSScreenManager::GetScreenSupportedHDRFormatsLocked(ScreenId id, std::vector<ScreenHDRFormat>& hdrFormats) const
1857 {
1858 auto screensIt = screens_.find(id);
1859 if (screensIt == screens_.end() || screensIt->second == nullptr) {
1860 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
1861 return StatusCode::SCREEN_NOT_FOUND;
1862 }
1863 return screensIt->second->GetScreenSupportedHDRFormats(hdrFormats);
1864 }
1865
GetScreenHDRFormatLocked(ScreenId id,ScreenHDRFormat & hdrFormat) const1866 int32_t RSScreenManager::GetScreenHDRFormatLocked(ScreenId id, ScreenHDRFormat& hdrFormat) const
1867 {
1868 auto screensIt = screens_.find(id);
1869 if (screensIt == screens_.end() || screensIt->second == nullptr) {
1870 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
1871 return StatusCode::SCREEN_NOT_FOUND;
1872 }
1873 return screensIt->second->GetScreenHDRFormat(hdrFormat);
1874 }
1875
SetScreenHDRFormatLocked(ScreenId id,int32_t modeIdx)1876 int32_t RSScreenManager::SetScreenHDRFormatLocked(ScreenId id, int32_t modeIdx)
1877 {
1878 auto screensIt = screens_.find(id);
1879 if (screensIt == screens_.end() || screensIt->second == nullptr) {
1880 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
1881 return StatusCode::SCREEN_NOT_FOUND;
1882 }
1883 return screensIt->second->SetScreenHDRFormat(modeIdx);
1884 }
1885
GetScreenSupportedColorSpacesLocked(ScreenId id,std::vector<GraphicCM_ColorSpaceType> & colorSpaces) const1886 int32_t RSScreenManager::GetScreenSupportedColorSpacesLocked(
1887 ScreenId id, std::vector<GraphicCM_ColorSpaceType>& colorSpaces) const
1888 {
1889 auto screensIt = screens_.find(id);
1890 if (screensIt == screens_.end() || screensIt->second == nullptr) {
1891 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
1892 return StatusCode::SCREEN_NOT_FOUND;
1893 }
1894 return screensIt->second->GetScreenSupportedColorSpaces(colorSpaces);
1895 }
1896
GetScreenColorSpaceLocked(ScreenId id,GraphicCM_ColorSpaceType & colorSpace) const1897 int32_t RSScreenManager::GetScreenColorSpaceLocked(ScreenId id, GraphicCM_ColorSpaceType& colorSpace) const
1898 {
1899 auto screensIt = screens_.find(id);
1900 if (screensIt == screens_.end() || screensIt->second == nullptr) {
1901 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
1902 return StatusCode::SCREEN_NOT_FOUND;
1903 }
1904 return screensIt->second->GetScreenColorSpace(colorSpace);
1905 }
1906
SetScreenColorSpaceLocked(ScreenId id,GraphicCM_ColorSpaceType colorSpace)1907 int32_t RSScreenManager::SetScreenColorSpaceLocked(ScreenId id, GraphicCM_ColorSpaceType colorSpace)
1908 {
1909 auto screensIt = screens_.find(id);
1910 if (screensIt == screens_.end() || screensIt->second == nullptr) {
1911 RS_LOGW("RSScreenManager %{public}s: There is no screen for id %{public}" PRIu64 ".", __func__, id);
1912 return StatusCode::SCREEN_NOT_FOUND;
1913 }
1914 return screensIt->second->SetScreenColorSpace(colorSpace);
1915 }
1916
GetScreenSupportedColorGamuts(ScreenId id,std::vector<ScreenColorGamut> & mode) const1917 int32_t RSScreenManager::GetScreenSupportedColorGamuts(ScreenId id, std::vector<ScreenColorGamut>& mode) const
1918 {
1919 std::lock_guard<std::mutex> lock(mutex_);
1920 return GetScreenSupportedColorGamutsLocked(id, mode);
1921 }
1922
GetScreenSupportedMetaDataKeys(ScreenId id,std::vector<ScreenHDRMetadataKey> & keys) const1923 int32_t RSScreenManager::GetScreenSupportedMetaDataKeys(ScreenId id, std::vector<ScreenHDRMetadataKey>& keys) const
1924 {
1925 std::lock_guard<std::mutex> lock(mutex_);
1926 return GetScreenSupportedMetaDataKeysLocked(id, keys);
1927 }
1928
GetActualScreensNum() const1929 uint32_t RSScreenManager::GetActualScreensNum() const
1930 {
1931 std::lock_guard<std::mutex> lock(mutex_);
1932 uint32_t num = 0;
1933 for (const auto &[id, screen] : screens_) {
1934 if (!screen) {
1935 continue;
1936 }
1937 if (!screen->IsVirtual()) {
1938 num += 1;
1939 } else {
1940 if (screen->GetProducerSurface()) {
1941 num += 1;
1942 }
1943 }
1944 }
1945 return num;
1946 }
1947
GetScreenColorGamut(ScreenId id,ScreenColorGamut & mode) const1948 int32_t RSScreenManager::GetScreenColorGamut(ScreenId id, ScreenColorGamut &mode) const
1949 {
1950 std::lock_guard<std::mutex> lock(mutex_);
1951 return GetScreenColorGamutLocked(id, mode);
1952 }
1953
SetScreenColorGamut(ScreenId id,int32_t modeIdx)1954 int32_t RSScreenManager::SetScreenColorGamut(ScreenId id, int32_t modeIdx)
1955 {
1956 std::lock_guard<std::mutex> lock(mutex_);
1957 return SetScreenColorGamutLocked(id, modeIdx);
1958 }
1959
SetScreenGamutMap(ScreenId id,ScreenGamutMap mode)1960 int32_t RSScreenManager::SetScreenGamutMap(ScreenId id, ScreenGamutMap mode)
1961 {
1962 std::lock_guard<std::mutex> lock(mutex_);
1963 return SetScreenGamutMapLocked(id, mode);
1964 }
1965
SetScreenCorrection(ScreenId id,ScreenRotation screenRotation)1966 int32_t RSScreenManager::SetScreenCorrection(ScreenId id, ScreenRotation screenRotation)
1967 {
1968 std::lock_guard<std::mutex> lock(mutex_);
1969 return SetScreenCorrectionLocked(id, screenRotation);
1970 }
1971
GetScreenGamutMap(ScreenId id,ScreenGamutMap & mode) const1972 int32_t RSScreenManager::GetScreenGamutMap(ScreenId id, ScreenGamutMap &mode) const
1973 {
1974 std::lock_guard<std::mutex> lock(mutex_);
1975 return GetScreenGamutMapLocked(id, mode);
1976 }
1977
GetScreenHDRCapability(ScreenId id,RSScreenHDRCapability & screenHdrCapability) const1978 int32_t RSScreenManager::GetScreenHDRCapability(ScreenId id, RSScreenHDRCapability& screenHdrCapability) const
1979 {
1980 std::lock_guard<std::mutex> lock(mutex_);
1981 return GetScreenHDRCapabilityLocked(id, screenHdrCapability);
1982 }
1983
GetScreenType(ScreenId id,RSScreenType & type) const1984 int32_t RSScreenManager::GetScreenType(ScreenId id, RSScreenType& type) const
1985 {
1986 std::lock_guard<std::mutex> lock(mutex_);
1987 return GetScreenTypeLocked(id, type);
1988 }
1989
SetScreenSkipFrameInterval(ScreenId id,uint32_t skipFrameInterval)1990 int32_t RSScreenManager::SetScreenSkipFrameInterval(ScreenId id, uint32_t skipFrameInterval)
1991 {
1992 std::lock_guard<std::mutex> lock(mutex_);
1993 return SetScreenSkipFrameIntervalLocked(id, skipFrameInterval);
1994 }
1995
GetPixelFormat(ScreenId id,GraphicPixelFormat & pixelFormat) const1996 int32_t RSScreenManager::GetPixelFormat(ScreenId id, GraphicPixelFormat& pixelFormat) const
1997 {
1998 std::lock_guard<std::mutex> lock(mutex_);
1999 return GetPixelFormatLocked(id, pixelFormat);
2000 }
2001
SetPixelFormat(ScreenId id,GraphicPixelFormat pixelFormat)2002 int32_t RSScreenManager::SetPixelFormat(ScreenId id, GraphicPixelFormat pixelFormat)
2003 {
2004 std::lock_guard<std::mutex> lock(mutex_);
2005 return SetPixelFormatLocked(id, pixelFormat);
2006 }
2007
GetScreenSupportedHDRFormats(ScreenId id,std::vector<ScreenHDRFormat> & hdrFormats) const2008 int32_t RSScreenManager::GetScreenSupportedHDRFormats(ScreenId id, std::vector<ScreenHDRFormat>& hdrFormats) const
2009 {
2010 std::lock_guard<std::mutex> lock(mutex_);
2011 return GetScreenSupportedHDRFormatsLocked(id, hdrFormats);
2012 }
2013
GetScreenHDRFormat(ScreenId id,ScreenHDRFormat & hdrFormat) const2014 int32_t RSScreenManager::GetScreenHDRFormat(ScreenId id, ScreenHDRFormat& hdrFormat) const
2015 {
2016 std::lock_guard<std::mutex> lock(mutex_);
2017 return GetScreenHDRFormatLocked(id, hdrFormat);
2018 }
2019
SetScreenHDRFormat(ScreenId id,int32_t modeIdx)2020 int32_t RSScreenManager::SetScreenHDRFormat(ScreenId id, int32_t modeIdx)
2021 {
2022 std::lock_guard<std::mutex> lock(mutex_);
2023 return SetScreenHDRFormatLocked(id, modeIdx);
2024 }
2025
GetScreenSupportedColorSpaces(ScreenId id,std::vector<GraphicCM_ColorSpaceType> & colorSpaces) const2026 int32_t RSScreenManager::GetScreenSupportedColorSpaces(
2027 ScreenId id, std::vector<GraphicCM_ColorSpaceType>& colorSpaces) const
2028 {
2029 std::lock_guard<std::mutex> lock(mutex_);
2030 return GetScreenSupportedColorSpacesLocked(id, colorSpaces);
2031 }
2032
GetScreenColorSpace(ScreenId id,GraphicCM_ColorSpaceType & colorSpace) const2033 int32_t RSScreenManager::GetScreenColorSpace(ScreenId id, GraphicCM_ColorSpaceType& colorSpace) const
2034 {
2035 std::lock_guard<std::mutex> lock(mutex_);
2036 return GetScreenColorSpaceLocked(id, colorSpace);
2037 }
2038
SetScreenColorSpace(ScreenId id,GraphicCM_ColorSpaceType colorSpace)2039 int32_t RSScreenManager::SetScreenColorSpace(ScreenId id, GraphicCM_ColorSpaceType colorSpace)
2040 {
2041 std::lock_guard<std::mutex> lock(mutex_);
2042 return SetScreenColorSpaceLocked(id, colorSpace);
2043 }
2044
MarkPowerOffNeedProcessOneFrame()2045 void RSScreenManager::MarkPowerOffNeedProcessOneFrame()
2046 {
2047 powerOffNeedProcessOneFrame_ = true;
2048 }
2049
ResetPowerOffNeedProcessOneFrame()2050 void RSScreenManager::ResetPowerOffNeedProcessOneFrame()
2051 {
2052 powerOffNeedProcessOneFrame_ = false;
2053 }
2054
GetPowerOffNeedProcessOneFrame() const2055 bool RSScreenManager::GetPowerOffNeedProcessOneFrame() const
2056 {
2057 return powerOffNeedProcessOneFrame_;
2058 }
2059
IsScreenPowerOff(ScreenId id) const2060 bool RSScreenManager::IsScreenPowerOff(ScreenId id) const
2061 {
2062 std::lock_guard<std::mutex> lock(mutex_);
2063 if (screenPowerStatus_.count(id) == 0) {
2064 return false;
2065 }
2066 return screenPowerStatus_.at(id) == GraphicDispPowerStatus::GRAPHIC_POWER_STATUS_SUSPEND ||
2067 screenPowerStatus_.at(id) == GraphicDispPowerStatus::GRAPHIC_POWER_STATUS_OFF;
2068 }
2069
DisablePowerOffRenderControl(ScreenId id)2070 void RSScreenManager::DisablePowerOffRenderControl(ScreenId id)
2071 {
2072 std::lock_guard<std::mutex> lock(mutex_);
2073 RS_LOGD("RSScreenManager Add Screen_%{public}" PRIu64 " for disable power-off render control.", id);
2074 disableRenderControlScreens_.insert(id);
2075 }
2076
GetDisableRenderControlScreensCount() const2077 int RSScreenManager::GetDisableRenderControlScreensCount() const
2078 {
2079 std::lock_guard<std::mutex> lock(mutex_);
2080 return disableRenderControlScreens_.size();
2081 }
2082 } // namespace impl
2083
CreateOrGetScreenManager()2084 sptr<RSScreenManager> CreateOrGetScreenManager()
2085 {
2086 return impl::RSScreenManager::GetInstance();
2087 }
2088 } // namespace Rosen
2089 } // namespace OHOS
2090