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 static_cast<void>(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 static_cast<void>(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_GET_INTERNAL_SCREEN_ID: {
87 reply.WriteUint64(GetInternalScreenId());
88 break;
89 }
90 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_POWER_BY_ID: {
91 ScreenId screenId = data.ReadUint64();
92 ScreenPowerState state = static_cast<ScreenPowerState>(data.ReadUint32());
93 PowerStateChangeReason reason = static_cast<PowerStateChangeReason>(data.ReadUint32());
94 reply.WriteBool(SetScreenPowerById(screenId, state, reason));
95 break;
96 }
97 case DisplayManagerMessage::TRANS_ID_SET_DISPLAY_STATE: {
98 DisplayState state = static_cast<DisplayState>(data.ReadUint32());
99 reply.WriteBool(SetDisplayState(state));
100 break;
101 }
102 case DisplayManagerMessage::TRANS_ID_SET_SPECIFIED_SCREEN_POWER: {
103 ScreenId screenId = static_cast<ScreenId>(data.ReadUint32());
104 ScreenPowerState state = static_cast<ScreenPowerState>(data.ReadUint32());
105 PowerStateChangeReason reason = static_cast<PowerStateChangeReason>(data.ReadUint32());
106 reply.WriteBool(SetSpecifiedScreenPower(screenId, state, reason));
107 break;
108 }
109 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_POWER_FOR_ALL: {
110 ScreenPowerState state = static_cast<ScreenPowerState>(data.ReadUint32());
111 PowerStateChangeReason reason = static_cast<PowerStateChangeReason>(data.ReadUint32());
112 reply.WriteBool(SetScreenPowerForAll(state, reason));
113 break;
114 }
115 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_STATE: {
116 DisplayState state = GetDisplayState(data.ReadUint64());
117 static_cast<void>(reply.WriteUint32(static_cast<uint32_t>(state)));
118 break;
119 }
120 case DisplayManagerMessage::TRANS_ID_NOTIFY_DISPLAY_EVENT: {
121 DisplayEvent event = static_cast<DisplayEvent>(data.ReadUint32());
122 NotifyDisplayEvent(event);
123 break;
124 }
125 case DisplayManagerMessage::TRANS_ID_GET_SCREEN_POWER: {
126 ScreenId dmsScreenId;
127 if (!data.ReadUint64(dmsScreenId)) {
128 WLOGFE("fail to read dmsScreenId.");
129 return ERR_INVALID_DATA;
130 }
131 static_cast<void>(reply.WriteUint32(static_cast<uint32_t>(GetScreenPower(dmsScreenId))));
132 break;
133 }
134 case DisplayManagerMessage::TRANS_ID_GET_SCREEN_POWER_AUTO: {
135 reply.WriteUint32(static_cast<uint32_t>(GetScreenPower()));
136 break;
137 }
138 case DisplayManagerMessage::TRANS_ID_TRY_TO_CANCEL_SCREEN_OFF: {
139 reply.WriteBool(TryToCancelScreenOff());
140 break;
141 }
142 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_BRIGHTNESS: {
143 uint64_t screenId = data.ReadUint64();
144 uint32_t level = data.ReadUint64();
145 reply.WriteBool(SetScreenBrightness(screenId, level));
146 break;
147 }
148 case DisplayManagerMessage::TRANS_ID_GET_SCREEN_BRIGHTNESS: {
149 uint64_t screenId = data.ReadUint64();
150 reply.WriteUint32(GetScreenBrightness(screenId));
151 break;
152 }
153 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_BY_ID: {
154 DisplayId displayId = data.ReadUint64();
155 auto info = GetDisplayInfoById(displayId);
156 reply.WriteParcelable(info);
157 break;
158 }
159 case DisplayManagerMessage::TRANS_ID_GET_VISIBLE_AREA_DISPLAY_INFO_BY_ID: {
160 DisplayId displayId = static_cast<DisplayId>(data.ReadUint64());
161 auto info = GetVisibleAreaDisplayInfoById(displayId);
162 reply.WriteParcelable(info);
163 break;
164 }
165 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_BY_SCREEN: {
166 ScreenId screenId = data.ReadUint64();
167 auto info = GetDisplayInfoByScreen(screenId);
168 reply.WriteParcelable(info);
169 break;
170 }
171 case DisplayManagerMessage::TRANS_ID_GET_ALL_DISPLAYIDS: {
172 std::vector<DisplayId> allDisplayIds = GetAllDisplayIds();
173 static_cast<void>(reply.WriteUInt64Vector(allDisplayIds));
174 break;
175 }
176 case DisplayManagerMessage::TRANS_ID_GET_SCREEN_INFO_BY_ID: {
177 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
178 auto screenInfo = GetScreenInfoById(screenId);
179 reply.WriteStrongParcelable(screenInfo);
180 break;
181 }
182 case DisplayManagerMessage::TRANS_ID_GET_ALL_SCREEN_INFOS: {
183 std::vector<sptr<ScreenInfo>> screenInfos;
184 DMError ret = GetAllScreenInfos(screenInfos);
185 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
186 if (!MarshallingHelper::MarshallingVectorParcelableObj<ScreenInfo>(reply, screenInfos)) {
187 WLOGE("fail to marshalling screenInfos in stub.");
188 }
189 break;
190 }
191 case DisplayManagerMessage::TRANS_ID_SCREEN_GET_SUPPORTED_COLOR_GAMUTS: {
192 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
193 std::vector<ScreenColorGamut> colorGamuts;
194 DMError ret = GetScreenSupportedColorGamuts(screenId, colorGamuts);
195 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
196 if (ret != DMError::DM_OK) {
197 break;
198 }
199 MarshallingHelper::MarshallingVectorObj<ScreenColorGamut>(reply, colorGamuts,
200 [](Parcel& parcel, const ScreenColorGamut& color) {
201 return parcel.WriteUint32(static_cast<uint32_t>(color));
202 }
203 );
204 break;
205 }
206 case DisplayManagerMessage::TRANS_ID_CREATE_VIRTUAL_SCREEN: {
207 std::string name = data.ReadString();
208 uint32_t width = data.ReadUint32();
209 uint32_t height = data.ReadUint32();
210 float density = data.ReadFloat();
211 int32_t flags = data.ReadInt32();
212 bool isForShot = data.ReadBool();
213 std::vector<uint64_t> missionIds;
214 data.ReadUInt64Vector(&missionIds);
215 VirtualScreenType virtualScreenType = static_cast<VirtualScreenType>(data.ReadUint32());
216 bool isSurfaceValid = data.ReadBool();
217 sptr<Surface> surface = nullptr;
218 if (isSurfaceValid) {
219 sptr<IRemoteObject> surfaceObject = data.ReadRemoteObject();
220 sptr<IBufferProducer> bp = iface_cast<IBufferProducer>(surfaceObject);
221 surface = Surface::CreateSurfaceAsProducer(bp);
222 }
223 sptr<IRemoteObject> virtualScreenAgent = data.ReadRemoteObject();
224 VirtualScreenOption virScrOption = {
225 .name_ = name,
226 .width_ = width,
227 .height_ = height,
228 .density_ = density,
229 .surface_ = surface,
230 .flags_ = flags,
231 .isForShot_ = isForShot,
232 .missionIds_ = missionIds,
233 .virtualScreenType_ = virtualScreenType
234 };
235 ScreenId screenId = CreateVirtualScreen(virScrOption, virtualScreenAgent);
236 static_cast<void>(reply.WriteUint64(static_cast<uint64_t>(screenId)));
237 break;
238 }
239 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_SURFACE: {
240 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
241 bool isSurfaceValid = data.ReadBool();
242 sptr<IBufferProducer> bp = nullptr;
243 if (isSurfaceValid) {
244 sptr<IRemoteObject> surfaceObject = data.ReadRemoteObject();
245 bp = iface_cast<IBufferProducer>(surfaceObject);
246 }
247 DMError result = SetVirtualScreenSurface(screenId, bp);
248 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(result)));
249 break;
250 }
251 case DisplayManagerMessage::TRANS_ID_ADD_VIRTUAL_SCREEN_BLOCK_LIST: {
252 uint64_t size = 0;
253 if (!data.ReadUint64(size)) {
254 TLOGE(WmsLogTag::DMS, "Read size failed.");
255 break;
256 }
257 std::vector<int32_t> persistentIds;
258 for (uint64_t i = 0; i < size; i++) {
259 int32_t persistentId = 0;
260 if (!data.ReadInt32(persistentId)) {
261 TLOGE(WmsLogTag::DMS, "Read persistentId failed.");
262 break;
263 }
264 persistentIds.push_back(persistentId);
265 }
266 DMError errCode = AddVirtualScreenBlockList(persistentIds);
267 reply.WriteInt32(static_cast<int32_t>(errCode));
268 break;
269 }
270 case DisplayManagerMessage::TRANS_ID_REMOVE_VIRTUAL_SCREEN_BLOCK_LIST: {
271 uint64_t size = 0;
272 if (!data.ReadUint64(size)) {
273 TLOGE(WmsLogTag::DMS, "Read size failed.");
274 break;
275 }
276 std::vector<int32_t> persistentIds;
277 for (uint64_t i = 0; i < size; i++) {
278 int32_t persistentId = 0;
279 if (!data.ReadInt32(persistentId)) {
280 TLOGE(WmsLogTag::DMS, "Read persistentId failed.");
281 break;
282 }
283 persistentIds.push_back(persistentId);
284 }
285 DMError errCode = RemoveVirtualScreenBlockList(persistentIds);
286 reply.WriteInt32(static_cast<int32_t>(errCode));
287 break;
288 }
289 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_PRIVACY_MASKIMAGE: {
290 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
291 std::shared_ptr<Media::PixelMap> privacyMaskImg{nullptr};
292 bool isPrivacyMaskImgValid = data.ReadBool();
293 if (isPrivacyMaskImgValid) {
294 privacyMaskImg = std::shared_ptr<Media::PixelMap>(data.ReadParcelable<Media::PixelMap>());
295 DMError result = SetScreenPrivacyMaskImage(screenId, privacyMaskImg);
296 reply.WriteInt32(static_cast<int32_t>(result));
297 } else {
298 DMError result = SetScreenPrivacyMaskImage(screenId, nullptr);
299 reply.WriteInt32(static_cast<int32_t>(result));
300 }
301 break;
302 }
303 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_CANVAS_ROTATION: {
304 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
305 bool autoRotate = data.ReadBool();
306 DMError result = SetVirtualMirrorScreenCanvasRotation(screenId, autoRotate);
307 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(result)));
308 break;
309 }
310 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_SCALE_MODE: {
311 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
312 ScreenScaleMode scaleMode = static_cast<ScreenScaleMode>(data.ReadUint32());
313 DMError result = SetVirtualMirrorScreenScaleMode(screenId, scaleMode);
314 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(result)));
315 break;
316 }
317 case DisplayManagerMessage::TRANS_ID_DESTROY_VIRTUAL_SCREEN: {
318 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
319 DMError result = DestroyVirtualScreen(screenId);
320 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(result)));
321 break;
322 }
323 case DisplayManagerMessage::TRANS_ID_SCREEN_MAKE_MIRROR: {
324 ScreenId mainScreenId = static_cast<ScreenId>(data.ReadUint64());
325 std::vector<ScreenId> mirrorScreenId;
326 if (!data.ReadUInt64Vector(&mirrorScreenId)) {
327 WLOGE("fail to receive mirror screen in stub. screen:%{public}" PRIu64"", mainScreenId);
328 break;
329 }
330 ScreenId screenGroupId = INVALID_SCREEN_ID;
331 DMError ret = MakeMirror(mainScreenId, mirrorScreenId, screenGroupId);
332 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
333 static_cast<void>(reply.WriteUint64(static_cast<uint64_t>(screenGroupId)));
334 break;
335 }
336 case DisplayManagerMessage::TRANS_ID_SCREEN_MAKE_MIRROR_FOR_RECORD: {
337 ScreenId mainScreenId = static_cast<ScreenId>(data.ReadUint64());
338 std::vector<ScreenId> mirrorScreenId;
339 if (!data.ReadUInt64Vector(&mirrorScreenId)) {
340 WLOGE("fail to receive mirror screen in stub. screen:%{public}" PRIu64"", mainScreenId);
341 break;
342 }
343 ScreenId screenGroupId = INVALID_SCREEN_ID;
344 DMError ret = MakeMirrorForRecord(mainScreenId, mirrorScreenId, screenGroupId);
345 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
346 static_cast<void>(reply.WriteUint64(static_cast<uint64_t>(screenGroupId)));
347 break;
348 }
349 case DisplayManagerMessage::TRANS_ID_SCREEN_MAKE_MIRROR_WITH_REGION: {
350 ScreenId mainScreenId = static_cast<ScreenId>(data.ReadUint64());
351 std::vector<ScreenId> mirrorScreenId;
352 if (!data.ReadUInt64Vector(&mirrorScreenId)) {
353 WLOGE("fail to receive mirror screen in stub. screen:%{public}" PRIu64"", mainScreenId);
354 break;
355 }
356 int32_t posX = data.ReadInt32();
357 int32_t posY = data.ReadInt32();
358 uint32_t width = data.ReadUint32();
359 uint32_t height = data.ReadUint32();
360 DMRect mainScreenRegion = { posX, posY, width, height };
361 ScreenId screenGroupId = INVALID_SCREEN_ID;
362 DMError ret = MakeMirror(mainScreenId, mirrorScreenId, mainScreenRegion, screenGroupId);
363 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
364 static_cast<void>(reply.WriteUint64(static_cast<uint64_t>(screenGroupId)));
365 break;
366 }
367 case DisplayManagerMessage::TRANS_ID_MULTI_SCREEN_MODE_SWITCH: {
368 ScreenId mainScreenId = static_cast<ScreenId>(data.ReadUint64());
369 ScreenId secondaryScreenId = static_cast<ScreenId>(data.ReadUint64());
370 MultiScreenMode screenMode = static_cast<MultiScreenMode>(data.ReadUint32());
371 DMError ret = SetMultiScreenMode(mainScreenId, secondaryScreenId, screenMode);
372 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
373 break;
374 }
375 case DisplayManagerMessage::TRANS_ID_SET_MULTI_SCREEN_POSITION: {
376 uint64_t mainScreenId = data.ReadUint64();
377 uint32_t mainScreenX = data.ReadUint32();
378 uint32_t mainScreenY = data.ReadUint32();
379 uint64_t secondaryScreenId = data.ReadUint64();
380 uint32_t secondaryScreenX = data.ReadUint32();
381 uint32_t secondaryScreenY = data.ReadUint32();
382 MultiScreenPositionOptions mainScreenOptions = {
383 .screenId_ = mainScreenId,
384 .startX_ = mainScreenX,
385 .startY_ = mainScreenY,
386 };
387 MultiScreenPositionOptions secondScreenOption = {
388 .screenId_ = secondaryScreenId,
389 .startX_ = secondaryScreenX,
390 .startY_ = secondaryScreenY,
391 };
392 DMError ret = SetMultiScreenRelativePosition(mainScreenOptions, secondScreenOption);
393 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
394 break;
395 }
396 case DisplayManagerMessage::TRANS_ID_SCREEN_STOP_MIRROR: {
397 std::vector<ScreenId> mirrorScreenIds;
398 if (!data.ReadUInt64Vector(&mirrorScreenIds)) {
399 WLOGE("fail to receive mirror screens in stub.");
400 break;
401 }
402 DMError ret = StopMirror(mirrorScreenIds);
403 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
404 break;
405 }
406 case DisplayManagerMessage::TRANS_ID_SCREEN_DISABLE_MIRROR: {
407 DMError ret = DisableMirror(data.ReadBool());
408 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
409 break;
410 }
411 case DisplayManagerMessage::TRANS_ID_SCREEN_MAKE_EXPAND: {
412 std::vector<ScreenId> screenId;
413 if (!data.ReadUInt64Vector(&screenId)) {
414 WLOGE("fail to receive expand screen in stub.");
415 break;
416 }
417 std::vector<Point> startPoint;
418 if (!MarshallingHelper::UnmarshallingVectorObj<Point>(data, startPoint, [](Parcel& parcel, Point& point) {
419 return parcel.ReadInt32(point.posX_) && parcel.ReadInt32(point.posY_);
420 })) {
421 WLOGE("fail to receive startPoint in stub.");
422 break;
423 }
424 ScreenId screenGroupId = INVALID_SCREEN_ID;
425 DMError ret = MakeExpand(screenId, startPoint, screenGroupId);
426 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
427 static_cast<void>(reply.WriteUint64(static_cast<uint64_t>(screenGroupId)));
428 break;
429 }
430 case DisplayManagerMessage::TRANS_ID_SCREEN_STOP_EXPAND: {
431 std::vector<ScreenId> expandScreenIds;
432 if (!data.ReadUInt64Vector(&expandScreenIds)) {
433 WLOGE("fail to receive expand screens in stub.");
434 break;
435 }
436 DMError ret = StopExpand(expandScreenIds);
437 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
438 break;
439 }
440 case DisplayManagerMessage::TRANS_ID_GET_SCREEN_GROUP_INFO_BY_ID: {
441 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
442 auto screenGroupInfo = GetScreenGroupInfoById(screenId);
443 reply.WriteStrongParcelable(screenGroupInfo);
444 break;
445 }
446 case DisplayManagerMessage::TRANS_ID_REMOVE_VIRTUAL_SCREEN_FROM_SCREEN_GROUP: {
447 std::vector<ScreenId> screenId;
448 if (!data.ReadUInt64Vector(&screenId)) {
449 WLOGE("fail to receive screens in stub.");
450 break;
451 }
452 RemoveVirtualScreenFromGroup(screenId);
453 break;
454 }
455 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_SNAPSHOT: {
456 DisplayId displayId = data.ReadUint64();
457 DmErrorCode errCode = DmErrorCode::DM_OK;
458 bool isUseDma = data.ReadBool();
459 std::shared_ptr<Media::PixelMap> displaySnapshot = GetDisplaySnapshot(displayId, &errCode, isUseDma);
460 reply.WriteParcelable(displaySnapshot == nullptr ? nullptr : displaySnapshot.get());
461 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(errCode)));
462 break;
463 }
464 case DisplayManagerMessage::TRANS_ID_GET_SNAPSHOT_BY_PICKER: {
465 ProcGetSnapshotByPicker(reply);
466 break;
467 }
468 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_ACTIVE_MODE: {
469 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
470 uint32_t modeId = data.ReadUint32();
471 DMError ret = SetScreenActiveMode(screenId, modeId);
472 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
473 break;
474 }
475 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_PIXEL_RATIO: {
476 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
477 float virtualPixelRatio = data.ReadFloat();
478 DMError ret = SetVirtualPixelRatio(screenId, virtualPixelRatio);
479 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
480 break;
481 }
482 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_PIXEL_RATIO_SYSTEM: {
483 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
484 float virtualPixelRatio = data.ReadFloat();
485 DMError ret = SetVirtualPixelRatioSystem(screenId, virtualPixelRatio);
486 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
487 break;
488 }
489 case DisplayManagerMessage::TRANS_ID_SET_DEFAULT_DENSITY_DPI: {
490 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
491 float virtualPixelRatio = data.ReadFloat();
492 DMError ret = SetDefaultDensityDpi(screenId, virtualPixelRatio);
493 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
494 break;
495 }
496 case DisplayManagerMessage::TRANS_ID_SET_RESOLUTION: {
497 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
498 uint32_t width = data.ReadUint32();
499 uint32_t height = data.ReadUint32();
500 float virtualPixelRatio = data.ReadFloat();
501 DMError ret = SetResolution(screenId, width, height, virtualPixelRatio);
502 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
503 break;
504 }
505 case DisplayManagerMessage::TRANS_ID_GET_DENSITY_IN_CURRENT_RESOLUTION: {
506 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
507 float virtualPixelRatio;
508 DMError ret = GetDensityInCurResolution(screenId, virtualPixelRatio);
509 reply.WriteFloat(virtualPixelRatio);
510 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
511 break;
512 }
513 case DisplayManagerMessage::TRANS_ID_SCREEN_GET_COLOR_GAMUT: {
514 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
515 ScreenColorGamut colorGamut;
516 DMError ret = GetScreenColorGamut(screenId, colorGamut);
517 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
518 if (ret != DMError::DM_OK) {
519 break;
520 }
521 static_cast<void>(reply.WriteUint32(static_cast<uint32_t>(colorGamut)));
522 break;
523 }
524 case DisplayManagerMessage::TRANS_ID_SCREEN_SET_COLOR_GAMUT: {
525 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
526 int32_t colorGamutIdx = data.ReadInt32();
527 DMError ret = SetScreenColorGamut(screenId, colorGamutIdx);
528 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
529 break;
530 }
531 case DisplayManagerMessage::TRANS_ID_SCREEN_GET_GAMUT_MAP: {
532 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
533 ScreenGamutMap gamutMap;
534 DMError ret = GetScreenGamutMap(screenId, gamutMap);
535 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
536 if (ret != DMError::DM_OK) {
537 break;
538 }
539 static_cast<void>(reply.WriteInt32(static_cast<uint32_t>(gamutMap)));
540 break;
541 }
542 case DisplayManagerMessage::TRANS_ID_SCREEN_SET_GAMUT_MAP: {
543 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
544 ScreenGamutMap gamutMap = static_cast<ScreenGamutMap>(data.ReadUint32());
545 DMError ret = SetScreenGamutMap(screenId, gamutMap);
546 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
547 break;
548 }
549 case DisplayManagerMessage::TRANS_ID_SCREEN_SET_COLOR_TRANSFORM: {
550 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
551 DMError ret = SetScreenColorTransform(screenId);
552 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
553 break;
554 }
555 case DisplayManagerMessage::TRANS_ID_SCREEN_GET_PIXEL_FORMAT: {
556 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
557 GraphicPixelFormat pixelFormat;
558 DMError ret = GetPixelFormat(screenId, pixelFormat);
559 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
560 if (ret != DMError::DM_OK) {
561 break;
562 }
563 static_cast<void>(reply.WriteInt32(static_cast<uint32_t>(pixelFormat)));
564 break;
565 }
566 case DisplayManagerMessage::TRANS_ID_SCREEN_SET_PIXEL_FORMAT: {
567 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
568 GraphicPixelFormat pixelFormat = static_cast<GraphicPixelFormat>(data.ReadUint32());
569 DMError ret = SetPixelFormat(screenId, pixelFormat);
570 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
571 break;
572 }
573 case DisplayManagerMessage::TRANS_ID_SCREEN_GET_SUPPORTED_HDR_FORMAT: {
574 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
575 std::vector<ScreenHDRFormat> hdrFormats;
576 DMError ret = GetSupportedHDRFormats(screenId, hdrFormats);
577 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
578 if (ret != DMError::DM_OK) {
579 break;
580 }
581 MarshallingHelper::MarshallingVectorObj<ScreenHDRFormat>(reply, hdrFormats,
582 [](Parcel& parcel, const ScreenHDRFormat& hdrFormat) {
583 return parcel.WriteUint32(static_cast<uint32_t>(hdrFormat));
584 }
585 );
586 break;
587 }
588 case DisplayManagerMessage::TRANS_ID_SCREEN_GET_HDR_FORMAT: {
589 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
590 ScreenHDRFormat hdrFormat;
591 DMError ret = GetScreenHDRFormat(screenId, hdrFormat);
592 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
593 if (ret != DMError::DM_OK) {
594 break;
595 }
596 static_cast<void>(reply.WriteInt32(static_cast<uint32_t>(hdrFormat)));
597 break;
598 }
599 case DisplayManagerMessage::TRANS_ID_SCREEN_SET_HDR_FORMAT: {
600 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
601 int32_t modeIdx = data.ReadInt32();
602 DMError ret = SetScreenHDRFormat(screenId, modeIdx);
603 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
604 break;
605 }
606 case DisplayManagerMessage::TRANS_ID_SCREEN_GET_SUPPORTED_COLOR_SPACE: {
607 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
608 std::vector<GraphicCM_ColorSpaceType> colorSpaces;
609 DMError ret = GetSupportedColorSpaces(screenId, colorSpaces);
610 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
611 if (ret != DMError::DM_OK) {
612 break;
613 }
614 MarshallingHelper::MarshallingVectorObj<GraphicCM_ColorSpaceType>(reply, colorSpaces,
615 [](Parcel& parcel, const GraphicCM_ColorSpaceType& color) {
616 return parcel.WriteUint32(static_cast<uint32_t>(color));
617 }
618 );
619 break;
620 }
621 case DisplayManagerMessage::TRANS_ID_SCREEN_GET_COLOR_SPACE: {
622 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
623 GraphicCM_ColorSpaceType colorSpace;
624 DMError ret = GetScreenColorSpace(screenId, colorSpace);
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>(colorSpace)));
630 break;
631 }
632 case DisplayManagerMessage::TRANS_ID_SCREEN_SET_COLOR_SPACE: {
633 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
634 GraphicCM_ColorSpaceType colorSpace = static_cast<GraphicCM_ColorSpaceType>(data.ReadUint32());
635 DMError ret = SetScreenColorSpace(screenId, colorSpace);
636 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
637 break;
638 }
639 case DisplayManagerMessage::TRANS_ID_SET_ORIENTATION: {
640 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
641 Orientation orientation = static_cast<Orientation>(data.ReadUint32());
642 DMError ret = SetOrientation(screenId, orientation);
643 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
644 break;
645 }
646 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_ROTATION_LOCKED: {
647 bool isLocked = static_cast<bool>(data.ReadBool());
648 DMError ret = SetScreenRotationLocked(isLocked);
649 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
650 break;
651 }
652 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_ROTATION_LOCKED_FROM_JS: {
653 bool isLocked = static_cast<bool>(data.ReadBool());
654 DMError ret = SetScreenRotationLockedFromJs(isLocked);
655 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
656 break;
657 }
658 case DisplayManagerMessage::TRANS_ID_IS_SCREEN_ROTATION_LOCKED: {
659 bool isLocked = false;
660 DMError ret = IsScreenRotationLocked(isLocked);
661 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
662 reply.WriteBool(isLocked);
663 break;
664 }
665 case DisplayManagerMessage::TRANS_ID_GET_CUTOUT_INFO: {
666 DisplayId displayId = static_cast<DisplayId>(data.ReadUint64());
667 sptr<CutoutInfo> cutoutInfo = GetCutoutInfo(displayId);
668 reply.WriteParcelable(cutoutInfo);
669 break;
670 }
671 case DisplayManagerMessage::TRANS_ID_HAS_PRIVATE_WINDOW: {
672 DisplayId id = static_cast<DisplayId>(data.ReadUint64());
673 bool hasPrivateWindow = false;
674 DMError ret = HasPrivateWindow(id, hasPrivateWindow);
675 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
676 reply.WriteBool(hasPrivateWindow);
677 break;
678 }
679 case DisplayManagerMessage::TRANS_ID_CONVERT_SCREENID_TO_RSSCREENID: {
680 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
681 ScreenId rsId = SCREEN_ID_INVALID;
682 bool ret = ConvertScreenIdToRsScreenId(screenId, rsId);
683 reply.WriteBool(ret);
684 static_cast<void>(reply.WriteUint64(rsId));
685 break;
686 }
687 case DisplayManagerMessage::TRANS_ID_HAS_IMMERSIVE_WINDOW: {
688 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
689 bool immersive = false;
690 DMError ret = HasImmersiveWindow(screenId, immersive);
691 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
692 reply.WriteBool(immersive);
693 break;
694 }
695 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_DUMP_ALL_SCREEN: {
696 std::string dumpInfo;
697 DumpAllScreensInfo(dumpInfo);
698 static_cast<void>(reply.WriteString(dumpInfo));
699 break;
700 }
701 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_DUMP_SPECIAL_SCREEN: {
702 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
703 std::string dumpInfo;
704 DumpSpecialScreenInfo(screenId, dumpInfo);
705 static_cast<void>(reply.WriteString(dumpInfo));
706 break;
707 }
708 case DisplayManagerMessage::TRANS_ID_DEVICE_IS_CAPTURE: {
709 reply.WriteBool(IsCaptured());
710 break;
711 }
712 //Fold Screen
713 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_SET_FOLD_DISPLAY_MODE: {
714 FoldDisplayMode displayMode = static_cast<FoldDisplayMode>(data.ReadUint32());
715 SetFoldDisplayMode(displayMode);
716 break;
717 }
718 case DisplayManagerMessage::TRANS_ID_SET_FOLD_DISPLAY_MODE_FROM_JS: {
719 FoldDisplayMode displayMode = static_cast<FoldDisplayMode>(data.ReadUint32());
720 std::string reason = data.ReadString();
721 DMError ret = SetFoldDisplayModeFromJs(displayMode, reason);
722 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
723 break;
724 }
725 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_LOCK_FOLD_DISPLAY_STATUS: {
726 bool lockDisplayStatus = static_cast<bool>(data.ReadUint32());
727 SetFoldStatusLocked(lockDisplayStatus);
728 break;
729 }
730 case DisplayManagerMessage::TRANS_ID_SET_LOCK_FOLD_DISPLAY_STATUS_FROM_JS: {
731 bool lockDisplayStatus = static_cast<bool>(data.ReadUint32());
732 DMError ret = SetFoldStatusLockedFromJs(lockDisplayStatus);
733 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
734 break;
735 }
736 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_SET_DISPLAY_SCALE: {
737 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
738 auto scaleX = data.ReadFloat();
739 auto scaleY = data.ReadFloat();
740 auto pivotX = data.ReadFloat();
741 auto pivotY = data.ReadFloat();
742 SetDisplayScale(screenId, scaleX, scaleY, pivotX, pivotY);
743 break;
744 }
745 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_GET_FOLD_DISPLAY_MODE: {
746 FoldDisplayMode displayMode = GetFoldDisplayMode();
747 static_cast<void>(reply.WriteUint32(static_cast<uint32_t>(displayMode)));
748 break;
749 }
750 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_IS_FOLDABLE: {
751 reply.WriteBool(IsFoldable());
752 break;
753 }
754 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_GET_FOLD_STATUS: {
755 static_cast<void>(reply.WriteUint32(static_cast<uint32_t>(GetFoldStatus())));
756 break;
757 }
758 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_GET_SUPER_FOLD_STATUS: {
759 static_cast<void>(reply.WriteUint32(static_cast<uint32_t>(GetSuperFoldStatus())));
760 break;
761 }
762 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_LANDSCAPE_LOCK_STATUS: {
763 bool isLocked = data.ReadBool();
764 SetLandscapeLockStatus(isLocked);
765 break;
766 }
767 case DisplayManagerMessage::TRANS_ID_GET_EXTEND_SCREEN_CONNECT_STATUS: {
768 static_cast<void>(reply.WriteUint32(static_cast<uint32_t>(GetExtendScreenConnectStatus())));
769 break;
770 }
771 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_GET_CURRENT_FOLD_CREASE_REGION: {
772 reply.WriteStrongParcelable(GetCurrentFoldCreaseRegion());
773 break;
774 }
775 case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_MAKE_UNIQUE_SCREEN: {
776 std::vector<ScreenId> uniqueScreenIds;
777 uint32_t size = data.ReadUint32();
778 if (size > MAX_SCREEN_SIZE) {
779 WLOGFE("screenIds size is bigger than %{public}u", MAX_SCREEN_SIZE);
780 break;
781 }
782 if (!data.ReadUInt64Vector(&uniqueScreenIds)) {
783 WLOGFE("failed to receive unique screens in stub");
784 break;
785 }
786 std::vector<DisplayId> displayIds;
787 DMError ret = MakeUniqueScreen(uniqueScreenIds, displayIds);
788 reply.WriteUInt64Vector(displayIds);
789 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
790 break;
791 }
792 case DisplayManagerMessage::TRANS_ID_SET_CLIENT: {
793 auto remoteObject = data.ReadRemoteObject();
794 auto clientProxy = iface_cast<IScreenSessionManagerClient>(remoteObject);
795 if (clientProxy == nullptr) {
796 WLOGFE("clientProxy is null");
797 break;
798 }
799 SetClient(clientProxy);
800 break;
801 }
802 case DisplayManagerMessage::TRANS_ID_GET_SCREEN_PROPERTY: {
803 auto screenId = static_cast<ScreenId>(data.ReadUint64());
804 if (!RSMarshallingHelper::Marshalling(reply, GetScreenProperty(screenId))) {
805 WLOGFE("Write screenProperty failed");
806 }
807 break;
808 }
809 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_NODE: {
810 auto screenId = static_cast<ScreenId>(data.ReadUint64());
811 auto displayNode = GetDisplayNode(screenId);
812 if (!displayNode || !displayNode->Marshalling(reply)) {
813 WLOGFE("Write displayNode failed");
814 }
815 break;
816 }
817 case DisplayManagerMessage::TRANS_ID_GET_SCREEN_COMBINATION: {
818 auto screenId = static_cast<ScreenId>(data.ReadUint64());
819 auto screenCombination = GetScreenCombination(screenId);
820 reply.WriteUint32(static_cast<uint32_t>(screenCombination));
821 break;
822 }
823 case DisplayManagerMessage::TRANS_ID_UPDATE_SCREEN_DIRECTION_INFO: {
824 auto screenId = static_cast<ScreenId>(data.ReadUint64());
825 auto screenComponentRotation = data.ReadFloat();
826 auto rotation = data.ReadFloat();
827 auto phyRotation = data.ReadFloat();
828 auto screenPropertyChangeType = static_cast<ScreenPropertyChangeType>(data.ReadUint32());
829 UpdateScreenDirectionInfo(screenId, screenComponentRotation, rotation, phyRotation,
830 screenPropertyChangeType);
831 break;
832 }
833 case DisplayManagerMessage::TRANS_ID_UPDATE_SCREEN_ROTATION_PROPERTY: {
834 auto screenId = static_cast<ScreenId>(data.ReadUint64());
835 RRect bounds;
836 if (!RSMarshallingHelper::Unmarshalling(data, bounds)) {
837 WLOGFE("Read bounds failed");
838 break;
839 }
840 auto rotation = data.ReadFloat();
841 auto screenPropertyChangeType = static_cast<ScreenPropertyChangeType>(data.ReadUint32());
842 UpdateScreenRotationProperty(screenId, bounds, rotation, screenPropertyChangeType);
843 break;
844 }
845 case DisplayManagerMessage::TRANS_ID_GET_CURVED_SCREEN_COMPRESSION_AREA: {
846 auto area = GetCurvedCompressionArea();
847 static_cast<void>(reply.WriteUint32(area));
848 break;
849 }
850 case DisplayManagerMessage::TRANS_ID_GET_PHY_SCREEN_PROPERTY: {
851 auto screenId = static_cast<ScreenId>(data.ReadUint64());
852 if (!RSMarshallingHelper::Marshalling(reply, GetPhyScreenProperty(screenId))) {
853 WLOGFE("Write screenProperty failed");
854 }
855 break;
856 }
857 case DisplayManagerMessage::TRANS_ID_NOTIFY_DISPLAY_CHANGE_INFO: {
858 sptr<DisplayChangeInfo> info = DisplayChangeInfo::Unmarshalling(data);
859 if (!info) {
860 WLOGFE("Read DisplayChangeInfo failed");
861 return ERR_INVALID_DATA;
862 }
863 NotifyDisplayChangeInfoChanged(info);
864 break;
865 }
866 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_PRIVACY_STATE: {
867 auto hasPrivate = data.ReadBool();
868 SetScreenPrivacyState(hasPrivate);
869 break;
870 }
871 case DisplayManagerMessage::TRANS_ID_SET_SCREENID_PRIVACY_STATE: {
872 DisplayId displayId = static_cast<DisplayId>(data.ReadUint64());
873 auto hasPrivate = data.ReadBool();
874 SetPrivacyStateByDisplayId(displayId, hasPrivate);
875 break;
876 }
877 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_PRIVACY_WINDOW_LIST: {
878 DisplayId displayId = static_cast<DisplayId>(data.ReadUint64());
879 std::vector<std::string> privacyWindowList;
880 data.ReadStringVector(&privacyWindowList);
881 SetScreenPrivacyWindowList(displayId, privacyWindowList);
882 break;
883 }
884 case DisplayManagerMessage::TRANS_ID_RESIZE_VIRTUAL_SCREEN: {
885 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
886 uint32_t width = data.ReadUint32();
887 uint32_t height = data.ReadUint32();
888 DMError ret = ResizeVirtualScreen(screenId, width, height);
889 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
890 break;
891 }
892 case DisplayManagerMessage::TRANS_ID_UPDATE_AVAILABLE_AREA: {
893 auto screenId = static_cast<ScreenId>(data.ReadUint64());
894 int32_t posX = data.ReadInt32();
895 int32_t posY = data.ReadInt32();
896 uint32_t width = data.ReadUint32();
897 uint32_t height = data.ReadUint32();
898 DMRect area = {posX, posY, width, height};
899 UpdateAvailableArea(screenId, area);
900 break;
901 }
902 case DisplayManagerMessage::TRANS_ID_UPDATE_SUPER_FOLD_AVAILABLE_AREA: {
903 auto screenId = static_cast<ScreenId>(data.ReadUint64());
904 int32_t bPosX = data.ReadInt32();
905 int32_t bPosY = data.ReadInt32();
906 uint32_t bWidth = data.ReadUint32();
907 uint32_t bHeight = data.ReadUint32();
908 DMRect bArea = {bPosX, bPosY, bWidth, bHeight};
909 int32_t cPosX = data.ReadInt32();
910 int32_t cPosY = data.ReadInt32();
911 uint32_t cWidth = data.ReadUint32();
912 uint32_t cHeight = data.ReadUint32();
913 DMRect cArea = {cPosX, cPosY, cWidth, cHeight};
914 UpdateSuperFoldAvailableArea(screenId, bArea, cArea);
915 break;
916 }
917 case DisplayManagerMessage::TRANS_ID_UPDATE_SUPER_FOLD_EXPAND_AVAILABLE_AREA: {
918 auto screenId = static_cast<ScreenId>(data.ReadUint64());
919 int32_t posX = data.ReadInt32();
920 int32_t posY = data.ReadInt32();
921 uint32_t width = data.ReadUint32();
922 uint32_t height = data.ReadUint32();
923 DMRect area = {posX, posY, width, height};
924 UpdateSuperFoldExpandAvailableArea(screenId, area);
925 break;
926 }
927 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_OFF_DELAY_TIME: {
928 int32_t delay = data.ReadInt32();
929 int32_t ret = SetScreenOffDelayTime(delay);
930 static_cast<void>(reply.WriteInt32(ret));
931 break;
932 }
933 case DisplayManagerMessage::TRANS_ID_GET_AVAILABLE_AREA: {
934 ProcGetAvailableArea(data, reply);
935 break;
936 }
937 case DisplayManagerMessage::TRANS_ID_GET_EXPAND_AVAILABLE_AREA: {
938 DisplayId displayId = static_cast<DisplayId>(data.ReadUint64());
939 DMRect area;
940 DMError ret = GetExpandAvailableArea(displayId, area);
941 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
942 static_cast<void>(reply.WriteInt32(area.posX_));
943 static_cast<void>(reply.WriteInt32(area.posY_));
944 static_cast<void>(reply.WriteUint32(area.width_));
945 static_cast<void>(reply.WriteUint32(area.height_));
946 break;
947 }
948 case DisplayManagerMessage::TRANS_ID_NOTIFY_FOLD_TO_EXPAND_COMPLETION: {
949 bool foldToExpand = data.ReadBool();
950 NotifyFoldToExpandCompletion(foldToExpand);
951 break;
952 }
953 case DisplayManagerMessage::TRANS_ID_GET_VIRTUAL_SCREEN_FLAG: {
954 ProcGetVirtualScreenFlag(data, reply);
955 break;
956 }
957 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_FLAG: {
958 ProcSetVirtualScreenFlag(data, reply);
959 break;
960 }
961 case DisplayManagerMessage::TRANS_ID_GET_DEVICE_SCREEN_CONFIG: {
962 if (!RSMarshallingHelper::Marshalling(reply, GetDeviceScreenConfig())) {
963 TLOGE(WmsLogTag::DMS, "Write deviceScreenConfig failed");
964 }
965 break;
966 }
967 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_REFRESH_RATE: {
968 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
969 uint32_t refreshInterval = data.ReadUint32();
970 DMError ret = SetVirtualScreenRefreshRate(screenId, refreshInterval);
971 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
972 break;
973 }
974 case DisplayManagerMessage::TRANS_ID_SWITCH_USER: {
975 SwitchUser();
976 break;
977 }
978 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_BLACK_LIST: {
979 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
980 std::vector<uint64_t> windowIdList;
981 if (!data.ReadUInt64Vector(&windowIdList)) {
982 TLOGE(WmsLogTag::DMS, "Failed to receive windowIdList in stub");
983 break;
984 }
985 std::vector<uint64_t> surfaceIdList;
986 if (!data.ReadUInt64Vector(&surfaceIdList)) {
987 TLOGE(WmsLogTag::DMS, "Failed to receive surfaceIdList in stub");
988 break;
989 }
990 SetVirtualScreenBlackList(screenId, windowIdList, surfaceIdList);
991 break;
992 }
993 case DisplayManagerMessage::TRANS_ID_DISABLE_POWEROFF_RENDER_CONTROL: {
994 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
995 DisablePowerOffRenderControl(screenId);
996 break;
997 }
998 case DisplayManagerMessage::TRANS_ID_PROXY_FOR_FREEZE: {
999 ProcProxyForFreeze(data, reply);
1000 break;
1001 }
1002 case DisplayManagerMessage::TRANS_ID_RESET_ALL_FREEZE_STATUS: {
1003 DMError ret = ResetAllFreezeStatus();
1004 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
1005 break;
1006 }
1007 case DisplayManagerMessage::TRANS_ID_NOTIFY_DISPLAY_HOOK_INFO: {
1008 int32_t uid = data.ReadInt32();
1009 bool enable = data.ReadBool();
1010 DMHookInfo hookInfo;
1011 hookInfo.width_ = data.ReadUint32();
1012 hookInfo.height_ = data.ReadUint32();
1013 hookInfo.density_ = data.ReadFloat();
1014 hookInfo.rotation_ = data.ReadUint32();
1015 hookInfo.enableHookRotation_ = data.ReadBool();
1016 UpdateDisplayHookInfo(uid, enable, hookInfo);
1017 break;
1018 }
1019 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_HOOK_INFO: {
1020 int32_t uid = data.ReadInt32();
1021 DMHookInfo hookInfo;
1022 GetDisplayHookInfo(uid, hookInfo);
1023 static_cast<void>(reply.WriteUint32(hookInfo.width_));
1024 static_cast<void>(reply.WriteUint32(hookInfo.height_));
1025 static_cast<void>(reply.WriteFloat(hookInfo.density_));
1026 static_cast<void>(reply.WriteUint32(hookInfo.width_));
1027 static_cast<void>(reply.WriteBool(hookInfo.enableHookRotation_));
1028 break;
1029 }
1030 case DisplayManagerMessage::TRANS_ID_GET_ALL_PHYSICAL_DISPLAY_RESOLUTION: {
1031 ProcGetAllDisplayPhysicalResolution(data, reply);
1032 break;
1033 }
1034 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_STATUS: {
1035 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
1036 VirtualScreenStatus screenStatus = static_cast<VirtualScreenStatus>(data.ReadInt32());
1037 bool res = SetVirtualScreenStatus(screenId, screenStatus);
1038 reply.WriteBool(res);
1039 break;
1040 }
1041 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_SECURITY_EXEMPTION: {
1042 ProcSetVirtualScreenSecurityExemption(data, reply);
1043 break;
1044 }
1045 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_MAX_REFRESHRATE: {
1046 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
1047 uint32_t refreshRate = data.ReadUint32();
1048 uint32_t actualRefreshRate;
1049 DMError ret = SetVirtualScreenMaxRefreshRate(screenId, refreshRate, actualRefreshRate);
1050 reply.WriteUint32(actualRefreshRate);
1051 reply.WriteInt32(static_cast<int32_t>(ret));
1052 break;
1053 }
1054 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_CAPTURE: {
1055 ProcGetScreenCapture(data, reply);
1056 break;
1057 }
1058 case DisplayManagerMessage::TRANS_ID_GET_PRIMARY_DISPLAY_INFO: {
1059 auto info = GetPrimaryDisplayInfo();
1060 reply.WriteParcelable(info);
1061 break;
1062 }
1063 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_SNAPSHOT_WITH_OPTION: {
1064 ProcGetDisplaySnapshotWithOption(data, reply);
1065 break;
1066 }
1067 case DisplayManagerMessage::TRANS_ID_SET_CAMERA_STATUS: {
1068 int32_t cameraStatus = data.ReadInt32();
1069 int32_t cameraPosition = data.ReadInt32();
1070 SetCameraStatus(cameraStatus, cameraPosition);
1071 break;
1072 }
1073 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_ON_DELAY_TIME: {
1074 int32_t delay = data.ReadInt32();
1075 int32_t ret = SetScreenOnDelayTime(delay);
1076 static_cast<void>(reply.WriteInt32(ret));
1077 break;
1078 }
1079 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_SKIP_PROTECTED_WINDOW: {
1080 ProcSetScreenSkipProtectedWindow(data, reply);
1081 break;
1082 }
1083 case DisplayManagerMessage::TRANS_ID_RECORD_EVENT_FROM_SCB: {
1084 std::string description = data.ReadString();
1085 bool needRecordEvent = data.ReadBool();
1086 RecordEventFromScb(description, needRecordEvent);
1087 break;
1088 }
1089 case DisplayManagerMessage::TRANS_ID_IS_ORIENTATION_NEED_CHANGE: {
1090 reply.WriteBool(IsOrientationNeedChanged());
1091 break;
1092 }
1093 case DisplayManagerMessage::TRANS_ID_GET_IS_REAL_SCREEN: {
1094 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
1095 reply.WriteBool(GetIsRealScreen(screenId));
1096 break;
1097 }
1098 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_CAPABILITY: {
1099 std::string capabilitInfo;
1100 DMError ret = GetDisplayCapability(capabilitInfo);
1101 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
1102 reply.WriteString(capabilitInfo);
1103 break;
1104 }
1105 case DisplayManagerMessage::TRANS_ID_SET_SYSTEM_KEYBOARD_ON: {
1106 bool isOn = static_cast<bool>(data.ReadBool());
1107 DMError ret = SetSystemKeyboardStatus(isOn);
1108 reply.WriteInt32(static_cast<int32_t>(ret));
1109 break;
1110 }
1111 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_DISPLAY_MUTE_FLAG: {
1112 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
1113 bool muteFlag = data.ReadBool();
1114 SetVirtualDisplayMuteFlag(screenId, muteFlag);
1115 break;
1116 }
1117 default:
1118 WLOGFW("unknown transaction code");
1119 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
1120 }
1121 return ERR_NONE;
1122 }
1123
ProcGetAvailableArea(MessageParcel & data,MessageParcel & reply)1124 void ScreenSessionManagerStub::ProcGetAvailableArea(MessageParcel& data, MessageParcel& reply)
1125 {
1126 DisplayId displayId = static_cast<DisplayId>(data.ReadUint64());
1127 DMRect area;
1128 DMError ret = GetAvailableArea(displayId, area);
1129 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
1130 static_cast<void>(reply.WriteInt32(area.posX_));
1131 static_cast<void>(reply.WriteInt32(area.posY_));
1132 static_cast<void>(reply.WriteUint32(area.width_));
1133 static_cast<void>(reply.WriteUint32(area.height_));
1134 }
1135
ProcGetSnapshotByPicker(MessageParcel & reply)1136 void ScreenSessionManagerStub::ProcGetSnapshotByPicker(MessageParcel& reply)
1137 {
1138 DmErrorCode errCode = DmErrorCode::DM_OK;
1139 Media::Rect imgRect { 0, 0, 0, 0 };
1140 std::shared_ptr<Media::PixelMap> snapshot = GetSnapshotByPicker(imgRect, &errCode);
1141 reply.WriteParcelable(snapshot == nullptr ? nullptr : snapshot.get());
1142 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(errCode)));
1143 static_cast<void>(reply.WriteInt32(imgRect.left));
1144 static_cast<void>(reply.WriteInt32(imgRect.top));
1145 static_cast<void>(reply.WriteInt32(imgRect.width));
1146 static_cast<void>(reply.WriteInt32(imgRect.height));
1147 }
1148
ProcSetVirtualScreenFlag(MessageParcel & data,MessageParcel & reply)1149 void ScreenSessionManagerStub::ProcSetVirtualScreenFlag(MessageParcel& data, MessageParcel& reply)
1150 {
1151 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
1152 VirtualScreenFlag screenFlag = static_cast<VirtualScreenFlag>(data.ReadUint32());
1153 DMError setRet = SetVirtualScreenFlag(screenId, screenFlag);
1154 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(setRet)));
1155 }
1156
ProcGetVirtualScreenFlag(MessageParcel & data,MessageParcel & reply)1157 void ScreenSessionManagerStub::ProcGetVirtualScreenFlag(MessageParcel& data, MessageParcel& reply)
1158 {
1159 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
1160 VirtualScreenFlag screenFlag = GetVirtualScreenFlag(screenId);
1161 static_cast<void>(reply.WriteUint32(static_cast<uint32_t>(screenFlag)));
1162 }
1163
ProcProxyForFreeze(MessageParcel & data,MessageParcel & reply)1164 void ScreenSessionManagerStub::ProcProxyForFreeze(MessageParcel& data, MessageParcel& reply)
1165 {
1166 std::set<int32_t> pidList;
1167 int32_t size = data.ReadInt32();
1168 if (size > MAX_BUFF_SIZE) {
1169 WLOGFE("pid List size invalid: %{public}d", size);
1170 size = MAX_BUFF_SIZE;
1171 }
1172 for (int32_t i = 0; i < size; i++) {
1173 pidList.insert(data.ReadInt32());
1174 }
1175 bool isProxy = data.ReadBool();
1176 DMError ret = ProxyForFreeze(pidList, isProxy);
1177 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
1178 }
1179
ProcGetAllDisplayPhysicalResolution(MessageParcel & data,MessageParcel & reply)1180 void ScreenSessionManagerStub::ProcGetAllDisplayPhysicalResolution(MessageParcel& data, MessageParcel& reply)
1181 {
1182 auto physicalInfos = GetAllDisplayPhysicalResolution();
1183 size_t infoSize = physicalInfos.size();
1184 bool writeRet = reply.WriteInt32(static_cast<int32_t>(infoSize));
1185 if (!writeRet) {
1186 WLOGFE("write physical size error");
1187 return;
1188 }
1189 for (const auto &physicalItem : physicalInfos) {
1190 writeRet = reply.WriteUint32(static_cast<uint32_t>(physicalItem.foldDisplayMode_));
1191 if (!writeRet) {
1192 WLOGFE("write display mode error");
1193 break;
1194 }
1195 writeRet = reply.WriteUint32(physicalItem.physicalWidth_);
1196 if (!writeRet) {
1197 WLOGFE("write physical width error");
1198 break;
1199 }
1200 writeRet = reply.WriteUint32(physicalItem.physicalHeight_);
1201 if (!writeRet) {
1202 WLOGFE("write physical height error");
1203 break;
1204 }
1205 }
1206 }
1207
ProcSetVirtualScreenSecurityExemption(MessageParcel & data,MessageParcel & reply)1208 void ScreenSessionManagerStub::ProcSetVirtualScreenSecurityExemption(MessageParcel& data, MessageParcel& reply)
1209 {
1210 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
1211 uint32_t pid = data.ReadUint32();
1212 std::vector<uint64_t> windowIdList;
1213 data.ReadUInt64Vector(&windowIdList);
1214 DMError ret = SetVirtualScreenSecurityExemption(screenId, pid, windowIdList);
1215 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(ret)));
1216 }
1217
ProcGetScreenCapture(MessageParcel & data,MessageParcel & reply)1218 void ScreenSessionManagerStub::ProcGetScreenCapture(MessageParcel& data, MessageParcel& reply)
1219 {
1220 CaptureOption option;
1221 option.displayId_ = static_cast<DisplayId>(data.ReadUint64());
1222 option.isNeedNotify_ = static_cast<bool>(data.ReadBool());
1223 option.isNeedPointer_ = static_cast<bool>(data.ReadBool());
1224 DmErrorCode errCode = DmErrorCode::DM_OK;
1225 std::shared_ptr<Media::PixelMap> capture = GetScreenCapture(option, &errCode);
1226 reply.WriteParcelable(capture == nullptr ? nullptr : capture.get());
1227 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(errCode)));
1228 }
1229
ProcGetDisplaySnapshotWithOption(MessageParcel & data,MessageParcel & reply)1230 void ScreenSessionManagerStub::ProcGetDisplaySnapshotWithOption(MessageParcel& data, MessageParcel& reply)
1231 {
1232 CaptureOption option;
1233 option.displayId_ = static_cast<DisplayId>(data.ReadUint64());
1234 option.isNeedNotify_ = static_cast<bool>(data.ReadBool());
1235 option.isNeedPointer_ = static_cast<bool>(data.ReadBool());
1236 DmErrorCode errCode = DmErrorCode::DM_OK;
1237 std::shared_ptr<Media::PixelMap> capture = GetDisplaySnapshotWithOption(option, &errCode);
1238 reply.WriteParcelable(capture == nullptr ? nullptr : capture.get());
1239 static_cast<void>(reply.WriteInt32(static_cast<int32_t>(errCode)));
1240 }
1241
ProcSetScreenSkipProtectedWindow(MessageParcel & data,MessageParcel & reply)1242 void ScreenSessionManagerStub::ProcSetScreenSkipProtectedWindow(MessageParcel& data, MessageParcel& reply)
1243 {
1244 std::vector<ScreenId> screenIds;
1245 if (!data.ReadUInt64Vector(&screenIds)) {
1246 TLOGE(WmsLogTag::DMS, "Read screenIds failed");
1247 return;
1248 }
1249 bool isEnable = static_cast<bool>(data.ReadBool());
1250 DMError ret = SetScreenSkipProtectedWindow(screenIds, isEnable);
1251 reply.WriteInt32(static_cast<int32_t>(ret));
1252 }
1253 } // namespace OHOS::Rosen
1254