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