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 DisplayPowerEvent event = static_cast<DisplayPowerEvent>(data.ReadUint32());
42 EventStatus status = static_cast<EventStatus>(data.ReadUint32());
43 NotifyDisplayPowerEvent(event, status);
44 break;
45 }
46 case TRANS_ID_NOTIFY_DISPLAY_STATE_CHANGED: {
47 DisplayState state = static_cast<DisplayState>(data.ReadUint32());
48 DisplayId id = static_cast<DisplayId>(data.ReadUint64());
49 NotifyDisplayStateChanged(id, state);
50 break;
51 }
52 case TRANS_ID_ON_SCREEN_CONNECT: {
53 sptr<ScreenInfo> screenInfo = data.ReadParcelable<ScreenInfo>();
54 OnScreenConnect(screenInfo);
55 break;
56 }
57 case TRANS_ID_ON_SCREEN_DISCONNECT: {
58 ScreenId screenId;
59 if (!data.ReadUint64(screenId)) {
60 WLOGFE("Read ScreenId failed");
61 return -1;
62 }
63 OnScreenDisconnect(screenId);
64 break;
65 }
66 case TRANS_ID_ON_SCREEN_CHANGED: {
67 sptr<ScreenInfo> screenInfo = data.ReadParcelable<ScreenInfo>();
68 uint32_t event;
69 if (!data.ReadUint32(event)) {
70 WLOGFE("Read ScreenChangeEvent failed");
71 return -1;
72 }
73 OnScreenChange(screenInfo, static_cast<ScreenChangeEvent>(event));
74 break;
75 }
76 case TRANS_ID_ON_SCREENGROUP_CHANGED: {
77 std::string trigger;
78 if (!data.ReadString(trigger)) {
79 WLOGFE("Read trigger failed");
80 return -1;
81 }
82 std::vector<sptr<ScreenInfo>> screenInfos;
83 if (!MarshallingHelper::UnmarshallingVectorParcelableObj<ScreenInfo>(data, screenInfos)) {
84 WLOGFE("Read ScreenInfo failed");
85 return -1;
86 }
87 uint32_t event;
88 if (!data.ReadUint32(event)) {
89 WLOGFE("Read ScreenChangeEvent failed");
90 return -1;
91 }
92 OnScreenGroupChange(trigger, screenInfos, static_cast<ScreenGroupChangeEvent>(event));
93 break;
94 }
95 case TRANS_ID_ON_DISPLAY_CONNECT: {
96 sptr<DisplayInfo> displayInfo = data.ReadParcelable<DisplayInfo>();
97 OnDisplayCreate(displayInfo);
98 break;
99 }
100 case TRANS_ID_ON_DISPLAY_DISCONNECT: {
101 DisplayId displayId;
102 if (!data.ReadUint64(displayId)) {
103 WLOGFE("Read DisplayId failed");
104 return -1;
105 }
106 OnDisplayDestroy(displayId);
107 break;
108 }
109 case TRANS_ID_ON_DISPLAY_CHANGED: {
110 sptr<DisplayInfo> displayInfo = data.ReadParcelable<DisplayInfo>();
111 uint32_t event;
112 if (!data.ReadUint32(event)) {
113 WLOGFE("Read DisplayChangeEvent failed");
114 return -1;
115 }
116 OnDisplayChange(displayInfo, static_cast<DisplayChangeEvent>(event));
117 break;
118 }
119 case TRANS_ID_ON_SCREEN_SHOT: {
120 sptr<ScreenshotInfo> snapshotInfo = data.ReadParcelable<ScreenshotInfo>();
121 OnScreenshot(snapshotInfo);
122 break;
123 }
124 case TRANS_ID_ON_PRIVATE_WINDOW: {
125 bool hasPrivate = data.ReadBool();
126 NotifyPrivateWindowStateChanged(hasPrivate);
127 break;
128 }
129 case TRANS_ID_ON_PRIVATE_WINDOW_LIST: {
130 return ProcPrivateWindowList(data);
131 }
132 case TRANS_ID_ON_FOLD_STATUS_CHANGED: {
133 uint32_t foldStatus;
134 if (!data.ReadUint32(foldStatus)) {
135 WLOGFE("Read FoldStatus failed");
136 return -1;
137 }
138 NotifyFoldStatusChanged(static_cast<FoldStatus>(foldStatus));
139 break;
140 }
141 case TRANS_ID_ON_DISPLAY_CHANGE_INFO_CHANGED: {
142 sptr<DisplayChangeInfo> info;
143 info = DisplayChangeInfo::Unmarshalling(data);
144 if (!info) {
145 WLOGFE("Read DisplayChangeInfo failed");
146 return -1;
147 }
148 NotifyDisplayChangeInfoChanged(info);
149 break;
150 }
151 case TRANS_ID_ON_DISPLAY_MODE_CHANGED: {
152 uint32_t displayMode;
153 if (!data.ReadUint32(displayMode)) {
154 WLOGFE("Read FoldDisplayMode failed");
155 return -1;
156 }
157 NotifyDisplayModeChanged(static_cast<FoldDisplayMode>(displayMode));
158 break;
159 }
160 case TRANS_ID_ON_AVAILABLE_AREA_CHANGED: {
161 DMRect rect;
162 rect.posX_ = data.ReadInt32();
163 rect.posY_ = data.ReadInt32();
164 rect.width_ = data.ReadUint32();
165 rect.height_ = data.ReadUint32();
166 NotifyAvailableAreaChanged(rect);
167 break;
168 }
169 case TRANS_ID_ON_FOLD_ANGLE_CHANGED: {
170 return ProcFoldAngleChanged(data);
171 }
172 case TRANS_ID_ON_CAPTURE_STATUS_CHANGED: {
173 return ProcCaptureStatusChanged(data);
174 }
175 case TRANS_ID_ON_SCREEN_MODE_CHANGED: {
176 std::vector<sptr<ScreenInfo>> screenInfos;
177 if (!MarshallingHelper::UnmarshallingVectorParcelableObj<ScreenInfo>(data, screenInfos)) {
178 WLOGFE("Read ScreenInfo failed");
179 return -1;
180 }
181 NotifyScreenModeChange(screenInfos);
182 break;
183 }
184 default: {
185 WLOGFW("unknown transaction code %{public}d", code);
186 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
187 }
188 }
189 return 0;
190 }
191
ProcFoldAngleChanged(MessageParcel & data)192 int32_t DisplayManagerAgentStub::ProcFoldAngleChanged(MessageParcel& data)
193 {
194 std::vector<float> foldAngles;
195 if (!data.ReadFloatVector(&foldAngles)) {
196 WLOGFE("Read foldAngles failed");
197 return -1;
198 }
199 NotifyFoldAngleChanged(foldAngles);
200 return 0;
201 }
202
ProcCaptureStatusChanged(MessageParcel & data)203 int32_t DisplayManagerAgentStub::ProcCaptureStatusChanged(MessageParcel& data)
204 {
205 bool isCapture = data.ReadBool();
206 NotifyCaptureStatusChanged(isCapture);
207 return 0;
208 }
209
ProcPrivateWindowList(MessageParcel & data)210 int32_t DisplayManagerAgentStub::ProcPrivateWindowList(MessageParcel& data)
211 {
212 DisplayId displayId = static_cast<DisplayId>(data.ReadUint64());
213 std::vector<std::string> privacyWindowList;
214 data.ReadStringVector(&privacyWindowList);
215 NotifyPrivateStateWindowListChanged(displayId, privacyWindowList);
216 return 0;
217 }
218 } // namespace OHOS::Rosen
219