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 "screen_client_window_adapter.h"
17
18 #include "rs_surface_node.h"
19 #include "window_option.h"
20 #include "wm_common.h"
21
22 #include "dscreen_constants.h"
23 #include "dscreen_errcode.h"
24 #include "dscreen_log.h"
25
26 namespace OHOS {
27 namespace DistributedHardware {
28 IMPLEMENT_SINGLE_INSTANCE(ScreenClientWindowAdapter);
~ScreenClientWindowAdapter()29 ScreenClientWindowAdapter::~ScreenClientWindowAdapter()
30 {
31 DHLOGD("~ScreenClientWindowAdapter");
32 {
33 std::lock_guard<std::mutex> dataLock(windowIdMapMutex_);
34 for (const auto &item : windowIdMap_) {
35 auto window = item.second;
36 if (window == nullptr) {
37 DHLOGE("window is nullptr(windowId = %d).", item.first);
38 return;
39 }
40 if (OHOS::Rosen::WMError::WM_OK != window->Destroy()) {
41 DHLOGE("screenclientSurface is nullptr(windowId = %d).", item.first);
42 return;
43 }
44 }
45 windowIdMap_.clear();
46 }
47 DHLOGD("ScreenClientWindowAdapter Destory.");
48 return;
49 }
50
CreateWindow(std::shared_ptr<WindowProperty> windowProperty,int32_t windowId)51 sptr<Surface> ScreenClientWindowAdapter::CreateWindow(std::shared_ptr<WindowProperty> windowProperty,
52 int32_t windowId)
53 {
54 if (windowProperty == nullptr) {
55 DHLOGE("windowProperty is nullptr.");
56 return nullptr;
57 }
58 sptr<Rosen::WindowOption> option = new Rosen::WindowOption();
59 option->SetWindowType(Rosen::WindowType::WINDOW_TYPE_APP_LAUNCHING);
60 option->SetWindowMode(Rosen::WindowMode::WINDOW_MODE_FLOATING);
61 option->SetDisplayId(windowProperty->displayId);
62 std::string windowName = SCREEN_CLIENT_WINDOW + std::to_string(windowId);
63 sptr<Rosen::Window> window = Rosen::Window::Create(windowName, option);
64 if (window == nullptr || window->GetSurfaceNode() == nullptr) {
65 DHLOGE("Create screen client window failed.");
66 return nullptr;
67 }
68 auto surface = window->GetSurfaceNode()->GetSurface();
69 if (surface == nullptr) {
70 window->Destroy();
71 DHLOGE("surface is nullptr");
72 return nullptr;
73 }
74 std::shared_ptr<MMI::IInputEventConsumer> listener =
75 std::make_shared<ScreenClientInputEventListener>(ScreenClientInputEventListener());
76 window->AddInputEventListener(listener);
77 DHLOGD("Create window name is %s.", windowName.c_str());
78 if (OHOS::Rosen::WMError::WM_OK != window->Resize(windowProperty->width, windowProperty->height)) {
79 window->Destroy();
80 DHLOGE("Window resize failed.");
81 return nullptr;
82 }
83 if (OHOS::Rosen::WMError::WM_OK != window->MoveTo(windowProperty->startX, windowProperty->startY)) {
84 window->Destroy();
85 DHLOGE("Window moveto failed.");
86 return nullptr;
87 }
88 {
89 std::lock_guard<std::mutex> dataLock(windowIdMapMutex_);
90 windowIdMap_.emplace(windowId, window);
91 }
92 DHLOGD("Get surface(windowId = %d) success.", windowId);
93 return surface;
94 }
95
ShowWindow(int32_t windowId)96 int32_t ScreenClientWindowAdapter::ShowWindow(int32_t windowId)
97 {
98 sptr<Rosen::Window> window = nullptr;
99 {
100 std::lock_guard<std::mutex> dataLock(windowIdMapMutex_);
101 auto iter = windowIdMap_.find(windowId);
102 if (iter == windowIdMap_.end()) {
103 DHLOGE("ERR_DH_SCREEN_SCREENCLIENT_SHOW_WINDOW_ERROR.");
104 return ERR_DH_SCREEN_SCREENCLIENT_SHOW_WINDOW_ERROR;
105 }
106 window = iter->second;
107 }
108 if (window == nullptr) {
109 DHLOGE("Current window is null.");
110 return ERR_DH_SCREEN_SCREENCLIENT_SHOW_WINDOW_ERROR;
111 }
112 if (OHOS::Rosen::WMError::WM_OK != window->Show()) {
113 DHLOGE("Show window failed.");
114 return ERR_DH_SCREEN_SCREENCLIENT_SHOW_WINDOW_ERROR;
115 }
116 DHLOGD("Show window (windowId = %d) success.", windowId);
117 return DH_SUCCESS;
118 }
119
HideWindow(int32_t windowId)120 int32_t ScreenClientWindowAdapter::HideWindow(int32_t windowId)
121 {
122 sptr<Rosen::Window> window = nullptr;
123 {
124 std::lock_guard<std::mutex> dataLock(windowIdMapMutex_);
125 auto iter = windowIdMap_.find(windowId);
126 if (iter == windowIdMap_.end()) {
127 DHLOGE("ERR_DH_SCREEN_SCREENCLIENT_HIDE_WINDOW_ERROR.");
128 return ERR_DH_SCREEN_SCREENCLIENT_HIDE_WINDOW_ERROR;
129 }
130 window = iter->second;
131 }
132 if (window == nullptr) {
133 DHLOGE("Current window is null.");
134 return ERR_DH_SCREEN_SCREENCLIENT_HIDE_WINDOW_ERROR;
135 }
136 if (OHOS::Rosen::WMError::WM_OK != window->Hide()) {
137 DHLOGE("Hide window failed.");
138 return ERR_DH_SCREEN_SCREENCLIENT_HIDE_WINDOW_ERROR;
139 }
140 DHLOGD("Hide window (windowId = %d) success.", windowId);
141 return DH_SUCCESS;
142 }
143
MoveWindow(int32_t windowId,int32_t startX,int32_t startY)144 int32_t ScreenClientWindowAdapter::MoveWindow(int32_t windowId, int32_t startX, int32_t startY)
145 {
146 sptr<Rosen::Window> window = nullptr;
147 {
148 std::lock_guard<std::mutex> dataLock(windowIdMapMutex_);
149 auto iter = windowIdMap_.find(windowId);
150 if (iter == windowIdMap_.end()) {
151 DHLOGE("Invalid windowId (windowId = %d).", windowId);
152 return ERR_DH_SCREEN_SCREENCLIENT_MOVE_WINDOW_ERROR;
153 }
154 window = iter->second;
155 }
156 if (window == nullptr) {
157 DHLOGE("Current window is null(windowId = %d).", windowId);
158 return ERR_DH_SCREEN_SCREENCLIENT_MOVE_WINDOW_ERROR;
159 }
160 if (OHOS::Rosen::WMError::WM_OK != window->MoveTo(startX, startY)) {
161 DHLOGE("Move window failed (windowId = %d).", windowId);
162 return ERR_DH_SCREEN_SCREENCLIENT_MOVE_WINDOW_ERROR;
163 }
164 DHLOGD("MoveTo window (windowId = %d) success.", windowId);
165 return DH_SUCCESS;
166 }
167
RemoveWindow(int32_t windowId)168 int32_t ScreenClientWindowAdapter::RemoveWindow(int32_t windowId)
169 {
170 sptr<Rosen::Window> window = nullptr;
171 {
172 std::lock_guard<std::mutex> dataLock(windowIdMapMutex_);
173 auto iter = windowIdMap_.find(windowId);
174 if (iter == windowIdMap_.end()) {
175 DHLOGE("Invalid windowId(windowId = %d).", windowId);
176 return ERR_DH_SCREEN_SCREENCLIENT_REMOVE_WINDOW_ERROR;
177 }
178 window = iter->second;
179 windowIdMap_.erase(windowId);
180 }
181 if (window == nullptr) {
182 DHLOGE("Current window is null(windowId = %d).", windowId);
183 return ERR_DH_SCREEN_SCREENCLIENT_REMOVE_WINDOW_ERROR;
184 }
185 if (OHOS::Rosen::WMError::WM_OK != window->Hide()) {
186 DHLOGE("Remove window window failed(windowId = %d).", windowId);
187 return ERR_DH_SCREEN_SCREENCLIENT_REMOVE_WINDOW_ERROR;
188 }
189 if (OHOS::Rosen::WMError::WM_OK != window->Destroy()) {
190 DHLOGE("Remove window window failed(windowId = %d).", windowId);
191 return ERR_DH_SCREEN_SCREENCLIENT_REMOVE_WINDOW_ERROR;
192 }
193 DHLOGD("Remove window success(windowId = %d).", windowId);
194 return DH_SUCCESS;
195 }
196
OnInputEvent(std::shared_ptr<MMI::PointerEvent> pointerEvent) const197 void ScreenClientInputEventListener::OnInputEvent(std::shared_ptr<MMI::PointerEvent> pointerEvent) const
198 {
199 DHLOGI("onInputEvent, pointerEvent");
200 pointerEvent->MarkProcessed();
201 }
202
OnInputEvent(std::shared_ptr<MMI::KeyEvent> keyEvent) const203 void ScreenClientInputEventListener::OnInputEvent(std::shared_ptr<MMI::KeyEvent> keyEvent) const
204 {
205 DHLOGI("onInputEvent, keyEvent");
206 keyEvent->MarkProcessed();
207 }
208
OnInputEvent(std::shared_ptr<MMI::AxisEvent> axisEvent) const209 void ScreenClientInputEventListener::OnInputEvent(std::shared_ptr<MMI::AxisEvent> axisEvent) const
210 {
211 DHLOGI("onInputEvent, axisEvent");
212 axisEvent->MarkProcessed();
213 }
214 } // namespace DistributedHardware
215 } // namespace OHOS