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 "display_manager_stub.h"
17
18 #include "dm_common.h"
19
20 #include <ipc_skeleton.h>
21
22 #include "marshalling_helper.h"
23 #include "window_manager_hilog.h"
24
25 #include "transaction/rs_interfaces.h"
26
27 namespace OHOS::Rosen {
28 namespace {
29 constexpr HiviewDFX::HiLogLabel LABEL = {LOG_CORE, HILOG_DOMAIN_DISPLAY, "DisplayManagerStub"};
30 }
31
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)32 int32_t DisplayManagerStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply,
33 MessageOption &option)
34 {
35 WLOGFD("OnRemoteRequest code is %{public}u", code);
36 if (data.ReadInterfaceToken() != GetDescriptor()) {
37 WLOGFE("InterfaceToken check failed");
38 return -1;
39 }
40 DisplayManagerMessage msgId = static_cast<DisplayManagerMessage>(code);
41 switch (msgId) {
42 case DisplayManagerMessage::TRANS_ID_GET_DEFAULT_DISPLAY_INFO: {
43 auto info = GetDefaultDisplayInfo();
44 reply.WriteParcelable(info);
45 break;
46 }
47 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_BY_ID: {
48 DisplayId displayId = data.ReadUint64();
49 auto info = GetDisplayInfoById(displayId);
50 reply.WriteParcelable(info);
51 break;
52 }
53 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_BY_SCREEN: {
54 ScreenId screenId = data.ReadUint64();
55 auto info = GetDisplayInfoByScreen(screenId);
56 reply.WriteParcelable(info);
57 break;
58 }
59 case DisplayManagerMessage::TRANS_ID_CREATE_VIRTUAL_SCREEN: {
60 std::string name = data.ReadString();
61 uint32_t width = data.ReadUint32();
62 uint32_t height = data.ReadUint32();
63 float density = data.ReadFloat();
64 int32_t flags = data.ReadInt32();
65 bool isForShot = data.ReadBool();
66 bool isSurfaceValid = data.ReadBool();
67 sptr<Surface> surface = nullptr;
68 if (isSurfaceValid) {
69 sptr<IRemoteObject> surfaceObject = data.ReadRemoteObject();
70 sptr<IBufferProducer> bp = iface_cast<IBufferProducer>(surfaceObject);
71 surface = Surface::CreateSurfaceAsProducer(bp);
72 }
73 sptr<IRemoteObject> virtualScreenAgent = data.ReadRemoteObject();
74 VirtualScreenOption virScrOption = {
75 .name_ = name,
76 .width_ = width,
77 .height_ = height,
78 .density_ = density,
79 .surface_ = surface,
80 .flags_ = flags,
81 .isForShot_ = isForShot
82 };
83 ScreenId screenId = CreateVirtualScreen(virScrOption, virtualScreenAgent);
84 reply.WriteUint64(static_cast<uint64_t>(screenId));
85 break;
86 }
87 case DisplayManagerMessage::TRANS_ID_DESTROY_VIRTUAL_SCREEN: {
88 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
89 DMError result = DestroyVirtualScreen(screenId);
90 reply.WriteInt32(static_cast<int32_t>(result));
91 break;
92 }
93 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_SURFACE: {
94 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
95 bool isSurfaceValid = data.ReadBool();
96 sptr<IBufferProducer> bp = nullptr;
97 if (isSurfaceValid) {
98 sptr<IRemoteObject> surfaceObject = data.ReadRemoteObject();
99 bp = iface_cast<IBufferProducer>(surfaceObject);
100 }
101 DMError result = SetVirtualScreenSurface(screenId, bp);
102 reply.WriteInt32(static_cast<int32_t>(result));
103 break;
104 }
105 case DisplayManagerMessage::TRANS_ID_SET_ORIENTATION: {
106 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
107 Orientation orientation = static_cast<Orientation>(data.ReadUint32());
108 DMError ret = SetOrientation(screenId, orientation);
109 reply.WriteInt32(static_cast<int32_t>(ret));
110 break;
111 }
112 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_SNAPSHOT: {
113 DisplayId displayId = data.ReadUint64();
114 DmErrorCode errorCode = DmErrorCode::DM_OK;
115 std::shared_ptr<Media::PixelMap> displaySnapshot = GetDisplaySnapshot(displayId, &errorCode);
116 reply.WriteParcelable(displaySnapshot == nullptr ? nullptr : displaySnapshot.get());
117 reply.WriteInt32(static_cast<int32_t>(errorCode));
118 break;
119 }
120 case DisplayManagerMessage::TRANS_ID_REGISTER_DISPLAY_MANAGER_AGENT: {
121 auto agent = iface_cast<IDisplayManagerAgent>(data.ReadRemoteObject());
122 auto type = static_cast<DisplayManagerAgentType>(data.ReadUint32());
123 DMError ret = RegisterDisplayManagerAgent(agent, type);
124 reply.WriteInt32(static_cast<int32_t>(ret));
125 break;
126 }
127 case DisplayManagerMessage::TRANS_ID_UNREGISTER_DISPLAY_MANAGER_AGENT: {
128 auto agent = iface_cast<IDisplayManagerAgent>(data.ReadRemoteObject());
129 auto type = static_cast<DisplayManagerAgentType>(data.ReadUint32());
130 DMError ret = UnregisterDisplayManagerAgent(agent, type);
131 reply.WriteInt32(static_cast<int32_t>(ret));
132 break;
133 }
134 case DisplayManagerMessage::TRANS_ID_WAKE_UP_BEGIN: {
135 PowerStateChangeReason reason = static_cast<PowerStateChangeReason>(data.ReadUint32());
136 reply.WriteBool(WakeUpBegin(reason));
137 break;
138 }
139 case DisplayManagerMessage::TRANS_ID_WAKE_UP_END: {
140 reply.WriteBool(WakeUpEnd());
141 break;
142 }
143 case DisplayManagerMessage::TRANS_ID_SUSPEND_BEGIN: {
144 PowerStateChangeReason reason = static_cast<PowerStateChangeReason>(data.ReadUint32());
145 reply.WriteBool(SuspendBegin(reason));
146 break;
147 }
148 case DisplayManagerMessage::TRANS_ID_SUSPEND_END: {
149 reply.WriteBool(SuspendEnd());
150 break;
151 }
152 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_POWER_FOR_ALL: {
153 ScreenPowerState state = static_cast<ScreenPowerState>(data.ReadUint32());
154 PowerStateChangeReason reason = static_cast<PowerStateChangeReason>(data.ReadUint32());
155 reply.WriteBool(SetScreenPowerForAll(state, reason));
156 break;
157 }
158 case DisplayManagerMessage::TRANS_ID_GET_SCREEN_POWER: {
159 ScreenId dmsScreenId;
160 if (!data.ReadUint64(dmsScreenId)) {
161 WLOGFE("fail to read dmsScreenId.");
162 break;
163 }
164 reply.WriteUint32(static_cast<uint32_t>(GetScreenPower(dmsScreenId)));
165 break;
166 }
167 case DisplayManagerMessage::TRANS_ID_SET_DISPLAY_STATE: {
168 DisplayState state = static_cast<DisplayState>(data.ReadUint32());
169 reply.WriteBool(SetDisplayState(state));
170 break;
171 }
172 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_STATE: {
173 DisplayState state = GetDisplayState(data.ReadUint64());
174 reply.WriteUint32(static_cast<uint32_t>(state));
175 break;
176 }
177 case DisplayManagerMessage::TRANS_ID_NOTIFY_DISPLAY_EVENT: {
178 DisplayEvent event = static_cast<DisplayEvent>(data.ReadUint32());
179 NotifyDisplayEvent(event);
180 break;
181 }
182 case DisplayManagerMessage::TRANS_ID_SET_FREEZE_EVENT: {
183 std::vector<DisplayId> ids;
184 data.ReadUInt64Vector(&ids);
185 SetFreeze(ids, data.ReadBool());
186 break;
187 }
188 case DisplayManagerMessage::TRANS_ID_SCREEN_MAKE_MIRROR: {
189 ScreenId mainScreenId = static_cast<ScreenId>(data.ReadUint64());
190 std::vector<ScreenId> mirrorScreenId;
191 if (!data.ReadUInt64Vector(&mirrorScreenId)) {
192 WLOGE("fail to receive mirror screen in stub. screen:%{public}" PRIu64"", mainScreenId);
193 break;
194 }
195 ScreenId screenGroupId = INVALID_SCREEN_ID;
196 DMError ret = MakeMirror(mainScreenId, mirrorScreenId, screenGroupId);
197 reply.WriteInt32(static_cast<int32_t>(ret));
198 reply.WriteUint64(static_cast<uint64_t>(screenGroupId));
199 break;
200 }
201 case DisplayManagerMessage::TRANS_ID_GET_SCREEN_INFO_BY_ID: {
202 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
203 auto screenInfo = GetScreenInfoById(screenId);
204 reply.WriteStrongParcelable(screenInfo);
205 break;
206 }
207 case DisplayManagerMessage::TRANS_ID_GET_SCREEN_GROUP_INFO_BY_ID: {
208 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
209 auto screenGroupInfo = GetScreenGroupInfoById(screenId);
210 reply.WriteStrongParcelable(screenGroupInfo);
211 break;
212 }
213 case DisplayManagerMessage::TRANS_ID_GET_ALL_SCREEN_INFOS: {
214 std::vector<sptr<ScreenInfo>> screenInfos;
215 DMError ret = GetAllScreenInfos(screenInfos);
216 reply.WriteInt32(static_cast<int32_t>(ret));
217 if (!MarshallingHelper::MarshallingVectorParcelableObj<ScreenInfo>(reply, screenInfos)) {
218 WLOGE("fail to marshalling screenInfos in stub.");
219 }
220 break;
221 }
222 case DisplayManagerMessage::TRANS_ID_GET_ALL_DISPLAYIDS: {
223 std::vector<DisplayId> allDisplayIds = GetAllDisplayIds();
224 reply.WriteUInt64Vector(allDisplayIds);
225 break;
226 }
227 case DisplayManagerMessage::TRANS_ID_SCREEN_MAKE_EXPAND: {
228 std::vector<ScreenId> screenId;
229 if (!data.ReadUInt64Vector(&screenId)) {
230 WLOGE("fail to receive expand screen in stub.");
231 break;
232 }
233 std::vector<Point> startPoint;
234 if (!MarshallingHelper::UnmarshallingVectorObj<Point>(data, startPoint, [](Parcel& parcel, Point& point) {
235 return parcel.ReadInt32(point.posX_) && parcel.ReadInt32(point.posY_);
236 })) {
237 WLOGE("fail to receive startPoint in stub.");
238 break;
239 }
240 ScreenId screenGroupId = INVALID_SCREEN_ID;
241 DMError ret = MakeExpand(screenId, startPoint, screenGroupId);
242 reply.WriteInt32(static_cast<int32_t>(ret));
243 reply.WriteUint64(static_cast<uint64_t>(screenGroupId));
244 break;
245 }
246 case DisplayManagerMessage::TRANS_ID_REMOVE_VIRTUAL_SCREEN_FROM_SCREEN_GROUP: {
247 std::vector<ScreenId> screenId;
248 if (!data.ReadUInt64Vector(&screenId)) {
249 WLOGE("fail to receive screens in stub.");
250 break;
251 }
252 RemoveVirtualScreenFromGroup(screenId);
253 break;
254 }
255 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_ACTIVE_MODE: {
256 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
257 uint32_t modeId = data.ReadUint32();
258 DMError ret = SetScreenActiveMode(screenId, modeId);
259 reply.WriteInt32(static_cast<int32_t>(ret));
260 break;
261 }
262 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_PIXEL_RATIO: {
263 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
264 float virtualPixelRatio = data.ReadFloat();
265 DMError ret = SetVirtualPixelRatio(screenId, virtualPixelRatio);
266 reply.WriteInt32(static_cast<int32_t>(ret));
267 break;
268 }
269 case DisplayManagerMessage::TRANS_ID_SCREEN_GET_SUPPORTED_COLOR_GAMUTS: {
270 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
271 std::vector<ScreenColorGamut> colorGamuts;
272 DMError ret = GetScreenSupportedColorGamuts(screenId, colorGamuts);
273 reply.WriteInt32(static_cast<int32_t>(ret));
274 if (ret != DMError::DM_OK) {
275 break;
276 }
277 MarshallingHelper::MarshallingVectorObj<ScreenColorGamut>(reply, colorGamuts,
278 [](Parcel& parcel, const ScreenColorGamut& color) {
279 return parcel.WriteUint32(static_cast<uint32_t>(color));
280 }
281 );
282 break;
283 }
284 case DisplayManagerMessage::TRANS_ID_SCREEN_GET_COLOR_GAMUT: {
285 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
286 ScreenColorGamut colorGamut;
287 DMError ret = GetScreenColorGamut(screenId, colorGamut);
288 reply.WriteInt32(static_cast<int32_t>(ret));
289 if (ret != DMError::DM_OK) {
290 break;
291 }
292 reply.WriteUint32(static_cast<uint32_t>(colorGamut));
293 break;
294 }
295 case DisplayManagerMessage::TRANS_ID_SCREEN_SET_COLOR_GAMUT: {
296 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
297 int32_t colorGamutIdx = data.ReadInt32();
298 DMError ret = SetScreenColorGamut(screenId, colorGamutIdx);
299 reply.WriteInt32(static_cast<int32_t>(ret));
300 break;
301 }
302 case DisplayManagerMessage::TRANS_ID_SCREEN_GET_GAMUT_MAP: {
303 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
304 ScreenGamutMap gamutMap;
305 DMError ret = GetScreenGamutMap(screenId, gamutMap);
306 reply.WriteInt32(static_cast<int32_t>(ret));
307 if (ret != DMError::DM_OK) {
308 break;
309 }
310 reply.WriteInt32(static_cast<uint32_t>(gamutMap));
311 break;
312 }
313 case DisplayManagerMessage::TRANS_ID_SCREEN_SET_GAMUT_MAP: {
314 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
315 ScreenGamutMap gamutMap = static_cast<ScreenGamutMap>(data.ReadUint32());
316 DMError ret = SetScreenGamutMap(screenId, gamutMap);
317 reply.WriteInt32(static_cast<int32_t>(ret));
318 break;
319 }
320 case DisplayManagerMessage::TRANS_ID_SCREEN_SET_COLOR_TRANSFORM: {
321 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
322 DMError ret = SetScreenColorTransform(screenId);
323 reply.WriteInt32(static_cast<int32_t>(ret));
324 break;
325 }
326 case DisplayManagerMessage::TRANS_ID_IS_SCREEN_ROTATION_LOCKED: {
327 bool isLocked = false;
328 DMError ret = IsScreenRotationLocked(isLocked);
329 reply.WriteInt32(static_cast<int32_t>(ret));
330 reply.WriteBool(isLocked);
331 break;
332 }
333 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_ROTATION_LOCKED: {
334 bool isLocked = static_cast<bool>(data.ReadBool());
335 DMError ret = SetScreenRotationLocked(isLocked);
336 reply.WriteInt32(static_cast<int32_t>(ret));
337 break;
338 }
339 case DisplayManagerMessage::TRANS_ID_HAS_PRIVATE_WINDOW: {
340 DisplayId id = static_cast<DisplayId>(data.ReadUint64());
341 bool hasPrivateWindow = false;
342 DMError ret = HasPrivateWindow(id, hasPrivateWindow);
343 reply.WriteInt32(static_cast<int32_t>(ret));
344 reply.WriteBool(hasPrivateWindow);
345 break;
346 }
347 case DisplayManagerMessage::TRANS_ID_GET_CUTOUT_INFO: {
348 DisplayId displayId = static_cast<DisplayId>(data.ReadUint64());
349 sptr<CutoutInfo> cutoutInfo = GetCutoutInfo(displayId);
350 reply.WriteParcelable(cutoutInfo);
351 break;
352 }
353 case DisplayManagerMessage::TRANS_ID_ADD_SURFACE_NODE: {
354 DisplayId displayId = static_cast<DisplayId>(data.ReadUint64());
355 std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Unmarshalling(data);
356 auto ret = AddSurfaceNodeToDisplay(displayId, surfaceNode, true);
357 reply.WriteUint32(static_cast<uint32_t>(ret));
358 break;
359 }
360 case DisplayManagerMessage::TRANS_ID_REMOVE_SURFACE_NODE: {
361 DisplayId displayId = static_cast<DisplayId>(data.ReadUint64());
362 std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Unmarshalling(data);
363 auto ret = RemoveSurfaceNodeFromDisplay(displayId, surfaceNode);
364 reply.WriteUint32(static_cast<uint32_t>(ret));
365 break;
366 }
367 case DisplayManagerMessage::TRANS_ID_SCREEN_STOP_MIRROR: {
368 std::vector<ScreenId> mirrorScreenIds;
369 if (!data.ReadUInt64Vector(&mirrorScreenIds)) {
370 WLOGE("fail to receive mirror screens in stub.");
371 break;
372 }
373 DMError ret = StopMirror(mirrorScreenIds);
374 reply.WriteInt32(static_cast<int32_t>(ret));
375 break;
376 }
377 case DisplayManagerMessage::TRANS_ID_SCREEN_STOP_EXPAND: {
378 std::vector<ScreenId> expandScreenIds;
379 if (!data.ReadUInt64Vector(&expandScreenIds)) {
380 WLOGE("fail to receive expand screens in stub.");
381 break;
382 }
383 DMError ret = StopExpand(expandScreenIds);
384 reply.WriteInt32(static_cast<int32_t>(ret));
385 break;
386 }
387 default:
388 WLOGFW("unknown transaction code");
389 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
390 }
391 return 0;
392 }
393 } // namespace OHOS::Rosen