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/display_manager_agent_stub.h"
17
18 #include <vector>
19
20 #include "display_info.h"
21 #include "display_change_info.h"
22 #include "dm_common.h"
23 #include "marshalling_helper.h"
24 #include "screen_info.h"
25 #include "window_manager_hilog.h"
26
27 namespace OHOS::Rosen {
28
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)29 int32_t DisplayManagerAgentStub::OnRemoteRequest(uint32_t code, MessageParcel& data,
30 MessageParcel& reply, MessageOption& option)
31 {
32 TLOGD(WmsLogTag::DMS, "code:%{public}u", code);
33 if (data.ReadInterfaceToken() != GetDescriptor()) {
34 TLOGE(WmsLogTag::DMS, "InterfaceToken check failed");
35 return -1;
36 }
37 switch (code) {
38 case TRANS_ID_NOTIFY_DISPLAY_POWER_EVENT: {
39 return ProcNotifyDisplayPowerEvent(data);
40 }
41 case TRANS_ID_NOTIFY_DISPLAY_STATE_CHANGED: {
42 return ProcNotifyDisplayStateChanged(data);
43 }
44 case TRANS_ID_ON_SCREEN_CONNECT: {
45 return ProcScreenConnect(data);
46 }
47 case TRANS_ID_ON_SCREEN_DISCONNECT: {
48 return ProcScreenDisconnect(data);
49 }
50 case TRANS_ID_ON_SCREEN_CHANGED: {
51 return ProcScreenChanged(data);
52 }
53 case TRANS_ID_ON_SCREENGROUP_CHANGED: {
54 return ProcScreenGroupChanged(data);
55 }
56 case TRANS_ID_ON_DISPLAY_CONNECT: {
57 return ProcDisplayConnect(data);
58 }
59 case TRANS_ID_ON_DISPLAY_DISCONNECT: {
60 return ProcDisplayDisconnect(data);
61 }
62 case TRANS_ID_ON_DISPLAY_CHANGED: {
63 return ProcDisplayChanged(data);
64 }
65 case TRANS_ID_ON_SCREEN_SHOT: {
66 return ProcScreenShot(data);
67 }
68 case TRANS_ID_ON_PRIVATE_WINDOW: {
69 return ProcPrivateWindow(data);
70 }
71 case TRANS_ID_ON_PRIVATE_WINDOW_LIST: {
72 return ProcPrivateWindowList(data);
73 }
74 case TRANS_ID_ON_FOLD_STATUS_CHANGED: {
75 return ProcFoldStatusChanged(data);
76 }
77 case TRANS_ID_ON_DISPLAY_CHANGE_INFO_CHANGED: {
78 return ProcDisplayChangeInfoChanged(data);
79 }
80 case TRANS_ID_ON_DISPLAY_MODE_CHANGED: {
81 return ProcDisplayModechanged(data);
82 }
83 case TRANS_ID_ON_AVAILABLE_AREA_CHANGED: {
84 return ProcAvailableAreaChanged(data);
85 }
86 case TRANS_ID_ON_FOLD_ANGLE_CHANGED: {
87 return ProcFoldAngleChanged(data);
88 }
89 case TRANS_ID_ON_CAPTURE_STATUS_CHANGED: {
90 return ProcCaptureStatusChanged(data);
91 }
92 case TRANS_ID_ON_SCREEN_MAGNETIC_STATE_CHANGED: {
93 return ProcScreenMagneticStatechanged(data);
94 }
95 case TRANS_ID_ON_SCREEN_MODE_CHANGED: {
96 std::vector<sptr<ScreenInfo>> screenInfos;
97 if (!MarshallingHelper::UnmarshallingVectorParcelableObj<ScreenInfo>(data, screenInfos)) {
98 TLOGE(WmsLogTag::DMS, "Read ScreenInfo failed");
99 return -1;
100 }
101 NotifyScreenModeChange(screenInfos);
102 break;
103 }
104 case TRANS_ID_NOTIFY_ABNORMAL_SCREEN_CONNECT_CHANGED: {
105 ScreenId screenId;
106 if (!data.ReadUint64(screenId)) {
107 TLOGE(WmsLogTag::DMS, "Read screenId failed");
108 return -1;
109 }
110 NotifyAbnormalScreenConnectChange(screenId);
111 break;
112 }
113 default: {
114 TLOGW(WmsLogTag::DMS, "unknown transaction code %{public}d", code);
115 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
116 }
117 }
118 return 0;
119 }
120
ProcFoldAngleChanged(MessageParcel & data)121 int32_t DisplayManagerAgentStub::ProcFoldAngleChanged(MessageParcel& data)
122 {
123 std::vector<float> foldAngles;
124 if (!data.ReadFloatVector(&foldAngles)) {
125 TLOGE(WmsLogTag::DMS, "Read foldAngles failed");
126 return -1;
127 }
128 NotifyFoldAngleChanged(foldAngles);
129 return 0;
130 }
131
ProcCaptureStatusChanged(MessageParcel & data)132 int32_t DisplayManagerAgentStub::ProcCaptureStatusChanged(MessageParcel& data)
133 {
134 bool isCapture = data.ReadBool();
135 NotifyCaptureStatusChanged(isCapture);
136 return 0;
137 }
138
ProcNotifyDisplayPowerEvent(MessageParcel & data)139 int32_t DisplayManagerAgentStub::ProcNotifyDisplayPowerEvent(MessageParcel& data)
140 {
141 DisplayPowerEvent event = static_cast<DisplayPowerEvent>(data.ReadUint32());
142 EventStatus status = static_cast<EventStatus>(data.ReadUint32());
143 NotifyDisplayPowerEvent(event, status);
144 return 0;
145 }
146
ProcNotifyDisplayStateChanged(MessageParcel & data)147 int32_t DisplayManagerAgentStub::ProcNotifyDisplayStateChanged(MessageParcel& data)
148 {
149 DisplayState state = static_cast<DisplayState>(data.ReadUint32());
150 DisplayId id = static_cast<DisplayId>(data.ReadUint64());
151 NotifyDisplayStateChanged(id, state);
152 return 0;
153 }
154
ProcScreenConnect(MessageParcel & data)155 int32_t DisplayManagerAgentStub::ProcScreenConnect(MessageParcel& data)
156 {
157 sptr<ScreenInfo> screenInfo = data.ReadParcelable<ScreenInfo>();
158 OnScreenConnect(screenInfo);
159 return 0;
160 }
161
ProcScreenDisconnect(MessageParcel & data)162 int32_t DisplayManagerAgentStub::ProcScreenDisconnect(MessageParcel& data)
163 {
164 ScreenId screenId;
165 if (!data.ReadUint64(screenId)) {
166 TLOGE(WmsLogTag::DMS, "Read ScreenId failed");
167 return -1;
168 }
169 OnScreenDisconnect(screenId);
170 return 0;
171 }
172
ProcScreenChanged(MessageParcel & data)173 int32_t DisplayManagerAgentStub::ProcScreenChanged(MessageParcel& data)
174 {
175 sptr<ScreenInfo> screenInfo = data.ReadParcelable<ScreenInfo>();
176 uint32_t event;
177 if (!data.ReadUint32(event)) {
178 TLOGE(WmsLogTag::DMS, "Read ScreenChangeEvent failed");
179 return -1;
180 }
181 OnScreenChange(screenInfo, static_cast<ScreenChangeEvent>(event));
182 return 0;
183 }
184
ProcScreenGroupChanged(MessageParcel & data)185 int32_t DisplayManagerAgentStub::ProcScreenGroupChanged(MessageParcel& data)
186 {
187 std::string trigger;
188 if (!data.ReadString(trigger)) {
189 TLOGE(WmsLogTag::DMS, "Read trigger failed");
190 return -1;
191 }
192 std::vector<sptr<ScreenInfo>> screenInfos;
193 if (!MarshallingHelper::UnmarshallingVectorParcelableObj<ScreenInfo>(data, screenInfos)) {
194 TLOGE(WmsLogTag::DMS, "Read ScreenInfo failed");
195 return -1;
196 }
197 uint32_t event;
198 if (!data.ReadUint32(event)) {
199 TLOGE(WmsLogTag::DMS, "Read ScreenChangeEvent failed");
200 return -1;
201 }
202 OnScreenGroupChange(trigger, screenInfos, static_cast<ScreenGroupChangeEvent>(event));
203 return 0;
204 }
205
ProcDisplayConnect(MessageParcel & data)206 int32_t DisplayManagerAgentStub::ProcDisplayConnect(MessageParcel& data)
207 {
208 sptr<DisplayInfo> displayInfo = data.ReadParcelable<DisplayInfo>();
209 OnDisplayCreate(displayInfo);
210 return 0;
211 }
212
ProcDisplayDisconnect(MessageParcel & data)213 int32_t DisplayManagerAgentStub::ProcDisplayDisconnect(MessageParcel& data)
214 {
215 DisplayId displayId;
216 if (!data.ReadUint64(displayId)) {
217 TLOGE(WmsLogTag::DMS, "Read DisplayId failed");
218 return -1;
219 }
220 OnDisplayDestroy(displayId);
221 return 0;
222 }
223
ProcDisplayChanged(MessageParcel & data)224 int32_t DisplayManagerAgentStub::ProcDisplayChanged(MessageParcel& data)
225 {
226 sptr<DisplayInfo> displayInfo = data.ReadParcelable<DisplayInfo>();
227 uint32_t event;
228 if (!data.ReadUint32(event)) {
229 TLOGE(WmsLogTag::DMS, "Read DisplayChangeEvent failed");
230 return -1;
231 }
232 OnDisplayChange(displayInfo, static_cast<DisplayChangeEvent>(event));
233 return 0;
234 }
235
ProcScreenShot(MessageParcel & data)236 int32_t DisplayManagerAgentStub::ProcScreenShot(MessageParcel& data)
237 {
238 sptr<ScreenshotInfo> snapshotInfo = data.ReadParcelable<ScreenshotInfo>();
239 OnScreenshot(snapshotInfo);
240 return 0;
241 }
242
ProcPrivateWindow(MessageParcel & data)243 int32_t DisplayManagerAgentStub::ProcPrivateWindow(MessageParcel& data)
244 {
245 bool hasPrivate = data.ReadBool();
246 NotifyPrivateWindowStateChanged(hasPrivate);
247 return 0;
248 }
249
ProcPrivateWindowList(MessageParcel & data)250 int32_t DisplayManagerAgentStub::ProcPrivateWindowList(MessageParcel& data)
251 {
252 DisplayId displayId = static_cast<DisplayId>(data.ReadUint64());
253 std::vector<std::string> privacyWindowList;
254 data.ReadStringVector(&privacyWindowList);
255 NotifyPrivateStateWindowListChanged(displayId, privacyWindowList);
256 return 0;
257 }
258
ProcFoldStatusChanged(MessageParcel & data)259 int32_t DisplayManagerAgentStub::ProcFoldStatusChanged(MessageParcel& data)
260 {
261 uint32_t foldStatus;
262 if (!data.ReadUint32(foldStatus)) {
263 TLOGE(WmsLogTag::DMS, "Read FoldStatus failed");
264 return -1;
265 }
266 NotifyFoldStatusChanged(static_cast<FoldStatus>(foldStatus));
267 return 0;
268 }
269
ProcDisplayChangeInfoChanged(MessageParcel & data)270 int32_t DisplayManagerAgentStub::ProcDisplayChangeInfoChanged(MessageParcel& data)
271 {
272 sptr<DisplayChangeInfo> info;
273 info = DisplayChangeInfo::Unmarshalling(data);
274 if (!info) {
275 TLOGE(WmsLogTag::DMS, "Read DisplayChangeInfo failed");
276 return -1;
277 }
278 NotifyDisplayChangeInfoChanged(info);
279 return 0;
280 }
281
ProcDisplayModechanged(MessageParcel & data)282 int32_t DisplayManagerAgentStub::ProcDisplayModechanged(MessageParcel& data)
283 {
284 uint32_t displayMode;
285 if (!data.ReadUint32(displayMode)) {
286 TLOGE(WmsLogTag::DMS, "Read FoldDisplayMode failed");
287 return -1;
288 }
289 NotifyDisplayModeChanged(static_cast<FoldDisplayMode>(displayMode));
290 return 0;
291 }
292
ProcAvailableAreaChanged(MessageParcel & data)293 int32_t DisplayManagerAgentStub::ProcAvailableAreaChanged(MessageParcel& data)
294 {
295 DMRect rect;
296 DisplayId displayId = static_cast<DisplayId>(data.ReadUint64());
297 rect.posX_ = data.ReadInt32();
298 rect.posY_ = data.ReadInt32();
299 rect.width_ = data.ReadUint32();
300 rect.height_ = data.ReadUint32();
301 NotifyAvailableAreaChanged(rect, displayId);
302 return 0;
303 }
304
ProcScreenMagneticStatechanged(MessageParcel & data)305 int32_t DisplayManagerAgentStub::ProcScreenMagneticStatechanged(MessageParcel& data)
306 {
307 bool isMagneticState = data.ReadBool();
308 NotifyScreenMagneticStateChanged(isMagneticState);
309 return 0;
310 }
311 } // namespace OHOS::Rosen
312