1 /*
2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "zidl/window_stub.h"
17 #include <vector>
18 #include "ipc_skeleton.h"
19 #include <key_event.h>
20 #include "pointer_event.h"
21 #include "window_manager_hilog.h"
22 #include <transaction/rs_transaction.h>
23
24 namespace OHOS {
25 namespace Rosen {
26 namespace {
27 constexpr HiviewDFX::HiLogLabel LABEL = {LOG_CORE, HILOG_DOMAIN_WINDOW, "WindowStub"};
28 }
29
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)30 int WindowStub::OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option)
31 {
32 if (staticDestroyMonitor_.IsDestroyed()) {
33 WLOGFE("Main thread finished, static data has been destroyed");
34 return ERR_INVALID_STATE;
35 }
36 if (data.ReadInterfaceToken() != GetDescriptor()) {
37 WLOGFE("InterfaceToken check failed");
38 return ERR_TRANSACTION_FAILED;
39 }
40 WindowMessage msgId = static_cast<WindowMessage>(code);
41 switch (msgId) {
42 case WindowMessage::TRANS_ID_UPDATE_WINDOW_RECT: {
43 int32_t posX = 0;
44 int32_t posY = 0;
45 uint32_t width = 0;
46 uint32_t height = 0;
47 if (!data.ReadInt32(posX) || !data.ReadInt32(posY) || !data.ReadUint32(width) || !data.ReadUint32(height)) {
48 TLOGE(WmsLogTag::WMS_LAYOUT, "read rect failed");
49 return ERR_INVALID_DATA;
50 }
51 Rect rect { posX, posY, width, height };
52 bool decoStatus = false;
53 if (!data.ReadBool(decoStatus)) {
54 TLOGE(WmsLogTag::WMS_LAYOUT, "read decoStatus failed");
55 return ERR_INVALID_DATA;
56 }
57 uint32_t changeReason = 0;
58 if (!data.ReadUint32(changeReason)) {
59 TLOGE(WmsLogTag::WMS_LAYOUT, "read changeReason failed");
60 return ERR_INVALID_DATA;
61 }
62 if (changeReason < static_cast<uint32_t>(WindowSizeChangeReason::UNDEFINED) ||
63 changeReason > static_cast<uint32_t>(WindowSizeChangeReason::END)) {
64 TLOGE(WmsLogTag::WMS_LAYOUT, "Unknown reason");
65 return ERR_INVALID_DATA;
66 }
67 WindowSizeChangeReason reason = static_cast<WindowSizeChangeReason>(changeReason);
68 bool hasRSTransaction = false;
69 if (!data.ReadBool(hasRSTransaction)) {
70 TLOGE(WmsLogTag::WMS_LAYOUT, "read hasRSTransaction failed");
71 return ERR_INVALID_DATA;
72 }
73 if (hasRSTransaction) {
74 auto rsTransaction = data.ReadParcelable<RSTransaction>();
75 if (!rsTransaction) {
76 WLOGFE("RSTransaction unMarsh failed");
77 return -1;
78 }
79 std::shared_ptr<RSTransaction> transaction(rsTransaction);
80 UpdateWindowRect(rect, decoStatus, reason, transaction);
81 } else {
82 UpdateWindowRect(rect, decoStatus, reason);
83 }
84 break;
85 }
86 case WindowMessage::TRANS_ID_UPDATE_WINDOW_MODE: {
87 uint32_t windowMode = 0;
88 if (!data.ReadUint32(windowMode)) {
89 TLOGE(WmsLogTag::WMS_LAYOUT, "read windowMode failed");
90 return ERR_INVALID_DATA;
91 }
92 if (windowMode < static_cast<uint32_t>(WindowMode::WINDOW_MODE_UNDEFINED) ||
93 windowMode > static_cast<uint32_t>(WindowMode::WINDOW_MODE_PIP)) {
94 TLOGE(WmsLogTag::WMS_LAYOUT, "invalid windowMode: %{public}d", windowMode);
95 return ERR_INVALID_DATA;
96 }
97 WindowMode mode = static_cast<WindowMode>(windowMode);
98 UpdateWindowMode(mode);
99 break;
100 }
101 case WindowMessage::TRANS_ID_UPDATE_MODE_SUPPORT_INFO: {
102 uint32_t windowModeSupportType = 0;
103 if (!data.ReadUint32(windowModeSupportType)) {
104 TLOGE(WmsLogTag::WMS_LAYOUT, "read windowModeSupportType failed");
105 return ERR_INVALID_DATA;
106 }
107 UpdateWindowModeSupportType(windowModeSupportType);
108 break;
109 }
110 case WindowMessage::TRANS_ID_UPDATE_FOCUS_STATUS: {
111 bool focused = data.ReadBool();
112 UpdateFocusStatus(focused);
113 break;
114 }
115 case WindowMessage::TRANS_ID_UPDATE_AVOID_AREA: {
116 sptr<AvoidArea> avoidArea = data.ReadStrongParcelable<AvoidArea>();
117 if (avoidArea == nullptr) {
118 return ERR_INVALID_DATA;
119 }
120 uint32_t type = 0;
121 if (!data.ReadUint32(type) ||
122 type >= static_cast<uint32_t>(AvoidAreaType::TYPE_END)) {
123 return ERR_INVALID_DATA;
124 }
125 UpdateAvoidArea(avoidArea, static_cast<AvoidAreaType>(type));
126 break;
127 }
128 case WindowMessage::TRANS_ID_UPDATE_WINDOW_STATE: {
129 uint32_t state = 0;
130 if (!data.ReadUint32(state)) {
131 TLOGE(WmsLogTag::DEFAULT, "read state error");
132 return ERR_INVALID_DATA;
133 }
134 UpdateWindowState(static_cast<WindowState>(state));
135 break;
136 }
137 case WindowMessage::TRANS_ID_UPDATE_DRAG_EVENT: {
138 PointInfo point = {0, 0};
139 if (!data.ReadInt32(point.x) || !data.ReadInt32(point.y)) {
140 return ERR_INVALID_DATA;
141 }
142 uint32_t eventType = 0;
143 if (!data.ReadUint32(eventType) || eventType > static_cast<uint32_t>(DragEvent::DRAG_EVENT_END)) {
144 return ERR_INVALID_DATA;
145 }
146 DragEvent event = static_cast<DragEvent>(eventType);
147 UpdateWindowDragInfo(point, event);
148 break;
149 }
150 case WindowMessage::TRANS_ID_UPDATE_DISPLAY_ID: {
151 uint64_t from = 0;
152 uint64_t to = 0;
153 if (!data.ReadUint64(from) || !data.ReadUint64(to)) {
154 TLOGE(WmsLogTag::DEFAULT, "read display id error");
155 return ERR_INVALID_DATA;
156 }
157 UpdateDisplayId(from, to);
158 break;
159 }
160 case WindowMessage::TRANS_ID_UPDATE_OCCUPIED_AREA: {
161 sptr<OccupiedAreaChangeInfo> info = data.ReadParcelable<OccupiedAreaChangeInfo>();
162 if (info == nullptr) {
163 WLOGFE("OccupiedAreaChangeInfo is null");
164 return ERR_INVALID_DATA;
165 }
166 bool hasRSTransaction = data.ReadBool();
167 if (hasRSTransaction) {
168 auto rsTransaction = data.ReadParcelable<RSTransaction>();
169 if (!rsTransaction) {
170 WLOGFE("RSTransaction unMarsh failed");
171 return ERR_INVALID_DATA;
172 }
173 std::shared_ptr<RSTransaction> transaction(rsTransaction);
174 UpdateOccupiedAreaChangeInfo(info, transaction);
175 } else {
176 UpdateOccupiedAreaChangeInfo(info);
177 }
178 break;
179 }
180 case WindowMessage::TRANS_ID_UPDATE_OCCUPIED_AREA_AND_RECT: {
181 sptr<OccupiedAreaChangeInfo> info = data.ReadParcelable<OccupiedAreaChangeInfo>();
182 if (info == nullptr) {
183 TLOGE(WmsLogTag::WMS_KEYBOARD, "OccupiedAreaChangeInfo is null");
184 return ERR_INVALID_DATA;
185 }
186 int32_t posX = 0;
187 int32_t posY = 0;
188 uint32_t width = 0;
189 uint32_t height = 0;
190 if (!data.ReadInt32(posX) || !data.ReadInt32(posY) ||
191 !data.ReadUint32(width) || !data.ReadUint32(height)) {
192 TLOGE(WmsLogTag::WMS_KEYBOARD, "Rect value read failed.");
193 return ERR_INVALID_DATA;
194 }
195 struct Rect rect { posX, posY, width, height };
196 bool hasRSTransaction = false;
197 if (!data.ReadBool(hasRSTransaction)) {
198 TLOGE(WmsLogTag::WMS_KEYBOARD, "hasRSTransaction value read failed.");
199 return ERR_INVALID_DATA;
200 }
201 if (hasRSTransaction) {
202 auto rsTransaction = data.ReadParcelable<RSTransaction>();
203 if (!rsTransaction) {
204 TLOGE(WmsLogTag::WMS_KEYBOARD, "RSTransaction unMarsh failed");
205 return ERR_INVALID_DATA;
206 }
207 std::shared_ptr<RSTransaction> transaction(rsTransaction);
208 UpdateOccupiedAreaAndRect(info, rect, transaction);
209 } else {
210 UpdateOccupiedAreaAndRect(info, rect);
211 }
212 break;
213 }
214 case WindowMessage::TRANS_ID_UPDATE_ACTIVE_STATUS: {
215 bool isActive = data.ReadBool();
216 UpdateActiveStatus(isActive);
217 break;
218 }
219 case WindowMessage::TRANS_ID_GET_WINDOW_PROPERTY: {
220 auto property = GetWindowProperty();
221 reply.WriteParcelable(property.GetRefPtr());
222 break;
223 }
224 case WindowMessage::TRANS_ID_NOTIFY_OUTSIDE_PRESSED: {
225 NotifyTouchOutside();
226 break;
227 }
228 case WindowMessage::TRANS_ID_NOTIFY_SCREEN_SHOT: {
229 NotifyScreenshot();
230 break;
231 }
232 case WindowMessage::TRANS_ID_NOTIFY_DESTROY: {
233 NotifyDestroy();
234 break;
235 }
236 case WindowMessage::TRANS_ID_NOTIFY_FOREGROUND: {
237 NotifyForeground();
238 break;
239 }
240 case WindowMessage::TRANS_ID_NOTIFY_BACKGROUND: {
241 NotifyBackground();
242 break;
243 }
244 case WindowMessage::TRANS_ID_DUMP_INFO: {
245 std::vector<std::string> params;
246 if (!data.ReadStringVector(¶ms)) {
247 WLOGFE("Fail to read params");
248 return ERR_INVALID_DATA;
249 }
250 DumpInfo(params);
251 break;
252 }
253 case WindowMessage::TRANS_ID_NOTIFY_CLIENT_POINT_UP: {
254 auto pointerEvent = MMI::PointerEvent::Create();
255 if (!pointerEvent || !pointerEvent->ReadFromParcel(data)) {
256 WLOGFE("Read Pointer Event failed");
257 return ERR_INVALID_DATA;
258 }
259 NotifyWindowClientPointUp(pointerEvent);
260 break;
261 }
262 case WindowMessage::TRANS_ID_UPDATE_ZOOM_TRANSFORM: {
263 Transform trans;
264 trans.Unmarshalling(data);
265 bool isDisplayZoomOn = data.ReadBool();
266 UpdateZoomTransform(trans, isDisplayZoomOn);
267 break;
268 }
269 case WindowMessage::TRANS_ID_RESTORE_SPLIT_WINDOW_MODE: {
270 uint32_t splitWindowMode = 0;
271 if (!data.ReadUint32(splitWindowMode)) {
272 TLOGE(WmsLogTag::WMS_LAYOUT, "read splitWindowMode failed");
273 return ERR_INVALID_DATA;
274 }
275 RestoreSplitWindowMode(splitWindowMode);
276 break;
277 }
278 case WindowMessage::TRANS_ID_CONSUME_KEY_EVENT: {
279 auto event = MMI::KeyEvent::Create();
280 if (!event || !event->ReadFromParcel(data)) {
281 WLOGFE("Read Pointer Event failed");
282 return ERR_INVALID_DATA;
283 }
284 ConsumeKeyEvent(event);
285 break;
286 }
287 case WindowMessage::TRANS_ID_NOTIFY_FOREGROUND_INTERACTIVE_STATUS: {
288 bool interactive = data.ReadBool();
289 NotifyForegroundInteractiveStatus(interactive);
290 break;
291 }
292 case WindowMessage::TRANS_ID_NOTIFY_MMI_SERVICE_ONLINE: {
293 uint32_t winId = data.ReadUint32();
294 NotifyMMIServiceOnline(winId);
295 break;
296 }
297 default:
298 WLOGFW("unknown transaction code %{public}d", code);
299 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
300 }
301 return ERR_NONE;
302 }
303 } // namespace Rosen
304 } // namespace OHOS
305