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