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 }
31
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)32 int32_t DisplayManagerStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply,
33 MessageOption &option)
34 {
35 WLOGFD("OnRemoteRequest code is %{public}u", code);
36 if (data.ReadInterfaceToken() != GetDescriptor()) {
37 WLOGFE("InterfaceToken check failed");
38 return -1;
39 }
40 DisplayManagerMessage msgId = static_cast<DisplayManagerMessage>(code);
41 switch (msgId) {
42 case DisplayManagerMessage::TRANS_ID_GET_DEFAULT_DISPLAY_INFO: {
43 auto info = GetDefaultDisplayInfo();
44 reply.WriteParcelable(info);
45 break;
46 }
47 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_BY_ID: {
48 DisplayId displayId = data.ReadUint64();
49 auto info = GetDisplayInfoById(displayId);
50 reply.WriteParcelable(info);
51 break;
52 }
53 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_BY_SCREEN: {
54 ScreenId screenId = data.ReadUint64();
55 auto info = GetDisplayInfoByScreen(screenId);
56 reply.WriteParcelable(info);
57 break;
58 }
59 case DisplayManagerMessage::TRANS_ID_CREATE_VIRTUAL_SCREEN: {
60 std::string name = data.ReadString();
61 uint32_t width = data.ReadUint32();
62 uint32_t height = data.ReadUint32();
63 float density = data.ReadFloat();
64 int32_t flags = data.ReadInt32();
65 bool isForShot = data.ReadBool();
66 bool isSurfaceValid = data.ReadBool();
67 sptr<Surface> surface = nullptr;
68 if (isSurfaceValid) {
69 sptr<IRemoteObject> surfaceObject = data.ReadRemoteObject();
70 sptr<IBufferProducer> bp = iface_cast<IBufferProducer>(surfaceObject);
71 surface = Surface::CreateSurfaceAsProducer(bp);
72 }
73 sptr<IRemoteObject> virtualScreenAgent = data.ReadRemoteObject();
74 VirtualScreenOption option = {
75 .name_ = name,
76 .width_ = width,
77 .height_ = height,
78 .density_ = density,
79 .surface_ = surface,
80 .flags_ = flags,
81 .isForShot_ = isForShot
82 };
83 ScreenId screenId = CreateVirtualScreen(option, virtualScreenAgent);
84 reply.WriteUint64(static_cast<uint64_t>(screenId));
85 break;
86 }
87 case DisplayManagerMessage::TRANS_ID_DESTROY_VIRTUAL_SCREEN: {
88 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
89 DMError result = DestroyVirtualScreen(screenId);
90 reply.WriteInt32(static_cast<int32_t>(result));
91 break;
92 }
93 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_SURFACE: {
94 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
95 bool isSurfaceValid = data.ReadBool();
96 sptr<Surface> surface = nullptr;
97 if (isSurfaceValid) {
98 sptr<IRemoteObject> surfaceObject = data.ReadRemoteObject();
99 sptr<IBufferProducer> bp = iface_cast<IBufferProducer>(surfaceObject);
100 surface = Surface::CreateSurfaceAsProducer(bp);
101 }
102 DMError result = SetVirtualScreenSurface(screenId, surface);
103 reply.WriteInt32(static_cast<int32_t>(result));
104 break;
105 }
106 case DisplayManagerMessage::TRANS_ID_SET_ORIENTATION: {
107 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
108 Orientation orientation = static_cast<Orientation>(data.ReadUint32());
109 reply.WriteBool(SetOrientation(screenId, orientation));
110 break;
111 }
112 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_SNAPSHOT: {
113 DisplayId displayId = data.ReadUint64();
114 std::shared_ptr<Media::PixelMap> displaySnapshot = GetDisplaySnapshot(displayId);
115 reply.WriteParcelable(displaySnapshot == nullptr ? nullptr : displaySnapshot.get());
116 break;
117 }
118 case DisplayManagerMessage::TRANS_ID_REGISTER_DISPLAY_MANAGER_AGENT: {
119 auto agent = iface_cast<IDisplayManagerAgent>(data.ReadRemoteObject());
120 auto type = static_cast<DisplayManagerAgentType>(data.ReadUint32());
121 reply.WriteBool(RegisterDisplayManagerAgent(agent, type));
122 break;
123 }
124 case DisplayManagerMessage::TRANS_ID_UNREGISTER_DISPLAY_MANAGER_AGENT: {
125 auto agent = iface_cast<IDisplayManagerAgent>(data.ReadRemoteObject());
126 auto type = static_cast<DisplayManagerAgentType>(data.ReadUint32());
127 reply.WriteBool(UnregisterDisplayManagerAgent(agent, type));
128 break;
129 }
130 case DisplayManagerMessage::TRANS_ID_WAKE_UP_BEGIN: {
131 PowerStateChangeReason reason = static_cast<PowerStateChangeReason>(data.ReadUint32());
132 reply.WriteBool(WakeUpBegin(reason));
133 break;
134 }
135 case DisplayManagerMessage::TRANS_ID_WAKE_UP_END: {
136 reply.WriteBool(WakeUpEnd());
137 break;
138 }
139 case DisplayManagerMessage::TRANS_ID_SUSPEND_BEGIN: {
140 PowerStateChangeReason reason = static_cast<PowerStateChangeReason>(data.ReadUint32());
141 reply.WriteBool(SuspendBegin(reason));
142 break;
143 }
144 case DisplayManagerMessage::TRANS_ID_SUSPEND_END: {
145 reply.WriteBool(SuspendEnd());
146 break;
147 }
148 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_POWER_FOR_ALL: {
149 ScreenPowerState state = static_cast<ScreenPowerState>(data.ReadUint32());
150 PowerStateChangeReason reason = static_cast<PowerStateChangeReason>(data.ReadUint32());
151 reply.WriteBool(SetScreenPowerForAll(state, reason));
152 break;
153 }
154 case DisplayManagerMessage::TRANS_ID_GET_SCREEN_POWER: {
155 ScreenId dmsScreenId;
156 if (!data.ReadUint64(dmsScreenId)) {
157 WLOGFE("fail to read dmsScreenId.");
158 break;
159 }
160 reply.WriteUint32(static_cast<uint32_t>(GetScreenPower(dmsScreenId)));
161 break;
162 }
163 case DisplayManagerMessage::TRANS_ID_SET_DISPLAY_STATE: {
164 DisplayState state = static_cast<DisplayState>(data.ReadUint32());
165 reply.WriteBool(SetDisplayState(state));
166 break;
167 }
168 case DisplayManagerMessage::TRANS_ID_GET_DISPLAY_STATE: {
169 DisplayState state = GetDisplayState(data.ReadUint64());
170 reply.WriteUint32(static_cast<uint32_t>(state));
171 break;
172 }
173 case DisplayManagerMessage::TRANS_ID_NOTIFY_DISPLAY_EVENT: {
174 DisplayEvent event = static_cast<DisplayEvent>(data.ReadUint32());
175 NotifyDisplayEvent(event);
176 break;
177 }
178 case DisplayManagerMessage::TRANS_ID_SET_FREEZE_EVENT: {
179 std::vector<DisplayId> ids;
180 data.ReadUInt64Vector(&ids);
181 SetFreeze(ids, data.ReadBool());
182 break;
183 }
184 case DisplayManagerMessage::TRANS_ID_SCREEN_MAKE_MIRROR: {
185 ScreenId mainScreenId = static_cast<ScreenId>(data.ReadUint64());
186 std::vector<ScreenId> mirrorScreenId;
187 if (!data.ReadUInt64Vector(&mirrorScreenId)) {
188 WLOGE("fail to receive mirror screen in stub. screen:%{public}" PRIu64"", mainScreenId);
189 break;
190 }
191 ScreenId result = MakeMirror(mainScreenId, mirrorScreenId);
192 reply.WriteUint64(static_cast<uint64_t>(result));
193 break;
194 }
195 case DisplayManagerMessage::TRANS_ID_GET_SCREEN_INFO_BY_ID: {
196 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
197 auto screenInfo = GetScreenInfoById(screenId);
198 reply.WriteStrongParcelable(screenInfo);
199 break;
200 }
201 case DisplayManagerMessage::TRANS_ID_GET_SCREEN_GROUP_INFO_BY_ID: {
202 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
203 auto screenGroupInfo = GetScreenGroupInfoById(screenId);
204 reply.WriteStrongParcelable(screenGroupInfo);
205 break;
206 }
207 case DisplayManagerMessage::TRANS_ID_GET_ALL_SCREEN_INFOS: {
208 std::vector<sptr<ScreenInfo>> screenInfos = GetAllScreenInfos();
209 if (!MarshallingHelper::MarshallingVectorParcelableObj<ScreenInfo>(reply, screenInfos)) {
210 WLOGE("fail to marshalling screenInfos in stub.");
211 }
212 break;
213 }
214 case DisplayManagerMessage::TRANS_ID_GET_ALL_DISPLAYIDS: {
215 std::vector<DisplayId> allDisplayIds = GetAllDisplayIds();
216 reply.WriteUInt64Vector(allDisplayIds);
217 break;
218 }
219 case DisplayManagerMessage::TRANS_ID_SCREEN_MAKE_EXPAND: {
220 std::vector<ScreenId> screenId;
221 if (!data.ReadUInt64Vector(&screenId)) {
222 WLOGE("fail to receive expand screen in stub.");
223 break;
224 }
225 std::vector<Point> startPoint;
226 if (!MarshallingHelper::UnmarshallingVectorObj<Point>(data, startPoint, [](Parcel& parcel, Point& point) {
227 return parcel.ReadInt32(point.posX_) && parcel.ReadInt32(point.posY_);
228 })) {
229 WLOGE("fail to receive startPoint in stub.");
230 break;
231 }
232 ScreenId result = MakeExpand(screenId, startPoint);
233 reply.WriteUint64(static_cast<uint64_t>(result));
234 break;
235 }
236 case DisplayManagerMessage::TRANS_ID_REMOVE_VIRTUAL_SCREEN_FROM_SCREEN_GROUP: {
237 std::vector<ScreenId> screenId;
238 if (!data.ReadUInt64Vector(&screenId)) {
239 WLOGE("fail to receive screens in stub.");
240 break;
241 }
242 RemoveVirtualScreenFromGroup(screenId);
243 break;
244 }
245 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_ACTIVE_MODE: {
246 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
247 uint32_t modeId = data.ReadUint32();
248 bool res = SetScreenActiveMode(screenId, modeId);
249 reply.WriteBool(res);
250 break;
251 }
252 case DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_PIXEL_RATIO: {
253 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
254 float virtualPixelRatio = data.ReadFloat();
255 bool res = SetVirtualPixelRatio(screenId, virtualPixelRatio);
256 reply.WriteBool(res);
257 break;
258 }
259 case DisplayManagerMessage::TRANS_ID_SCREEN_GET_SUPPORTED_COLOR_GAMUTS: {
260 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
261 std::vector<ScreenColorGamut> colorGamuts;
262 DMError ret = GetScreenSupportedColorGamuts(screenId, colorGamuts);
263 reply.WriteInt32(static_cast<int32_t>(ret));
264 if (ret != DMError::DM_OK) {
265 break;
266 }
267 MarshallingHelper::MarshallingVectorObj<ScreenColorGamut>(reply, colorGamuts,
268 [](Parcel& parcel, const ScreenColorGamut& color) {
269 return parcel.WriteUint32(static_cast<uint32_t>(color));
270 }
271 );
272 break;
273 }
274 case DisplayManagerMessage::TRANS_ID_SCREEN_GET_COLOR_GAMUT: {
275 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
276 ScreenColorGamut colorGamut;
277 DMError ret = GetScreenColorGamut(screenId, colorGamut);
278 reply.WriteInt32(static_cast<int32_t>(ret));
279 if (ret != DMError::DM_OK) {
280 break;
281 }
282 reply.WriteUint32(static_cast<uint32_t>(colorGamut));
283 break;
284 }
285 case DisplayManagerMessage::TRANS_ID_SCREEN_SET_COLOR_GAMUT: {
286 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
287 int32_t colorGamutIdx = data.ReadInt32();
288 DMError ret = SetScreenColorGamut(screenId, colorGamutIdx);
289 reply.WriteInt32(static_cast<int32_t>(ret));
290 break;
291 }
292 case DisplayManagerMessage::TRANS_ID_SCREEN_GET_GAMUT_MAP: {
293 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
294 ScreenGamutMap gamutMap;
295 DMError ret = GetScreenGamutMap(screenId, gamutMap);
296 reply.WriteInt32(static_cast<int32_t>(ret));
297 if (ret != DMError::DM_OK) {
298 break;
299 }
300 reply.WriteInt32(static_cast<uint32_t>(gamutMap));
301 break;
302 }
303 case DisplayManagerMessage::TRANS_ID_SCREEN_SET_GAMUT_MAP: {
304 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
305 ScreenGamutMap gamutMap = static_cast<ScreenGamutMap>(data.ReadUint32());
306 DMError ret = SetScreenGamutMap(screenId, gamutMap);
307 reply.WriteInt32(static_cast<int32_t>(ret));
308 break;
309 }
310 case DisplayManagerMessage::TRANS_ID_SCREEN_SET_COLOR_TRANSFORM: {
311 ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
312 DMError ret = SetScreenColorTransform(screenId);
313 reply.WriteInt32(static_cast<int32_t>(ret));
314 break;
315 }
316 case DisplayManagerMessage::TRANS_ID_IS_SCREEN_ROTATION_LOCKED: {
317 bool isLocked = IsScreenRotationLocked();
318 reply.WriteBool(isLocked);
319 break;
320 }
321 case DisplayManagerMessage::TRANS_ID_SET_SCREEN_ROTATION_LOCKED: {
322 bool isLocked = static_cast<bool>(data.ReadBool());
323 SetScreenRotationLocked(isLocked);
324 break;
325 }
326 case DisplayManagerMessage::TRANS_ID_HAS_PRIVATE_WINDOW: {
327 DisplayId id = static_cast<DisplayId>(data.ReadUint64());
328 bool hasPrivateWindow = false;
329 DMError ret = HasPrivateWindow(id, hasPrivateWindow);
330 reply.WriteInt32(static_cast<int32_t>(ret));
331 reply.WriteBool(hasPrivateWindow);
332 break;
333 }
334 case DisplayManagerMessage::TRANS_ID_GET_CUTOUT_INFO: {
335 DisplayId displayId = static_cast<DisplayId>(data.ReadUint64());
336 sptr<CutoutInfo> cutoutInfo = GetCutoutInfo(displayId);
337 reply.WriteParcelable(cutoutInfo);
338 break;
339 }
340 default:
341 WLOGFW("unknown transaction code");
342 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
343 }
344 return 0;
345 }
346 } // namespace OHOS::Rosen