1 /*
2 * Copyright (c) 2023 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/screen_session_manager_stub.h"
17
18 #include "common/rs_rect.h"
19 #include "dm_common.h"
20 #include <ipc_skeleton.h>
21 #include "transaction/rs_marshalling_helper.h"
22
23 #include "marshalling_helper.h"
24
25 namespace OHOS::Rosen {
26 namespace {
27 constexpr HiviewDFX::HiLogLabel LABEL = {LOG_CORE, HILOG_DOMAIN_DISPLAY, "ScreenSessionManagerStub"};
28 const static uint32_t MAX_SCREEN_SIZE = 32;
29 const static int32_t ERR_INVALID_DATA = -1;
30 const static int32_t MAX_BUFF_SIZE = 100;
31 }
32
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)33 int32_t ScreenSessionManagerStub::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 ERR_TRANSACTION_FAILED;
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_REGISTER_DISPLAY_MANAGER_AGENT: {
49 auto agent = iface_cast<IDisplayManagerAgent>(data.ReadRemoteObject());
50 if (agent == nullptr) {
51 return ERR_INVALID_DATA;
52 }
53 auto type = static_cast<DisplayManagerAgentType>(data.ReadUint32());
54 DMError ret = RegisterDisplayManagerAgent(agent, type);
55 reply.WriteInt32(static_cast<int32_t>(ret));
56 break;
57 }
58 case DisplayManagerMessage::TRANS_ID_UNREGISTER_DISPLAY_MANAGER_AGENT: {
59 auto agent = iface_cast<IDisplayManagerAgent>(data.ReadRemoteObject());
60 if (agent == nullptr) {
61 return ERR_INVALID_DATA;
62 }
63 auto type = static_cast<DisplayManagerAgentType>(data.ReadUint32());
64 DMError ret = UnregisterDisplayManagerAgent(agent, type);
65 reply.WriteInt32(static_cast<int32_t>(ret));
66 break;
67 }
68 case DisplayManagerMessage::TRANS_ID_WAKE_UP_BEGIN: {
69 PowerStateChangeReason reason = static_cast<PowerStateChangeReason>(data.ReadUint32());
70 reply.WriteBool(WakeUpBegin(reason));
71 break;
72 }
73 case DisplayManagerMessage::TRANS_ID_WAKE_UP_END: {
74 reply.WriteBool(WakeUpEnd());
75 break;
76 }
77 case DisplayManagerMessage::TRANS_ID_SUSPEND_BEGIN: {
78 PowerStateChangeReason reason = static_cast<PowerStateChangeReason>(data.ReadUint32());
79 reply.WriteBool(SuspendBegin(reason));
80 break;
81 }
82 case DisplayManagerMessage::TRANS_ID_SUSPEND_END: {
83 reply.WriteBool(SuspendEnd());
84 break;
85 }
86 case DisplayManagerMessage::TRANS_ID_SET_DISPLAY_STATE: {
87 DisplayState state = static_cast<DisplayState>(data.ReadUint32());
88 reply.WriteBool(SetDisplayState(state));
89 break;
90 }
91 case DisplayManagerMessage::TRANS_ID_SET_SPECIFIED_SCREEN_POWER: {
92 ScreenId screenId = static_cast<ScreenId>(data.ReadUint32());
93 ScreenPowerState state = static_cast<ScreenPowerState>(data.ReadUint32());
94 PowerStateChangeReason reason = static_cast<PowerStateChangeReason>(data.ReadUint32());
95 reply.WriteBool(SetSpecifiedScreenPower(screenId, state, reason));
96 break;
97 }
98 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_POWER_FOR_ALL: {
99 ScreenPowerState state = static_cast<ScreenPowerState>(data.ReadUint32());
100 PowerStateChangeReason reason = static_cast<PowerStateChangeReason>(data.ReadUint32());
101 reply.WriteBool(SetScreenPowerForAll(state, reason));
102 break;
103 }
104 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_STATE: {
105 DisplayState state = GetDisplayState(data.ReadUint64());
106 reply.WriteUint32(static_cast<uint32_t>(state));
107 break;
108 }
109 case DisplayManagerMessage::TRANS_ID_NOTIFY_DISPLAY_EVENT: {
110 DisplayEvent event = static_cast<DisplayEvent>(data.ReadUint32());
111 NotifyDisplayEvent(event);
112 break;
113 }
114 case DisplayManagerMessage::TRANS_ID_GET_SCREEN_POWER: {
115 ScreenId dmsScreenId;
116 if (!data.ReadUint64(dmsScreenId)) {
117 WLOGFE("fail to read dmsScreenId.");
118 return ERR_INVALID_DATA;
119 }
120 reply.WriteUint32(static_cast<uint32_t>(GetScreenPower(dmsScreenId)));
121 break;
122 }
123 case DisplayManagerMessage::TRANS_ID_TRY_TO_CANCEL_SCREEN_OFF: {
124 reply.WriteBool(TryToCancelScreenOff());
125 break;
126 }
127 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_BRIGHTNESS: {
128 uint64_t screenId = data.ReadUint64();
129 uint32_t level = data.ReadUint64();
130 reply.WriteBool(SetScreenBrightness(screenId, level));
131 break;
132 }
133 case DisplayManagerMessage::TRANS_ID_GET_SCREEN_BRIGHTNESS: {
134 uint64_t screenId = data.ReadUint64();
135 reply.WriteUint32(GetScreenBrightness(screenId));
136 break;
137 }
138 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_BY_ID: {
139 DisplayId displayId = data.ReadUint64();
140 auto info = GetDisplayInfoById(displayId);
141 reply.WriteParcelable(info);
142 break;
143 }
144 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_BY_SCREEN: {
145 ScreenId screenId = data.ReadUint64();
146 auto info = GetDisplayInfoByScreen(screenId);
147 reply.WriteParcelable(info);
148 break;
149 }
150 case DisplayManagerMessage::TRANS_ID_GET_ALL_DISPLAYIDS: {
151 std::vector<DisplayId> allDisplayIds = GetAllDisplayIds();
152 reply.WriteUInt64Vector(allDisplayIds);
153 break;
154 }
155 case DisplayManagerMessage::TRANS_ID_GET_SCREEN_INFO_BY_ID: {
156 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
157 auto screenInfo = GetScreenInfoById(screenId);
158 reply.WriteStrongParcelable(screenInfo);
159 break;
160 }
161 case DisplayManagerMessage::TRANS_ID_GET_ALL_SCREEN_INFOS: {
162 std::vector<sptr<ScreenInfo>> screenInfos;
163 DMError ret = GetAllScreenInfos(screenInfos);
164 reply.WriteInt32(static_cast<int32_t>(ret));
165 if (!MarshallingHelper::MarshallingVectorParcelableObj<ScreenInfo>(reply, screenInfos)) {
166 WLOGE("fail to marshalling screenInfos in stub.");
167 }
168 break;
169 }
170 case DisplayManagerMessage::TRANS_ID_SCREEN_GET_SUPPORTED_COLOR_GAMUTS: {
171 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
172 std::vector<ScreenColorGamut> colorGamuts;
173 DMError ret = GetScreenSupportedColorGamuts(screenId, colorGamuts);
174 reply.WriteInt32(static_cast<int32_t>(ret));
175 if (ret != DMError::DM_OK) {
176 break;
177 }
178 MarshallingHelper::MarshallingVectorObj<ScreenColorGamut>(reply, colorGamuts,
179 [](Parcel& parcel, const ScreenColorGamut& color) {
180 return parcel.WriteUint32(static_cast<uint32_t>(color));
181 }
182 );
183 break;
184 }
185 case DisplayManagerMessage::TRANS_ID_CREATE_VIRTUAL_SCREEN: {
186 std::string name = data.ReadString();
187 uint32_t width = data.ReadUint32();
188 uint32_t height = data.ReadUint32();
189 float density = data.ReadFloat();
190 int32_t flags = data.ReadInt32();
191 bool isForShot = data.ReadBool();
192 std::vector<uint64_t> missionIds;
193 data.ReadUInt64Vector(&missionIds);
194 bool isSurfaceValid = data.ReadBool();
195 sptr<Surface> surface = nullptr;
196 if (isSurfaceValid) {
197 sptr<IRemoteObject> surfaceObject = data.ReadRemoteObject();
198 sptr<IBufferProducer> bp = iface_cast<IBufferProducer>(surfaceObject);
199 surface = Surface::CreateSurfaceAsProducer(bp);
200 }
201 sptr<IRemoteObject> virtualScreenAgent = data.ReadRemoteObject();
202 VirtualScreenOption virScrOption = {
203 .name_ = name,
204 .width_ = width,
205 .height_ = height,
206 .density_ = density,
207 .surface_ = surface,
208 .flags_ = flags,
209 .isForShot_ = isForShot,
210 .missionIds_ = missionIds
211 };
212 ScreenId screenId = CreateVirtualScreen(virScrOption, virtualScreenAgent);
213 reply.WriteUint64(static_cast<uint64_t>(screenId));
214 break;
215 }
216 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_SURFACE: {
217 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
218 bool isSurfaceValid = data.ReadBool();
219 sptr<IBufferProducer> bp = nullptr;
220 if (isSurfaceValid) {
221 sptr<IRemoteObject> surfaceObject = data.ReadRemoteObject();
222 bp = iface_cast<IBufferProducer>(surfaceObject);
223 }
224 DMError result = SetVirtualScreenSurface(screenId, bp);
225 reply.WriteInt32(static_cast<int32_t>(result));
226 break;
227 }
228 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_CANVAS_ROTATION: {
229 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
230 bool autoRotate = data.ReadBool();
231 DMError result = SetVirtualMirrorScreenCanvasRotation(screenId, autoRotate);
232 reply.WriteInt32(static_cast<int32_t>(result));
233 break;
234 }
235 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_SCALE_MODE: {
236 ProcSetVirtualScreenScaleMode(data, reply);
237 break;
238 }
239 case DisplayManagerMessage::TRANS_ID_DESTROY_VIRTUAL_SCREEN: {
240 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
241 DMError result = DestroyVirtualScreen(screenId);
242 reply.WriteInt32(static_cast<int32_t>(result));
243 break;
244 }
245 case DisplayManagerMessage::TRANS_ID_SCREEN_MAKE_MIRROR: {
246 ScreenId mainScreenId = static_cast<ScreenId>(data.ReadUint64());
247 std::vector<ScreenId> mirrorScreenId;
248 if (!data.ReadUInt64Vector(&mirrorScreenId)) {
249 WLOGE("fail to receive mirror screen in stub. screen:%{public}" PRIu64"", mainScreenId);
250 break;
251 }
252 ScreenId screenGroupId = INVALID_SCREEN_ID;
253 DMError ret = MakeMirror(mainScreenId, mirrorScreenId, screenGroupId);
254 reply.WriteInt32(static_cast<int32_t>(ret));
255 reply.WriteUint64(static_cast<uint64_t>(screenGroupId));
256 break;
257 }
258 case DisplayManagerMessage::TRANS_ID_SCREEN_STOP_MIRROR: {
259 std::vector<ScreenId> mirrorScreenIds;
260 if (!data.ReadUInt64Vector(&mirrorScreenIds)) {
261 WLOGE("fail to receive mirror screens in stub.");
262 break;
263 }
264 DMError ret = StopMirror(mirrorScreenIds);
265 reply.WriteInt32(static_cast<int32_t>(ret));
266 break;
267 }
268 case DisplayManagerMessage::TRANS_ID_SCREEN_DISABLE_MIRROR: {
269 DMError ret = DisableMirror(data.ReadBool());
270 reply.WriteInt32(static_cast<int32_t>(ret));
271 break;
272 }
273 case DisplayManagerMessage::TRANS_ID_SCREEN_MAKE_EXPAND: {
274 std::vector<ScreenId> screenId;
275 if (!data.ReadUInt64Vector(&screenId)) {
276 WLOGE("fail to receive expand screen in stub.");
277 break;
278 }
279 std::vector<Point> startPoint;
280 if (!MarshallingHelper::UnmarshallingVectorObj<Point>(data, startPoint, [](Parcel& parcel, Point& point) {
281 return parcel.ReadInt32(point.posX_) && parcel.ReadInt32(point.posY_);
282 })) {
283 WLOGE("fail to receive startPoint in stub.");
284 break;
285 }
286 ScreenId screenGroupId = INVALID_SCREEN_ID;
287 DMError ret = MakeExpand(screenId, startPoint, screenGroupId);
288 reply.WriteInt32(static_cast<int32_t>(ret));
289 reply.WriteUint64(static_cast<uint64_t>(screenGroupId));
290 break;
291 }
292 case DisplayManagerMessage::TRANS_ID_SCREEN_STOP_EXPAND: {
293 std::vector<ScreenId> expandScreenIds;
294 if (!data.ReadUInt64Vector(&expandScreenIds)) {
295 WLOGE("fail to receive expand screens in stub.");
296 break;
297 }
298 DMError ret = StopExpand(expandScreenIds);
299 reply.WriteInt32(static_cast<int32_t>(ret));
300 break;
301 }
302 case DisplayManagerMessage::TRANS_ID_GET_SCREEN_GROUP_INFO_BY_ID: {
303 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
304 auto screenGroupInfo = GetScreenGroupInfoById(screenId);
305 reply.WriteStrongParcelable(screenGroupInfo);
306 break;
307 }
308 case DisplayManagerMessage::TRANS_ID_REMOVE_VIRTUAL_SCREEN_FROM_SCREEN_GROUP: {
309 std::vector<ScreenId> screenId;
310 if (!data.ReadUInt64Vector(&screenId)) {
311 WLOGE("fail to receive screens in stub.");
312 break;
313 }
314 RemoveVirtualScreenFromGroup(screenId);
315 break;
316 }
317 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_SNAPSHOT: {
318 DisplayId displayId = data.ReadUint64();
319 DmErrorCode errCode = DmErrorCode::DM_OK;
320 std::shared_ptr<Media::PixelMap> displaySnapshot = GetDisplaySnapshot(displayId, &errCode);
321 reply.WriteParcelable(displaySnapshot == nullptr ? nullptr : displaySnapshot.get());
322 reply.WriteInt32(static_cast<int32_t>(errCode));
323 break;
324 }
325 case DisplayManagerMessage::TRANS_ID_GET_SNAPSHOT_BY_PICKER: {
326 ProcGetSnapshotByPicker(reply);
327 break;
328 }
329 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_ACTIVE_MODE: {
330 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
331 uint32_t modeId = data.ReadUint32();
332 DMError ret = SetScreenActiveMode(screenId, modeId);
333 reply.WriteInt32(static_cast<int32_t>(ret));
334 break;
335 }
336 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_PIXEL_RATIO: {
337 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
338 float virtualPixelRatio = data.ReadFloat();
339 DMError ret = SetVirtualPixelRatio(screenId, virtualPixelRatio);
340 reply.WriteInt32(static_cast<int32_t>(ret));
341 break;
342 }
343 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_PIXEL_RATIO_SYSTEM: {
344 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
345 float virtualPixelRatio = data.ReadFloat();
346 DMError ret = SetVirtualPixelRatioSystem(screenId, virtualPixelRatio);
347 reply.WriteInt32(static_cast<int32_t>(ret));
348 break;
349 }
350 case DisplayManagerMessage::TRANS_ID_SET_RESOLUTION: {
351 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
352 uint32_t width = data.ReadUint32();
353 uint32_t height = data.ReadUint32();
354 float virtualPixelRatio = data.ReadFloat();
355 DMError ret = SetResolution(screenId, width, height, virtualPixelRatio);
356 reply.WriteInt32(static_cast<int32_t>(ret));
357 break;
358 }
359 case DisplayManagerMessage::TRANS_ID_GET_DENSITY_IN_CURRENT_RESOLUTION: {
360 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
361 float virtualPixelRatio;
362 DMError ret = GetDensityInCurResolution(screenId, virtualPixelRatio);
363 reply.WriteFloat(virtualPixelRatio);
364 reply.WriteInt32(static_cast<int32_t>(ret));
365 break;
366 }
367 case DisplayManagerMessage::TRANS_ID_SCREEN_GET_COLOR_GAMUT: {
368 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
369 ScreenColorGamut colorGamut;
370 DMError ret = GetScreenColorGamut(screenId, colorGamut);
371 reply.WriteInt32(static_cast<int32_t>(ret));
372 if (ret != DMError::DM_OK) {
373 break;
374 }
375 reply.WriteUint32(static_cast<uint32_t>(colorGamut));
376 break;
377 }
378 case DisplayManagerMessage::TRANS_ID_SCREEN_SET_COLOR_GAMUT: {
379 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
380 int32_t colorGamutIdx = data.ReadInt32();
381 DMError ret = SetScreenColorGamut(screenId, colorGamutIdx);
382 reply.WriteInt32(static_cast<int32_t>(ret));
383 break;
384 }
385 case DisplayManagerMessage::TRANS_ID_SCREEN_GET_GAMUT_MAP: {
386 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
387 ScreenGamutMap gamutMap;
388 DMError ret = GetScreenGamutMap(screenId, gamutMap);
389 reply.WriteInt32(static_cast<int32_t>(ret));
390 if (ret != DMError::DM_OK) {
391 break;
392 }
393 reply.WriteInt32(static_cast<uint32_t>(gamutMap));
394 break;
395 }
396 case DisplayManagerMessage::TRANS_ID_SCREEN_SET_GAMUT_MAP: {
397 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
398 ScreenGamutMap gamutMap = static_cast<ScreenGamutMap>(data.ReadUint32());
399 DMError ret = SetScreenGamutMap(screenId, gamutMap);
400 reply.WriteInt32(static_cast<int32_t>(ret));
401 break;
402 }
403 case DisplayManagerMessage::TRANS_ID_SCREEN_SET_COLOR_TRANSFORM: {
404 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
405 DMError ret = SetScreenColorTransform(screenId);
406 reply.WriteInt32(static_cast<int32_t>(ret));
407 break;
408 }
409 case DisplayManagerMessage::TRANS_ID_SCREEN_GET_PIXEL_FORMAT: {
410 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
411 GraphicPixelFormat pixelFormat;
412 DMError ret = GetPixelFormat(screenId, pixelFormat);
413 reply.WriteInt32(static_cast<int32_t>(ret));
414 if (ret != DMError::DM_OK) {
415 break;
416 }
417 reply.WriteInt32(static_cast<uint32_t>(pixelFormat));
418 break;
419 }
420 case DisplayManagerMessage::TRANS_ID_SCREEN_SET_PIXEL_FORMAT: {
421 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
422 GraphicPixelFormat pixelFormat = static_cast<GraphicPixelFormat>(data.ReadUint32());
423 DMError ret = SetPixelFormat(screenId, pixelFormat);
424 reply.WriteInt32(static_cast<int32_t>(ret));
425 break;
426 }
427 case DisplayManagerMessage::TRANS_ID_SCREEN_GET_SUPPORTED_HDR_FORMAT: {
428 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
429 std::vector<ScreenHDRFormat> hdrFormats;
430 DMError ret = GetSupportedHDRFormats(screenId, hdrFormats);
431 reply.WriteInt32(static_cast<int32_t>(ret));
432 if (ret != DMError::DM_OK) {
433 break;
434 }
435 MarshallingHelper::MarshallingVectorObj<ScreenHDRFormat>(reply, hdrFormats,
436 [](Parcel& parcel, const ScreenHDRFormat& hdrFormat) {
437 return parcel.WriteUint32(static_cast<uint32_t>(hdrFormat));
438 }
439 );
440 break;
441 }
442 case DisplayManagerMessage::TRANS_ID_SCREEN_GET_HDR_FORMAT: {
443 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
444 ScreenHDRFormat hdrFormat;
445 DMError ret = GetScreenHDRFormat(screenId, hdrFormat);
446 reply.WriteInt32(static_cast<int32_t>(ret));
447 if (ret != DMError::DM_OK) {
448 break;
449 }
450 reply.WriteInt32(static_cast<uint32_t>(hdrFormat));
451 break;
452 }
453 case DisplayManagerMessage::TRANS_ID_SCREEN_SET_HDR_FORMAT: {
454 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
455 int32_t modeIdx = data.ReadInt32();
456 DMError ret = SetScreenHDRFormat(screenId, modeIdx);
457 reply.WriteInt32(static_cast<int32_t>(ret));
458 break;
459 }
460 case DisplayManagerMessage::TRANS_ID_SCREEN_GET_SUPPORTED_COLOR_SPACE: {
461 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
462 std::vector<GraphicCM_ColorSpaceType> colorSpaces;
463 DMError ret = GetSupportedColorSpaces(screenId, colorSpaces);
464 reply.WriteInt32(static_cast<int32_t>(ret));
465 if (ret != DMError::DM_OK) {
466 break;
467 }
468 MarshallingHelper::MarshallingVectorObj<GraphicCM_ColorSpaceType>(reply, colorSpaces,
469 [](Parcel& parcel, const GraphicCM_ColorSpaceType& color) {
470 return parcel.WriteUint32(static_cast<uint32_t>(color));
471 }
472 );
473 break;
474 }
475 case DisplayManagerMessage::TRANS_ID_SCREEN_GET_COLOR_SPACE: {
476 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
477 GraphicCM_ColorSpaceType colorSpace;
478 DMError ret = GetScreenColorSpace(screenId, colorSpace);
479 reply.WriteInt32(static_cast<int32_t>(ret));
480 if (ret != DMError::DM_OK) {
481 break;
482 }
483 reply.WriteInt32(static_cast<uint32_t>(colorSpace));
484 break;
485 }
486 case DisplayManagerMessage::TRANS_ID_SCREEN_SET_COLOR_SPACE: {
487 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
488 GraphicCM_ColorSpaceType colorSpace = static_cast<GraphicCM_ColorSpaceType>(data.ReadUint32());
489 DMError ret = SetScreenColorSpace(screenId, colorSpace);
490 reply.WriteInt32(static_cast<int32_t>(ret));
491 break;
492 }
493 case DisplayManagerMessage::TRANS_ID_SET_ORIENTATION: {
494 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
495 Orientation orientation = static_cast<Orientation>(data.ReadUint32());
496 DMError ret = SetOrientation(screenId, orientation);
497 reply.WriteInt32(static_cast<int32_t>(ret));
498 break;
499 }
500 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_ROTATION_LOCKED: {
501 bool isLocked = static_cast<bool>(data.ReadBool());
502 DMError ret = SetScreenRotationLocked(isLocked);
503 reply.WriteInt32(static_cast<int32_t>(ret));
504 break;
505 }
506 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_ROTATION_LOCKED_FROM_JS: {
507 bool isLocked = static_cast<bool>(data.ReadBool());
508 DMError ret = SetScreenRotationLockedFromJs(isLocked);
509 reply.WriteInt32(static_cast<int32_t>(ret));
510 break;
511 }
512 case DisplayManagerMessage::TRANS_ID_IS_SCREEN_ROTATION_LOCKED: {
513 bool isLocked = false;
514 DMError ret = IsScreenRotationLocked(isLocked);
515 reply.WriteInt32(static_cast<int32_t>(ret));
516 reply.WriteBool(isLocked);
517 break;
518 }
519 case DisplayManagerMessage::TRANS_ID_GET_CUTOUT_INFO: {
520 DisplayId displayId = static_cast<DisplayId>(data.ReadUint64());
521 sptr<CutoutInfo> cutoutInfo = GetCutoutInfo(displayId);
522 reply.WriteParcelable(cutoutInfo);
523 break;
524 }
525 case DisplayManagerMessage::TRANS_ID_HAS_PRIVATE_WINDOW: {
526 DisplayId id = static_cast<DisplayId>(data.ReadUint64());
527 bool hasPrivateWindow = false;
528 DMError ret = HasPrivateWindow(id, hasPrivateWindow);
529 reply.WriteInt32(static_cast<int32_t>(ret));
530 reply.WriteBool(hasPrivateWindow);
531 break;
532 }
533 case DisplayManagerMessage::TRANS_ID_CONVERT_SCREENID_TO_RSSCREENID: {
534 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
535 ScreenId rsId = SCREEN_ID_INVALID;
536 bool ret = ConvertScreenIdToRsScreenId(screenId, rsId);
537 reply.WriteBool(ret);
538 reply.WriteUint64(rsId);
539 break;
540 }
541 case DisplayManagerMessage::TRANS_ID_HAS_IMMERSIVE_WINDOW: {
542 bool immersive = false;
543 DMError ret = HasImmersiveWindow(immersive);
544 reply.WriteInt32(static_cast<int32_t>(ret));
545 reply.WriteBool(immersive);
546 break;
547 }
548 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_DUMP_ALL_SCREEN: {
549 std::string dumpInfo;
550 DumpAllScreensInfo(dumpInfo);
551 reply.WriteString(dumpInfo);
552 break;
553 }
554 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_DUMP_SPECIAL_SCREEN: {
555 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
556 std::string dumpInfo;
557 DumpSpecialScreenInfo(screenId, dumpInfo);
558 reply.WriteString(dumpInfo);
559 break;
560 }
561 case DisplayManagerMessage::TRANS_ID_DEVICE_IS_CAPTURE: {
562 reply.WriteBool(IsCaptured());
563 break;
564 }
565 //Fold Screen
566 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_SET_FOLD_DISPLAY_MODE: {
567 FoldDisplayMode displayMode = static_cast<FoldDisplayMode>(data.ReadUint32());
568 SetFoldDisplayMode(displayMode);
569 break;
570 }
571 case DisplayManagerMessage::TRANS_ID_SET_FOLD_DISPLAY_MODE_FROM_JS: {
572 FoldDisplayMode displayMode = static_cast<FoldDisplayMode>(data.ReadUint32());
573 DMError ret = SetFoldDisplayModeFromJs(displayMode);
574 reply.WriteInt32(static_cast<int32_t>(ret));
575 break;
576 }
577 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_LOCK_FOLD_DISPLAY_STATUS: {
578 bool lockDisplayStatus = static_cast<bool>(data.ReadUint32());
579 SetFoldStatusLocked(lockDisplayStatus);
580 break;
581 }
582 case DisplayManagerMessage::TRANS_ID_SET_LOCK_FOLD_DISPLAY_STATUS_FROM_JS: {
583 bool lockDisplayStatus = static_cast<bool>(data.ReadUint32());
584 DMError ret = SetFoldStatusLockedFromJs(lockDisplayStatus);
585 reply.WriteInt32(static_cast<int32_t>(ret));
586 break;
587 }
588 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_SET_DISPLAY_SCALE: {
589 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
590 auto scaleX = data.ReadFloat();
591 auto scaleY = data.ReadFloat();
592 auto pivotX = data.ReadFloat();
593 auto pivotY = data.ReadFloat();
594 SetDisplayScale(screenId, scaleX, scaleY, pivotX, pivotY);
595 break;
596 }
597 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_GET_FOLD_DISPLAY_MODE: {
598 FoldDisplayMode displayMode = GetFoldDisplayMode();
599 reply.WriteUint32(static_cast<uint32_t>(displayMode));
600 break;
601 }
602 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_IS_FOLDABLE: {
603 reply.WriteBool(IsFoldable());
604 break;
605 }
606 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_GET_FOLD_STATUS: {
607 reply.WriteUint32(static_cast<uint32_t>(GetFoldStatus()));
608 break;
609 }
610 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_GET_CURRENT_FOLD_CREASE_REGION: {
611 reply.WriteStrongParcelable(GetCurrentFoldCreaseRegion());
612 break;
613 }
614 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_MAKE_UNIQUE_SCREEN: {
615 std::vector<ScreenId> uniqueScreenIds;
616 uint32_t size = data.ReadUint32();
617 if (size > MAX_SCREEN_SIZE) {
618 WLOGFE("screenIds size is bigger than %{public}u", MAX_SCREEN_SIZE);
619 break;
620 }
621 if (!data.ReadUInt64Vector(&uniqueScreenIds)) {
622 WLOGFE("failed to receive unique screens in stub");
623 break;
624 }
625 DMError ret = MakeUniqueScreen(uniqueScreenIds);
626 reply.WriteInt32(static_cast<int32_t>(ret));
627 break;
628 }
629 case DisplayManagerMessage::TRANS_ID_SET_CLIENT: {
630 auto remoteObject = data.ReadRemoteObject();
631 auto clientProxy = iface_cast<IScreenSessionManagerClient>(remoteObject);
632 if (clientProxy == nullptr) {
633 WLOGFE("clientProxy is null");
634 break;
635 }
636 SetClient(clientProxy);
637 break;
638 }
639 case DisplayManagerMessage::TRANS_ID_GET_SCREEN_PROPERTY: {
640 auto screenId = static_cast<ScreenId>(data.ReadUint64());
641 if (!RSMarshallingHelper::Marshalling(reply, GetScreenProperty(screenId))) {
642 WLOGFE("Write screenProperty failed");
643 }
644 break;
645 }
646 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_NODE: {
647 auto screenId = static_cast<ScreenId>(data.ReadUint64());
648 auto displayNode = GetDisplayNode(screenId);
649 if (!displayNode || !displayNode->Marshalling(reply)) {
650 WLOGFE("Write displayNode failed");
651 }
652 break;
653 }
654 case DisplayManagerMessage::TRANS_ID_UPDATE_SCREEN_ROTATION_PROPERTY: {
655 auto screenId = static_cast<ScreenId>(data.ReadUint64());
656 RRect bounds;
657 if (!RSMarshallingHelper::Unmarshalling(data, bounds)) {
658 WLOGFE("Read bounds failed");
659 break;
660 }
661 auto rotation = data.ReadFloat();
662 auto screenPropertyChangeType = static_cast<ScreenPropertyChangeType>(data.ReadUint32());
663 UpdateScreenRotationProperty(screenId, bounds, rotation, screenPropertyChangeType);
664 break;
665 }
666 case DisplayManagerMessage::TRANS_ID_GET_CURVED_SCREEN_COMPRESSION_AREA: {
667 auto area = GetCurvedCompressionArea();
668 reply.WriteUint32(area);
669 break;
670 }
671 case DisplayManagerMessage::TRANS_ID_GET_PHY_SCREEN_PROPERTY: {
672 auto screenId = static_cast<ScreenId>(data.ReadUint64());
673 if (!RSMarshallingHelper::Marshalling(reply, GetPhyScreenProperty(screenId))) {
674 WLOGFE("Write screenProperty failed");
675 }
676 break;
677 }
678 case DisplayManagerMessage::TRANS_ID_NOTIFY_DISPLAY_CHANGE_INFO: {
679 sptr<DisplayChangeInfo> info = DisplayChangeInfo::Unmarshalling(data);
680 if (!info) {
681 WLOGFE("Read DisplayChangeInfo failed");
682 return ERR_INVALID_DATA;
683 }
684 NotifyDisplayChangeInfoChanged(info);
685 break;
686 }
687 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_PRIVACY_STATE: {
688 auto hasPrivate = data.ReadBool();
689 SetScreenPrivacyState(hasPrivate);
690 break;
691 }
692 case DisplayManagerMessage::TRANS_ID_SET_SCREENID_PRIVACY_STATE: {
693 DisplayId displayId = static_cast<DisplayId>(data.ReadUint64());
694 auto hasPrivate = data.ReadBool();
695 SetPrivacyStateByDisplayId(displayId, hasPrivate);
696 break;
697 }
698 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_PRIVACY_WINDOW_LIST: {
699 DisplayId displayId = static_cast<DisplayId>(data.ReadUint64());
700 std::vector<std::string> privacyWindowList;
701 data.ReadStringVector(&privacyWindowList);
702 SetScreenPrivacyWindowList(displayId, privacyWindowList);
703 break;
704 }
705 case DisplayManagerMessage::TRANS_ID_RESIZE_VIRTUAL_SCREEN: {
706 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
707 uint32_t width = data.ReadUint32();
708 uint32_t height = data.ReadUint32();
709 DMError ret = ResizeVirtualScreen(screenId, width, height);
710 reply.WriteInt32(static_cast<int32_t>(ret));
711 break;
712 }
713 case DisplayManagerMessage::TRANS_ID_UPDATE_AVAILABLE_AREA: {
714 auto screenId = static_cast<ScreenId>(data.ReadUint64());
715 int32_t posX = data.ReadInt32();
716 int32_t posY = data.ReadInt32();
717 uint32_t width = data.ReadUint32();
718 uint32_t height = data.ReadUint32();
719 DMRect area = {posX, posY, width, height};
720 UpdateAvailableArea(screenId, area);
721 break;
722 }
723 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_OFF_DELAY_TIME: {
724 int32_t delay = data.ReadInt32();
725 int32_t ret = SetScreenOffDelayTime(delay);
726 reply.WriteInt32(ret);
727 break;
728 }
729 case DisplayManagerMessage::TRANS_ID_GET_AVAILABLE_AREA: {
730 ProcGetAvailableArea(data, reply);
731 break;
732 }
733 case DisplayManagerMessage::TRANS_ID_NOTIFY_FOLD_TO_EXPAND_COMPLETION: {
734 bool foldToExpand = data.ReadBool();
735 NotifyFoldToExpandCompletion(foldToExpand);
736 break;
737 }
738 case DisplayManagerMessage::TRANS_ID_GET_VIRTUAL_SCREEN_FLAG: {
739 ProcGetVirtualScreenFlag(data, reply);
740 break;
741 }
742 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_FLAG: {
743 ProcSetVirtualScreenFlag(data, reply);
744 break;
745 }
746 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_REFRESH_RATE: {
747 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
748 uint32_t refreshInterval = data.ReadUint32();
749 DMError ret = SetVirtualScreenRefreshRate(screenId, refreshInterval);
750 reply.WriteInt32(static_cast<int32_t>(ret));
751 break;
752 }
753 case DisplayManagerMessage::TRANS_ID_GET_DEVICE_SCREEN_CONFIG: {
754 if (!RSMarshallingHelper::Marshalling(reply, GetDeviceScreenConfig())) {
755 TLOGE(WmsLogTag::DMS, "Write deviceScreenConfig failed");
756 }
757 break;
758 }
759 case DisplayManagerMessage::TRANS_ID_SWITCH_USER: {
760 SwitchUser();
761 break;
762 }
763 case DisplayManagerMessage::TRANS_ID_PROXY_FOR_FREEZE: {
764 ProcProxyForFreeze(data, reply);
765 break;
766 }
767 case DisplayManagerMessage::TRANS_ID_RESET_ALL_FREEZE_STATUS: {
768 DMError ret = ResetAllFreezeStatus();
769 reply.WriteInt32(static_cast<int32_t>(ret));
770 break;
771 }
772 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_BLACK_LIST: {
773 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
774 std::vector<uint64_t> windowIdList;
775 if (!data.ReadUInt64Vector(&windowIdList)) {
776 TLOGE(WmsLogTag::DMS, "Failed to receive windowIdList in stub");
777 break;
778 }
779 SetVirtualScreenBlackList(screenId, windowIdList);
780 break;
781 }
782 case DisplayManagerMessage::TRANS_ID_DISABLE_POWEROFF_RENDER_CONTROL: {
783 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
784 DisablePowerOffRenderControl(screenId);
785 break;
786 }
787 case DisplayManagerMessage::TRANS_ID_NOTIFY_DISPLAY_HOOK_INFO: {
788 int32_t uid = data.ReadInt32();
789 bool enable = data.ReadBool();
790 DMHookInfo hookInfo;
791 hookInfo.width_ = data.ReadUint32();
792 hookInfo.height_ = data.ReadUint32();
793 hookInfo.density_ = data.ReadFloat();
794 hookInfo.rotation_ = data.ReadUint32();
795 hookInfo.enableHookRotation_ = data.ReadBool();
796 UpdateDisplayHookInfo(uid, enable, hookInfo);
797 break;
798 }
799 case DisplayManagerMessage::TRANS_ID_GET_ALL_PHYSICAL_DISPLAY_RESOLUTION: {
800 ProcGetAllDisplayPhysicalResolution(data, reply);
801 break;
802 }
803 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_SECURITY_EXEMPTION: {
804 ProcSetVirtualScreenSecurityExemption(data, reply);
805 break;
806 }
807 default:
808 WLOGFW("unknown transaction code");
809 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
810 }
811 return ERR_NONE;
812 }
813
ProcGetAvailableArea(MessageParcel & data,MessageParcel & reply)814 void ScreenSessionManagerStub::ProcGetAvailableArea(MessageParcel& data, MessageParcel& reply)
815 {
816 DisplayId displayId = static_cast<DisplayId>(data.ReadUint64());
817 DMRect area;
818 DMError ret = GetAvailableArea(displayId, area);
819 reply.WriteInt32(static_cast<int32_t>(ret));
820 reply.WriteInt32(area.posX_);
821 reply.WriteInt32(area.posY_);
822 reply.WriteUint32(area.width_);
823 reply.WriteUint32(area.height_);
824 }
825
ProcGetSnapshotByPicker(MessageParcel & reply)826 void ScreenSessionManagerStub::ProcGetSnapshotByPicker(MessageParcel& reply)
827 {
828 DmErrorCode errCode = DmErrorCode::DM_OK;
829 Media::Rect imgRect { 0, 0, 0, 0 };
830 std::shared_ptr<Media::PixelMap> snapshot = GetSnapshotByPicker(imgRect, &errCode);
831 reply.WriteParcelable(snapshot == nullptr ? nullptr : snapshot.get());
832 reply.WriteInt32(static_cast<int32_t>(errCode));
833 reply.WriteInt32(imgRect.left);
834 reply.WriteInt32(imgRect.top);
835 reply.WriteInt32(imgRect.width);
836 reply.WriteInt32(imgRect.height);
837 }
838
ProcSetVirtualScreenFlag(MessageParcel & data,MessageParcel & reply)839 void ScreenSessionManagerStub::ProcSetVirtualScreenFlag(MessageParcel& data, MessageParcel& reply)
840 {
841 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
842 VirtualScreenFlag screenFlag = static_cast<VirtualScreenFlag>(data.ReadUint32());
843 DMError setRet = SetVirtualScreenFlag(screenId, screenFlag);
844 reply.WriteInt32(static_cast<int32_t>(setRet));
845 }
846
ProcGetVirtualScreenFlag(MessageParcel & data,MessageParcel & reply)847 void ScreenSessionManagerStub::ProcGetVirtualScreenFlag(MessageParcel& data, MessageParcel& reply)
848 {
849 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
850 VirtualScreenFlag screenFlag = GetVirtualScreenFlag(screenId);
851 reply.WriteUint32(static_cast<uint32_t>(screenFlag));
852 }
853
ProcSetVirtualScreenScaleMode(MessageParcel & data,MessageParcel & reply)854 void ScreenSessionManagerStub::ProcSetVirtualScreenScaleMode(MessageParcel& data, MessageParcel& reply)
855 {
856 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
857 ScreenScaleMode scaleMode = static_cast<ScreenScaleMode>(data.ReadUint32());
858 DMError result = SetVirtualMirrorScreenScaleMode(screenId, scaleMode);
859 reply.WriteInt32(static_cast<int32_t>(result));
860 }
861
ProcProxyForFreeze(MessageParcel & data,MessageParcel & reply)862 void ScreenSessionManagerStub::ProcProxyForFreeze(MessageParcel& data, MessageParcel& reply)
863 {
864 std::set<int32_t> pidList;
865 int32_t size = data.ReadInt32();
866 if (size > MAX_BUFF_SIZE) {
867 WLOGFE("pid List size invalid: %{public}d", size);
868 size = MAX_BUFF_SIZE;
869 }
870 for (int32_t i = 0; i < size; i++) {
871 pidList.insert(data.ReadInt32());
872 }
873 bool isProxy = data.ReadBool();
874 DMError ret = ProxyForFreeze(pidList, isProxy);
875 reply.WriteInt32(static_cast<int32_t>(ret));
876 }
877
ProcGetAllDisplayPhysicalResolution(MessageParcel & data,MessageParcel & reply)878 void ScreenSessionManagerStub::ProcGetAllDisplayPhysicalResolution(MessageParcel& data, MessageParcel& reply)
879 {
880 auto physicalInfos = GetAllDisplayPhysicalResolution();
881 size_t infoSize = physicalInfos.size();
882 bool writeRet = reply.WriteInt32(static_cast<int32_t>(infoSize));
883 if (!writeRet) {
884 WLOGFE("write physical size error");
885 return;
886 }
887 for (const auto &physicalItem : physicalInfos) {
888 writeRet = reply.WriteUint32(static_cast<uint32_t>(physicalItem.foldDisplayMode_));
889 if (!writeRet) {
890 WLOGFE("write display mode error");
891 break;
892 }
893 writeRet = reply.WriteUint32(physicalItem.physicalWidth_);
894 if (!writeRet) {
895 WLOGFE("write physical width error");
896 break;
897 }
898 writeRet = reply.WriteUint32(physicalItem.physicalHeight_);
899 if (!writeRet) {
900 WLOGFE("write physical height error");
901 break;
902 }
903 }
904 }
905
ProcSetVirtualScreenSecurityExemption(MessageParcel & data,MessageParcel & reply)906 void ScreenSessionManagerStub::ProcSetVirtualScreenSecurityExemption(MessageParcel& data, MessageParcel& reply)
907 {
908 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
909 uint32_t pid = data.ReadUint32();
910 std::vector<uint64_t> windowIdList;
911 data.ReadUInt64Vector(&windowIdList);
912 DMError ret = SetVirtualScreenSecurityExemption(screenId, pid, windowIdList);
913 reply.WriteInt32(static_cast<int32_t>(ret));
914 }
915 } // namespace OHOS::Rosen
916