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_GET_SCREEN_POWER_AUTO: {
124 reply.WriteUint32(static_cast<uint32_t>(GetScreenPower()));
125 break;
126 }
127 case DisplayManagerMessage::TRANS_ID_TRY_TO_CANCEL_SCREEN_OFF: {
128 reply.WriteBool(TryToCancelScreenOff());
129 break;
130 }
131 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_BRIGHTNESS: {
132 uint64_t screenId = data.ReadUint64();
133 uint32_t level = data.ReadUint64();
134 reply.WriteBool(SetScreenBrightness(screenId, level));
135 break;
136 }
137 case DisplayManagerMessage::TRANS_ID_GET_SCREEN_BRIGHTNESS: {
138 uint64_t screenId = data.ReadUint64();
139 reply.WriteUint32(GetScreenBrightness(screenId));
140 break;
141 }
142 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_BY_ID: {
143 DisplayId displayId = data.ReadUint64();
144 auto info = GetDisplayInfoById(displayId);
145 reply.WriteParcelable(info);
146 break;
147 }
148 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_BY_SCREEN: {
149 ScreenId screenId = data.ReadUint64();
150 auto info = GetDisplayInfoByScreen(screenId);
151 reply.WriteParcelable(info);
152 break;
153 }
154 case DisplayManagerMessage::TRANS_ID_GET_ALL_DISPLAYIDS: {
155 std::vector<DisplayId> allDisplayIds = GetAllDisplayIds();
156 reply.WriteUInt64Vector(allDisplayIds);
157 break;
158 }
159 case DisplayManagerMessage::TRANS_ID_GET_SCREEN_INFO_BY_ID: {
160 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
161 auto screenInfo = GetScreenInfoById(screenId);
162 reply.WriteStrongParcelable(screenInfo);
163 break;
164 }
165 case DisplayManagerMessage::TRANS_ID_GET_ALL_SCREEN_INFOS: {
166 std::vector<sptr<ScreenInfo>> screenInfos;
167 DMError ret = GetAllScreenInfos(screenInfos);
168 reply.WriteInt32(static_cast<int32_t>(ret));
169 if (!MarshallingHelper::MarshallingVectorParcelableObj<ScreenInfo>(reply, screenInfos)) {
170 WLOGE("fail to marshalling screenInfos in stub.");
171 }
172 break;
173 }
174 case DisplayManagerMessage::TRANS_ID_SCREEN_GET_SUPPORTED_COLOR_GAMUTS: {
175 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
176 std::vector<ScreenColorGamut> colorGamuts;
177 DMError ret = GetScreenSupportedColorGamuts(screenId, colorGamuts);
178 reply.WriteInt32(static_cast<int32_t>(ret));
179 if (ret != DMError::DM_OK) {
180 break;
181 }
182 MarshallingHelper::MarshallingVectorObj<ScreenColorGamut>(reply, colorGamuts,
183 [](Parcel& parcel, const ScreenColorGamut& color) {
184 return parcel.WriteUint32(static_cast<uint32_t>(color));
185 }
186 );
187 break;
188 }
189 case DisplayManagerMessage::TRANS_ID_CREATE_VIRTUAL_SCREEN: {
190 std::string name = data.ReadString();
191 uint32_t width = data.ReadUint32();
192 uint32_t height = data.ReadUint32();
193 float density = data.ReadFloat();
194 int32_t flags = data.ReadInt32();
195 bool isForShot = data.ReadBool();
196 std::vector<uint64_t> missionIds;
197 data.ReadUInt64Vector(&missionIds);
198 VirtualScreenType virtualScreenType = static_cast<VirtualScreenType>(data.ReadUint32());
199 bool isSurfaceValid = data.ReadBool();
200 sptr<Surface> surface = nullptr;
201 if (isSurfaceValid) {
202 sptr<IRemoteObject> surfaceObject = data.ReadRemoteObject();
203 sptr<IBufferProducer> bp = iface_cast<IBufferProducer>(surfaceObject);
204 surface = Surface::CreateSurfaceAsProducer(bp);
205 }
206 sptr<IRemoteObject> virtualScreenAgent = data.ReadRemoteObject();
207 VirtualScreenOption virScrOption = {
208 .name_ = name,
209 .width_ = width,
210 .height_ = height,
211 .density_ = density,
212 .surface_ = surface,
213 .flags_ = flags,
214 .isForShot_ = isForShot,
215 .missionIds_ = missionIds,
216 .virtualScreenType_ = virtualScreenType
217 };
218 ScreenId screenId = CreateVirtualScreen(virScrOption, virtualScreenAgent);
219 reply.WriteUint64(static_cast<uint64_t>(screenId));
220 break;
221 }
222 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_SURFACE: {
223 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
224 bool isSurfaceValid = data.ReadBool();
225 sptr<IBufferProducer> bp = nullptr;
226 if (isSurfaceValid) {
227 sptr<IRemoteObject> surfaceObject = data.ReadRemoteObject();
228 bp = iface_cast<IBufferProducer>(surfaceObject);
229 }
230 DMError result = SetVirtualScreenSurface(screenId, bp);
231 reply.WriteInt32(static_cast<int32_t>(result));
232 break;
233 }
234 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_CANVAS_ROTATION: {
235 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
236 bool autoRotate = data.ReadBool();
237 DMError result = SetVirtualMirrorScreenCanvasRotation(screenId, autoRotate);
238 reply.WriteInt32(static_cast<int32_t>(result));
239 break;
240 }
241 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_SCALE_MODE: {
242 ProcSetVirtualScreenScaleMode(data, reply);
243 break;
244 }
245 case DisplayManagerMessage::TRANS_ID_DESTROY_VIRTUAL_SCREEN: {
246 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
247 DMError result = DestroyVirtualScreen(screenId);
248 reply.WriteInt32(static_cast<int32_t>(result));
249 break;
250 }
251 case DisplayManagerMessage::TRANS_ID_SCREEN_MAKE_MIRROR: {
252 ScreenId mainScreenId = static_cast<ScreenId>(data.ReadUint64());
253 std::vector<ScreenId> mirrorScreenId;
254 if (!data.ReadUInt64Vector(&mirrorScreenId)) {
255 WLOGE("fail to receive mirror screen in stub. screen:%{public}" PRIu64"", mainScreenId);
256 break;
257 }
258 ScreenId screenGroupId = INVALID_SCREEN_ID;
259 DMError ret = MakeMirror(mainScreenId, mirrorScreenId, screenGroupId);
260 reply.WriteInt32(static_cast<int32_t>(ret));
261 reply.WriteUint64(static_cast<uint64_t>(screenGroupId));
262 break;
263 }
264 case DisplayManagerMessage::TRANS_ID_SCREEN_MAKE_MIRROR_WITH_REGION: {
265 ScreenId mainScreenId = static_cast<ScreenId>(data.ReadUint64());
266 std::vector<ScreenId> mirrorScreenId;
267 if (!data.ReadUInt64Vector(&mirrorScreenId)) {
268 WLOGE("fail to receive mirror screen in stub. screen:%{public}" PRIu64"", mainScreenId);
269 break;
270 }
271 int32_t posX = data.ReadInt32();
272 int32_t posY = data.ReadInt32();
273 uint32_t width = data.ReadUint32();
274 uint32_t height = data.ReadUint32();
275 DMRect mainScreenRegion = { posX, posY, width, height };
276 ScreenId screenGroupId = INVALID_SCREEN_ID;
277 DMError ret = MakeMirror(mainScreenId, mirrorScreenId, mainScreenRegion, screenGroupId);
278 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
279 static_cast<void>(reply.WriteUint64(static_cast<uint64_t>(screenGroupId)));
280 break;
281 }
282 case DisplayManagerMessage::TRANS_ID_SCREEN_STOP_MIRROR: {
283 std::vector<ScreenId> mirrorScreenIds;
284 if (!data.ReadUInt64Vector(&mirrorScreenIds)) {
285 WLOGE("fail to receive mirror screens in stub.");
286 break;
287 }
288 DMError ret = StopMirror(mirrorScreenIds);
289 reply.WriteInt32(static_cast<int32_t>(ret));
290 break;
291 }
292 case DisplayManagerMessage::TRANS_ID_SCREEN_DISABLE_MIRROR: {
293 DMError ret = DisableMirror(data.ReadBool());
294 reply.WriteInt32(static_cast<int32_t>(ret));
295 break;
296 }
297 case DisplayManagerMessage::TRANS_ID_SCREEN_MAKE_EXPAND: {
298 std::vector<ScreenId> screenId;
299 if (!data.ReadUInt64Vector(&screenId)) {
300 WLOGE("fail to receive expand screen in stub.");
301 break;
302 }
303 std::vector<Point> startPoint;
304 if (!MarshallingHelper::UnmarshallingVectorObj<Point>(data, startPoint, [](Parcel& parcel, Point& point) {
305 return parcel.ReadInt32(point.posX_) && parcel.ReadInt32(point.posY_);
306 })) {
307 WLOGE("fail to receive startPoint in stub.");
308 break;
309 }
310 ScreenId screenGroupId = INVALID_SCREEN_ID;
311 DMError ret = MakeExpand(screenId, startPoint, screenGroupId);
312 reply.WriteInt32(static_cast<int32_t>(ret));
313 reply.WriteUint64(static_cast<uint64_t>(screenGroupId));
314 break;
315 }
316 case DisplayManagerMessage::TRANS_ID_SCREEN_STOP_EXPAND: {
317 std::vector<ScreenId> expandScreenIds;
318 if (!data.ReadUInt64Vector(&expandScreenIds)) {
319 WLOGE("fail to receive expand screens in stub.");
320 break;
321 }
322 DMError ret = StopExpand(expandScreenIds);
323 reply.WriteInt32(static_cast<int32_t>(ret));
324 break;
325 }
326 case DisplayManagerMessage::TRANS_ID_GET_SCREEN_GROUP_INFO_BY_ID: {
327 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
328 auto screenGroupInfo = GetScreenGroupInfoById(screenId);
329 reply.WriteStrongParcelable(screenGroupInfo);
330 break;
331 }
332 case DisplayManagerMessage::TRANS_ID_REMOVE_VIRTUAL_SCREEN_FROM_SCREEN_GROUP: {
333 std::vector<ScreenId> screenId;
334 if (!data.ReadUInt64Vector(&screenId)) {
335 WLOGE("fail to receive screens in stub.");
336 break;
337 }
338 RemoveVirtualScreenFromGroup(screenId);
339 break;
340 }
341 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_SNAPSHOT: {
342 DisplayId displayId = data.ReadUint64();
343 DmErrorCode errCode = DmErrorCode::DM_OK;
344 bool isUseDma = data.ReadBool();
345 std::shared_ptr<Media::PixelMap> displaySnapshot = GetDisplaySnapshot(displayId, &errCode, isUseDma);
346 reply.WriteParcelable(displaySnapshot == nullptr ? nullptr : displaySnapshot.get());
347 reply.WriteInt32(static_cast<int32_t>(errCode));
348 break;
349 }
350 case DisplayManagerMessage::TRANS_ID_GET_SNAPSHOT_BY_PICKER: {
351 ProcGetSnapshotByPicker(reply);
352 break;
353 }
354 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_ACTIVE_MODE: {
355 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
356 uint32_t modeId = data.ReadUint32();
357 DMError ret = SetScreenActiveMode(screenId, modeId);
358 reply.WriteInt32(static_cast<int32_t>(ret));
359 break;
360 }
361 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_PIXEL_RATIO: {
362 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
363 float virtualPixelRatio = data.ReadFloat();
364 DMError ret = SetVirtualPixelRatio(screenId, virtualPixelRatio);
365 reply.WriteInt32(static_cast<int32_t>(ret));
366 break;
367 }
368 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_PIXEL_RATIO_SYSTEM: {
369 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
370 float virtualPixelRatio = data.ReadFloat();
371 DMError ret = SetVirtualPixelRatioSystem(screenId, virtualPixelRatio);
372 reply.WriteInt32(static_cast<int32_t>(ret));
373 break;
374 }
375 case DisplayManagerMessage::TRANS_ID_SET_RESOLUTION: {
376 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
377 uint32_t width = data.ReadUint32();
378 uint32_t height = data.ReadUint32();
379 float virtualPixelRatio = data.ReadFloat();
380 DMError ret = SetResolution(screenId, width, height, virtualPixelRatio);
381 reply.WriteInt32(static_cast<int32_t>(ret));
382 break;
383 }
384 case DisplayManagerMessage::TRANS_ID_GET_DENSITY_IN_CURRENT_RESOLUTION: {
385 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
386 float virtualPixelRatio;
387 DMError ret = GetDensityInCurResolution(screenId, virtualPixelRatio);
388 reply.WriteFloat(virtualPixelRatio);
389 reply.WriteInt32(static_cast<int32_t>(ret));
390 break;
391 }
392 case DisplayManagerMessage::TRANS_ID_SCREEN_GET_COLOR_GAMUT: {
393 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
394 ScreenColorGamut colorGamut;
395 DMError ret = GetScreenColorGamut(screenId, colorGamut);
396 reply.WriteInt32(static_cast<int32_t>(ret));
397 if (ret != DMError::DM_OK) {
398 break;
399 }
400 reply.WriteUint32(static_cast<uint32_t>(colorGamut));
401 break;
402 }
403 case DisplayManagerMessage::TRANS_ID_SCREEN_SET_COLOR_GAMUT: {
404 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
405 int32_t colorGamutIdx = data.ReadInt32();
406 DMError ret = SetScreenColorGamut(screenId, colorGamutIdx);
407 reply.WriteInt32(static_cast<int32_t>(ret));
408 break;
409 }
410 case DisplayManagerMessage::TRANS_ID_SCREEN_GET_GAMUT_MAP: {
411 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
412 ScreenGamutMap gamutMap;
413 DMError ret = GetScreenGamutMap(screenId, gamutMap);
414 reply.WriteInt32(static_cast<int32_t>(ret));
415 if (ret != DMError::DM_OK) {
416 break;
417 }
418 reply.WriteInt32(static_cast<uint32_t>(gamutMap));
419 break;
420 }
421 case DisplayManagerMessage::TRANS_ID_SCREEN_SET_GAMUT_MAP: {
422 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
423 ScreenGamutMap gamutMap = static_cast<ScreenGamutMap>(data.ReadUint32());
424 DMError ret = SetScreenGamutMap(screenId, gamutMap);
425 reply.WriteInt32(static_cast<int32_t>(ret));
426 break;
427 }
428 case DisplayManagerMessage::TRANS_ID_SCREEN_SET_COLOR_TRANSFORM: {
429 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
430 DMError ret = SetScreenColorTransform(screenId);
431 reply.WriteInt32(static_cast<int32_t>(ret));
432 break;
433 }
434 case DisplayManagerMessage::TRANS_ID_SCREEN_GET_PIXEL_FORMAT: {
435 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
436 GraphicPixelFormat pixelFormat;
437 DMError ret = GetPixelFormat(screenId, pixelFormat);
438 reply.WriteInt32(static_cast<int32_t>(ret));
439 if (ret != DMError::DM_OK) {
440 break;
441 }
442 reply.WriteInt32(static_cast<uint32_t>(pixelFormat));
443 break;
444 }
445 case DisplayManagerMessage::TRANS_ID_SCREEN_SET_PIXEL_FORMAT: {
446 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
447 GraphicPixelFormat pixelFormat = static_cast<GraphicPixelFormat>(data.ReadUint32());
448 DMError ret = SetPixelFormat(screenId, pixelFormat);
449 reply.WriteInt32(static_cast<int32_t>(ret));
450 break;
451 }
452 case DisplayManagerMessage::TRANS_ID_SCREEN_GET_SUPPORTED_HDR_FORMAT: {
453 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
454 std::vector<ScreenHDRFormat> hdrFormats;
455 DMError ret = GetSupportedHDRFormats(screenId, hdrFormats);
456 reply.WriteInt32(static_cast<int32_t>(ret));
457 if (ret != DMError::DM_OK) {
458 break;
459 }
460 MarshallingHelper::MarshallingVectorObj<ScreenHDRFormat>(reply, hdrFormats,
461 [](Parcel& parcel, const ScreenHDRFormat& hdrFormat) {
462 return parcel.WriteUint32(static_cast<uint32_t>(hdrFormat));
463 }
464 );
465 break;
466 }
467 case DisplayManagerMessage::TRANS_ID_SCREEN_GET_HDR_FORMAT: {
468 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
469 ScreenHDRFormat hdrFormat;
470 DMError ret = GetScreenHDRFormat(screenId, hdrFormat);
471 reply.WriteInt32(static_cast<int32_t>(ret));
472 if (ret != DMError::DM_OK) {
473 break;
474 }
475 reply.WriteInt32(static_cast<uint32_t>(hdrFormat));
476 break;
477 }
478 case DisplayManagerMessage::TRANS_ID_SCREEN_SET_HDR_FORMAT: {
479 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
480 int32_t modeIdx = data.ReadInt32();
481 DMError ret = SetScreenHDRFormat(screenId, modeIdx);
482 reply.WriteInt32(static_cast<int32_t>(ret));
483 break;
484 }
485 case DisplayManagerMessage::TRANS_ID_SCREEN_GET_SUPPORTED_COLOR_SPACE: {
486 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
487 std::vector<GraphicCM_ColorSpaceType> colorSpaces;
488 DMError ret = GetSupportedColorSpaces(screenId, colorSpaces);
489 reply.WriteInt32(static_cast<int32_t>(ret));
490 if (ret != DMError::DM_OK) {
491 break;
492 }
493 MarshallingHelper::MarshallingVectorObj<GraphicCM_ColorSpaceType>(reply, colorSpaces,
494 [](Parcel& parcel, const GraphicCM_ColorSpaceType& color) {
495 return parcel.WriteUint32(static_cast<uint32_t>(color));
496 }
497 );
498 break;
499 }
500 case DisplayManagerMessage::TRANS_ID_SCREEN_GET_COLOR_SPACE: {
501 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
502 GraphicCM_ColorSpaceType colorSpace;
503 DMError ret = GetScreenColorSpace(screenId, colorSpace);
504 reply.WriteInt32(static_cast<int32_t>(ret));
505 if (ret != DMError::DM_OK) {
506 break;
507 }
508 reply.WriteInt32(static_cast<uint32_t>(colorSpace));
509 break;
510 }
511 case DisplayManagerMessage::TRANS_ID_SCREEN_SET_COLOR_SPACE: {
512 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
513 GraphicCM_ColorSpaceType colorSpace = static_cast<GraphicCM_ColorSpaceType>(data.ReadUint32());
514 DMError ret = SetScreenColorSpace(screenId, colorSpace);
515 reply.WriteInt32(static_cast<int32_t>(ret));
516 break;
517 }
518 case DisplayManagerMessage::TRANS_ID_SET_ORIENTATION: {
519 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
520 Orientation orientation = static_cast<Orientation>(data.ReadUint32());
521 DMError ret = SetOrientation(screenId, orientation);
522 reply.WriteInt32(static_cast<int32_t>(ret));
523 break;
524 }
525 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_ROTATION_LOCKED: {
526 bool isLocked = static_cast<bool>(data.ReadBool());
527 DMError ret = SetScreenRotationLocked(isLocked);
528 reply.WriteInt32(static_cast<int32_t>(ret));
529 break;
530 }
531 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_ROTATION_LOCKED_FROM_JS: {
532 bool isLocked = static_cast<bool>(data.ReadBool());
533 DMError ret = SetScreenRotationLockedFromJs(isLocked);
534 reply.WriteInt32(static_cast<int32_t>(ret));
535 break;
536 }
537 case DisplayManagerMessage::TRANS_ID_IS_SCREEN_ROTATION_LOCKED: {
538 bool isLocked = false;
539 DMError ret = IsScreenRotationLocked(isLocked);
540 reply.WriteInt32(static_cast<int32_t>(ret));
541 reply.WriteBool(isLocked);
542 break;
543 }
544 case DisplayManagerMessage::TRANS_ID_GET_CUTOUT_INFO: {
545 DisplayId displayId = static_cast<DisplayId>(data.ReadUint64());
546 sptr<CutoutInfo> cutoutInfo = GetCutoutInfo(displayId);
547 reply.WriteParcelable(cutoutInfo);
548 break;
549 }
550 case DisplayManagerMessage::TRANS_ID_HAS_PRIVATE_WINDOW: {
551 DisplayId id = static_cast<DisplayId>(data.ReadUint64());
552 bool hasPrivateWindow = false;
553 DMError ret = HasPrivateWindow(id, hasPrivateWindow);
554 reply.WriteInt32(static_cast<int32_t>(ret));
555 reply.WriteBool(hasPrivateWindow);
556 break;
557 }
558 case DisplayManagerMessage::TRANS_ID_CONVERT_SCREENID_TO_RSSCREENID: {
559 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
560 ScreenId rsId = SCREEN_ID_INVALID;
561 bool ret = ConvertScreenIdToRsScreenId(screenId, rsId);
562 reply.WriteBool(ret);
563 reply.WriteUint64(rsId);
564 break;
565 }
566 case DisplayManagerMessage::TRANS_ID_HAS_IMMERSIVE_WINDOW: {
567 bool immersive = false;
568 DMError ret = HasImmersiveWindow(immersive);
569 reply.WriteInt32(static_cast<int32_t>(ret));
570 reply.WriteBool(immersive);
571 break;
572 }
573 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_DUMP_ALL_SCREEN: {
574 std::string dumpInfo;
575 DumpAllScreensInfo(dumpInfo);
576 reply.WriteString(dumpInfo);
577 break;
578 }
579 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_DUMP_SPECIAL_SCREEN: {
580 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
581 std::string dumpInfo;
582 DumpSpecialScreenInfo(screenId, dumpInfo);
583 reply.WriteString(dumpInfo);
584 break;
585 }
586 case DisplayManagerMessage::TRANS_ID_DEVICE_IS_CAPTURE: {
587 reply.WriteBool(IsCaptured());
588 break;
589 }
590 //Fold Screen
591 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_SET_FOLD_DISPLAY_MODE: {
592 FoldDisplayMode displayMode = static_cast<FoldDisplayMode>(data.ReadUint32());
593 SetFoldDisplayMode(displayMode);
594 break;
595 }
596 case DisplayManagerMessage::TRANS_ID_SET_FOLD_DISPLAY_MODE_FROM_JS: {
597 FoldDisplayMode displayMode = static_cast<FoldDisplayMode>(data.ReadUint32());
598 std::string reason = data.ReadString();
599 DMError ret = SetFoldDisplayModeFromJs(displayMode, reason);
600 reply.WriteInt32(static_cast<int32_t>(ret));
601 break;
602 }
603 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_LOCK_FOLD_DISPLAY_STATUS: {
604 bool lockDisplayStatus = static_cast<bool>(data.ReadUint32());
605 SetFoldStatusLocked(lockDisplayStatus);
606 break;
607 }
608 case DisplayManagerMessage::TRANS_ID_SET_LOCK_FOLD_DISPLAY_STATUS_FROM_JS: {
609 bool lockDisplayStatus = static_cast<bool>(data.ReadUint32());
610 DMError ret = SetFoldStatusLockedFromJs(lockDisplayStatus);
611 reply.WriteInt32(static_cast<int32_t>(ret));
612 break;
613 }
614 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_SET_DISPLAY_SCALE: {
615 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
616 auto scaleX = data.ReadFloat();
617 auto scaleY = data.ReadFloat();
618 auto pivotX = data.ReadFloat();
619 auto pivotY = data.ReadFloat();
620 SetDisplayScale(screenId, scaleX, scaleY, pivotX, pivotY);
621 break;
622 }
623 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_GET_FOLD_DISPLAY_MODE: {
624 FoldDisplayMode displayMode = GetFoldDisplayMode();
625 reply.WriteUint32(static_cast<uint32_t>(displayMode));
626 break;
627 }
628 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_IS_FOLDABLE: {
629 reply.WriteBool(IsFoldable());
630 break;
631 }
632 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_GET_FOLD_STATUS: {
633 reply.WriteUint32(static_cast<uint32_t>(GetFoldStatus()));
634 break;
635 }
636 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_GET_CURRENT_FOLD_CREASE_REGION: {
637 reply.WriteStrongParcelable(GetCurrentFoldCreaseRegion());
638 break;
639 }
640 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_MAKE_UNIQUE_SCREEN: {
641 std::vector<ScreenId> uniqueScreenIds;
642 uint32_t size = data.ReadUint32();
643 if (size > MAX_SCREEN_SIZE) {
644 WLOGFE("screenIds size is bigger than %{public}u", MAX_SCREEN_SIZE);
645 break;
646 }
647 if (!data.ReadUInt64Vector(&uniqueScreenIds)) {
648 WLOGFE("failed to receive unique screens in stub");
649 break;
650 }
651 DMError ret = MakeUniqueScreen(uniqueScreenIds);
652 reply.WriteInt32(static_cast<int32_t>(ret));
653 break;
654 }
655 case DisplayManagerMessage::TRANS_ID_SET_CLIENT: {
656 auto remoteObject = data.ReadRemoteObject();
657 auto clientProxy = iface_cast<IScreenSessionManagerClient>(remoteObject);
658 if (clientProxy == nullptr) {
659 WLOGFE("clientProxy is null");
660 break;
661 }
662 SetClient(clientProxy);
663 break;
664 }
665 case DisplayManagerMessage::TRANS_ID_GET_SCREEN_PROPERTY: {
666 auto screenId = static_cast<ScreenId>(data.ReadUint64());
667 if (!RSMarshallingHelper::Marshalling(reply, GetScreenProperty(screenId))) {
668 WLOGFE("Write screenProperty failed");
669 }
670 break;
671 }
672 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_NODE: {
673 auto screenId = static_cast<ScreenId>(data.ReadUint64());
674 auto displayNode = GetDisplayNode(screenId);
675 if (!displayNode || !displayNode->Marshalling(reply)) {
676 WLOGFE("Write displayNode failed");
677 }
678 break;
679 }
680 case DisplayManagerMessage::TRANS_ID_GET_SCREEN_COMBINATION: {
681 auto screenId = static_cast<ScreenId>(data.ReadUint64());
682 auto screenCombination = GetScreenCombination(screenId);
683 reply.WriteUint32(static_cast<uint32_t>(screenCombination));
684 break;
685 }
686 case DisplayManagerMessage::TRANS_ID_UPDATE_SCREEN_DIRECTION_INFO: {
687 auto screenId = static_cast<ScreenId>(data.ReadUint64());
688 auto screenComponentRotation = data.ReadFloat();
689 auto rotation = data.ReadFloat();
690 auto phyRotation = data.ReadFloat();
691 auto screenPropertyChangeType = static_cast<ScreenPropertyChangeType>(data.ReadUint32());
692 UpdateScreenDirectionInfo(screenId, screenComponentRotation, rotation, phyRotation,
693 screenPropertyChangeType);
694 break;
695 }
696 case DisplayManagerMessage::TRANS_ID_UPDATE_SCREEN_ROTATION_PROPERTY: {
697 auto screenId = static_cast<ScreenId>(data.ReadUint64());
698 RRect bounds;
699 if (!RSMarshallingHelper::Unmarshalling(data, bounds)) {
700 WLOGFE("Read bounds failed");
701 break;
702 }
703 auto rotation = data.ReadFloat();
704 auto screenPropertyChangeType = static_cast<ScreenPropertyChangeType>(data.ReadUint32());
705 UpdateScreenRotationProperty(screenId, bounds, rotation, screenPropertyChangeType);
706 break;
707 }
708 case DisplayManagerMessage::TRANS_ID_GET_CURVED_SCREEN_COMPRESSION_AREA: {
709 auto area = GetCurvedCompressionArea();
710 reply.WriteUint32(area);
711 break;
712 }
713 case DisplayManagerMessage::TRANS_ID_GET_PHY_SCREEN_PROPERTY: {
714 auto screenId = static_cast<ScreenId>(data.ReadUint64());
715 if (!RSMarshallingHelper::Marshalling(reply, GetPhyScreenProperty(screenId))) {
716 WLOGFE("Write screenProperty failed");
717 }
718 break;
719 }
720 case DisplayManagerMessage::TRANS_ID_NOTIFY_DISPLAY_CHANGE_INFO: {
721 sptr<DisplayChangeInfo> info = DisplayChangeInfo::Unmarshalling(data);
722 if (!info) {
723 WLOGFE("Read DisplayChangeInfo failed");
724 return ERR_INVALID_DATA;
725 }
726 NotifyDisplayChangeInfoChanged(info);
727 break;
728 }
729 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_PRIVACY_STATE: {
730 auto hasPrivate = data.ReadBool();
731 SetScreenPrivacyState(hasPrivate);
732 break;
733 }
734 case DisplayManagerMessage::TRANS_ID_SET_SCREENID_PRIVACY_STATE: {
735 DisplayId displayId = static_cast<DisplayId>(data.ReadUint64());
736 auto hasPrivate = data.ReadBool();
737 SetPrivacyStateByDisplayId(displayId, hasPrivate);
738 break;
739 }
740 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_PRIVACY_WINDOW_LIST: {
741 DisplayId displayId = static_cast<DisplayId>(data.ReadUint64());
742 std::vector<std::string> privacyWindowList;
743 data.ReadStringVector(&privacyWindowList);
744 SetScreenPrivacyWindowList(displayId, privacyWindowList);
745 break;
746 }
747 case DisplayManagerMessage::TRANS_ID_RESIZE_VIRTUAL_SCREEN: {
748 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
749 uint32_t width = data.ReadUint32();
750 uint32_t height = data.ReadUint32();
751 DMError ret = ResizeVirtualScreen(screenId, width, height);
752 reply.WriteInt32(static_cast<int32_t>(ret));
753 break;
754 }
755 case DisplayManagerMessage::TRANS_ID_UPDATE_AVAILABLE_AREA: {
756 auto screenId = static_cast<ScreenId>(data.ReadUint64());
757 int32_t posX = data.ReadInt32();
758 int32_t posY = data.ReadInt32();
759 uint32_t width = data.ReadUint32();
760 uint32_t height = data.ReadUint32();
761 DMRect area = {posX, posY, width, height};
762 UpdateAvailableArea(screenId, area);
763 break;
764 }
765 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_OFF_DELAY_TIME: {
766 int32_t delay = data.ReadInt32();
767 int32_t ret = SetScreenOffDelayTime(delay);
768 reply.WriteInt32(ret);
769 break;
770 }
771 case DisplayManagerMessage::TRANS_ID_GET_AVAILABLE_AREA: {
772 ProcGetAvailableArea(data, reply);
773 break;
774 }
775 case DisplayManagerMessage::TRANS_ID_NOTIFY_FOLD_TO_EXPAND_COMPLETION: {
776 bool foldToExpand = data.ReadBool();
777 NotifyFoldToExpandCompletion(foldToExpand);
778 break;
779 }
780 case DisplayManagerMessage::TRANS_ID_GET_VIRTUAL_SCREEN_FLAG: {
781 ProcGetVirtualScreenFlag(data, reply);
782 break;
783 }
784 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_FLAG: {
785 ProcSetVirtualScreenFlag(data, reply);
786 break;
787 }
788 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_REFRESH_RATE: {
789 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
790 uint32_t refreshInterval = data.ReadUint32();
791 DMError ret = SetVirtualScreenRefreshRate(screenId, refreshInterval);
792 reply.WriteInt32(static_cast<int32_t>(ret));
793 break;
794 }
795 case DisplayManagerMessage::TRANS_ID_GET_DEVICE_SCREEN_CONFIG: {
796 if (!RSMarshallingHelper::Marshalling(reply, GetDeviceScreenConfig())) {
797 TLOGE(WmsLogTag::DMS, "Write deviceScreenConfig failed");
798 }
799 break;
800 }
801 case DisplayManagerMessage::TRANS_ID_SWITCH_USER: {
802 SwitchUser();
803 break;
804 }
805 case DisplayManagerMessage::TRANS_ID_PROXY_FOR_FREEZE: {
806 ProcProxyForFreeze(data, reply);
807 break;
808 }
809 case DisplayManagerMessage::TRANS_ID_RESET_ALL_FREEZE_STATUS: {
810 DMError ret = ResetAllFreezeStatus();
811 reply.WriteInt32(static_cast<int32_t>(ret));
812 break;
813 }
814 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_BLACK_LIST: {
815 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
816 std::vector<uint64_t> windowIdList;
817 if (!data.ReadUInt64Vector(&windowIdList)) {
818 TLOGE(WmsLogTag::DMS, "Failed to receive windowIdList in stub");
819 break;
820 }
821 std::vector<uint64_t> surfaceIdList;
822 if (!data.ReadUInt64Vector(&surfaceIdList)) {
823 TLOGE(WmsLogTag::DMS, "Failed to receive surfaceIdList in stub");
824 break;
825 }
826 SetVirtualScreenBlackList(screenId, windowIdList, surfaceIdList);
827 break;
828 }
829 case DisplayManagerMessage::TRANS_ID_DISABLE_POWEROFF_RENDER_CONTROL: {
830 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
831 DisablePowerOffRenderControl(screenId);
832 break;
833 }
834 case DisplayManagerMessage::TRANS_ID_NOTIFY_DISPLAY_HOOK_INFO: {
835 int32_t uid = data.ReadInt32();
836 bool enable = data.ReadBool();
837 DMHookInfo hookInfo;
838 hookInfo.width_ = data.ReadUint32();
839 hookInfo.height_ = data.ReadUint32();
840 hookInfo.density_ = data.ReadFloat();
841 hookInfo.rotation_ = data.ReadUint32();
842 hookInfo.enableHookRotation_ = data.ReadBool();
843 UpdateDisplayHookInfo(uid, enable, hookInfo);
844 break;
845 }
846 case DisplayManagerMessage::TRANS_ID_GET_ALL_PHYSICAL_DISPLAY_RESOLUTION: {
847 ProcGetAllDisplayPhysicalResolution(data, reply);
848 break;
849 }
850 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_SECURITY_EXEMPTION: {
851 ProcSetVirtualScreenSecurityExemption(data, reply);
852 break;
853 }
854 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_MAX_REFRESHRATE: {
855 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
856 uint32_t refreshRate = data.ReadUint32();
857 uint32_t actualRefreshRate;
858 DMError ret = SetVirtualScreenMaxRefreshRate(screenId, refreshRate, actualRefreshRate);
859 reply.WriteUint32(actualRefreshRate);
860 reply.WriteInt32(static_cast<int32_t>(ret));
861 break;
862 }
863 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_CAPTURE: {
864 ProcGetScreenCapture(data, reply);
865 break;
866 }
867 case DisplayManagerMessage::TRANS_ID_GET_PRIMARY_DISPLAY_INFO: {
868 auto info = GetPrimaryDisplayInfo();
869 reply.WriteParcelable(info);
870 break;
871 }
872 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_SNAPSHOT_WITH_OPTION: {
873 ProcGetDisplaySnapshotWithOption(data, reply);
874 break;
875 }
876 case DisplayManagerMessage::TRANS_ID_SET_CAMERA_STATUS: {
877 int32_t cameraStatus = data.ReadInt32();
878 int32_t cameraPosition = data.ReadInt32();
879 SetCameraStatus(cameraStatus, cameraPosition);
880 break;
881 }
882 case DisplayManagerMessage::TRANS_ID_RECORD_EVENT_FROM_SCB: {
883 std::string description = data.ReadString();
884 bool needRecordEvent = data.ReadBool();
885 RecordEventFromScb(description, needRecordEvent);
886 break;
887 }
888 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_CAPABILITY: {
889 reply.WriteString(GetDisplayCapability());
890 break;
891 }
892 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_SKIP_PROTECTED_WINDOW: {
893 ProcSetScreenSkipProtectedWindow(data, reply);
894 break;
895 }
896 default:
897 WLOGFW("unknown transaction code");
898 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
899 }
900 return ERR_NONE;
901 }
902
ProcGetAvailableArea(MessageParcel & data,MessageParcel & reply)903 void ScreenSessionManagerStub::ProcGetAvailableArea(MessageParcel& data, MessageParcel& reply)
904 {
905 DisplayId displayId = static_cast<DisplayId>(data.ReadUint64());
906 DMRect area;
907 DMError ret = GetAvailableArea(displayId, area);
908 reply.WriteInt32(static_cast<int32_t>(ret));
909 reply.WriteInt32(area.posX_);
910 reply.WriteInt32(area.posY_);
911 reply.WriteUint32(area.width_);
912 reply.WriteUint32(area.height_);
913 }
914
ProcGetSnapshotByPicker(MessageParcel & reply)915 void ScreenSessionManagerStub::ProcGetSnapshotByPicker(MessageParcel& reply)
916 {
917 DmErrorCode errCode = DmErrorCode::DM_OK;
918 Media::Rect imgRect { 0, 0, 0, 0 };
919 std::shared_ptr<Media::PixelMap> snapshot = GetSnapshotByPicker(imgRect, &errCode);
920 reply.WriteParcelable(snapshot == nullptr ? nullptr : snapshot.get());
921 reply.WriteInt32(static_cast<int32_t>(errCode));
922 reply.WriteInt32(imgRect.left);
923 reply.WriteInt32(imgRect.top);
924 reply.WriteInt32(imgRect.width);
925 reply.WriteInt32(imgRect.height);
926 }
927
ProcSetVirtualScreenFlag(MessageParcel & data,MessageParcel & reply)928 void ScreenSessionManagerStub::ProcSetVirtualScreenFlag(MessageParcel& data, MessageParcel& reply)
929 {
930 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
931 VirtualScreenFlag screenFlag = static_cast<VirtualScreenFlag>(data.ReadUint32());
932 DMError setRet = SetVirtualScreenFlag(screenId, screenFlag);
933 reply.WriteInt32(static_cast<int32_t>(setRet));
934 }
935
ProcGetVirtualScreenFlag(MessageParcel & data,MessageParcel & reply)936 void ScreenSessionManagerStub::ProcGetVirtualScreenFlag(MessageParcel& data, MessageParcel& reply)
937 {
938 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
939 VirtualScreenFlag screenFlag = GetVirtualScreenFlag(screenId);
940 reply.WriteUint32(static_cast<uint32_t>(screenFlag));
941 }
942
ProcSetVirtualScreenScaleMode(MessageParcel & data,MessageParcel & reply)943 void ScreenSessionManagerStub::ProcSetVirtualScreenScaleMode(MessageParcel& data, MessageParcel& reply)
944 {
945 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
946 ScreenScaleMode scaleMode = static_cast<ScreenScaleMode>(data.ReadUint32());
947 DMError result = SetVirtualMirrorScreenScaleMode(screenId, scaleMode);
948 reply.WriteInt32(static_cast<int32_t>(result));
949 }
950
ProcProxyForFreeze(MessageParcel & data,MessageParcel & reply)951 void ScreenSessionManagerStub::ProcProxyForFreeze(MessageParcel& data, MessageParcel& reply)
952 {
953 std::set<int32_t> pidList;
954 int32_t size = data.ReadInt32();
955 if (size > MAX_BUFF_SIZE) {
956 WLOGFE("pid List size invalid: %{public}d", size);
957 size = MAX_BUFF_SIZE;
958 }
959 for (int32_t i = 0; i < size; i++) {
960 pidList.insert(data.ReadInt32());
961 }
962 bool isProxy = data.ReadBool();
963 DMError ret = ProxyForFreeze(pidList, isProxy);
964 reply.WriteInt32(static_cast<int32_t>(ret));
965 }
966
ProcGetAllDisplayPhysicalResolution(MessageParcel & data,MessageParcel & reply)967 void ScreenSessionManagerStub::ProcGetAllDisplayPhysicalResolution(MessageParcel& data, MessageParcel& reply)
968 {
969 auto physicalInfos = GetAllDisplayPhysicalResolution();
970 size_t infoSize = physicalInfos.size();
971 bool writeRet = reply.WriteInt32(static_cast<int32_t>(infoSize));
972 if (!writeRet) {
973 WLOGFE("write physical size error");
974 return;
975 }
976 for (const auto &physicalItem : physicalInfos) {
977 writeRet = reply.WriteUint32(static_cast<uint32_t>(physicalItem.foldDisplayMode_));
978 if (!writeRet) {
979 WLOGFE("write display mode error");
980 break;
981 }
982 writeRet = reply.WriteUint32(physicalItem.physicalWidth_);
983 if (!writeRet) {
984 WLOGFE("write physical width error");
985 break;
986 }
987 writeRet = reply.WriteUint32(physicalItem.physicalHeight_);
988 if (!writeRet) {
989 WLOGFE("write physical height error");
990 break;
991 }
992 }
993 }
994
ProcSetVirtualScreenSecurityExemption(MessageParcel & data,MessageParcel & reply)995 void ScreenSessionManagerStub::ProcSetVirtualScreenSecurityExemption(MessageParcel& data, MessageParcel& reply)
996 {
997 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
998 uint32_t pid = data.ReadUint32();
999 std::vector<uint64_t> windowIdList;
1000 data.ReadUInt64Vector(&windowIdList);
1001 DMError ret = SetVirtualScreenSecurityExemption(screenId, pid, windowIdList);
1002 reply.WriteInt32(static_cast<int32_t>(ret));
1003 }
ProcGetScreenCapture(MessageParcel & data,MessageParcel & reply)1004 void ScreenSessionManagerStub::ProcGetScreenCapture(MessageParcel& data, MessageParcel& reply)
1005 {
1006 CaptureOption option;
1007 option.displayId_ = static_cast<DisplayId>(data.ReadUint64());
1008 option.isNeedNotify_ = static_cast<bool>(data.ReadBool());
1009 option.isNeedPointer_ = static_cast<bool>(data.ReadBool());
1010 DmErrorCode errCode = DmErrorCode::DM_OK;
1011 std::shared_ptr<Media::PixelMap> capture = GetScreenCapture(option, &errCode);
1012 reply.WriteParcelable(capture == nullptr ? nullptr : capture.get());
1013 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(errCode)));
1014 }
1015
ProcGetDisplaySnapshotWithOption(MessageParcel & data,MessageParcel & reply)1016 void ScreenSessionManagerStub::ProcGetDisplaySnapshotWithOption(MessageParcel& data, MessageParcel& reply)
1017 {
1018 CaptureOption option;
1019 option.displayId_ = static_cast<DisplayId>(data.ReadUint64());
1020 option.isNeedNotify_ = static_cast<bool>(data.ReadBool());
1021 option.isNeedPointer_ = static_cast<bool>(data.ReadBool());
1022 DmErrorCode errCode = DmErrorCode::DM_OK;
1023 std::shared_ptr<Media::PixelMap> capture = GetDisplaySnapshotWithOption(option, &errCode);
1024 reply.WriteParcelable(capture == nullptr ? nullptr : capture.get());
1025 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(errCode)));
1026 }
1027
ProcSetScreenSkipProtectedWindow(MessageParcel & data,MessageParcel & reply)1028 void ScreenSessionManagerStub::ProcSetScreenSkipProtectedWindow(MessageParcel& data, MessageParcel& reply)
1029 {
1030 std::vector<ScreenId> screenIds;
1031 if (!data.ReadUInt64Vector(&screenIds)) {
1032 TLOGE(WmsLogTag::DMS, "Read screenIds failed");
1033 return;
1034 }
1035 bool isEnable = static_cast<bool>(data.ReadBool());
1036 DMError ret = SetScreenSkipProtectedWindow(screenIds, isEnable);
1037 reply.WriteInt32(static_cast<int32_t>(ret));
1038 }
1039 } // namespace OHOS::Rosen
1040