1 /*
2 * Copyright (c) 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 "common/include/screen_manager_adapter.h"
17
18 #include <memory>
19
20 #include "display_manager.h"
21 #include "dm_common.h"
22 #include "screen.h"
23
24 #include "dscreen_constants.h"
25 #include "dscreen_errcode.h"
26 #include "dscreen_hisysevent.h"
27 #include "dscreen_log.h"
28 #include "dscreen_util.h"
29
30 namespace OHOS {
31 namespace DistributedHardware {
32 IMPLEMENT_SINGLE_INSTANCE(ScreenMgrAdapter);
~ScreenMgrAdapter()33 ScreenMgrAdapter::~ScreenMgrAdapter()
34 {
35 screenIdMap_.clear();
36 DHLOGI("~ScreenMgrAdapter");
37 }
38
ByteCalculate(std::uint32_t screenWidth)39 uint32_t ScreenMgrAdapter::ByteCalculate(std::uint32_t screenWidth)
40 {
41 if (screenWidth % BYTE_ALIGNMENT == 0) {
42 return screenWidth;
43 }
44 uint32_t alignedInt = (screenWidth + BYTE_ALIGNMENT_CALCULATION) / BYTE_ALIGNMENT * BYTE_ALIGNMENT;
45 return alignedInt;
46 }
47
CreateVirtualScreen(const std::string & devId,const std::string & dhId,const std::shared_ptr<VideoParam> & videoParam)48 uint64_t ScreenMgrAdapter::CreateVirtualScreen(const std::string &devId, const std::string &dhId,
49 const std::shared_ptr<VideoParam> &videoParam)
50 {
51 if (videoParam == nullptr) {
52 DHLOGE("ScreenMgrAdapter::CreateVirtualScreen, videoParam is nullptr");
53 return SCREEN_ID_INVALID;
54 }
55 DHLOGI("CreateVirtualScreen, width: %u, height: %u", videoParam->GetScreenWidth(),
56 videoParam->GetScreenHeight());
57 std::string screenName = DSCREEN_PREFIX + SEPERATOR + GetInterruptString(devId) +
58 SEPERATOR + GetInterruptString(dhId);
59 auto iter = screenIdMap_.find(screenName);
60 if (iter != screenIdMap_.end()) {
61 DHLOGI("remove an exist virtual screen.");
62 Rosen::DMError err = Rosen::ScreenManager::GetInstance().DestroyVirtualScreen(iter->second);
63 if (err != Rosen::DMError::DM_OK) {
64 DHLOGE("remove virtual screen failed, screenId:%", PRIu64, iter->second);
65 return SCREEN_ID_INVALID;
66 }
67 screenIdMap_.erase(screenName);
68 }
69 uint32_t width = videoParam->GetScreenWidth();
70 width = ByteCalculate(width);
71 DHLOGI("screenWidth is : %" PRIu32, width);
72 Rosen::VirtualScreenOption option = {
73 screenName,
74 width,
75 videoParam->GetScreenHeight(),
76 DEFAULT_DENSITY,
77 nullptr,
78 DEFAULT_SCREEN_FLAGS,
79 false
80 };
81
82 uint64_t screenId = Rosen::ScreenManager::GetInstance().CreateVirtualScreen(option);
83 DHLOGI("virtualScreen id is: %" PRIu64, screenId);
84 screenIdMap_.emplace(screenName, screenId);
85 return screenId;
86 }
87
RegisterScreenGroupListener(sptr<Rosen::ScreenManager::IScreenGroupListener> listener)88 int32_t ScreenMgrAdapter::RegisterScreenGroupListener(sptr<Rosen::ScreenManager::IScreenGroupListener> listener)
89 {
90 if (listener == nullptr) {
91 DHLOGE("ScreenMgrAdapter::RegisterScreenGroupListener, listener is nullptr.");
92 return ERR_DH_SCREEN_SA_REGISTER_SCREENLISTENER_FAIL;
93 }
94 DHLOGI("RegisterScreenGroupListener");
95 if (listenerRegistered_) {
96 DHLOGI("already registered listener.");
97 return DH_SUCCESS;
98 }
99 Rosen::DMError ret = Rosen::ScreenManager::GetInstance().RegisterScreenGroupListener(listener);
100 if (ret != Rosen::DMError::DM_OK) {
101 DHLOGE("RegisterScreenGroupListener Failed.");
102 return ERR_DH_SCREEN_SA_REGISTER_SCREENLISTENER_FAIL;
103 }
104 listenerRegistered_ = true;
105 return DH_SUCCESS;
106 }
107
UnregisterScreenGroupListener(sptr<Rosen::ScreenManager::IScreenGroupListener> listener)108 int32_t ScreenMgrAdapter::UnregisterScreenGroupListener(sptr<Rosen::ScreenManager::IScreenGroupListener> listener)
109 {
110 if (listener == nullptr) {
111 DHLOGE("ScreenMgrAdapter::UnregisterScreenGroupListener, listener is nullptr.");
112 return ERR_DH_SCREEN_SA_UNREGISTER_SCREENLISTENER_FAIL;
113 }
114 DHLOGI("UnregisterScreenGroupListener");
115 if (!listenerRegistered_) {
116 DHLOGI("listener already unregistered.");
117 return DH_SUCCESS;
118 }
119 Rosen::DMError ret = Rosen::ScreenManager::GetInstance().UnregisterScreenGroupListener(listener);
120 if (ret != Rosen::DMError::DM_OK) {
121 DHLOGE("UnregisterScreenGroupListener Failed.");
122 return ERR_DH_SCREEN_SA_UNREGISTER_SCREENLISTENER_FAIL;
123 }
124 listenerRegistered_ = false;
125 return DH_SUCCESS;
126 }
127
RemoveScreenFromGroup(uint64_t screenId)128 void ScreenMgrAdapter::RemoveScreenFromGroup(uint64_t screenId)
129 {
130 DHLOGI("remove screen from group, screenId: %" PRIu64, screenId);
131 std::vector<uint64_t> screenIds;
132 screenIds.push_back(screenId);
133 Rosen::ScreenManager::GetInstance().RemoveVirtualScreenFromGroup(screenIds);
134 }
135
RemoveVirtualScreen(uint64_t screenId)136 int32_t ScreenMgrAdapter::RemoveVirtualScreen(uint64_t screenId)
137 {
138 DHLOGI("remove virtual screen, screenId: %" PRIu64, screenId);
139 Rosen::DMError err = Rosen::ScreenManager::GetInstance().DestroyVirtualScreen(screenId);
140 if (err != Rosen::DMError::DM_OK) {
141 DHLOGE("remove virtual screen failed, screenId:%" PRIu64, screenId);
142 return ERR_DH_SCREEN_SA_REMOVE_VIRTUALSCREEN_FAIL;
143 }
144 return DH_SUCCESS;
145 }
146
SetImageSurface(uint64_t screenId,sptr<OHOS::Surface> surface)147 int32_t ScreenMgrAdapter::SetImageSurface(uint64_t screenId, sptr<OHOS::Surface> surface)
148 {
149 if (surface == nullptr) {
150 DHLOGE("ScreenMgrAdapter::SetImageSurface, surface is nullptr");
151 return ERR_DH_SCREEN_SA_SET_IMAGESURFACE_FAIL;
152 }
153 DHLOGI("SetImageSurface for virtualscreen, screenId: %" PRIu64, screenId);
154 Rosen::RSInterfaces::GetInstance().SetVirtualScreenUsingStatus(true);
155 Rosen::ScreenManager::GetInstance().SetVirtualScreenSurface(screenId, surface);
156 return DH_SUCCESS;
157 }
158
GetMapRelation(uint64_t screenId)159 std::shared_ptr<DScreenMapRelation> ScreenMgrAdapter::GetMapRelation(uint64_t screenId)
160 {
161 DHLOGI("GetMapRelation screenId: %" PRIu64, screenId);
162 std::shared_ptr<DScreenMapRelation> mapRelation = std::make_shared<DScreenMapRelation>();
163 sptr<Rosen::Screen> screen = Rosen::ScreenManager::GetInstance().GetScreenById(screenId);
164 if (screen == nullptr) {
165 DHLOGE("screen is nullptr.");
166 return nullptr;
167 }
168 sptr<Rosen::Display> display = Rosen::DisplayManager::GetInstance().GetDefaultDisplay();
169 if (display == nullptr) {
170 DHLOGE("display is nullptr.");
171 return nullptr;
172 }
173 mapRelation->SetDisplayId(display->GetId());
174 mapRelation->SetScreenId(screenId);
175
176 uint32_t width = screen->GetWidth();
177 width = ByteCalculate(width);
178 DHLOGI("screenWidth is : %" PRIu32, width);
179 ScreenRect screenRect = {0, 0, width, screen->GetHeight()};
180 DisplayRect displayRect = {0, 0, width, display->GetHeight()};
181 mapRelation->SetDisplayRect(displayRect);
182 mapRelation->SetScreenRect(screenRect);
183 return mapRelation;
184 }
185 } // namespace DistributedHardware
186 } // namespace OHOS