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 struct Rect rect { data.ReadInt32(), data.ReadInt32(), data.ReadUint32(), data.ReadUint32() };
44 bool decoStatus = data.ReadBool();
45 WindowSizeChangeReason reason = static_cast<WindowSizeChangeReason>(data.ReadUint32());
46 bool hasRSTransaction = data.ReadBool();
47 if (hasRSTransaction) {
48 auto rsTransaction = data.ReadParcelable<RSTransaction>();
49 if (!rsTransaction) {
50 WLOGFE("RSTransaction unMarsh failed");
51 return -1;
52 }
53 std::shared_ptr<RSTransaction> transaction(rsTransaction);
54 UpdateWindowRect(rect, decoStatus, reason, transaction);
55 } else {
56 UpdateWindowRect(rect, decoStatus, reason);
57 }
58 break;
59 }
60 case WindowMessage::TRANS_ID_UPDATE_WINDOW_MODE: {
61 WindowMode mode = static_cast<WindowMode>(data.ReadUint32());
62 UpdateWindowMode(mode);
63 break;
64 }
65 case WindowMessage::TRANS_ID_UPDATE_MODE_SUPPORT_INFO: {
66 uint32_t modeSupportInfo = data.ReadUint32();
67 UpdateWindowModeSupportInfo(modeSupportInfo);
68 break;
69 }
70 case WindowMessage::TRANS_ID_UPDATE_FOCUS_STATUS: {
71 bool focused = data.ReadBool();
72 UpdateFocusStatus(focused);
73 break;
74 }
75 case WindowMessage::TRANS_ID_UPDATE_AVOID_AREA: {
76 sptr<AvoidArea> avoidArea = data.ReadStrongParcelable<AvoidArea>();
77 if (avoidArea == nullptr) {
78 return ERR_INVALID_DATA;
79 }
80 uint32_t type;
81 if (!data.ReadUint32(type)) {
82 return ERR_INVALID_DATA;
83 }
84 UpdateAvoidArea(avoidArea, static_cast<AvoidAreaType>(type));
85 break;
86 }
87 case WindowMessage::TRANS_ID_UPDATE_WINDOW_STATE: {
88 UpdateWindowState(static_cast<WindowState>(data.ReadUint32()));
89 break;
90 }
91 case WindowMessage::TRANS_ID_UPDATE_DRAG_EVENT: {
92 PointInfo point;
93 point.x = data.ReadInt32();
94 point.y = data.ReadInt32();
95 DragEvent event = static_cast<DragEvent>(data.ReadUint32());
96 UpdateWindowDragInfo(point, event);
97 break;
98 }
99 case WindowMessage::TRANS_ID_UPDATE_DISPLAY_ID: {
100 UpdateDisplayId(data.ReadUint64(), data.ReadUint64());
101 break;
102 }
103 case WindowMessage::TRANS_ID_UPDATE_OCCUPIED_AREA: {
104 sptr<OccupiedAreaChangeInfo> info = data.ReadParcelable<OccupiedAreaChangeInfo>();
105 if (info == nullptr) {
106 WLOGFE("OccupiedAreaChangeInfo is null");
107 return ERR_INVALID_DATA;
108 }
109 bool hasRSTransaction = data.ReadBool();
110 if (hasRSTransaction) {
111 auto rsTransaction = data.ReadParcelable<RSTransaction>();
112 if (!rsTransaction) {
113 WLOGFE("RSTransaction unMarsh failed");
114 return ERR_INVALID_DATA;
115 }
116 std::shared_ptr<RSTransaction> transaction(rsTransaction);
117 UpdateOccupiedAreaChangeInfo(info, transaction);
118 } else {
119 UpdateOccupiedAreaChangeInfo(info);
120 }
121
122 break;
123 }
124 case WindowMessage::TRANS_ID_UPDATE_OCCUPIED_AREA_AND_RECT: {
125 sptr<OccupiedAreaChangeInfo> info = data.ReadParcelable<OccupiedAreaChangeInfo>();
126 if (info == nullptr) {
127 WLOGFE("OccupiedAreaChangeInfo is null");
128 return ERR_INVALID_DATA;
129 }
130 struct Rect rect { data.ReadInt32(), data.ReadInt32(), data.ReadUint32(), data.ReadUint32() };
131 bool hasRSTransaction = data.ReadBool();
132 if (hasRSTransaction) {
133 auto rsTransaction = data.ReadParcelable<RSTransaction>();
134 if (!rsTransaction) {
135 WLOGFE("RSTransaction unMarsh failed");
136 return ERR_INVALID_DATA;
137 }
138 std::shared_ptr<RSTransaction> transaction(rsTransaction);
139 UpdateOccupiedAreaAndRect(info, rect, transaction);
140 } else {
141 UpdateOccupiedAreaAndRect(info, rect);
142 }
143
144 break;
145 }
146 case WindowMessage::TRANS_ID_UPDATE_ACTIVE_STATUS: {
147 bool isActive = data.ReadBool();
148 UpdateActiveStatus(isActive);
149 break;
150 }
151 case WindowMessage::TRANS_ID_GET_WINDOW_PROPERTY: {
152 auto property = GetWindowProperty();
153 reply.WriteParcelable(property.GetRefPtr());
154 break;
155 }
156 case WindowMessage::TRANS_ID_NOTIFY_OUTSIDE_PRESSED: {
157 NotifyTouchOutside();
158 break;
159 }
160 case WindowMessage::TRANS_ID_NOTIFY_SCREEN_SHOT: {
161 NotifyScreenshot();
162 break;
163 }
164 case WindowMessage::TRANS_ID_NOTIFY_DESTROY: {
165 NotifyDestroy();
166 break;
167 }
168 case WindowMessage::TRANS_ID_NOTIFY_FOREGROUND: {
169 NotifyForeground();
170 break;
171 }
172 case WindowMessage::TRANS_ID_NOTIFY_BACKGROUND: {
173 NotifyBackground();
174 break;
175 }
176 case WindowMessage::TRANS_ID_DUMP_INFO: {
177 std::vector<std::string> params;
178 if (!data.ReadStringVector(¶ms)) {
179 WLOGFE("Fail to read params");
180 return ERR_INVALID_DATA;
181 }
182 DumpInfo(params);
183 break;
184 }
185 case WindowMessage::TRANS_ID_NOTIFY_CLIENT_POINT_UP: {
186 auto pointerEvent = MMI::PointerEvent::Create();
187 if (!pointerEvent || !pointerEvent->ReadFromParcel(data)) {
188 WLOGFE("Read Pointer Event failed");
189 return ERR_INVALID_DATA;
190 }
191 NotifyWindowClientPointUp(pointerEvent);
192 break;
193 }
194 case WindowMessage::TRANS_ID_UPDATE_ZOOM_TRANSFORM: {
195 Transform trans;
196 trans.Unmarshalling(data);
197 bool isDisplayZoomOn = data.ReadBool();
198 UpdateZoomTransform(trans, isDisplayZoomOn);
199 break;
200 }
201 case WindowMessage::TRANS_ID_RESTORE_SPLIT_WINDOW_MODE: {
202 RestoreSplitWindowMode(data.ReadUint32());
203 break;
204 }
205 case WindowMessage::TRANS_ID_CONSUME_KEY_EVENT: {
206 auto event = MMI::KeyEvent::Create();
207 if (!event || !event->ReadFromParcel(data)) {
208 WLOGFE("Read Pointer Event failed");
209 return ERR_INVALID_DATA;
210 }
211 ConsumeKeyEvent(event);
212 break;
213 }
214 case WindowMessage::TRANS_ID_NOTIFY_FOREGROUND_INTERACTIVE_STATUS: {
215 bool interactive = data.ReadBool();
216 NotifyForegroundInteractiveStatus(interactive);
217 break;
218 }
219 default:
220 WLOGFW("unknown transaction code %{public}d", code);
221 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
222 }
223 return ERR_NONE;
224 }
225 } // namespace Rosen
226 } // namespace OHOS
227