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