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: %{public}u, height: %{public}" PRIu32, 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:%{public}" 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     Rosen::VirtualScreenOption option = {
72         screenName,
73         width,
74         videoParam->GetScreenHeight(),
75         DEFAULT_DENSITY,
76         nullptr,
77         DEFAULT_SCREEN_FLAGS,
78         false
79     };
80 
81     uint64_t screenId = Rosen::ScreenManager::GetInstance().CreateVirtualScreen(option);
82     DHLOGI("virtualScreen id is: %{public}" PRIu64, screenId);
83     screenIdMap_.emplace(screenName, screenId);
84     return screenId;
85 }
86 
RegisterScreenGroupListener(sptr<Rosen::ScreenManager::IScreenGroupListener> listener)87 int32_t ScreenMgrAdapter::RegisterScreenGroupListener(sptr<Rosen::ScreenManager::IScreenGroupListener> listener)
88 {
89     if (listener == nullptr) {
90         DHLOGE("ScreenMgrAdapter::RegisterScreenGroupListener, listener is nullptr.");
91         return ERR_DH_SCREEN_SA_REGISTER_SCREENLISTENER_FAIL;
92     }
93     DHLOGI("RegisterScreenGroupListener");
94     if (listenerRegistered_) {
95         DHLOGI("already registered listener.");
96         return DH_SUCCESS;
97     }
98     Rosen::DMError ret = Rosen::ScreenManager::GetInstance().RegisterScreenGroupListener(listener);
99     if (ret != Rosen::DMError::DM_OK) {
100         DHLOGE("RegisterScreenGroupListener Failed.");
101         return ERR_DH_SCREEN_SA_REGISTER_SCREENLISTENER_FAIL;
102     }
103     listenerRegistered_ = true;
104     return DH_SUCCESS;
105 }
106 
UnregisterScreenGroupListener(sptr<Rosen::ScreenManager::IScreenGroupListener> listener)107 int32_t ScreenMgrAdapter::UnregisterScreenGroupListener(sptr<Rosen::ScreenManager::IScreenGroupListener> listener)
108 {
109     if (listener == nullptr) {
110         DHLOGE("ScreenMgrAdapter::UnregisterScreenGroupListener, listener is nullptr.");
111         return ERR_DH_SCREEN_SA_UNREGISTER_SCREENLISTENER_FAIL;
112     }
113     DHLOGI("UnregisterScreenGroupListener");
114     if (!listenerRegistered_) {
115         DHLOGI("listener already unregistered.");
116         return DH_SUCCESS;
117     }
118     Rosen::DMError ret = Rosen::ScreenManager::GetInstance().UnregisterScreenGroupListener(listener);
119     if (ret != Rosen::DMError::DM_OK) {
120         DHLOGE("UnregisterScreenGroupListener Failed.");
121         return ERR_DH_SCREEN_SA_UNREGISTER_SCREENLISTENER_FAIL;
122     }
123     listenerRegistered_ = false;
124     return DH_SUCCESS;
125 }
126 
RemoveScreenFromGroup(uint64_t screenId)127 void ScreenMgrAdapter::RemoveScreenFromGroup(uint64_t screenId)
128 {
129     DHLOGI("remove screen from group, screenId: %{public}" PRIu64, screenId);
130     std::vector<uint64_t> screenIds;
131     screenIds.push_back(screenId);
132     Rosen::ScreenManager::GetInstance().RemoveVirtualScreenFromGroup(screenIds);
133 }
134 
RemoveVirtualScreen(uint64_t screenId)135 int32_t ScreenMgrAdapter::RemoveVirtualScreen(uint64_t screenId)
136 {
137     DHLOGI("remove virtual screen, screenId: %{public}" PRIu64, screenId);
138     Rosen::DMError err = Rosen::ScreenManager::GetInstance().DestroyVirtualScreen(screenId);
139     if (err != Rosen::DMError::DM_OK) {
140         DHLOGE("remove virtual screen failed, screenId:%{public}" PRIu64, screenId);
141         return ERR_DH_SCREEN_SA_REMOVE_VIRTUALSCREEN_FAIL;
142     }
143     return DH_SUCCESS;
144 }
145 
SetImageSurface(uint64_t screenId,sptr<OHOS::Surface> surface)146 int32_t ScreenMgrAdapter::SetImageSurface(uint64_t screenId, sptr<OHOS::Surface> surface)
147 {
148     if (surface == nullptr) {
149         DHLOGE("ScreenMgrAdapter::SetImageSurface, surface is nullptr");
150         return ERR_DH_SCREEN_SA_SET_IMAGESURFACE_FAIL;
151     }
152     DHLOGI("SetImageSurface for virtualscreen, screenId: %{public}" PRIu64, screenId);
153     Rosen::RSInterfaces::GetInstance().SetVirtualScreenUsingStatus(true);
154     Rosen::ScreenManager::GetInstance().SetVirtualScreenSurface(screenId, surface);
155     return DH_SUCCESS;
156 }
157 
GetMapRelation(uint64_t screenId)158 std::shared_ptr<DScreenMapRelation> ScreenMgrAdapter::GetMapRelation(uint64_t screenId)
159 {
160     DHLOGI("GetMapRelation screenId: %{public}" PRIu64, screenId);
161     std::shared_ptr<DScreenMapRelation> mapRelation = std::make_shared<DScreenMapRelation>();
162     sptr<Rosen::Screen> screen = Rosen::ScreenManager::GetInstance().GetScreenById(screenId);
163     if (screen == nullptr) {
164         DHLOGE("screen is nullptr.");
165         return nullptr;
166     }
167     sptr<Rosen::Display> display = Rosen::DisplayManager::GetInstance().GetDefaultDisplay();
168     if (display == nullptr) {
169         DHLOGE("display is nullptr.");
170         return nullptr;
171     }
172     mapRelation->SetDisplayId(display->GetId());
173     mapRelation->SetScreenId(screenId);
174 
175     uint32_t width = screen->GetWidth();
176     width = ByteCalculate(width);
177     ScreenRect screenRect = {0, 0, width, screen->GetHeight()};
178     DisplayRect displayRect = {0, 0, width, display->GetHeight()};
179     mapRelation->SetDisplayRect(displayRect);
180     mapRelation->SetScreenRect(screenRect);
181     return mapRelation;
182 }
183 } // namespace DistributedHardware
184 } // namespace OHOS