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