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 const static uint32_t MAX_SCREEN_SIZE = 32;
28 const static int32_t ERR_INVALID_DATA = -1;
29 const static int32_t MAX_BUFF_SIZE = 100;
30 const static float INVALID_DEFAULT_DENSITY = 1.0f;
31 const static uint32_t PIXMAP_VECTOR_SIZE = 2;
32 constexpr uint32_t MAX_CREASE_REGION_SIZE = 20;
33 }
34
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)35 int32_t ScreenSessionManagerStub::OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel& reply,
36 MessageOption& option)
37 {
38 TLOGD(WmsLogTag::DMS, "OnRemoteRequest code is %{public}u", code);
39 if (data.ReadInterfaceToken() != GetDescriptor()) {
40 TLOGE(WmsLogTag::DMS, "InterfaceToken check failed");
41 return ERR_TRANSACTION_FAILED;
42 }
43 DisplayManagerMessage msgId = static_cast<DisplayManagerMessage>(code);
44 switch (msgId) {
45 case DisplayManagerMessage::TRANS_ID_GET_DEFAULT_DISPLAY_INFO: {
46 auto info = GetDefaultDisplayInfo();
47 reply.WriteParcelable(info);
48 break;
49 }
50 case DisplayManagerMessage::TRANS_ID_REGISTER_DISPLAY_MANAGER_AGENT: {
51 auto agent = iface_cast<IDisplayManagerAgent>(data.ReadRemoteObject());
52 if (agent == nullptr) {
53 return ERR_INVALID_DATA;
54 }
55 auto type = static_cast<DisplayManagerAgentType>(data.ReadUint32());
56 DMError ret = RegisterDisplayManagerAgent(agent, type);
57 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
58 break;
59 }
60 case DisplayManagerMessage::TRANS_ID_UNREGISTER_DISPLAY_MANAGER_AGENT: {
61 auto agent = iface_cast<IDisplayManagerAgent>(data.ReadRemoteObject());
62 if (agent == nullptr) {
63 return ERR_INVALID_DATA;
64 }
65 auto type = static_cast<DisplayManagerAgentType>(data.ReadUint32());
66 DMError ret = UnregisterDisplayManagerAgent(agent, type);
67 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
68 break;
69 }
70 case DisplayManagerMessage::TRANS_ID_WAKE_UP_BEGIN: {
71 PowerStateChangeReason reason = static_cast<PowerStateChangeReason>(data.ReadUint32());
72 reply.WriteBool(WakeUpBegin(reason));
73 break;
74 }
75 case DisplayManagerMessage::TRANS_ID_WAKE_UP_END: {
76 reply.WriteBool(WakeUpEnd());
77 break;
78 }
79 case DisplayManagerMessage::TRANS_ID_SUSPEND_BEGIN: {
80 PowerStateChangeReason reason = static_cast<PowerStateChangeReason>(data.ReadUint32());
81 reply.WriteBool(SuspendBegin(reason));
82 break;
83 }
84 case DisplayManagerMessage::TRANS_ID_SUSPEND_END: {
85 reply.WriteBool(SuspendEnd());
86 break;
87 }
88 case DisplayManagerMessage::TRANS_ID_GET_INTERNAL_SCREEN_ID: {
89 reply.WriteUint64(GetInternalScreenId());
90 break;
91 }
92 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_POWER_BY_ID: {
93 ScreenId screenId = data.ReadUint64();
94 ScreenPowerState state = static_cast<ScreenPowerState>(data.ReadUint32());
95 PowerStateChangeReason reason = static_cast<PowerStateChangeReason>(data.ReadUint32());
96 reply.WriteBool(SetScreenPowerById(screenId, state, reason));
97 break;
98 }
99 case DisplayManagerMessage::TRANS_ID_SET_DISPLAY_STATE: {
100 DisplayState state = static_cast<DisplayState>(data.ReadUint32());
101 reply.WriteBool(SetDisplayState(state));
102 break;
103 }
104 case DisplayManagerMessage::TRANS_ID_SET_SPECIFIED_SCREEN_POWER: {
105 ScreenId screenId = static_cast<ScreenId>(data.ReadUint32());
106 ScreenPowerState state = static_cast<ScreenPowerState>(data.ReadUint32());
107 PowerStateChangeReason reason = static_cast<PowerStateChangeReason>(data.ReadUint32());
108 reply.WriteBool(SetSpecifiedScreenPower(screenId, state, reason));
109 break;
110 }
111 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_POWER_FOR_ALL: {
112 ScreenPowerState state = static_cast<ScreenPowerState>(data.ReadUint32());
113 PowerStateChangeReason reason = static_cast<PowerStateChangeReason>(data.ReadUint32());
114 reply.WriteBool(SetScreenPowerForAll(state, reason));
115 break;
116 }
117 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_STATE: {
118 DisplayState state = GetDisplayState(data.ReadUint64());
119 static_cast<void>(reply.WriteUint32(static_cast<uint32_t>(state)));
120 break;
121 }
122 case DisplayManagerMessage::TRANS_ID_NOTIFY_DISPLAY_EVENT: {
123 DisplayEvent event = static_cast<DisplayEvent>(data.ReadUint32());
124 NotifyDisplayEvent(event);
125 break;
126 }
127 case DisplayManagerMessage::TRANS_ID_GET_SCREEN_POWER: {
128 ScreenId dmsScreenId;
129 if (!data.ReadUint64(dmsScreenId)) {
130 TLOGE(WmsLogTag::DMS, "fail to read dmsScreenId.");
131 return ERR_INVALID_DATA;
132 }
133 static_cast<void>(reply.WriteUint32(static_cast<uint32_t>(GetScreenPower(dmsScreenId))));
134 break;
135 }
136 case DisplayManagerMessage::TRANS_ID_GET_SCREEN_POWER_AUTO: {
137 reply.WriteUint32(static_cast<uint32_t>(GetScreenPower()));
138 break;
139 }
140 case DisplayManagerMessage::TRANS_ID_TRY_TO_CANCEL_SCREEN_OFF: {
141 reply.WriteBool(TryToCancelScreenOff());
142 break;
143 }
144 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_BRIGHTNESS: {
145 uint64_t screenId = data.ReadUint64();
146 uint32_t level = data.ReadUint64();
147 reply.WriteBool(SetScreenBrightness(screenId, level));
148 break;
149 }
150 case DisplayManagerMessage::TRANS_ID_GET_SCREEN_BRIGHTNESS: {
151 uint64_t screenId = data.ReadUint64();
152 reply.WriteUint32(GetScreenBrightness(screenId));
153 break;
154 }
155 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_BY_ID: {
156 DisplayId displayId = data.ReadUint64();
157 auto info = GetDisplayInfoById(displayId);
158 reply.WriteParcelable(info);
159 break;
160 }
161 case DisplayManagerMessage::TRANS_ID_GET_VISIBLE_AREA_DISPLAY_INFO_BY_ID: {
162 DisplayId displayId = static_cast<DisplayId>(data.ReadUint64());
163 auto info = GetVisibleAreaDisplayInfoById(displayId);
164 reply.WriteParcelable(info);
165 break;
166 }
167 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_BY_SCREEN: {
168 ScreenId screenId = data.ReadUint64();
169 auto info = GetDisplayInfoByScreen(screenId);
170 reply.WriteParcelable(info);
171 break;
172 }
173 case DisplayManagerMessage::TRANS_ID_GET_ALL_DISPLAYIDS: {
174 std::vector<DisplayId> allDisplayIds = GetAllDisplayIds();
175 static_cast<void>(reply.WriteUInt64Vector(allDisplayIds));
176 break;
177 }
178 case DisplayManagerMessage::TRANS_ID_GET_SCREEN_INFO_BY_ID: {
179 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
180 auto screenInfo = GetScreenInfoById(screenId);
181 reply.WriteStrongParcelable(screenInfo);
182 break;
183 }
184 case DisplayManagerMessage::TRANS_ID_GET_ALL_SCREEN_INFOS: {
185 std::vector<sptr<ScreenInfo>> screenInfos;
186 DMError ret = GetAllScreenInfos(screenInfos);
187 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
188 if (!MarshallingHelper::MarshallingVectorParcelableObj<ScreenInfo>(reply, screenInfos)) {
189 TLOGE(WmsLogTag::DMS, "fail to marshalling screenInfos in stub.");
190 }
191 break;
192 }
193 case DisplayManagerMessage::TRANS_ID_GET_PHYSICAL_SCREEN_IDS: {
194 std::vector<ScreenId> screenIds;
195 DMError ret = GetPhysicalScreenIds(screenIds);
196 reply.WriteInt32(static_cast<int32_t>(ret));
197 bool res = MarshallingHelper::MarshallingVectorObj<ScreenId>(reply, screenIds,
198 [](Parcel& parcel, const ScreenId& screenId) {
199 return parcel.WriteUint64(static_cast<uint64_t>(screenId));
200 }
201 );
202 if (!res) {
203 TLOGE(WmsLogTag::DMS, "fail to marshalling screenIds in stub.");
204 break;
205 }
206 break;
207 }
208 case DisplayManagerMessage::TRANS_ID_SCREEN_GET_SUPPORTED_COLOR_GAMUTS: {
209 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
210 std::vector<ScreenColorGamut> colorGamuts;
211 DMError ret = GetScreenSupportedColorGamuts(screenId, colorGamuts);
212 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
213 if (ret != DMError::DM_OK) {
214 break;
215 }
216 MarshallingHelper::MarshallingVectorObj<ScreenColorGamut>(reply, colorGamuts,
217 [](Parcel& parcel, const ScreenColorGamut& color) {
218 return parcel.WriteUint32(static_cast<uint32_t>(color));
219 }
220 );
221 break;
222 }
223 case DisplayManagerMessage::TRANS_ID_CREATE_VIRTUAL_SCREEN: {
224 std::string name = data.ReadString();
225 uint32_t width = data.ReadUint32();
226 uint32_t height = data.ReadUint32();
227 float density = data.ReadFloat();
228 int32_t flags = data.ReadInt32();
229 bool isForShot = data.ReadBool();
230 std::vector<uint64_t> missionIds;
231 data.ReadUInt64Vector(&missionIds);
232 VirtualScreenType virtualScreenType = static_cast<VirtualScreenType>(data.ReadUint32());
233 bool isSecurity = data.ReadBool();
234 bool isSurfaceValid = data.ReadBool();
235 sptr<Surface> surface = nullptr;
236 if (isSurfaceValid) {
237 sptr<IRemoteObject> surfaceObject = data.ReadRemoteObject();
238 sptr<IBufferProducer> bp = iface_cast<IBufferProducer>(surfaceObject);
239 surface = Surface::CreateSurfaceAsProducer(bp);
240 }
241 sptr<IRemoteObject> virtualScreenAgent = data.ReadRemoteObject();
242 VirtualScreenOption virScrOption = {
243 .name_ = name,
244 .width_ = width,
245 .height_ = height,
246 .density_ = density,
247 .surface_ = surface,
248 .flags_ = flags,
249 .isForShot_ = isForShot,
250 .missionIds_ = missionIds,
251 .virtualScreenType_ = virtualScreenType,
252 .isSecurity_ = isSecurity
253 };
254 ScreenId screenId = CreateVirtualScreen(virScrOption, virtualScreenAgent);
255 static_cast<void>(reply.WriteUint64(static_cast<uint64_t>(screenId)));
256 break;
257 }
258 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_SURFACE: {
259 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
260 bool isSurfaceValid = data.ReadBool();
261 sptr<IBufferProducer> bp = nullptr;
262 if (isSurfaceValid) {
263 sptr<IRemoteObject> surfaceObject = data.ReadRemoteObject();
264 bp = iface_cast<IBufferProducer>(surfaceObject);
265 }
266 DMError result = SetVirtualScreenSurface(screenId, bp);
267 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(result)));
268 break;
269 }
270 case DisplayManagerMessage::TRANS_ID_ADD_VIRTUAL_SCREEN_BLOCK_LIST: {
271 uint64_t size = 0;
272 if (!data.ReadUint64(size)) {
273 TLOGE(WmsLogTag::DMS, "Read size failed.");
274 reply.WriteInt32(static_cast<int32_t>(DMError::DM_ERROR_INVALID_PARAM));
275 break;
276 }
277 static constexpr uint64_t MAX_SIZE = 100;
278 if (size > MAX_SIZE) {
279 TLOGE(WmsLogTag::DMS, "Size too large.");
280 reply.WriteInt32(static_cast<int32_t>(DMError::DM_ERROR_INVALID_PARAM));
281 break;
282 }
283 std::vector<int32_t> persistentIds;
284 for (uint64_t i = 0; i < size; i++) {
285 int32_t persistentId = 0;
286 if (!data.ReadInt32(persistentId)) {
287 TLOGE(WmsLogTag::DMS, "Read persistentId failed.");
288 break;
289 }
290 persistentIds.push_back(persistentId);
291 }
292 DMError errCode = AddVirtualScreenBlockList(persistentIds);
293 reply.WriteInt32(static_cast<int32_t>(errCode));
294 break;
295 }
296 case DisplayManagerMessage::TRANS_ID_REMOVE_VIRTUAL_SCREEN_BLOCK_LIST: {
297 uint64_t size = 0;
298 if (!data.ReadUint64(size)) {
299 TLOGE(WmsLogTag::DMS, "Read size failed.");
300 reply.WriteInt32(static_cast<int32_t>(DMError::DM_ERROR_INVALID_PARAM));
301 break;
302 }
303 static constexpr uint64_t MAX_SIZE = 100;
304 if (size > MAX_SIZE) {
305 TLOGE(WmsLogTag::DMS, "Size too large.");
306 reply.WriteInt32(static_cast<int32_t>(DMError::DM_ERROR_INVALID_PARAM));
307 break;
308 }
309 std::vector<int32_t> persistentIds;
310 for (uint64_t i = 0; i < size; i++) {
311 int32_t persistentId = 0;
312 if (!data.ReadInt32(persistentId)) {
313 TLOGE(WmsLogTag::DMS, "Read persistentId failed.");
314 break;
315 }
316 persistentIds.push_back(persistentId);
317 }
318 DMError errCode = RemoveVirtualScreenBlockList(persistentIds);
319 reply.WriteInt32(static_cast<int32_t>(errCode));
320 break;
321 }
322 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_PRIVACY_MASKIMAGE: {
323 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
324 std::shared_ptr<Media::PixelMap> privacyMaskImg{nullptr};
325 bool isPrivacyMaskImgValid = data.ReadBool();
326 if (isPrivacyMaskImgValid) {
327 privacyMaskImg = std::shared_ptr<Media::PixelMap>(data.ReadParcelable<Media::PixelMap>());
328 DMError result = SetScreenPrivacyMaskImage(screenId, privacyMaskImg);
329 reply.WriteInt32(static_cast<int32_t>(result));
330 } else {
331 DMError result = SetScreenPrivacyMaskImage(screenId, nullptr);
332 reply.WriteInt32(static_cast<int32_t>(result));
333 }
334 break;
335 }
336 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_CANVAS_ROTATION: {
337 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
338 bool autoRotate = data.ReadBool();
339 DMError result = SetVirtualMirrorScreenCanvasRotation(screenId, autoRotate);
340 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(result)));
341 break;
342 }
343 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_SCALE_MODE: {
344 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
345 ScreenScaleMode scaleMode = static_cast<ScreenScaleMode>(data.ReadUint32());
346 DMError result = SetVirtualMirrorScreenScaleMode(screenId, scaleMode);
347 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(result)));
348 break;
349 }
350 case DisplayManagerMessage::TRANS_ID_DESTROY_VIRTUAL_SCREEN: {
351 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
352 DMError result = DestroyVirtualScreen(screenId);
353 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(result)));
354 break;
355 }
356 case DisplayManagerMessage::TRANS_ID_SCREEN_MAKE_MIRROR: {
357 ScreenId mainScreenId = static_cast<ScreenId>(data.ReadUint64());
358 std::vector<ScreenId> mirrorScreenId;
359 if (!data.ReadUInt64Vector(&mirrorScreenId)) {
360 TLOGE(WmsLogTag::DMS, "fail to receive mirror screen in stub. screen:%{public}" PRIu64"", mainScreenId);
361 break;
362 }
363 ScreenId screenGroupId = INVALID_SCREEN_ID;
364 DMError ret = MakeMirror(mainScreenId, mirrorScreenId, screenGroupId);
365 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
366 static_cast<void>(reply.WriteUint64(static_cast<uint64_t>(screenGroupId)));
367 break;
368 }
369 case DisplayManagerMessage::TRANS_ID_SCREEN_MAKE_MIRROR_FOR_RECORD: {
370 ScreenId mainScreenId = static_cast<ScreenId>(data.ReadUint64());
371 std::vector<ScreenId> mirrorScreenId;
372 if (!data.ReadUInt64Vector(&mirrorScreenId)) {
373 TLOGE(WmsLogTag::DMS, "fail to receive mirror screen in stub. screen:%{public}" PRIu64"", mainScreenId);
374 break;
375 }
376 ScreenId screenGroupId = INVALID_SCREEN_ID;
377 DMError ret = MakeMirrorForRecord(mainScreenId, mirrorScreenId, screenGroupId);
378 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
379 static_cast<void>(reply.WriteUint64(static_cast<uint64_t>(screenGroupId)));
380 break;
381 }
382 case DisplayManagerMessage::TRANS_ID_SCREEN_MAKE_MIRROR_WITH_REGION: {
383 ScreenId mainScreenId = static_cast<ScreenId>(data.ReadUint64());
384 std::vector<ScreenId> mirrorScreenId;
385 if (!data.ReadUInt64Vector(&mirrorScreenId)) {
386 TLOGE(WmsLogTag::DMS, "fail to receive mirror screen in stub. screen:%{public}" PRIu64"", mainScreenId);
387 break;
388 }
389 int32_t posX = data.ReadInt32();
390 int32_t posY = data.ReadInt32();
391 uint32_t width = data.ReadUint32();
392 uint32_t height = data.ReadUint32();
393 DMRect mainScreenRegion = { posX, posY, width, height };
394 ScreenId screenGroupId = INVALID_SCREEN_ID;
395 DMError ret = MakeMirror(mainScreenId, mirrorScreenId, mainScreenRegion, screenGroupId);
396 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
397 static_cast<void>(reply.WriteUint64(static_cast<uint64_t>(screenGroupId)));
398 break;
399 }
400 case DisplayManagerMessage::TRANS_ID_MULTI_SCREEN_MODE_SWITCH: {
401 ScreenId mainScreenId = static_cast<ScreenId>(data.ReadUint64());
402 ScreenId secondaryScreenId = static_cast<ScreenId>(data.ReadUint64());
403 MultiScreenMode screenMode = static_cast<MultiScreenMode>(data.ReadUint32());
404 DMError ret = SetMultiScreenMode(mainScreenId, secondaryScreenId, screenMode);
405 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
406 break;
407 }
408 case DisplayManagerMessage::TRANS_ID_SET_MULTI_SCREEN_POSITION: {
409 uint64_t mainScreenId = data.ReadUint64();
410 uint32_t mainScreenX = data.ReadUint32();
411 uint32_t mainScreenY = data.ReadUint32();
412 uint64_t secondaryScreenId = data.ReadUint64();
413 uint32_t secondaryScreenX = data.ReadUint32();
414 uint32_t secondaryScreenY = data.ReadUint32();
415 MultiScreenPositionOptions mainScreenOptions = {
416 .screenId_ = mainScreenId,
417 .startX_ = mainScreenX,
418 .startY_ = mainScreenY,
419 };
420 MultiScreenPositionOptions secondScreenOption = {
421 .screenId_ = secondaryScreenId,
422 .startX_ = secondaryScreenX,
423 .startY_ = secondaryScreenY,
424 };
425 DMError ret = SetMultiScreenRelativePosition(mainScreenOptions, secondScreenOption);
426 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
427 break;
428 }
429 case DisplayManagerMessage::TRANS_ID_SCREEN_STOP_MIRROR: {
430 std::vector<ScreenId> mirrorScreenIds;
431 if (!data.ReadUInt64Vector(&mirrorScreenIds)) {
432 TLOGE(WmsLogTag::DMS, "fail to receive mirror screens in stub.");
433 break;
434 }
435 DMError ret = StopMirror(mirrorScreenIds);
436 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
437 break;
438 }
439 case DisplayManagerMessage::TRANS_ID_SCREEN_DISABLE_MIRROR: {
440 DMError ret = DisableMirror(data.ReadBool());
441 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
442 break;
443 }
444 case DisplayManagerMessage::TRANS_ID_SCREEN_MAKE_EXPAND: {
445 std::vector<ScreenId> screenId;
446 if (!data.ReadUInt64Vector(&screenId)) {
447 TLOGE(WmsLogTag::DMS, "fail to receive expand screen in stub.");
448 break;
449 }
450 std::vector<Point> startPoint;
451 if (!MarshallingHelper::UnmarshallingVectorObj<Point>(data, startPoint, [](Parcel& parcel, Point& point) {
452 return parcel.ReadInt32(point.posX_) && parcel.ReadInt32(point.posY_);
453 })) {
454 TLOGE(WmsLogTag::DMS, "fail to receive startPoint in stub.");
455 break;
456 }
457 ScreenId screenGroupId = INVALID_SCREEN_ID;
458 DMError ret = MakeExpand(screenId, startPoint, screenGroupId);
459 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
460 static_cast<void>(reply.WriteUint64(static_cast<uint64_t>(screenGroupId)));
461 break;
462 }
463 case DisplayManagerMessage::TRANS_ID_SCREEN_STOP_EXPAND: {
464 std::vector<ScreenId> expandScreenIds;
465 if (!data.ReadUInt64Vector(&expandScreenIds)) {
466 TLOGE(WmsLogTag::DMS, "fail to receive expand screens in stub.");
467 break;
468 }
469 DMError ret = StopExpand(expandScreenIds);
470 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
471 break;
472 }
473 case DisplayManagerMessage::TRANS_ID_GET_SCREEN_GROUP_INFO_BY_ID: {
474 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
475 auto screenGroupInfo = GetScreenGroupInfoById(screenId);
476 reply.WriteStrongParcelable(screenGroupInfo);
477 break;
478 }
479 case DisplayManagerMessage::TRANS_ID_REMOVE_VIRTUAL_SCREEN_FROM_SCREEN_GROUP: {
480 std::vector<ScreenId> screenId;
481 if (!data.ReadUInt64Vector(&screenId)) {
482 TLOGE(WmsLogTag::DMS, "fail to receive screens in stub.");
483 break;
484 }
485 RemoveVirtualScreenFromGroup(screenId);
486 break;
487 }
488 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_SNAPSHOT: {
489 DisplayId displayId = data.ReadUint64();
490 DmErrorCode errCode = DmErrorCode::DM_OK;
491 bool isUseDma = data.ReadBool();
492 bool isCaptureFullOfScreen = data.ReadBool();
493 std::shared_ptr<Media::PixelMap> displaySnapshot = GetDisplaySnapshot(displayId, &errCode, isUseDma,
494 isCaptureFullOfScreen);
495 reply.WriteParcelable(displaySnapshot == nullptr ? nullptr : displaySnapshot.get());
496 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(errCode)));
497 break;
498 }
499 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_HDR_SNAPSHOT: {
500 DisplayId displayId = DISPLAY_ID_INVALID;
501 bool isUseDma = false;
502 bool isCaptureFullOfScreen = false;
503 DmErrorCode errCode = DmErrorCode::DM_OK;
504 if (!data.ReadUint64(displayId)) {
505 TLOGE(WmsLogTag::DMS, "Read displayId failed");
506 return ERR_INVALID_DATA;
507 }
508 if (!data.ReadBool(isUseDma)) {
509 TLOGE(WmsLogTag::DMS, "Read isUseDma failed");
510 return ERR_INVALID_DATA;
511 }
512 if (!data.ReadBool(isCaptureFullOfScreen)) {
513 TLOGE(WmsLogTag::DMS, "Read isCaptureFullOfScreen failed");
514 return ERR_INVALID_DATA;
515 }
516 std::vector<std::shared_ptr<Media::PixelMap>> displaySnapshotVec = GetDisplayHDRSnapshot(
517 displayId, errCode, isUseDma, isCaptureFullOfScreen);
518 if (displaySnapshotVec.size() != PIXMAP_VECTOR_SIZE) {
519 TLOGE(WmsLogTag::DMS, "Dail to receive displaySnapshotVec in stub.");
520 reply.WriteParcelable(nullptr);
521 reply.WriteParcelable(nullptr);
522 } else {
523 TLOGI(WmsLogTag::DMS, "WriteParcelable to receive displaySnapshotVec in stub.");
524 reply.WriteParcelable(displaySnapshotVec[0] == nullptr ? nullptr : displaySnapshotVec[0].get());
525 reply.WriteParcelable(displaySnapshotVec[1] == nullptr ? nullptr : displaySnapshotVec[1].get());
526 }
527 reply.WriteInt32(static_cast<int32_t>(errCode));
528 break;
529 }
530 case DisplayManagerMessage::TRANS_ID_GET_SNAPSHOT_BY_PICKER: {
531 ProcGetSnapshotByPicker(reply);
532 break;
533 }
534 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_ACTIVE_MODE: {
535 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
536 uint32_t modeId = data.ReadUint32();
537 DMError ret = SetScreenActiveMode(screenId, modeId);
538 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
539 break;
540 }
541 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_PIXEL_RATIO: {
542 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
543 float virtualPixelRatio = data.ReadFloat();
544 DMError ret = SetVirtualPixelRatio(screenId, virtualPixelRatio);
545 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
546 break;
547 }
548 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_PIXEL_RATIO_SYSTEM: {
549 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
550 float virtualPixelRatio = data.ReadFloat();
551 DMError ret = SetVirtualPixelRatioSystem(screenId, virtualPixelRatio);
552 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
553 break;
554 }
555 case DisplayManagerMessage::TRANS_ID_SET_DEFAULT_DENSITY_DPI: {
556 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
557 float virtualPixelRatio = data.ReadFloat();
558 DMError ret = SetDefaultDensityDpi(screenId, virtualPixelRatio);
559 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
560 break;
561 }
562 case DisplayManagerMessage::TRANS_ID_SET_RESOLUTION: {
563 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
564 uint32_t width = data.ReadUint32();
565 uint32_t height = data.ReadUint32();
566 float virtualPixelRatio = data.ReadFloat();
567 DMError ret = SetResolution(screenId, width, height, virtualPixelRatio);
568 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
569 break;
570 }
571 case DisplayManagerMessage::TRANS_ID_GET_DENSITY_IN_CURRENT_RESOLUTION: {
572 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
573 float virtualPixelRatio;
574 DMError ret = GetDensityInCurResolution(screenId, virtualPixelRatio);
575 reply.WriteFloat(virtualPixelRatio);
576 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
577 break;
578 }
579 case DisplayManagerMessage::TRANS_ID_SCREEN_GET_COLOR_GAMUT: {
580 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
581 ScreenColorGamut colorGamut;
582 DMError ret = GetScreenColorGamut(screenId, colorGamut);
583 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
584 if (ret != DMError::DM_OK) {
585 break;
586 }
587 static_cast<void>(reply.WriteUint32(static_cast<uint32_t>(colorGamut)));
588 break;
589 }
590 case DisplayManagerMessage::TRANS_ID_SCREEN_SET_COLOR_GAMUT: {
591 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
592 int32_t colorGamutIdx = data.ReadInt32();
593 DMError ret = SetScreenColorGamut(screenId, colorGamutIdx);
594 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
595 break;
596 }
597 case DisplayManagerMessage::TRANS_ID_SCREEN_GET_GAMUT_MAP: {
598 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
599 ScreenGamutMap gamutMap;
600 DMError ret = GetScreenGamutMap(screenId, gamutMap);
601 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
602 if (ret != DMError::DM_OK) {
603 break;
604 }
605 static_cast<void>(reply.WriteInt32(static_cast<uint32_t>(gamutMap)));
606 break;
607 }
608 case DisplayManagerMessage::TRANS_ID_SCREEN_SET_GAMUT_MAP: {
609 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
610 ScreenGamutMap gamutMap = static_cast<ScreenGamutMap>(data.ReadUint32());
611 DMError ret = SetScreenGamutMap(screenId, gamutMap);
612 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
613 break;
614 }
615 case DisplayManagerMessage::TRANS_ID_SCREEN_SET_COLOR_TRANSFORM: {
616 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
617 DMError ret = SetScreenColorTransform(screenId);
618 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
619 break;
620 }
621 case DisplayManagerMessage::TRANS_ID_SCREEN_GET_PIXEL_FORMAT: {
622 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
623 GraphicPixelFormat pixelFormat;
624 DMError ret = GetPixelFormat(screenId, pixelFormat);
625 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
626 if (ret != DMError::DM_OK) {
627 break;
628 }
629 static_cast<void>(reply.WriteInt32(static_cast<uint32_t>(pixelFormat)));
630 break;
631 }
632 case DisplayManagerMessage::TRANS_ID_SCREEN_SET_PIXEL_FORMAT: {
633 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
634 GraphicPixelFormat pixelFormat = static_cast<GraphicPixelFormat>(data.ReadUint32());
635 DMError ret = SetPixelFormat(screenId, pixelFormat);
636 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
637 break;
638 }
639 case DisplayManagerMessage::TRANS_ID_SCREEN_GET_SUPPORTED_HDR_FORMAT: {
640 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
641 std::vector<ScreenHDRFormat> hdrFormats;
642 DMError ret = GetSupportedHDRFormats(screenId, hdrFormats);
643 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
644 if (ret != DMError::DM_OK) {
645 break;
646 }
647 MarshallingHelper::MarshallingVectorObj<ScreenHDRFormat>(reply, hdrFormats,
648 [](Parcel& parcel, const ScreenHDRFormat& hdrFormat) {
649 return parcel.WriteUint32(static_cast<uint32_t>(hdrFormat));
650 }
651 );
652 break;
653 }
654 case DisplayManagerMessage::TRANS_ID_SCREEN_GET_HDR_FORMAT: {
655 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
656 ScreenHDRFormat hdrFormat;
657 DMError ret = GetScreenHDRFormat(screenId, hdrFormat);
658 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
659 if (ret != DMError::DM_OK) {
660 break;
661 }
662 static_cast<void>(reply.WriteInt32(static_cast<uint32_t>(hdrFormat)));
663 break;
664 }
665 case DisplayManagerMessage::TRANS_ID_SCREEN_SET_HDR_FORMAT: {
666 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
667 int32_t modeIdx = data.ReadInt32();
668 DMError ret = SetScreenHDRFormat(screenId, modeIdx);
669 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
670 break;
671 }
672 case DisplayManagerMessage::TRANS_ID_SCREEN_GET_SUPPORTED_COLOR_SPACE: {
673 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
674 std::vector<GraphicCM_ColorSpaceType> colorSpaces;
675 DMError ret = GetSupportedColorSpaces(screenId, colorSpaces);
676 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
677 if (ret != DMError::DM_OK) {
678 break;
679 }
680 MarshallingHelper::MarshallingVectorObj<GraphicCM_ColorSpaceType>(reply, colorSpaces,
681 [](Parcel& parcel, const GraphicCM_ColorSpaceType& color) {
682 return parcel.WriteUint32(static_cast<uint32_t>(color));
683 }
684 );
685 break;
686 }
687 case DisplayManagerMessage::TRANS_ID_SCREEN_GET_COLOR_SPACE: {
688 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
689 GraphicCM_ColorSpaceType colorSpace;
690 DMError ret = GetScreenColorSpace(screenId, colorSpace);
691 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
692 if (ret != DMError::DM_OK) {
693 break;
694 }
695 static_cast<void>(reply.WriteInt32(static_cast<uint32_t>(colorSpace)));
696 break;
697 }
698 case DisplayManagerMessage::TRANS_ID_SCREEN_SET_COLOR_SPACE: {
699 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
700 GraphicCM_ColorSpaceType colorSpace = static_cast<GraphicCM_ColorSpaceType>(data.ReadUint32());
701 DMError ret = SetScreenColorSpace(screenId, colorSpace);
702 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
703 break;
704 }
705 case DisplayManagerMessage::TRANS_ID_SET_ORIENTATION: {
706 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
707 Orientation orientation = static_cast<Orientation>(data.ReadUint32());
708 DMError ret = SetOrientation(screenId, orientation);
709 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
710 break;
711 }
712 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_ROTATION_LOCKED: {
713 bool isLocked = static_cast<bool>(data.ReadBool());
714 DMError ret = SetScreenRotationLocked(isLocked);
715 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
716 break;
717 }
718 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_ROTATION_LOCKED_FROM_JS: {
719 bool isLocked = static_cast<bool>(data.ReadBool());
720 DMError ret = SetScreenRotationLockedFromJs(isLocked);
721 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
722 break;
723 }
724 case DisplayManagerMessage::TRANS_ID_IS_SCREEN_ROTATION_LOCKED: {
725 bool isLocked = false;
726 DMError ret = IsScreenRotationLocked(isLocked);
727 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
728 reply.WriteBool(isLocked);
729 break;
730 }
731 case DisplayManagerMessage::TRANS_ID_GET_CUTOUT_INFO: {
732 DisplayId displayId = static_cast<DisplayId>(data.ReadUint64());
733 sptr<CutoutInfo> cutoutInfo = GetCutoutInfo(displayId);
734 reply.WriteParcelable(cutoutInfo);
735 break;
736 }
737 case DisplayManagerMessage::TRANS_ID_GET_CUTOUT_INFO_WITH_ROTATION: {
738 DisplayId displayId = static_cast<DisplayId>(data.ReadUint64());
739 int32_t width = 0;
740 if (!data.ReadInt32(width)) {
741 TLOGE(WmsLogTag::DMS, "Read width failed");
742 return ERR_INVALID_DATA;
743 }
744 int32_t height = 0;
745 if (!data.ReadInt32(height)) {
746 TLOGE(WmsLogTag::DMS, "Read height failed");
747 return ERR_INVALID_DATA;
748 }
749 Rotation rotation = static_cast<Rotation>(data.ReadUint32());
750 sptr<CutoutInfo> cutoutInfo = GetCutoutInfo(displayId, width, height, rotation);
751 reply.WriteParcelable(cutoutInfo);
752 break;
753 }
754 case DisplayManagerMessage::TRANS_ID_HAS_PRIVATE_WINDOW: {
755 DisplayId id = static_cast<DisplayId>(data.ReadUint64());
756 bool hasPrivateWindow = false;
757 DMError ret = HasPrivateWindow(id, hasPrivateWindow);
758 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
759 reply.WriteBool(hasPrivateWindow);
760 break;
761 }
762 case DisplayManagerMessage::TRANS_ID_CONVERT_SCREENID_TO_RSSCREENID: {
763 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
764 ScreenId rsId = SCREEN_ID_INVALID;
765 bool ret = ConvertScreenIdToRsScreenId(screenId, rsId);
766 reply.WriteBool(ret);
767 static_cast<void>(reply.WriteUint64(rsId));
768 break;
769 }
770 case DisplayManagerMessage::TRANS_ID_HAS_IMMERSIVE_WINDOW: {
771 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
772 bool immersive = false;
773 DMError ret = HasImmersiveWindow(screenId, immersive);
774 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
775 reply.WriteBool(immersive);
776 break;
777 }
778 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_DUMP_ALL_SCREEN: {
779 std::string dumpInfo;
780 DumpAllScreensInfo(dumpInfo);
781 static_cast<void>(reply.WriteString(dumpInfo));
782 break;
783 }
784 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_DUMP_SPECIAL_SCREEN: {
785 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
786 std::string dumpInfo;
787 DumpSpecialScreenInfo(screenId, dumpInfo);
788 static_cast<void>(reply.WriteString(dumpInfo));
789 break;
790 }
791 case DisplayManagerMessage::TRANS_ID_DEVICE_IS_CAPTURE: {
792 reply.WriteBool(IsCaptured());
793 break;
794 }
795 //Fold Screen
796 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_SET_FOLD_DISPLAY_MODE: {
797 FoldDisplayMode displayMode = static_cast<FoldDisplayMode>(data.ReadUint32());
798 SetFoldDisplayMode(displayMode);
799 break;
800 }
801 case DisplayManagerMessage::TRANS_ID_SET_FOLD_DISPLAY_MODE_FROM_JS: {
802 FoldDisplayMode displayMode = static_cast<FoldDisplayMode>(data.ReadUint32());
803 std::string reason = data.ReadString();
804 DMError ret = SetFoldDisplayModeFromJs(displayMode, reason);
805 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
806 break;
807 }
808 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_LOCK_FOLD_DISPLAY_STATUS: {
809 bool lockDisplayStatus = static_cast<bool>(data.ReadUint32());
810 SetFoldStatusLocked(lockDisplayStatus);
811 break;
812 }
813 case DisplayManagerMessage::TRANS_ID_SET_LOCK_FOLD_DISPLAY_STATUS_FROM_JS: {
814 bool lockDisplayStatus = static_cast<bool>(data.ReadUint32());
815 DMError ret = SetFoldStatusLockedFromJs(lockDisplayStatus);
816 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
817 break;
818 }
819 case DisplayManagerMessage::TRANS_ID_SET_FOLD_STATUS_EXPAND_AND_LOCKED: {
820 bool lockDisplayStatus = static_cast<bool>(data.ReadUint32());
821 SetFoldStatusExpandAndLocked(lockDisplayStatus);
822 break;
823 }
824 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_SET_DISPLAY_SCALE: {
825 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
826 auto scaleX = data.ReadFloat();
827 auto scaleY = data.ReadFloat();
828 auto pivotX = data.ReadFloat();
829 auto pivotY = data.ReadFloat();
830 SetDisplayScale(screenId, scaleX, scaleY, pivotX, pivotY);
831 break;
832 }
833 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_GET_FOLD_DISPLAY_MODE: {
834 FoldDisplayMode displayMode = GetFoldDisplayMode();
835 static_cast<void>(reply.WriteUint32(static_cast<uint32_t>(displayMode)));
836 break;
837 }
838 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_IS_FOLDABLE: {
839 reply.WriteBool(IsFoldable());
840 break;
841 }
842 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_GET_FOLD_STATUS: {
843 static_cast<void>(reply.WriteUint32(static_cast<uint32_t>(GetFoldStatus())));
844 break;
845 }
846 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_GET_SUPER_FOLD_STATUS: {
847 static_cast<void>(reply.WriteUint32(static_cast<uint32_t>(GetSuperFoldStatus())));
848 break;
849 }
850 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_GET_SUPER_ROTATION: {
851 static_cast<void>(reply.WriteFloat(GetSuperRotation()));
852 break;
853 }
854 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_LANDSCAPE_LOCK_STATUS: {
855 bool isLocked = data.ReadBool();
856 SetLandscapeLockStatus(isLocked);
857 break;
858 }
859 case DisplayManagerMessage::TRANS_ID_GET_EXTEND_SCREEN_CONNECT_STATUS: {
860 static_cast<void>(reply.WriteUint32(static_cast<uint32_t>(GetExtendScreenConnectStatus())));
861 break;
862 }
863 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_GET_CURRENT_FOLD_CREASE_REGION: {
864 reply.WriteStrongParcelable(GetCurrentFoldCreaseRegion());
865 break;
866 }
867 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_GET_LIVE_CREASE_REGION: {
868 FoldCreaseRegion region;
869 DMError ret = GetLiveCreaseRegion(region);
870 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
871 if (ret != DMError::DM_OK) {
872 break;
873 }
874 static_cast<void>(reply.WriteUint64(region.GetDisplayId()));
875 const auto& creaseRects = region.GetCreaseRects();
876 uint32_t size = static_cast<uint32_t>(creaseRects.size());
877 if (size > MAX_CREASE_REGION_SIZE) {
878 TLOGE(WmsLogTag::DMS, "CreaseRects size exceeds max limit");
879 break;
880 }
881 static_cast<void>(reply.WriteUint32(size));
882 for (const auto& rect : creaseRects) {
883 static_cast<void>(reply.WriteInt32(rect.posX_));
884 static_cast<void>(reply.WriteInt32(rect.posY_));
885 static_cast<void>(reply.WriteUint32(rect.width_));
886 static_cast<void>(reply.WriteUint32(rect.height_));
887 }
888 break;
889 }
890 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_MAKE_UNIQUE_SCREEN: {
891 std::vector<ScreenId> uniqueScreenIds;
892 uint32_t size = data.ReadUint32();
893 if (size > MAX_SCREEN_SIZE) {
894 TLOGE(WmsLogTag::DMS, "screenIds size is bigger than %{public}u", MAX_SCREEN_SIZE);
895 break;
896 }
897 if (!data.ReadUInt64Vector(&uniqueScreenIds)) {
898 TLOGE(WmsLogTag::DMS, "failed to receive unique screens in stub");
899 break;
900 }
901 std::vector<DisplayId> displayIds;
902 DMError ret = MakeUniqueScreen(uniqueScreenIds, displayIds);
903 reply.WriteUInt64Vector(displayIds);
904 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
905 break;
906 }
907 case DisplayManagerMessage::TRANS_ID_SET_CLIENT: {
908 auto remoteObject = data.ReadRemoteObject();
909 auto clientProxy = iface_cast<IScreenSessionManagerClient>(remoteObject);
910 if (clientProxy == nullptr) {
911 TLOGE(WmsLogTag::DMS, "clientProxy is null");
912 break;
913 }
914 SetClient(clientProxy);
915 break;
916 }
917 case DisplayManagerMessage::TRANS_ID_GET_SCREEN_PROPERTY: {
918 auto screenId = static_cast<ScreenId>(data.ReadUint64());
919 if (!RSMarshallingHelper::Marshalling(reply, GetScreenProperty(screenId))) {
920 TLOGE(WmsLogTag::DMS, "Write screenProperty failed");
921 }
922 break;
923 }
924 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_NODE: {
925 auto screenId = static_cast<ScreenId>(data.ReadUint64());
926 auto displayNode = GetDisplayNode(screenId);
927 if (!displayNode || !displayNode->Marshalling(reply)) {
928 TLOGE(WmsLogTag::DMS, "Write displayNode failed");
929 }
930 break;
931 }
932 case DisplayManagerMessage::TRANS_ID_GET_SCREEN_COMBINATION: {
933 auto screenId = static_cast<ScreenId>(data.ReadUint64());
934 auto screenCombination = GetScreenCombination(screenId);
935 reply.WriteUint32(static_cast<uint32_t>(screenCombination));
936 break;
937 }
938 case DisplayManagerMessage::TRANS_ID_UPDATE_SCREEN_DIRECTION_INFO: {
939 auto screenId = static_cast<ScreenId>(data.ReadUint64());
940 auto screenComponentRotation = data.ReadFloat();
941 auto rotation = data.ReadFloat();
942 auto phyRotation = data.ReadFloat();
943 auto screenPropertyChangeType = static_cast<ScreenPropertyChangeType>(data.ReadUint32());
944 RRect bounds;
945 if (!RSMarshallingHelper::Unmarshalling(data, bounds)) {
946 TLOGE(WmsLogTag::DMS, "Read bounds failed");
947 break;
948 }
949 ScreenDirectionInfo directionInfo;
950 directionInfo.screenRotation_ = screenComponentRotation;
951 directionInfo.rotation_ = rotation;
952 directionInfo.phyRotation_ = phyRotation;
953 UpdateScreenDirectionInfo(screenId, directionInfo, screenPropertyChangeType, bounds);
954 break;
955 }
956 case DisplayManagerMessage::TRANS_ID_UPDATE_SCREEN_ROTATION_PROPERTY: {
957 auto screenId = static_cast<ScreenId>(data.ReadUint64());
958 RRect bounds;
959 if (!RSMarshallingHelper::Unmarshalling(data, bounds)) {
960 TLOGE(WmsLogTag::DMS, "Read bounds failed");
961 break;
962 }
963 auto rotation = data.ReadFloat();
964 auto screenPropertyChangeType = static_cast<ScreenPropertyChangeType>(data.ReadUint32());
965 bool isSwitchUser = data.ReadBool();
966 UpdateScreenRotationProperty(screenId, bounds, rotation, screenPropertyChangeType, isSwitchUser);
967 break;
968 }
969 case DisplayManagerMessage::TRANS_ID_GET_CURVED_SCREEN_COMPRESSION_AREA: {
970 auto area = GetCurvedCompressionArea();
971 static_cast<void>(reply.WriteUint32(area));
972 break;
973 }
974 case DisplayManagerMessage::TRANS_ID_GET_PHY_SCREEN_PROPERTY: {
975 auto screenId = static_cast<ScreenId>(data.ReadUint64());
976 if (!RSMarshallingHelper::Marshalling(reply, GetPhyScreenProperty(screenId))) {
977 TLOGE(WmsLogTag::DMS, "Write screenProperty failed");
978 }
979 break;
980 }
981 case DisplayManagerMessage::TRANS_ID_NOTIFY_DISPLAY_CHANGE_INFO: {
982 sptr<DisplayChangeInfo> info = DisplayChangeInfo::Unmarshalling(data);
983 if (!info) {
984 TLOGE(WmsLogTag::DMS, "Read DisplayChangeInfo failed");
985 return ERR_INVALID_DATA;
986 }
987 NotifyDisplayChangeInfoChanged(info);
988 break;
989 }
990 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_PRIVACY_STATE: {
991 auto hasPrivate = data.ReadBool();
992 SetScreenPrivacyState(hasPrivate);
993 break;
994 }
995 case DisplayManagerMessage::TRANS_ID_SET_SCREENID_PRIVACY_STATE: {
996 DisplayId displayId = static_cast<DisplayId>(data.ReadUint64());
997 auto hasPrivate = data.ReadBool();
998 SetPrivacyStateByDisplayId(displayId, hasPrivate);
999 break;
1000 }
1001 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_PRIVACY_WINDOW_LIST: {
1002 DisplayId displayId = static_cast<DisplayId>(data.ReadUint64());
1003 std::vector<std::string> privacyWindowList;
1004 data.ReadStringVector(&privacyWindowList);
1005 SetScreenPrivacyWindowList(displayId, privacyWindowList);
1006 break;
1007 }
1008 case DisplayManagerMessage::TRANS_ID_RESIZE_VIRTUAL_SCREEN: {
1009 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
1010 uint32_t width = data.ReadUint32();
1011 uint32_t height = data.ReadUint32();
1012 DMError ret = ResizeVirtualScreen(screenId, width, height);
1013 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
1014 break;
1015 }
1016 case DisplayManagerMessage::TRANS_ID_UPDATE_AVAILABLE_AREA: {
1017 auto screenId = static_cast<ScreenId>(data.ReadUint64());
1018 int32_t posX = data.ReadInt32();
1019 int32_t posY = data.ReadInt32();
1020 uint32_t width = data.ReadUint32();
1021 uint32_t height = data.ReadUint32();
1022 DMRect area = {posX, posY, width, height};
1023 UpdateAvailableArea(screenId, area);
1024 break;
1025 }
1026 case DisplayManagerMessage::TRANS_ID_UPDATE_SUPER_FOLD_AVAILABLE_AREA: {
1027 auto screenId = static_cast<ScreenId>(data.ReadUint64());
1028 int32_t bPosX = data.ReadInt32();
1029 int32_t bPosY = data.ReadInt32();
1030 uint32_t bWidth = data.ReadUint32();
1031 uint32_t bHeight = data.ReadUint32();
1032 DMRect bArea = {bPosX, bPosY, bWidth, bHeight};
1033 int32_t cPosX = data.ReadInt32();
1034 int32_t cPosY = data.ReadInt32();
1035 uint32_t cWidth = data.ReadUint32();
1036 uint32_t cHeight = data.ReadUint32();
1037 DMRect cArea = {cPosX, cPosY, cWidth, cHeight};
1038 UpdateSuperFoldAvailableArea(screenId, bArea, cArea);
1039 break;
1040 }
1041 case DisplayManagerMessage::TRANS_ID_UPDATE_SUPER_FOLD_EXPAND_AVAILABLE_AREA: {
1042 auto screenId = static_cast<ScreenId>(data.ReadUint64());
1043 int32_t posX = data.ReadInt32();
1044 int32_t posY = data.ReadInt32();
1045 uint32_t width = data.ReadUint32();
1046 uint32_t height = data.ReadUint32();
1047 DMRect area = {posX, posY, width, height};
1048 UpdateSuperFoldExpandAvailableArea(screenId, area);
1049 break;
1050 }
1051 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_OFF_DELAY_TIME: {
1052 int32_t delay = data.ReadInt32();
1053 int32_t ret = SetScreenOffDelayTime(delay);
1054 static_cast<void>(reply.WriteInt32(ret));
1055 break;
1056 }
1057 case DisplayManagerMessage::TRANS_ID_GET_AVAILABLE_AREA: {
1058 ProcGetAvailableArea(data, reply);
1059 break;
1060 }
1061 case DisplayManagerMessage::TRANS_ID_GET_EXPAND_AVAILABLE_AREA: {
1062 DisplayId displayId = static_cast<DisplayId>(data.ReadUint64());
1063 DMRect area;
1064 DMError ret = GetExpandAvailableArea(displayId, area);
1065 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
1066 static_cast<void>(reply.WriteInt32(area.posX_));
1067 static_cast<void>(reply.WriteInt32(area.posY_));
1068 static_cast<void>(reply.WriteUint32(area.width_));
1069 static_cast<void>(reply.WriteUint32(area.height_));
1070 break;
1071 }
1072 case DisplayManagerMessage::TRANS_ID_NOTIFY_FOLD_TO_EXPAND_COMPLETION: {
1073 bool foldToExpand = data.ReadBool();
1074 NotifyFoldToExpandCompletion(foldToExpand);
1075 break;
1076 }
1077 case DisplayManagerMessage::TRANS_ID_NOTIFY_SCREEN_CONNECT_COMPLETION: {
1078 ScreenId screenId = SCREEN_ID_INVALID;
1079 if (!data.ReadUint64(screenId)) {
1080 TLOGE(WmsLogTag::DMS, "Read screenId failed");
1081 return ERR_INVALID_DATA;
1082 }
1083 NotifyScreenConnectCompletion(static_cast<ScreenId>(screenId));
1084 break;
1085 }
1086 case DisplayManagerMessage::TRANS_ID_GET_VIRTUAL_SCREEN_FLAG: {
1087 ProcGetVirtualScreenFlag(data, reply);
1088 break;
1089 }
1090 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_FLAG: {
1091 ProcSetVirtualScreenFlag(data, reply);
1092 break;
1093 }
1094 case DisplayManagerMessage::TRANS_ID_GET_DEVICE_SCREEN_CONFIG: {
1095 if (!RSMarshallingHelper::Marshalling(reply, GetDeviceScreenConfig())) {
1096 TLOGE(WmsLogTag::DMS, "Write deviceScreenConfig failed");
1097 }
1098 break;
1099 }
1100 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_REFRESH_RATE: {
1101 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
1102 uint32_t refreshInterval = data.ReadUint32();
1103 DMError ret = SetVirtualScreenRefreshRate(screenId, refreshInterval);
1104 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
1105 break;
1106 }
1107 case DisplayManagerMessage::TRANS_ID_SWITCH_USER: {
1108 SwitchUser();
1109 break;
1110 }
1111 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_BLACK_LIST: {
1112 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
1113 std::vector<uint64_t> windowIdList;
1114 if (!data.ReadUInt64Vector(&windowIdList)) {
1115 TLOGE(WmsLogTag::DMS, "Failed to receive windowIdList in stub");
1116 break;
1117 }
1118 std::vector<uint64_t> surfaceIdList;
1119 if (!data.ReadUInt64Vector(&surfaceIdList)) {
1120 TLOGE(WmsLogTag::DMS, "Failed to receive surfaceIdList in stub");
1121 break;
1122 }
1123 std::vector<uint8_t> typeBlackList;
1124 if (!data.ReadUInt8Vector(&typeBlackList)) {
1125 TLOGE(WmsLogTag::DMS, "Failed to receive typeBlackList in stub");
1126 break;
1127 }
1128 SetVirtualScreenBlackList(screenId, windowIdList, surfaceIdList, typeBlackList);
1129 break;
1130 }
1131 case DisplayManagerMessage::TRANS_ID_DISABLE_POWEROFF_RENDER_CONTROL: {
1132 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
1133 DisablePowerOffRenderControl(screenId);
1134 break;
1135 }
1136 case DisplayManagerMessage::TRANS_ID_PROXY_FOR_FREEZE: {
1137 ProcProxyForFreeze(data, reply);
1138 break;
1139 }
1140 case DisplayManagerMessage::TRANS_ID_RESET_ALL_FREEZE_STATUS: {
1141 DMError ret = ResetAllFreezeStatus();
1142 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
1143 break;
1144 }
1145 case DisplayManagerMessage::TRANS_ID_NOTIFY_DISPLAY_HOOK_INFO: {
1146 int32_t uid = data.ReadInt32();
1147 bool enable = data.ReadBool();
1148 DMHookInfo hookInfo;
1149 hookInfo.width_ = data.ReadUint32();
1150 hookInfo.height_ = data.ReadUint32();
1151 hookInfo.density_ = data.ReadFloat();
1152 hookInfo.rotation_ = data.ReadUint32();
1153 hookInfo.enableHookRotation_ = data.ReadBool();
1154 hookInfo.displayOrientation_ = data.ReadUint32();
1155 hookInfo.enableHookDisplayOrientation_ = data.ReadBool();
1156 UpdateDisplayHookInfo(uid, enable, hookInfo);
1157 break;
1158 }
1159 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_HOOK_INFO: {
1160 int32_t uid = data.ReadInt32();
1161 DMHookInfo hookInfo;
1162 GetDisplayHookInfo(uid, hookInfo);
1163 if (!reply.WriteUint32(hookInfo.width_) || !reply.WriteUint32(hookInfo.height_) ||
1164 !reply.WriteFloat(hookInfo.density_) || !reply.WriteUint32(hookInfo.rotation_) ||
1165 !reply.WriteBool(hookInfo.enableHookRotation_)) {
1166 TLOGE(WmsLogTag::DMS, "read reply hookInfo failed!");
1167 }
1168 break;
1169 }
1170 case DisplayManagerMessage::TRANS_ID_GET_ALL_PHYSICAL_DISPLAY_RESOLUTION: {
1171 ProcGetAllDisplayPhysicalResolution(data, reply);
1172 break;
1173 }
1174 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_STATUS: {
1175 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
1176 VirtualScreenStatus screenStatus = static_cast<VirtualScreenStatus>(data.ReadInt32());
1177 bool res = SetVirtualScreenStatus(screenId, screenStatus);
1178 reply.WriteBool(res);
1179 break;
1180 }
1181 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_SECURITY_EXEMPTION: {
1182 ProcSetVirtualScreenSecurityExemption(data, reply);
1183 break;
1184 }
1185 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_MAX_REFRESHRATE: {
1186 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
1187 uint32_t refreshRate = data.ReadUint32();
1188 uint32_t actualRefreshRate;
1189 DMError ret = SetVirtualScreenMaxRefreshRate(screenId, refreshRate, actualRefreshRate);
1190 reply.WriteUint32(actualRefreshRate);
1191 reply.WriteInt32(static_cast<int32_t>(ret));
1192 break;
1193 }
1194 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_CAPTURE: {
1195 ProcGetScreenCapture(data, reply);
1196 break;
1197 }
1198 case DisplayManagerMessage::TRANS_ID_GET_PRIMARY_DISPLAY_INFO: {
1199 auto info = GetPrimaryDisplayInfo();
1200 reply.WriteParcelable(info);
1201 break;
1202 }
1203 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_SNAPSHOT_WITH_OPTION: {
1204 ProcGetDisplaySnapshotWithOption(data, reply);
1205 break;
1206 }
1207 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_HDR_SNAPSHOT_WITH_OPTION: {
1208 ProcGetDisplayHDRSnapshotWithOption(data, reply);
1209 break;
1210 }
1211 case DisplayManagerMessage::TRANS_ID_SET_CAMERA_STATUS: {
1212 int32_t cameraStatus = data.ReadInt32();
1213 int32_t cameraPosition = data.ReadInt32();
1214 SetCameraStatus(cameraStatus, cameraPosition);
1215 break;
1216 }
1217 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_ON_DELAY_TIME: {
1218 int32_t delay = data.ReadInt32();
1219 int32_t ret = SetScreenOnDelayTime(delay);
1220 static_cast<void>(reply.WriteInt32(ret));
1221 break;
1222 }
1223 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_SKIP_PROTECTED_WINDOW: {
1224 ProcSetScreenSkipProtectedWindow(data, reply);
1225 break;
1226 }
1227 case DisplayManagerMessage::TRANS_ID_RECORD_EVENT_FROM_SCB: {
1228 std::string description = data.ReadString();
1229 bool needRecordEvent = data.ReadBool();
1230 RecordEventFromScb(description, needRecordEvent);
1231 break;
1232 }
1233 case DisplayManagerMessage::TRANS_ID_GET_IS_REAL_SCREEN: {
1234 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
1235 reply.WriteBool(GetIsRealScreen(screenId));
1236 break;
1237 }
1238 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_CAPABILITY: {
1239 std::string capabilitInfo;
1240 DMError ret = GetDisplayCapability(capabilitInfo);
1241 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
1242 reply.WriteString(capabilitInfo);
1243 break;
1244 }
1245 case DisplayManagerMessage::TRANS_ID_SET_SYSTEM_KEYBOARD_STATUS: {
1246 bool isTpKeyboardOn = static_cast<bool>(data.ReadBool());
1247 DMError ret = SetSystemKeyboardStatus(isTpKeyboardOn);
1248 reply.WriteInt32(static_cast<int32_t>(ret));
1249 break;
1250 }
1251 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_DISPLAY_MUTE_FLAG: {
1252 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
1253 bool muteFlag = data.ReadBool();
1254 SetVirtualDisplayMuteFlag(screenId, muteFlag);
1255 break;
1256 }
1257 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_FORCE_CLOSE_HDR: {
1258 ScreenId screenId = SCREEN_ID_INVALID;
1259 if (!data.ReadUint64(screenId)) {
1260 TLOGE(WmsLogTag::DMS, "Read screenId failed");
1261 return ERR_INVALID_DATA;
1262 }
1263 bool isForceCloseHdr = false;
1264 if (!data.ReadBool(isForceCloseHdr)) {
1265 TLOGE(WmsLogTag::DMS, "Read isForceCloseHdr failed");
1266 return ERR_INVALID_DATA;
1267 }
1268 SetForceCloseHdr(screenId, isForceCloseHdr);
1269 break;
1270 }
1271 case DisplayManagerMessage::TRANS_ID_SET_DEFAULT_MODE_WHEN_SWITCH_USER: {
1272 SetDefaultMultiScreenModeWhenSwitchUser();
1273 break;
1274 }
1275 case DisplayManagerMessage::TRANS_ID_NOTIFY_EXTEND_SCREEN_CREATE_FINISH: {
1276 NotifyExtendScreenCreateFinish();
1277 break;
1278 }
1279 case DisplayManagerMessage::TRANS_ID_NOTIFY_EXTEND_SCREEN_DESTROY_FINISH: {
1280 NotifyExtendScreenDestroyFinish();
1281 break;
1282 }
1283 case DisplayManagerMessage::TRANS_ID_NOTIFY_SCREEN_MASK_APPEAR: {
1284 NotifyScreenMaskAppear();
1285 break;
1286 }
1287 case DisplayManagerMessage::TRANS_ID_GET_KEYBOARD_STATE: {
1288 bool isKeyboardOn = GetKeyboardState();
1289 reply.WriteBool(isKeyboardOn);
1290 break;
1291 }
1292 case DisplayManagerMessage::TRANS_ID_GET_SCREEN_AREA_OF_DISPLAY_AREA: {
1293 ProcGetScreenAreaOfDisplayArea(data, reply);
1294 break;
1295 }
1296 case DisplayManagerMessage::TRANS_ID_SET_PRIMARY_DISPLAY_SYSTEM_DPI: {
1297 ProcSetPrimaryDisplaySystemDpi(data, reply);
1298 break;
1299 }
1300 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_AUTO_ROTATION: {
1301 ProcSetVirtualScreenAutoRotation(data, reply);
1302 break;
1303 }
1304 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_PRIVACY_WINDOW_TAG_SWITCH: {
1305 ScreenId screenId = SCREEN_ID_INVALID;
1306 if (!data.ReadUint64(screenId)) {
1307 TLOGE(WmsLogTag::DMS, "Read screenId failed");
1308 return ERR_INVALID_DATA;
1309 }
1310 std::vector<std::string> privacyWindowTag;
1311 if (!data.ReadStringVector(&privacyWindowTag)) {
1312 TLOGE(WmsLogTag::DMS, "Read privacyWindowTag failed");
1313 return ERR_INVALID_DATA;
1314 }
1315 bool enable = false;
1316 if (!data.ReadBool(enable)) {
1317 TLOGE(WmsLogTag::DMS, "Read enable failed");
1318 return ERR_INVALID_DATA;
1319 }
1320 DMError ret = SetScreenPrivacyWindowTagSwitch(screenId, privacyWindowTag, enable);
1321 if (!reply.WriteInt32(static_cast<int32_t>(ret))) {
1322 TLOGE(WmsLogTag::DMS, "Write reault failed");
1323 return ERR_INVALID_DATA;
1324 }
1325 break;
1326 }
1327 case DisplayManagerMessage::TRANS_ID_SYNCHRONIZED_POWER_STATUS: {
1328 uint32_t stateTemp = 0;
1329 if (!data.ReadUint32(stateTemp)) {
1330 TLOGE(WmsLogTag::DMS, "Read state failed");
1331 return ERR_INVALID_DATA;
1332 }
1333 ScreenPowerState state = static_cast<ScreenPowerState>(stateTemp);
1334 bool res = SynchronizePowerStatus(state);
1335 if (!reply.WriteBool(res)) {
1336 TLOGE(WmsLogTag::DMS, "Write res failed");
1337 return ERR_INVALID_DATA;
1338 }
1339 break;
1340 }
1341 default:
1342 TLOGW(WmsLogTag::DMS, "unknown transaction code");
1343 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
1344 }
1345 return ERR_NONE;
1346 }
1347
ProcGetAvailableArea(MessageParcel & data,MessageParcel & reply)1348 void ScreenSessionManagerStub::ProcGetAvailableArea(MessageParcel& data, MessageParcel& reply)
1349 {
1350 DisplayId displayId = static_cast<DisplayId>(data.ReadUint64());
1351 DMRect area;
1352 DMError ret = GetAvailableArea(displayId, area);
1353 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
1354 static_cast<void>(reply.WriteInt32(area.posX_));
1355 static_cast<void>(reply.WriteInt32(area.posY_));
1356 static_cast<void>(reply.WriteUint32(area.width_));
1357 static_cast<void>(reply.WriteUint32(area.height_));
1358 }
1359
ProcGetSnapshotByPicker(MessageParcel & reply)1360 void ScreenSessionManagerStub::ProcGetSnapshotByPicker(MessageParcel& reply)
1361 {
1362 DmErrorCode errCode = DmErrorCode::DM_OK;
1363 Media::Rect imgRect { 0, 0, 0, 0 };
1364 std::shared_ptr<Media::PixelMap> snapshot = GetSnapshotByPicker(imgRect, &errCode);
1365 reply.WriteParcelable(snapshot == nullptr ? nullptr : snapshot.get());
1366 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(errCode)));
1367 static_cast<void>(reply.WriteInt32(imgRect.left));
1368 static_cast<void>(reply.WriteInt32(imgRect.top));
1369 static_cast<void>(reply.WriteInt32(imgRect.width));
1370 static_cast<void>(reply.WriteInt32(imgRect.height));
1371 }
1372
ProcSetVirtualScreenFlag(MessageParcel & data,MessageParcel & reply)1373 void ScreenSessionManagerStub::ProcSetVirtualScreenFlag(MessageParcel& data, MessageParcel& reply)
1374 {
1375 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
1376 VirtualScreenFlag screenFlag = static_cast<VirtualScreenFlag>(data.ReadUint32());
1377 DMError setRet = SetVirtualScreenFlag(screenId, screenFlag);
1378 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(setRet)));
1379 }
1380
ProcGetVirtualScreenFlag(MessageParcel & data,MessageParcel & reply)1381 void ScreenSessionManagerStub::ProcGetVirtualScreenFlag(MessageParcel& data, MessageParcel& reply)
1382 {
1383 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
1384 VirtualScreenFlag screenFlag = GetVirtualScreenFlag(screenId);
1385 static_cast<void>(reply.WriteUint32(static_cast<uint32_t>(screenFlag)));
1386 }
1387
ProcProxyForFreeze(MessageParcel & data,MessageParcel & reply)1388 void ScreenSessionManagerStub::ProcProxyForFreeze(MessageParcel& data, MessageParcel& reply)
1389 {
1390 std::set<int32_t> pidList;
1391 int32_t size = data.ReadInt32();
1392 if (size > MAX_BUFF_SIZE) {
1393 TLOGE(WmsLogTag::DMS, "pid List size invalid: %{public}d", size);
1394 size = MAX_BUFF_SIZE;
1395 }
1396 for (int32_t i = 0; i < size; i++) {
1397 pidList.insert(data.ReadInt32());
1398 }
1399 bool isProxy = data.ReadBool();
1400 DMError ret = ProxyForFreeze(pidList, isProxy);
1401 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
1402 }
1403
ProcGetAllDisplayPhysicalResolution(MessageParcel & data,MessageParcel & reply)1404 void ScreenSessionManagerStub::ProcGetAllDisplayPhysicalResolution(MessageParcel& data, MessageParcel& reply)
1405 {
1406 auto physicalInfos = GetAllDisplayPhysicalResolution();
1407 size_t infoSize = physicalInfos.size();
1408 bool writeRet = reply.WriteInt32(static_cast<int32_t>(infoSize));
1409 if (!writeRet) {
1410 TLOGE(WmsLogTag::DMS, "write physical size error");
1411 return;
1412 }
1413 for (const auto &physicalItem : physicalInfos) {
1414 writeRet = reply.WriteUint32(static_cast<uint32_t>(physicalItem.foldDisplayMode_));
1415 if (!writeRet) {
1416 TLOGE(WmsLogTag::DMS, "write display mode error");
1417 break;
1418 }
1419 writeRet = reply.WriteUint32(physicalItem.physicalWidth_);
1420 if (!writeRet) {
1421 TLOGE(WmsLogTag::DMS, "write physical width error");
1422 break;
1423 }
1424 writeRet = reply.WriteUint32(physicalItem.physicalHeight_);
1425 if (!writeRet) {
1426 TLOGE(WmsLogTag::DMS, "write physical height error");
1427 break;
1428 }
1429 }
1430 }
1431
ProcSetVirtualScreenSecurityExemption(MessageParcel & data,MessageParcel & reply)1432 void ScreenSessionManagerStub::ProcSetVirtualScreenSecurityExemption(MessageParcel& data, MessageParcel& reply)
1433 {
1434 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
1435 uint32_t pid = data.ReadUint32();
1436 std::vector<uint64_t> windowIdList;
1437 data.ReadUInt64Vector(&windowIdList);
1438 DMError ret = SetVirtualScreenSecurityExemption(screenId, pid, windowIdList);
1439 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
1440 }
1441
ProcGetScreenCapture(MessageParcel & data,MessageParcel & reply)1442 void ScreenSessionManagerStub::ProcGetScreenCapture(MessageParcel& data, MessageParcel& reply)
1443 {
1444 CaptureOption option;
1445 option.displayId_ = static_cast<DisplayId>(data.ReadUint64());
1446 option.isNeedNotify_ = static_cast<bool>(data.ReadBool());
1447 option.isNeedPointer_ = static_cast<bool>(data.ReadBool());
1448 DmErrorCode errCode = DmErrorCode::DM_OK;
1449 std::shared_ptr<Media::PixelMap> capture = GetScreenCapture(option, &errCode);
1450 reply.WriteParcelable(capture == nullptr ? nullptr : capture.get());
1451 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(errCode)));
1452 }
1453
ProcGetDisplaySnapshotWithOption(MessageParcel & data,MessageParcel & reply)1454 void ScreenSessionManagerStub::ProcGetDisplaySnapshotWithOption(MessageParcel& data, MessageParcel& reply)
1455 {
1456 CaptureOption option;
1457 option.displayId_ = static_cast<DisplayId>(data.ReadUint64());
1458 option.isNeedNotify_ = static_cast<bool>(data.ReadBool());
1459 option.isNeedPointer_ = static_cast<bool>(data.ReadBool());
1460 option.isCaptureFullOfScreen_ = static_cast<bool>(data.ReadBool());
1461 if (!data.ReadUInt64Vector(&option.surfaceNodesList_)) {
1462 TLOGE(WmsLogTag::DMS, "Read node surfaceNodesList failed");
1463 return;
1464 }
1465 option.isCaptureFullOfScreen_ = static_cast<bool>(data.ReadBool());
1466 DmErrorCode errCode = DmErrorCode::DM_OK;
1467 std::shared_ptr<Media::PixelMap> capture = GetDisplaySnapshotWithOption(option, &errCode);
1468 reply.WriteParcelable(capture == nullptr ? nullptr : capture.get());
1469 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(errCode)));
1470 }
1471
ProcGetDisplayHDRSnapshotWithOption(MessageParcel & data,MessageParcel & reply)1472 void ScreenSessionManagerStub::ProcGetDisplayHDRSnapshotWithOption(MessageParcel& data, MessageParcel& reply)
1473 {
1474 CaptureOption option;
1475 option.displayId_ = DISPLAY_ID_INVALID;
1476 option.isNeedNotify_ = false;
1477 option.isCaptureFullOfScreen_ = false;
1478 if (!data.ReadUint64(option.displayId_)) {
1479 TLOGE(WmsLogTag::DMS, "Read displayId failed");
1480 return;
1481 }
1482 if (!data.ReadBool(option.isNeedNotify_)) {
1483 TLOGE(WmsLogTag::DMS, "Read isNeedNotify failed");
1484 return;
1485 }
1486 if (!data.ReadBool(option.isCaptureFullOfScreen_)) {
1487 TLOGE(WmsLogTag::DMS, "Read isCaptureFullOfScreen failed");
1488 return;
1489 }
1490 if (!data.ReadUInt64Vector(&option.surfaceNodesList_)) {
1491 TLOGE(WmsLogTag::DMS, "Read surfaceNodesList failed");
1492 return;
1493 }
1494 DmErrorCode errCode = DmErrorCode::DM_OK;
1495 std::vector<std::shared_ptr<Media::PixelMap>> captureVec = GetDisplayHDRSnapshotWithOption(option, errCode);
1496 if (captureVec.size() != PIXMAP_VECTOR_SIZE) {
1497 TLOGE(WmsLogTag::DMS, "captureVec size: %{public}zu", captureVec.size());
1498 reply.WriteParcelable(nullptr);
1499 reply.WriteParcelable(nullptr);
1500 } else {
1501 reply.WriteParcelable(captureVec[0] == nullptr ? nullptr : captureVec[0].get());
1502 reply.WriteParcelable(captureVec[1] == nullptr ? nullptr : captureVec[1].get());
1503 }
1504 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(errCode)));
1505 }
1506
ProcSetScreenSkipProtectedWindow(MessageParcel & data,MessageParcel & reply)1507 void ScreenSessionManagerStub::ProcSetScreenSkipProtectedWindow(MessageParcel& data, MessageParcel& reply)
1508 {
1509 std::vector<ScreenId> screenIds;
1510 if (!data.ReadUInt64Vector(&screenIds)) {
1511 TLOGE(WmsLogTag::DMS, "Read screenIds failed");
1512 return;
1513 }
1514 bool isEnable = static_cast<bool>(data.ReadBool());
1515 DMError ret = SetScreenSkipProtectedWindow(screenIds, isEnable);
1516 reply.WriteInt32(static_cast<int32_t>(ret));
1517 }
1518
ProcGetScreenAreaOfDisplayArea(MessageParcel & data,MessageParcel & reply)1519 void ScreenSessionManagerStub::ProcGetScreenAreaOfDisplayArea(MessageParcel& data, MessageParcel& reply)
1520 {
1521 DisplayId displayId = static_cast<DisplayId>(data.ReadUint64());
1522 int32_t posX = data.ReadInt32();
1523 int32_t posY = data.ReadInt32();
1524 uint32_t width = data.ReadUint32();
1525 uint32_t height = data.ReadUint32();
1526 DMRect displayArea = { posX, posY, width, height };
1527 DMRect screenArea = DMRect::NONE();
1528 ScreenId screenId = 0;
1529 DMError ret = GetScreenAreaOfDisplayArea(displayId, displayArea, screenId, screenArea);
1530 reply.WriteInt32(static_cast<int32_t>(ret));
1531 static_cast<void>(reply.WriteUint64(screenId));
1532 static_cast<void>(reply.WriteInt32(screenArea.posX_));
1533 static_cast<void>(reply.WriteInt32(screenArea.posY_));
1534 static_cast<void>(reply.WriteUint32(screenArea.width_));
1535 static_cast<void>(reply.WriteUint32(screenArea.height_));
1536 }
1537
ProcSetPrimaryDisplaySystemDpi(MessageParcel & data,MessageParcel & reply)1538 void ScreenSessionManagerStub::ProcSetPrimaryDisplaySystemDpi(MessageParcel& data, MessageParcel& reply)
1539 {
1540 float dpi = INVALID_DEFAULT_DENSITY;
1541 if (!data.ReadFloat(dpi)) {
1542 TLOGE(WmsLogTag::DMS, "Read dpi failed.");
1543 return;
1544 }
1545 DMError ret = SetPrimaryDisplaySystemDpi(dpi);
1546 reply.WriteInt32(static_cast<int32_t>(ret));
1547 }
1548
ProcSetVirtualScreenAutoRotation(MessageParcel & data,MessageParcel & reply)1549 void ScreenSessionManagerStub::ProcSetVirtualScreenAutoRotation(MessageParcel& data, MessageParcel& reply)
1550 {
1551 ScreenId screenId = 0;
1552 if (!data.ReadUint64(screenId)) {
1553 TLOGE(WmsLogTag::DMS, "Read screenId failed.");
1554 return;
1555 }
1556 bool enable = false;
1557 if (!data.ReadBool(enable)) {
1558 TLOGE(WmsLogTag::DMS, "Read enable failed.");
1559 return;
1560 }
1561 DMError ret = SetVirtualScreenAutoRotation(screenId, enable);
1562 reply.WriteInt32(static_cast<int32_t>(ret));
1563 }
1564 } // namespace OHOS::Rosen
1565