1 /*
2  * Copyright (c) 2021-2022 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 "display_manager_stub.h"
17 
18 #include "dm_common.h"
19 
20 #include <ipc_skeleton.h>
21 
22 #include "marshalling_helper.h"
23 #include "window_manager_hilog.h"
24 
25 #include "transaction/rs_interfaces.h"
26 
27 namespace OHOS::Rosen {
28 namespace {
29 constexpr HiviewDFX::HiLogLabel LABEL = {LOG_CORE, HILOG_DOMAIN_DISPLAY, "DisplayManagerStub"};
30 const static uint32_t MAX_SCREEN_SIZE = 32;
31 }
32 
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)33 int32_t DisplayManagerStub::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 -1;
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_GET_DISPLAY_BY_ID: {
49             DisplayId displayId = data.ReadUint64();
50             auto info = GetDisplayInfoById(displayId);
51             reply.WriteParcelable(info);
52             break;
53         }
54         case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_BY_SCREEN: {
55             ScreenId screenId = data.ReadUint64();
56             auto info = GetDisplayInfoByScreen(screenId);
57             reply.WriteParcelable(info);
58             break;
59         }
60         case DisplayManagerMessage::TRANS_ID_CREATE_VIRTUAL_SCREEN: {
61             std::string name = data.ReadString();
62             uint32_t width = data.ReadUint32();
63             uint32_t height = data.ReadUint32();
64             float density = data.ReadFloat();
65             int32_t flags = data.ReadInt32();
66             bool isForShot = data.ReadBool();
67             std::vector<uint64_t> missionIds;
68             data.ReadUInt64Vector(&missionIds);
69             bool isSurfaceValid = data.ReadBool();
70             sptr<Surface> surface = nullptr;
71             if (isSurfaceValid) {
72                 sptr<IRemoteObject> surfaceObject = data.ReadRemoteObject();
73                 sptr<IBufferProducer> bp = iface_cast<IBufferProducer>(surfaceObject);
74                 surface = Surface::CreateSurfaceAsProducer(bp);
75             }
76             sptr<IRemoteObject> virtualScreenAgent = data.ReadRemoteObject();
77             VirtualScreenOption virScrOption = {
78                 .name_ = name,
79                 .width_ = width,
80                 .height_ = height,
81                 .density_ = density,
82                 .surface_ = surface,
83                 .flags_ = flags,
84                 .isForShot_ = isForShot,
85                 .missionIds_ = missionIds
86             };
87             ScreenId screenId = CreateVirtualScreen(virScrOption, virtualScreenAgent);
88             reply.WriteUint64(static_cast<uint64_t>(screenId));
89             break;
90         }
91         case DisplayManagerMessage::TRANS_ID_DESTROY_VIRTUAL_SCREEN: {
92             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
93             DMError result = DestroyVirtualScreen(screenId);
94             reply.WriteInt32(static_cast<int32_t>(result));
95             break;
96         }
97         case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_SURFACE: {
98             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
99             bool isSurfaceValid = data.ReadBool();
100             sptr<IBufferProducer> bp = nullptr;
101             if (isSurfaceValid) {
102                 sptr<IRemoteObject> surfaceObject = data.ReadRemoteObject();
103                 bp = iface_cast<IBufferProducer>(surfaceObject);
104             }
105             DMError result = SetVirtualScreenSurface(screenId, bp);
106             reply.WriteInt32(static_cast<int32_t>(result));
107             break;
108         }
109         case DisplayManagerMessage::TRANS_ID_SET_ORIENTATION: {
110             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
111             Orientation orientation = static_cast<Orientation>(data.ReadUint32());
112             DMError ret = SetOrientation(screenId, orientation);
113             reply.WriteInt32(static_cast<int32_t>(ret));
114             break;
115         }
116         case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_SNAPSHOT: {
117             DisplayId displayId = data.ReadUint64();
118             DmErrorCode errorCode = DmErrorCode::DM_OK;
119             std::shared_ptr<Media::PixelMap> displaySnapshot = GetDisplaySnapshot(displayId, &errorCode);
120             reply.WriteParcelable(displaySnapshot == nullptr ? nullptr : displaySnapshot.get());
121             reply.WriteInt32(static_cast<int32_t>(errorCode));
122             break;
123         }
124         case DisplayManagerMessage::TRANS_ID_REGISTER_DISPLAY_MANAGER_AGENT: {
125             auto agent = iface_cast<IDisplayManagerAgent>(data.ReadRemoteObject());
126             if (agent == nullptr) {
127                 WLOGFE("agent is nullptr");
128                 break;
129             }
130             auto type = static_cast<DisplayManagerAgentType>(data.ReadUint32());
131             DMError ret = RegisterDisplayManagerAgent(agent, type);
132             reply.WriteInt32(static_cast<int32_t>(ret));
133             break;
134         }
135         case DisplayManagerMessage::TRANS_ID_UNREGISTER_DISPLAY_MANAGER_AGENT: {
136             auto agent = iface_cast<IDisplayManagerAgent>(data.ReadRemoteObject());
137             if (agent == nullptr) {
138                 WLOGFE("agent is nullptr");
139                 break;
140             }
141             auto type = static_cast<DisplayManagerAgentType>(data.ReadUint32());
142             DMError ret = UnregisterDisplayManagerAgent(agent, type);
143             reply.WriteInt32(static_cast<int32_t>(ret));
144             break;
145         }
146         case DisplayManagerMessage::TRANS_ID_WAKE_UP_BEGIN: {
147             PowerStateChangeReason reason = static_cast<PowerStateChangeReason>(data.ReadUint32());
148             reply.WriteBool(WakeUpBegin(reason));
149             break;
150         }
151         case DisplayManagerMessage::TRANS_ID_WAKE_UP_END: {
152             reply.WriteBool(WakeUpEnd());
153             break;
154         }
155         case DisplayManagerMessage::TRANS_ID_SUSPEND_BEGIN: {
156             PowerStateChangeReason reason = static_cast<PowerStateChangeReason>(data.ReadUint32());
157             reply.WriteBool(SuspendBegin(reason));
158             break;
159         }
160         case DisplayManagerMessage::TRANS_ID_SUSPEND_END: {
161             reply.WriteBool(SuspendEnd());
162             break;
163         }
164         case DisplayManagerMessage::TRANS_ID_SET_SPECIFIED_SCREEN_POWER: {
165             ScreenId screenId = static_cast<ScreenId>(data.ReadUint32());
166             ScreenPowerState state = static_cast<ScreenPowerState>(data.ReadUint32());
167             PowerStateChangeReason reason = static_cast<PowerStateChangeReason>(data.ReadUint32());
168             reply.WriteBool(SetSpecifiedScreenPower(screenId, state, reason));
169             break;
170         }
171         case DisplayManagerMessage::TRANS_ID_SET_SCREEN_POWER_FOR_ALL: {
172             ScreenPowerState state = static_cast<ScreenPowerState>(data.ReadUint32());
173             PowerStateChangeReason reason = static_cast<PowerStateChangeReason>(data.ReadUint32());
174             reply.WriteBool(SetScreenPowerForAll(state, reason));
175             break;
176         }
177         case DisplayManagerMessage::TRANS_ID_GET_SCREEN_POWER: {
178             ScreenId dmsScreenId;
179             if (!data.ReadUint64(dmsScreenId)) {
180                 WLOGFE("fail to read dmsScreenId.");
181                 break;
182             }
183             reply.WriteUint32(static_cast<uint32_t>(GetScreenPower(dmsScreenId)));
184             break;
185         }
186         case DisplayManagerMessage::TRANS_ID_SET_DISPLAY_STATE: {
187             DisplayState state = static_cast<DisplayState>(data.ReadUint32());
188             reply.WriteBool(SetDisplayState(state));
189             break;
190         }
191         case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_STATE: {
192             DisplayState state = GetDisplayState(data.ReadUint64());
193             reply.WriteUint32(static_cast<uint32_t>(state));
194             break;
195         }
196         case DisplayManagerMessage::TRANS_ID_SET_SCREEN_BRIGHTNESS: {
197             uint64_t screenId = data.ReadUint64();
198             uint32_t level = data.ReadUint64();
199             reply.WriteBool(SetScreenBrightness(screenId, level));
200             break;
201         }
202         case DisplayManagerMessage::TRANS_ID_GET_SCREEN_BRIGHTNESS: {
203             uint64_t screenId = data.ReadUint64();
204             reply.WriteUint32(GetScreenBrightness(screenId));
205             break;
206         }
207         case DisplayManagerMessage::TRANS_ID_NOTIFY_DISPLAY_EVENT: {
208             DisplayEvent event = static_cast<DisplayEvent>(data.ReadUint32());
209             NotifyDisplayEvent(event);
210             break;
211         }
212         case DisplayManagerMessage::TRANS_ID_SET_FREEZE_EVENT: {
213             std::vector<DisplayId> ids;
214             data.ReadUInt64Vector(&ids);
215             SetFreeze(ids, data.ReadBool());
216             break;
217         }
218         case DisplayManagerMessage::TRANS_ID_SCREEN_MAKE_MIRROR: {
219             ScreenId mainScreenId = static_cast<ScreenId>(data.ReadUint64());
220             std::vector<ScreenId> mirrorScreenId;
221             if (!data.ReadUInt64Vector(&mirrorScreenId)) {
222                 WLOGE("fail to receive mirror screen in stub. screen:%{public}" PRIu64"", mainScreenId);
223                 break;
224             }
225             ScreenId screenGroupId = INVALID_SCREEN_ID;
226             DMError ret = MakeMirror(mainScreenId, mirrorScreenId, screenGroupId);
227             reply.WriteInt32(static_cast<int32_t>(ret));
228             reply.WriteUint64(static_cast<uint64_t>(screenGroupId));
229             break;
230         }
231         case DisplayManagerMessage::TRANS_ID_GET_SCREEN_INFO_BY_ID: {
232             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
233             auto screenInfo = GetScreenInfoById(screenId);
234             reply.WriteStrongParcelable(screenInfo);
235             break;
236         }
237         case DisplayManagerMessage::TRANS_ID_GET_SCREEN_GROUP_INFO_BY_ID: {
238             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
239             auto screenGroupInfo = GetScreenGroupInfoById(screenId);
240             reply.WriteStrongParcelable(screenGroupInfo);
241             break;
242         }
243         case DisplayManagerMessage::TRANS_ID_GET_ALL_SCREEN_INFOS: {
244             std::vector<sptr<ScreenInfo>> screenInfos;
245             DMError ret  = GetAllScreenInfos(screenInfos);
246             reply.WriteInt32(static_cast<int32_t>(ret));
247             if (!MarshallingHelper::MarshallingVectorParcelableObj<ScreenInfo>(reply, screenInfos)) {
248                 WLOGE("fail to marshalling screenInfos in stub.");
249             }
250             break;
251         }
252         case DisplayManagerMessage::TRANS_ID_GET_ALL_DISPLAYIDS: {
253             std::vector<DisplayId> allDisplayIds = GetAllDisplayIds();
254             reply.WriteUInt64Vector(allDisplayIds);
255             break;
256         }
257         case DisplayManagerMessage::TRANS_ID_SCREEN_MAKE_EXPAND: {
258             std::vector<ScreenId> screenId;
259             if (!data.ReadUInt64Vector(&screenId)) {
260                 WLOGE("fail to receive expand screen in stub.");
261                 break;
262             }
263             std::vector<Point> startPoint;
264             if (!MarshallingHelper::UnmarshallingVectorObj<Point>(data, startPoint, [](Parcel& parcel, Point& point) {
265                     return parcel.ReadInt32(point.posX_) && parcel.ReadInt32(point.posY_);
266                 })) {
267                 WLOGE("fail to receive startPoint in stub.");
268                 break;
269             }
270             ScreenId screenGroupId = INVALID_SCREEN_ID;
271             DMError ret = MakeExpand(screenId, startPoint, screenGroupId);
272             reply.WriteInt32(static_cast<int32_t>(ret));
273             reply.WriteUint64(static_cast<uint64_t>(screenGroupId));
274             break;
275         }
276         case DisplayManagerMessage::TRANS_ID_REMOVE_VIRTUAL_SCREEN_FROM_SCREEN_GROUP: {
277             std::vector<ScreenId> screenId;
278             if (!data.ReadUInt64Vector(&screenId)) {
279                 WLOGE("fail to receive screens in stub.");
280                 break;
281             }
282             RemoveVirtualScreenFromGroup(screenId);
283             break;
284         }
285         case DisplayManagerMessage::TRANS_ID_SET_SCREEN_ACTIVE_MODE: {
286             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
287             uint32_t modeId = data.ReadUint32();
288             DMError ret = SetScreenActiveMode(screenId, modeId);
289             reply.WriteInt32(static_cast<int32_t>(ret));
290             break;
291         }
292         case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_PIXEL_RATIO: {
293             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
294             float virtualPixelRatio = data.ReadFloat();
295             DMError ret = SetVirtualPixelRatio(screenId, virtualPixelRatio);
296             reply.WriteInt32(static_cast<int32_t>(ret));
297             break;
298         }
299         case DisplayManagerMessage::TRANS_ID_SCREEN_GET_SUPPORTED_COLOR_GAMUTS: {
300             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
301             std::vector<ScreenColorGamut> colorGamuts;
302             DMError ret = GetScreenSupportedColorGamuts(screenId, colorGamuts);
303             reply.WriteInt32(static_cast<int32_t>(ret));
304             if (ret != DMError::DM_OK) {
305                 break;
306             }
307             MarshallingHelper::MarshallingVectorObj<ScreenColorGamut>(reply, colorGamuts,
308                 [](Parcel& parcel, const ScreenColorGamut& color) {
309                     return parcel.WriteUint32(static_cast<uint32_t>(color));
310                 }
311             );
312             break;
313         }
314         case DisplayManagerMessage::TRANS_ID_SCREEN_GET_COLOR_GAMUT: {
315             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
316             ScreenColorGamut colorGamut;
317             DMError ret = GetScreenColorGamut(screenId, colorGamut);
318             reply.WriteInt32(static_cast<int32_t>(ret));
319             if (ret != DMError::DM_OK) {
320                 break;
321             }
322             reply.WriteUint32(static_cast<uint32_t>(colorGamut));
323             break;
324         }
325         case DisplayManagerMessage::TRANS_ID_SCREEN_SET_COLOR_GAMUT: {
326             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
327             int32_t colorGamutIdx = data.ReadInt32();
328             DMError ret = SetScreenColorGamut(screenId, colorGamutIdx);
329             reply.WriteInt32(static_cast<int32_t>(ret));
330             break;
331         }
332         case DisplayManagerMessage::TRANS_ID_SCREEN_GET_GAMUT_MAP: {
333             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
334             ScreenGamutMap gamutMap;
335             DMError ret = GetScreenGamutMap(screenId, gamutMap);
336             reply.WriteInt32(static_cast<int32_t>(ret));
337             if (ret != DMError::DM_OK) {
338                 break;
339             }
340             reply.WriteInt32(static_cast<uint32_t>(gamutMap));
341             break;
342         }
343         case DisplayManagerMessage::TRANS_ID_SCREEN_SET_GAMUT_MAP: {
344             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
345             ScreenGamutMap gamutMap = static_cast<ScreenGamutMap>(data.ReadUint32());
346             DMError ret = SetScreenGamutMap(screenId, gamutMap);
347             reply.WriteInt32(static_cast<int32_t>(ret));
348             break;
349         }
350         case DisplayManagerMessage::TRANS_ID_SCREEN_SET_COLOR_TRANSFORM: {
351             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
352             DMError ret = SetScreenColorTransform(screenId);
353             reply.WriteInt32(static_cast<int32_t>(ret));
354             break;
355         }
356         case DisplayManagerMessage::TRANS_ID_IS_SCREEN_ROTATION_LOCKED: {
357             bool isLocked = false;
358             DMError ret = IsScreenRotationLocked(isLocked);
359             reply.WriteInt32(static_cast<int32_t>(ret));
360             reply.WriteBool(isLocked);
361             break;
362         }
363         case DisplayManagerMessage::TRANS_ID_SET_SCREEN_ROTATION_LOCKED: {
364             bool isLocked = static_cast<bool>(data.ReadBool());
365             DMError ret = SetScreenRotationLocked(isLocked);
366             reply.WriteInt32(static_cast<int32_t>(ret));
367             break;
368         }
369         case DisplayManagerMessage::TRANS_ID_SET_SCREEN_ROTATION_LOCKED_FROM_JS: {
370             bool isLocked = static_cast<bool>(data.ReadBool());
371             DMError ret = SetScreenRotationLockedFromJs(isLocked);
372             reply.WriteInt32(static_cast<int32_t>(ret));
373             break;
374         }
375         case DisplayManagerMessage::TRANS_ID_HAS_PRIVATE_WINDOW: {
376             DisplayId id = static_cast<DisplayId>(data.ReadUint64());
377             bool hasPrivateWindow = false;
378             DMError ret = HasPrivateWindow(id, hasPrivateWindow);
379             reply.WriteInt32(static_cast<int32_t>(ret));
380             reply.WriteBool(hasPrivateWindow);
381             break;
382         }
383         case DisplayManagerMessage::TRANS_ID_GET_CUTOUT_INFO: {
384             DisplayId displayId = static_cast<DisplayId>(data.ReadUint64());
385             sptr<CutoutInfo> cutoutInfo = GetCutoutInfo(displayId);
386             reply.WriteParcelable(cutoutInfo);
387             break;
388         }
389         case DisplayManagerMessage::TRANS_ID_ADD_SURFACE_NODE: {
390             DisplayId displayId = static_cast<DisplayId>(data.ReadUint64());
391             std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Unmarshalling(data);
392             auto ret = AddSurfaceNodeToDisplay(displayId, surfaceNode, true);
393             reply.WriteUint32(static_cast<uint32_t>(ret));
394             break;
395         }
396         case DisplayManagerMessage::TRANS_ID_REMOVE_SURFACE_NODE: {
397             DisplayId displayId = static_cast<DisplayId>(data.ReadUint64());
398             std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Unmarshalling(data);
399             auto ret = RemoveSurfaceNodeFromDisplay(displayId, surfaceNode);
400             reply.WriteUint32(static_cast<uint32_t>(ret));
401             break;
402         }
403         case DisplayManagerMessage::TRANS_ID_SCREEN_STOP_MIRROR: {
404             std::vector<ScreenId> mirrorScreenIds;
405             if (!data.ReadUInt64Vector(&mirrorScreenIds)) {
406                 WLOGE("fail to receive mirror screens in stub.");
407                 break;
408             }
409             DMError ret = StopMirror(mirrorScreenIds);
410             reply.WriteInt32(static_cast<int32_t>(ret));
411             break;
412         }
413         case DisplayManagerMessage::TRANS_ID_SCREEN_STOP_EXPAND: {
414             std::vector<ScreenId> expandScreenIds;
415             if (!data.ReadUInt64Vector(&expandScreenIds)) {
416                 WLOGE("fail to receive expand screens in stub.");
417                 break;
418             }
419             DMError ret = StopExpand(expandScreenIds);
420             reply.WriteInt32(static_cast<int32_t>(ret));
421             break;
422         }
423         case DisplayManagerMessage::TRANS_ID_RESIZE_VIRTUAL_SCREEN: {
424             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
425             uint32_t width = data.ReadUint32();
426             uint32_t height = data.ReadUint32();
427             DMError ret = ResizeVirtualScreen(screenId, width, height);
428             reply.WriteInt32(static_cast<int32_t>(ret));
429             break;
430         }
431         case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_MAKE_UNIQUE_SCREEN: {
432             std::vector<ScreenId> uniqueScreenIds;
433             uint32_t size = data.ReadUint32();
434             if (size > MAX_SCREEN_SIZE) {
435                 WLOGFE("screenIds size is bigger than %{public}u", MAX_SCREEN_SIZE);
436                 break;
437             }
438             if (!data.ReadUInt64Vector(&uniqueScreenIds)) {
439                 WLOGFE("failed to receive unique screens in stub");
440                 break;
441             }
442             DMError ret = MakeUniqueScreen(uniqueScreenIds);
443             reply.WriteInt32(static_cast<int32_t>(ret));
444             break;
445         }
446         case DisplayManagerMessage::TRANS_ID_GET_ALL_PHYSICAL_DISPLAY_RESOLUTION: {
447             auto physicalInfos = GetAllDisplayPhysicalResolution();
448             size_t infoSize = physicalInfos.size();
449             bool writeRet = reply.WriteInt32(static_cast<int32_t>(infoSize));
450             if (!writeRet) {
451                 WLOGFE("write physical size error");
452                 break;
453             }
454             for (const auto &physicalItem : physicalInfos) {
455                 writeRet = reply.WriteUint32(static_cast<uint32_t>(physicalItem.foldDisplayMode_));
456                 if (!writeRet) {
457                     WLOGFE("write display mode error");
458                     break;
459                 }
460                 writeRet = reply.WriteUint32(physicalItem.physicalWidth_);
461                 if (!writeRet) {
462                     WLOGFE("write physical width error");
463                     break;
464                 }
465                 writeRet = reply.WriteUint32(physicalItem.physicalHeight_);
466                 if (!writeRet) {
467                     WLOGFE("write physical height error");
468                     break;
469                 }
470             }
471             break;
472         }
473         default:
474             WLOGFW("unknown transaction code");
475             return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
476     }
477     return 0;
478 }
479 } // namespace OHOS::Rosen