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             bool isUseDma = data.ReadBool();
321             std::shared_ptr<Media::PixelMap> displaySnapshot = GetDisplaySnapshot(displayId, &errCode, isUseDma);
322             reply.WriteParcelable(displaySnapshot == nullptr ? nullptr : displaySnapshot.get());
323             reply.WriteInt32(static_cast<int32_t>(errCode));
324             break;
325         }
326         case DisplayManagerMessage::TRANS_ID_GET_SNAPSHOT_BY_PICKER: {
327             ProcGetSnapshotByPicker(reply);
328             break;
329         }
330         case DisplayManagerMessage::TRANS_ID_SET_SCREEN_ACTIVE_MODE: {
331             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
332             uint32_t modeId = data.ReadUint32();
333             DMError ret = SetScreenActiveMode(screenId, modeId);
334             reply.WriteInt32(static_cast<int32_t>(ret));
335             break;
336         }
337         case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_PIXEL_RATIO: {
338             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
339             float virtualPixelRatio = data.ReadFloat();
340             DMError ret = SetVirtualPixelRatio(screenId, virtualPixelRatio);
341             reply.WriteInt32(static_cast<int32_t>(ret));
342             break;
343         }
344         case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_PIXEL_RATIO_SYSTEM: {
345             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
346             float virtualPixelRatio = data.ReadFloat();
347             DMError ret = SetVirtualPixelRatioSystem(screenId, virtualPixelRatio);
348             reply.WriteInt32(static_cast<int32_t>(ret));
349             break;
350         }
351         case DisplayManagerMessage::TRANS_ID_SET_RESOLUTION: {
352             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
353             uint32_t width = data.ReadUint32();
354             uint32_t height = data.ReadUint32();
355             float virtualPixelRatio = data.ReadFloat();
356             DMError ret = SetResolution(screenId, width, height, virtualPixelRatio);
357             reply.WriteInt32(static_cast<int32_t>(ret));
358             break;
359         }
360         case DisplayManagerMessage::TRANS_ID_GET_DENSITY_IN_CURRENT_RESOLUTION: {
361             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
362             float virtualPixelRatio;
363             DMError ret = GetDensityInCurResolution(screenId, virtualPixelRatio);
364             reply.WriteFloat(virtualPixelRatio);
365             reply.WriteInt32(static_cast<int32_t>(ret));
366             break;
367         }
368         case DisplayManagerMessage::TRANS_ID_SCREEN_GET_COLOR_GAMUT: {
369             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
370             ScreenColorGamut colorGamut;
371             DMError ret = GetScreenColorGamut(screenId, colorGamut);
372             reply.WriteInt32(static_cast<int32_t>(ret));
373             if (ret != DMError::DM_OK) {
374                 break;
375             }
376             reply.WriteUint32(static_cast<uint32_t>(colorGamut));
377             break;
378         }
379         case DisplayManagerMessage::TRANS_ID_SCREEN_SET_COLOR_GAMUT: {
380             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
381             int32_t colorGamutIdx = data.ReadInt32();
382             DMError ret = SetScreenColorGamut(screenId, colorGamutIdx);
383             reply.WriteInt32(static_cast<int32_t>(ret));
384             break;
385         }
386         case DisplayManagerMessage::TRANS_ID_SCREEN_GET_GAMUT_MAP: {
387             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
388             ScreenGamutMap gamutMap;
389             DMError ret = GetScreenGamutMap(screenId, gamutMap);
390             reply.WriteInt32(static_cast<int32_t>(ret));
391             if (ret != DMError::DM_OK) {
392                 break;
393             }
394             reply.WriteInt32(static_cast<uint32_t>(gamutMap));
395             break;
396         }
397         case DisplayManagerMessage::TRANS_ID_SCREEN_SET_GAMUT_MAP: {
398             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
399             ScreenGamutMap gamutMap = static_cast<ScreenGamutMap>(data.ReadUint32());
400             DMError ret = SetScreenGamutMap(screenId, gamutMap);
401             reply.WriteInt32(static_cast<int32_t>(ret));
402             break;
403         }
404         case DisplayManagerMessage::TRANS_ID_SCREEN_SET_COLOR_TRANSFORM: {
405             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
406             DMError ret = SetScreenColorTransform(screenId);
407             reply.WriteInt32(static_cast<int32_t>(ret));
408             break;
409         }
410         case DisplayManagerMessage::TRANS_ID_SCREEN_GET_PIXEL_FORMAT: {
411             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
412             GraphicPixelFormat pixelFormat;
413             DMError ret = GetPixelFormat(screenId, pixelFormat);
414             reply.WriteInt32(static_cast<int32_t>(ret));
415             if (ret != DMError::DM_OK) {
416                 break;
417             }
418             reply.WriteInt32(static_cast<uint32_t>(pixelFormat));
419             break;
420         }
421         case DisplayManagerMessage::TRANS_ID_SCREEN_SET_PIXEL_FORMAT: {
422             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
423             GraphicPixelFormat pixelFormat = static_cast<GraphicPixelFormat>(data.ReadUint32());
424             DMError ret = SetPixelFormat(screenId, pixelFormat);
425             reply.WriteInt32(static_cast<int32_t>(ret));
426             break;
427         }
428         case DisplayManagerMessage::TRANS_ID_SCREEN_GET_SUPPORTED_HDR_FORMAT: {
429             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
430             std::vector<ScreenHDRFormat> hdrFormats;
431             DMError ret = GetSupportedHDRFormats(screenId, hdrFormats);
432             reply.WriteInt32(static_cast<int32_t>(ret));
433             if (ret != DMError::DM_OK) {
434                 break;
435             }
436             MarshallingHelper::MarshallingVectorObj<ScreenHDRFormat>(reply, hdrFormats,
437                 [](Parcel& parcel, const ScreenHDRFormat& hdrFormat) {
438                     return parcel.WriteUint32(static_cast<uint32_t>(hdrFormat));
439                 }
440             );
441             break;
442         }
443         case DisplayManagerMessage::TRANS_ID_SCREEN_GET_HDR_FORMAT: {
444             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
445             ScreenHDRFormat hdrFormat;
446             DMError ret = GetScreenHDRFormat(screenId, hdrFormat);
447             reply.WriteInt32(static_cast<int32_t>(ret));
448             if (ret != DMError::DM_OK) {
449                 break;
450             }
451             reply.WriteInt32(static_cast<uint32_t>(hdrFormat));
452             break;
453         }
454         case DisplayManagerMessage::TRANS_ID_SCREEN_SET_HDR_FORMAT: {
455             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
456             int32_t modeIdx = data.ReadInt32();
457             DMError ret = SetScreenHDRFormat(screenId, modeIdx);
458             reply.WriteInt32(static_cast<int32_t>(ret));
459             break;
460         }
461         case DisplayManagerMessage::TRANS_ID_SCREEN_GET_SUPPORTED_COLOR_SPACE: {
462             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
463             std::vector<GraphicCM_ColorSpaceType> colorSpaces;
464             DMError ret = GetSupportedColorSpaces(screenId, colorSpaces);
465             reply.WriteInt32(static_cast<int32_t>(ret));
466             if (ret != DMError::DM_OK) {
467                 break;
468             }
469             MarshallingHelper::MarshallingVectorObj<GraphicCM_ColorSpaceType>(reply, colorSpaces,
470                 [](Parcel& parcel, const GraphicCM_ColorSpaceType& color) {
471                     return parcel.WriteUint32(static_cast<uint32_t>(color));
472                 }
473             );
474             break;
475         }
476         case DisplayManagerMessage::TRANS_ID_SCREEN_GET_COLOR_SPACE: {
477             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
478             GraphicCM_ColorSpaceType colorSpace;
479             DMError ret = GetScreenColorSpace(screenId, colorSpace);
480             reply.WriteInt32(static_cast<int32_t>(ret));
481             if (ret != DMError::DM_OK) {
482                 break;
483             }
484             reply.WriteInt32(static_cast<uint32_t>(colorSpace));
485             break;
486         }
487         case DisplayManagerMessage::TRANS_ID_SCREEN_SET_COLOR_SPACE: {
488             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
489             GraphicCM_ColorSpaceType colorSpace = static_cast<GraphicCM_ColorSpaceType>(data.ReadUint32());
490             DMError ret = SetScreenColorSpace(screenId, colorSpace);
491             reply.WriteInt32(static_cast<int32_t>(ret));
492             break;
493         }
494         case DisplayManagerMessage::TRANS_ID_SET_ORIENTATION: {
495             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
496             Orientation orientation = static_cast<Orientation>(data.ReadUint32());
497             DMError ret = SetOrientation(screenId, orientation);
498             reply.WriteInt32(static_cast<int32_t>(ret));
499             break;
500         }
501         case DisplayManagerMessage::TRANS_ID_SET_SCREEN_ROTATION_LOCKED: {
502             bool isLocked = static_cast<bool>(data.ReadBool());
503             DMError ret = SetScreenRotationLocked(isLocked);
504             reply.WriteInt32(static_cast<int32_t>(ret));
505             break;
506         }
507         case DisplayManagerMessage::TRANS_ID_SET_SCREEN_ROTATION_LOCKED_FROM_JS: {
508             bool isLocked = static_cast<bool>(data.ReadBool());
509             DMError ret = SetScreenRotationLockedFromJs(isLocked);
510             reply.WriteInt32(static_cast<int32_t>(ret));
511             break;
512         }
513         case DisplayManagerMessage::TRANS_ID_IS_SCREEN_ROTATION_LOCKED: {
514             bool isLocked = false;
515             DMError ret = IsScreenRotationLocked(isLocked);
516             reply.WriteInt32(static_cast<int32_t>(ret));
517             reply.WriteBool(isLocked);
518             break;
519         }
520         case DisplayManagerMessage::TRANS_ID_GET_CUTOUT_INFO: {
521             DisplayId displayId = static_cast<DisplayId>(data.ReadUint64());
522             sptr<CutoutInfo> cutoutInfo = GetCutoutInfo(displayId);
523             reply.WriteParcelable(cutoutInfo);
524             break;
525         }
526         case DisplayManagerMessage::TRANS_ID_HAS_PRIVATE_WINDOW: {
527             DisplayId id = static_cast<DisplayId>(data.ReadUint64());
528             bool hasPrivateWindow = false;
529             DMError ret = HasPrivateWindow(id, hasPrivateWindow);
530             reply.WriteInt32(static_cast<int32_t>(ret));
531             reply.WriteBool(hasPrivateWindow);
532             break;
533         }
534         case DisplayManagerMessage::TRANS_ID_CONVERT_SCREENID_TO_RSSCREENID: {
535             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
536             ScreenId rsId = SCREEN_ID_INVALID;
537             bool ret = ConvertScreenIdToRsScreenId(screenId, rsId);
538             reply.WriteBool(ret);
539             reply.WriteUint64(rsId);
540             break;
541         }
542         case DisplayManagerMessage::TRANS_ID_HAS_IMMERSIVE_WINDOW: {
543             bool immersive = false;
544             DMError ret = HasImmersiveWindow(immersive);
545             reply.WriteInt32(static_cast<int32_t>(ret));
546             reply.WriteBool(immersive);
547             break;
548         }
549         case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_DUMP_ALL_SCREEN: {
550             std::string dumpInfo;
551             DumpAllScreensInfo(dumpInfo);
552             reply.WriteString(dumpInfo);
553             break;
554         }
555         case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_DUMP_SPECIAL_SCREEN: {
556             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
557             std::string dumpInfo;
558             DumpSpecialScreenInfo(screenId, dumpInfo);
559             reply.WriteString(dumpInfo);
560             break;
561         }
562         case DisplayManagerMessage::TRANS_ID_DEVICE_IS_CAPTURE: {
563             reply.WriteBool(IsCaptured());
564             break;
565         }
566         //Fold Screen
567         case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_SET_FOLD_DISPLAY_MODE: {
568             FoldDisplayMode displayMode = static_cast<FoldDisplayMode>(data.ReadUint32());
569             SetFoldDisplayMode(displayMode);
570             break;
571         }
572         case DisplayManagerMessage::TRANS_ID_SET_FOLD_DISPLAY_MODE_FROM_JS: {
573             FoldDisplayMode displayMode = static_cast<FoldDisplayMode>(data.ReadUint32());
574             DMError ret = SetFoldDisplayModeFromJs(displayMode);
575             reply.WriteInt32(static_cast<int32_t>(ret));
576             break;
577         }
578         case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_LOCK_FOLD_DISPLAY_STATUS: {
579             bool lockDisplayStatus = static_cast<bool>(data.ReadUint32());
580             SetFoldStatusLocked(lockDisplayStatus);
581             break;
582         }
583         case DisplayManagerMessage::TRANS_ID_SET_LOCK_FOLD_DISPLAY_STATUS_FROM_JS: {
584             bool lockDisplayStatus = static_cast<bool>(data.ReadUint32());
585             DMError ret = SetFoldStatusLockedFromJs(lockDisplayStatus);
586             reply.WriteInt32(static_cast<int32_t>(ret));
587             break;
588         }
589         case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_SET_DISPLAY_SCALE: {
590             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
591             auto scaleX = data.ReadFloat();
592             auto scaleY = data.ReadFloat();
593             auto pivotX = data.ReadFloat();
594             auto pivotY = data.ReadFloat();
595             SetDisplayScale(screenId, scaleX, scaleY, pivotX, pivotY);
596             break;
597         }
598         case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_GET_FOLD_DISPLAY_MODE: {
599             FoldDisplayMode displayMode = GetFoldDisplayMode();
600             reply.WriteUint32(static_cast<uint32_t>(displayMode));
601             break;
602         }
603         case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_IS_FOLDABLE: {
604             reply.WriteBool(IsFoldable());
605             break;
606         }
607         case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_GET_FOLD_STATUS: {
608             reply.WriteUint32(static_cast<uint32_t>(GetFoldStatus()));
609             break;
610         }
611         case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_GET_CURRENT_FOLD_CREASE_REGION: {
612             reply.WriteStrongParcelable(GetCurrentFoldCreaseRegion());
613             break;
614         }
615         case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_MAKE_UNIQUE_SCREEN: {
616             std::vector<ScreenId> uniqueScreenIds;
617             uint32_t size = data.ReadUint32();
618             if (size > MAX_SCREEN_SIZE) {
619                 WLOGFE("screenIds size is bigger than %{public}u", MAX_SCREEN_SIZE);
620                 break;
621             }
622             if (!data.ReadUInt64Vector(&uniqueScreenIds)) {
623                 WLOGFE("failed to receive unique screens in stub");
624                 break;
625             }
626             DMError ret = MakeUniqueScreen(uniqueScreenIds);
627             reply.WriteInt32(static_cast<int32_t>(ret));
628             break;
629         }
630         case DisplayManagerMessage::TRANS_ID_SET_CLIENT: {
631             auto remoteObject = data.ReadRemoteObject();
632             auto clientProxy = iface_cast<IScreenSessionManagerClient>(remoteObject);
633             if (clientProxy == nullptr) {
634                 WLOGFE("clientProxy is null");
635                 break;
636             }
637             SetClient(clientProxy);
638             break;
639         }
640         case DisplayManagerMessage::TRANS_ID_GET_SCREEN_PROPERTY: {
641             auto screenId = static_cast<ScreenId>(data.ReadUint64());
642             if (!RSMarshallingHelper::Marshalling(reply, GetScreenProperty(screenId))) {
643                 WLOGFE("Write screenProperty failed");
644             }
645             break;
646         }
647         case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_NODE: {
648             auto screenId = static_cast<ScreenId>(data.ReadUint64());
649             auto displayNode = GetDisplayNode(screenId);
650             if (!displayNode || !displayNode->Marshalling(reply)) {
651                 WLOGFE("Write displayNode failed");
652             }
653             break;
654         }
655         case DisplayManagerMessage::TRANS_ID_UPDATE_SCREEN_DIRECTION_INFO: {
656             auto screenId = static_cast<ScreenId>(data.ReadUint64());
657             auto screenComponentRotation = data.ReadFloat();
658             auto rotation = data.ReadFloat();
659             auto phyRotation = data.ReadFloat();
660             auto screenPropertyChangeType = static_cast<ScreenPropertyChangeType>(data.ReadUint32());
661             UpdateScreenDirectionInfo(screenId, screenComponentRotation, rotation, phyRotation,
662                 screenPropertyChangeType);
663             break;
664         }
665         case DisplayManagerMessage::TRANS_ID_UPDATE_SCREEN_ROTATION_PROPERTY: {
666             auto screenId = static_cast<ScreenId>(data.ReadUint64());
667             RRect bounds;
668             if (!RSMarshallingHelper::Unmarshalling(data, bounds)) {
669                 WLOGFE("Read bounds failed");
670                 break;
671             }
672             auto rotation = data.ReadFloat();
673             auto screenPropertyChangeType = static_cast<ScreenPropertyChangeType>(data.ReadUint32());
674             UpdateScreenRotationProperty(screenId, bounds, rotation, screenPropertyChangeType);
675             break;
676         }
677         case DisplayManagerMessage::TRANS_ID_GET_CURVED_SCREEN_COMPRESSION_AREA: {
678             auto area = GetCurvedCompressionArea();
679             reply.WriteUint32(area);
680             break;
681         }
682         case DisplayManagerMessage::TRANS_ID_GET_PHY_SCREEN_PROPERTY: {
683             auto screenId = static_cast<ScreenId>(data.ReadUint64());
684             if (!RSMarshallingHelper::Marshalling(reply, GetPhyScreenProperty(screenId))) {
685                 WLOGFE("Write screenProperty failed");
686             }
687             break;
688         }
689         case DisplayManagerMessage::TRANS_ID_NOTIFY_DISPLAY_CHANGE_INFO: {
690             sptr<DisplayChangeInfo> info = DisplayChangeInfo::Unmarshalling(data);
691             if (!info) {
692                 WLOGFE("Read DisplayChangeInfo failed");
693                 return ERR_INVALID_DATA;
694             }
695             NotifyDisplayChangeInfoChanged(info);
696             break;
697         }
698         case DisplayManagerMessage::TRANS_ID_SET_SCREEN_PRIVACY_STATE: {
699             auto hasPrivate = data.ReadBool();
700             SetScreenPrivacyState(hasPrivate);
701             break;
702         }
703         case DisplayManagerMessage::TRANS_ID_SET_SCREENID_PRIVACY_STATE: {
704             DisplayId displayId = static_cast<DisplayId>(data.ReadUint64());
705             auto hasPrivate = data.ReadBool();
706             SetPrivacyStateByDisplayId(displayId, hasPrivate);
707             break;
708         }
709         case DisplayManagerMessage::TRANS_ID_SET_SCREEN_PRIVACY_WINDOW_LIST: {
710             DisplayId displayId = static_cast<DisplayId>(data.ReadUint64());
711             std::vector<std::string> privacyWindowList;
712             data.ReadStringVector(&privacyWindowList);
713             SetScreenPrivacyWindowList(displayId, privacyWindowList);
714             break;
715         }
716         case DisplayManagerMessage::TRANS_ID_RESIZE_VIRTUAL_SCREEN: {
717             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
718             uint32_t width = data.ReadUint32();
719             uint32_t height = data.ReadUint32();
720             DMError ret = ResizeVirtualScreen(screenId, width, height);
721             reply.WriteInt32(static_cast<int32_t>(ret));
722             break;
723         }
724         case DisplayManagerMessage::TRANS_ID_UPDATE_AVAILABLE_AREA: {
725             auto screenId = static_cast<ScreenId>(data.ReadUint64());
726             int32_t posX = data.ReadInt32();
727             int32_t posY = data.ReadInt32();
728             uint32_t width = data.ReadUint32();
729             uint32_t height = data.ReadUint32();
730             DMRect area = {posX, posY, width, height};
731             UpdateAvailableArea(screenId, area);
732             break;
733         }
734         case DisplayManagerMessage::TRANS_ID_SET_SCREEN_OFF_DELAY_TIME: {
735             int32_t delay = data.ReadInt32();
736             int32_t ret = SetScreenOffDelayTime(delay);
737             reply.WriteInt32(ret);
738             break;
739         }
740         case DisplayManagerMessage::TRANS_ID_GET_AVAILABLE_AREA: {
741             ProcGetAvailableArea(data, reply);
742             break;
743         }
744         case DisplayManagerMessage::TRANS_ID_NOTIFY_FOLD_TO_EXPAND_COMPLETION: {
745             bool foldToExpand = data.ReadBool();
746             NotifyFoldToExpandCompletion(foldToExpand);
747             break;
748         }
749         case DisplayManagerMessage::TRANS_ID_GET_VIRTUAL_SCREEN_FLAG: {
750             ProcGetVirtualScreenFlag(data, reply);
751             break;
752         }
753         case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_FLAG: {
754             ProcSetVirtualScreenFlag(data, reply);
755             break;
756         }
757         case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_REFRESH_RATE: {
758             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
759             uint32_t refreshInterval = data.ReadUint32();
760             DMError ret = SetVirtualScreenRefreshRate(screenId, refreshInterval);
761             reply.WriteInt32(static_cast<int32_t>(ret));
762             break;
763         }
764         case DisplayManagerMessage::TRANS_ID_GET_DEVICE_SCREEN_CONFIG: {
765             if (!RSMarshallingHelper::Marshalling(reply, GetDeviceScreenConfig())) {
766                 TLOGE(WmsLogTag::DMS, "Write deviceScreenConfig failed");
767             }
768             break;
769         }
770         case DisplayManagerMessage::TRANS_ID_SWITCH_USER: {
771             SwitchUser();
772             break;
773         }
774         case DisplayManagerMessage::TRANS_ID_PROXY_FOR_FREEZE: {
775             ProcProxyForFreeze(data, reply);
776             break;
777         }
778         case DisplayManagerMessage::TRANS_ID_RESET_ALL_FREEZE_STATUS: {
779             DMError ret = ResetAllFreezeStatus();
780             reply.WriteInt32(static_cast<int32_t>(ret));
781             break;
782         }
783         case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_BLACK_LIST: {
784             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
785             std::vector<uint64_t> windowIdList;
786             if (!data.ReadUInt64Vector(&windowIdList)) {
787                 TLOGE(WmsLogTag::DMS, "Failed to receive windowIdList in stub");
788                 break;
789             }
790             SetVirtualScreenBlackList(screenId, windowIdList);
791             break;
792         }
793         case DisplayManagerMessage::TRANS_ID_DISABLE_POWEROFF_RENDER_CONTROL: {
794             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
795             DisablePowerOffRenderControl(screenId);
796             break;
797         }
798         case DisplayManagerMessage::TRANS_ID_NOTIFY_DISPLAY_HOOK_INFO: {
799             int32_t uid = data.ReadInt32();
800             bool enable = data.ReadBool();
801             DMHookInfo hookInfo;
802             hookInfo.width_ = data.ReadUint32();
803             hookInfo.height_ = data.ReadUint32();
804             hookInfo.density_ = data.ReadFloat();
805             hookInfo.rotation_ = data.ReadUint32();
806             hookInfo.enableHookRotation_ = data.ReadBool();
807             UpdateDisplayHookInfo(uid, enable, hookInfo);
808             break;
809         }
810         case DisplayManagerMessage::TRANS_ID_GET_ALL_PHYSICAL_DISPLAY_RESOLUTION: {
811             ProcGetAllDisplayPhysicalResolution(data, reply);
812             break;
813         }
814         case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_SECURITY_EXEMPTION: {
815             ProcSetVirtualScreenSecurityExemption(data, reply);
816             break;
817         }
818         case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_MAX_REFRESHRATE: {
819             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
820             uint32_t refreshRate = data.ReadUint32();
821             uint32_t actualRefreshRate;
822             DMError ret = SetVirtualScreenMaxRefreshRate(screenId, refreshRate, actualRefreshRate);
823             reply.WriteUint32(actualRefreshRate);
824             reply.WriteInt32(static_cast<int32_t>(ret));
825             break;
826         }
827         case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_CAPTURE: {
828             ProcGetScreenCapture(data, reply);
829             break;
830         }
831         case DisplayManagerMessage::TRANS_ID_GET_PRIMARY_DISPLAY_INFO: {
832             auto info = GetPrimaryDisplayInfo();
833             reply.WriteParcelable(info);
834             break;
835         }
836         case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_SNAPSHOT_WITH_OPTION: {
837             ProcGetDisplaySnapshotWithOption(data, reply);
838             break;
839         }
840         case DisplayManagerMessage::TRANS_ID_SET_CAMERA_STATUS: {
841             int32_t cameraStatus = data.ReadInt32();
842             int32_t cameraPosition = data.ReadInt32();
843             SetCameraStatus(cameraStatus, cameraPosition);
844             break;
845         }
846         default:
847             WLOGFW("unknown transaction code");
848             return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
849     }
850     return ERR_NONE;
851 }
852 
ProcGetAvailableArea(MessageParcel & data,MessageParcel & reply)853 void ScreenSessionManagerStub::ProcGetAvailableArea(MessageParcel& data, MessageParcel& reply)
854 {
855     DisplayId displayId = static_cast<DisplayId>(data.ReadUint64());
856     DMRect area;
857     DMError ret = GetAvailableArea(displayId, area);
858     reply.WriteInt32(static_cast<int32_t>(ret));
859     reply.WriteInt32(area.posX_);
860     reply.WriteInt32(area.posY_);
861     reply.WriteUint32(area.width_);
862     reply.WriteUint32(area.height_);
863 }
864 
ProcGetSnapshotByPicker(MessageParcel & reply)865 void ScreenSessionManagerStub::ProcGetSnapshotByPicker(MessageParcel& reply)
866 {
867     DmErrorCode errCode = DmErrorCode::DM_OK;
868     Media::Rect imgRect { 0, 0, 0, 0 };
869     std::shared_ptr<Media::PixelMap> snapshot = GetSnapshotByPicker(imgRect, &errCode);
870     reply.WriteParcelable(snapshot == nullptr ? nullptr : snapshot.get());
871     reply.WriteInt32(static_cast<int32_t>(errCode));
872     reply.WriteInt32(imgRect.left);
873     reply.WriteInt32(imgRect.top);
874     reply.WriteInt32(imgRect.width);
875     reply.WriteInt32(imgRect.height);
876 }
877 
ProcSetVirtualScreenFlag(MessageParcel & data,MessageParcel & reply)878 void ScreenSessionManagerStub::ProcSetVirtualScreenFlag(MessageParcel& data, MessageParcel& reply)
879 {
880     ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
881     VirtualScreenFlag screenFlag = static_cast<VirtualScreenFlag>(data.ReadUint32());
882     DMError setRet = SetVirtualScreenFlag(screenId, screenFlag);
883     reply.WriteInt32(static_cast<int32_t>(setRet));
884 }
885 
ProcGetVirtualScreenFlag(MessageParcel & data,MessageParcel & reply)886 void ScreenSessionManagerStub::ProcGetVirtualScreenFlag(MessageParcel& data, MessageParcel& reply)
887 {
888     ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
889     VirtualScreenFlag screenFlag = GetVirtualScreenFlag(screenId);
890     reply.WriteUint32(static_cast<uint32_t>(screenFlag));
891 }
892 
ProcSetVirtualScreenScaleMode(MessageParcel & data,MessageParcel & reply)893 void ScreenSessionManagerStub::ProcSetVirtualScreenScaleMode(MessageParcel& data, MessageParcel& reply)
894 {
895     ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
896     ScreenScaleMode scaleMode = static_cast<ScreenScaleMode>(data.ReadUint32());
897     DMError result = SetVirtualMirrorScreenScaleMode(screenId, scaleMode);
898     reply.WriteInt32(static_cast<int32_t>(result));
899 }
900 
ProcProxyForFreeze(MessageParcel & data,MessageParcel & reply)901 void ScreenSessionManagerStub::ProcProxyForFreeze(MessageParcel& data, MessageParcel& reply)
902 {
903     std::set<int32_t> pidList;
904     int32_t size = data.ReadInt32();
905     if (size > MAX_BUFF_SIZE) {
906         WLOGFE("pid List size invalid: %{public}d", size);
907         size = MAX_BUFF_SIZE;
908     }
909     for (int32_t i = 0; i < size; i++) {
910         pidList.insert(data.ReadInt32());
911     }
912     bool isProxy = data.ReadBool();
913     DMError ret = ProxyForFreeze(pidList, isProxy);
914     reply.WriteInt32(static_cast<int32_t>(ret));
915 }
916 
ProcGetAllDisplayPhysicalResolution(MessageParcel & data,MessageParcel & reply)917 void ScreenSessionManagerStub::ProcGetAllDisplayPhysicalResolution(MessageParcel& data, MessageParcel& reply)
918 {
919     auto physicalInfos = GetAllDisplayPhysicalResolution();
920     size_t infoSize = physicalInfos.size();
921     bool writeRet = reply.WriteInt32(static_cast<int32_t>(infoSize));
922     if (!writeRet) {
923         WLOGFE("write physical size error");
924         return;
925     }
926     for (const auto &physicalItem : physicalInfos) {
927         writeRet = reply.WriteUint32(static_cast<uint32_t>(physicalItem.foldDisplayMode_));
928         if (!writeRet) {
929             WLOGFE("write display mode error");
930             break;
931         }
932         writeRet = reply.WriteUint32(physicalItem.physicalWidth_);
933         if (!writeRet) {
934             WLOGFE("write physical width error");
935             break;
936         }
937         writeRet = reply.WriteUint32(physicalItem.physicalHeight_);
938         if (!writeRet) {
939             WLOGFE("write physical height error");
940             break;
941         }
942     }
943 }
944 
ProcSetVirtualScreenSecurityExemption(MessageParcel & data,MessageParcel & reply)945 void ScreenSessionManagerStub::ProcSetVirtualScreenSecurityExemption(MessageParcel& data, MessageParcel& reply)
946 {
947     ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
948     uint32_t pid = data.ReadUint32();
949     std::vector<uint64_t> windowIdList;
950     data.ReadUInt64Vector(&windowIdList);
951     DMError ret = SetVirtualScreenSecurityExemption(screenId, pid, windowIdList);
952     reply.WriteInt32(static_cast<int32_t>(ret));
953 }
ProcGetScreenCapture(MessageParcel & data,MessageParcel & reply)954 void ScreenSessionManagerStub::ProcGetScreenCapture(MessageParcel& data, MessageParcel& reply)
955 {
956     CaptureOption option;
957     option.displayId_ = static_cast<DisplayId>(data.ReadUint64());
958     option.isNeedNotify_ = static_cast<bool>(data.ReadBool());
959     option.isNeedPointer_ = static_cast<bool>(data.ReadBool());
960     DmErrorCode errCode = DmErrorCode::DM_OK;
961     std::shared_ptr<Media::PixelMap> capture = GetScreenCapture(option, &errCode);
962     reply.WriteParcelable(capture == nullptr ? nullptr : capture.get());
963     static_cast<void>(reply.WriteInt32(static_cast<int32_t>(errCode)));
964 }
965 
ProcGetDisplaySnapshotWithOption(MessageParcel & data,MessageParcel & reply)966 void ScreenSessionManagerStub::ProcGetDisplaySnapshotWithOption(MessageParcel& data, MessageParcel& reply)
967 {
968     CaptureOption option;
969     option.displayId_ = static_cast<DisplayId>(data.ReadUint64());
970     option.isNeedNotify_ = static_cast<bool>(data.ReadBool());
971     option.isNeedPointer_ = static_cast<bool>(data.ReadBool());
972     DmErrorCode errCode = DmErrorCode::DM_OK;
973     std::shared_ptr<Media::PixelMap> capture = GetDisplaySnapshotWithOption(option, &errCode);
974     reply.WriteParcelable(capture == nullptr ? nullptr : capture.get());
975     static_cast<void>(reply.WriteInt32(static_cast<int32_t>(errCode)));
976 }
977 } // namespace OHOS::Rosen
978