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 "session_manager/include/zidl/scene_session_manager_stub.h"
17
18 #include <ipc_types.h>
19 #include <ui/rs_surface_node.h>
20 #include "marshalling_helper.h"
21 #include "session/host/include/scene_session.h"
22 #include "window_manager.h"
23 #include "window_manager_agent_proxy.h"
24 #include "window_manager_hilog.h"
25
26 namespace OHOS::Rosen {
27 namespace {
28 constexpr HiviewDFX::HiLogLabel LABEL = {LOG_CORE, HILOG_DOMAIN_WINDOW, "SceneSessionManagerStub"};
29 }
30
31 const std::map<uint32_t, SceneSessionManagerStubFunc> SceneSessionManagerStub::stubFuncMap_{
32 std::make_pair(static_cast<uint32_t>(SceneSessionManagerMessage::TRANS_ID_CREATE_AND_CONNECT_SPECIFIC_SESSION),
33 &SceneSessionManagerStub::HandleCreateAndConnectSpecificSession),
34 std::make_pair(static_cast<uint32_t>(SceneSessionManagerMessage::TRANS_ID_DESTROY_AND_DISCONNECT_SPECIFIC_SESSION),
35 &SceneSessionManagerStub::HandleDestroyAndDisconnectSpcificSession),
36 std::make_pair(static_cast<uint32_t>(SceneSessionManagerMessage::TRANS_ID_UPDATE_PROPERTY),
37 &SceneSessionManagerStub::HandleUpdateProperty),
38 std::make_pair(static_cast<uint32_t>(SceneSessionManagerMessage::TRANS_ID_REGISTER_WINDOW_MANAGER_AGENT),
39 &SceneSessionManagerStub::HandleRegisterWindowManagerAgent),
40 std::make_pair(static_cast<uint32_t>(SceneSessionManagerMessage::TRANS_ID_UNREGISTER_WINDOW_MANAGER_AGENT),
41 &SceneSessionManagerStub::HandleUnregisterWindowManagerAgent),
42 std::make_pair(static_cast<uint32_t>(SceneSessionManagerMessage::TRANS_ID_GET_FOCUS_SESSION_INFO),
43 &SceneSessionManagerStub::HandleGetFocusSessionInfo),
44 std::make_pair(static_cast<uint32_t>(SceneSessionManagerMessage::TRANS_ID_SET_SESSION_LABEL),
45 &SceneSessionManagerStub::HandleSetSessionLabel),
46 std::make_pair(static_cast<uint32_t>(SceneSessionManagerMessage::TRANS_ID_SET_SESSION_ICON),
47 &SceneSessionManagerStub::HandleSetSessionIcon),
48 std::make_pair(static_cast<uint32_t>(SceneSessionManagerMessage::TRANS_ID_IS_VALID_SESSION_IDS),
49 &SceneSessionManagerStub::HandleIsValidSessionIds),
50 std::make_pair(static_cast<uint32_t>(SceneSessionManagerMessage::TRANS_ID_REGISTER_SESSION_CHANGE_LISTENER),
51 &SceneSessionManagerStub::HandleRegisterSessionChangeListener),
52 std::make_pair(static_cast<uint32_t>(SceneSessionManagerMessage::TRANS_ID_UNREGISTER_SESSION_CHANGE_LISTENER),
53 &SceneSessionManagerStub::HandleUnRegisterSessionChangeListener),
54 std::make_pair(static_cast<uint32_t>(SceneSessionManagerMessage::TRANS_ID_PENDING_SESSION_TO_FOREGROUND),
55 &SceneSessionManagerStub::HandlePendingSessionToForeground),
56 std::make_pair(static_cast<uint32_t>(SceneSessionManagerMessage::TRANS_ID_PENDING_SESSION_TO_BACKGROUND_FOR_DELEGATOR),
57 &SceneSessionManagerStub::HandlePendingSessionToBackgroundForDelegator),
58 std::make_pair(static_cast<uint32_t>(SceneSessionManagerMessage::TRANS_ID_GET_FOCUS_SESSION_TOKEN),
59 &SceneSessionManagerStub::HandleGetFocusSessionToken),
60 std::make_pair(static_cast<uint32_t>(SceneSessionManagerMessage::TRANS_ID_SET_GESTURE_NAVIGATION_ENABLED),
61 &SceneSessionManagerStub::HandleSetGestureNavigationEnabled),
62 std::make_pair(static_cast<uint32_t>(SceneSessionManagerMessage::TRANS_ID_GET_WINDOW_INFO),
63 &SceneSessionManagerStub::HandleGetAccessibilityWindowInfo),
64
65 std::make_pair(static_cast<uint32_t>(SceneSessionManagerMessage::TRANS_ID_REGISTER_SESSION_LISTENER),
66 &SceneSessionManagerStub::HandleRegisterSessionListener),
67 std::make_pair(static_cast<uint32_t>(SceneSessionManagerMessage::TRANS_ID_UNREGISTER_SESSION_LISTENER),
68 &SceneSessionManagerStub::HandleUnRegisterSessionListener),
69 std::make_pair(static_cast<uint32_t>(SceneSessionManagerMessage::TRANS_ID_GET_MISSION_INFOS),
70 &SceneSessionManagerStub::HandleGetSessionInfos),
71 std::make_pair(static_cast<uint32_t>(SceneSessionManagerMessage::TRANS_ID_GET_MISSION_INFO_BY_ID),
72 &SceneSessionManagerStub::HandleGetSessionInfo),
73
74 std::make_pair(static_cast<uint32_t>(SceneSessionManagerMessage::TRANS_ID_TERMINATE_SESSION_NEW),
75 &SceneSessionManagerStub::HandleTerminateSessionNew),
76 std::make_pair(static_cast<uint32_t>(SceneSessionManagerMessage::TRANS_ID_UPDATE_AVOIDAREA_LISTENER),
77 &SceneSessionManagerStub::HandleUpdateSessionAvoidAreaListener),
78 std::make_pair(static_cast<uint32_t>(SceneSessionManagerMessage::TRANS_ID_GET_SESSION_DUMP_INFO),
79 &SceneSessionManagerStub::HandleGetSessionDump),
80 std::make_pair(static_cast<uint32_t>(SceneSessionManagerMessage::TRANS_ID_BIND_DIALOG_TARGET),
81 &SceneSessionManagerStub::HandleBindDialogTarget),
82 std::make_pair(static_cast<uint32_t>(SceneSessionManagerMessage::TRANS_ID_GET_SESSION_SNAPSHOT),
83 &SceneSessionManagerStub::HandleGetSessionSnapshot),
84 std::make_pair(static_cast<uint32_t>(SceneSessionManagerMessage::TRANS_ID_GET_SESSION_DUMP_INFO),
85 &SceneSessionManagerStub::HandleGetSessionDump),
86 std::make_pair(static_cast<uint32_t>(SceneSessionManagerMessage::TRANS_ID_NOTIFY_DUMP_INFO_RESULT),
87 &SceneSessionManagerStub::HandleNotifyDumpInfoResult),
88 std::make_pair(static_cast<uint32_t>(SceneSessionManagerMessage::TRANS_ID_SET_SESSION_CONTINUE_STATE),
89 &SceneSessionManagerStub::HandleSetSessionContinueState),
90 std::make_pair(static_cast<uint32_t>(SceneSessionManagerMessage::TRANS_ID_SET_SESSION_GRAVITY),
91 &SceneSessionManagerStub::HandleSetSessionGravity),
92 std::make_pair(static_cast<uint32_t>(SceneSessionManagerMessage::TRANS_ID_CLEAR_SESSION),
93 &SceneSessionManagerStub::HandleClearSession),
94 std::make_pair(static_cast<uint32_t>(SceneSessionManagerMessage::TRANS_ID_CLEAR_ALL_SESSIONS),
95 &SceneSessionManagerStub::HandleClearAllSessions),
96 std::make_pair(static_cast<uint32_t>(SceneSessionManagerMessage::TRANS_ID_REGISTER_COLLABORATOR),
97 &SceneSessionManagerStub::HandleRegisterCollaborator),
98 std::make_pair(static_cast<uint32_t>(SceneSessionManagerMessage::TRANS_ID_UNREGISTER_COLLABORATOR),
99 &SceneSessionManagerStub::HandleUnregisterCollaborator),
100 };
101
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)102 int SceneSessionManagerStub::OnRemoteRequest(uint32_t code,
103 MessageParcel &data, MessageParcel &reply, MessageOption &option)
104 {
105 WLOGFD("Scene session on remote request!, code: %{public}u", code);
106 if (data.ReadInterfaceToken() != GetDescriptor()) {
107 WLOGFE("Failed to check interface token!");
108 return ERR_INVALID_STATE;
109 }
110
111 const auto& func = stubFuncMap_.find(code);
112 if (func == stubFuncMap_.end()) {
113 WLOGFE("Failed to find function handler!");
114 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
115 }
116
117 return (this->*(func->second))(data, reply);
118 }
119
HandleCreateAndConnectSpecificSession(MessageParcel & data,MessageParcel & reply)120 int SceneSessionManagerStub::HandleCreateAndConnectSpecificSession(MessageParcel &data, MessageParcel &reply)
121 {
122 WLOGFI("run HandleCreateAndConnectSpecificSession!");
123 sptr<IRemoteObject> sessionStageObject = data.ReadRemoteObject();
124 sptr<ISessionStage> sessionStage = iface_cast<ISessionStage>(sessionStageObject);
125 sptr<IRemoteObject> eventChannelObject = data.ReadRemoteObject();
126 sptr<IWindowEventChannel> eventChannel = iface_cast<IWindowEventChannel>(eventChannelObject);
127 std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Unmarshalling(data);
128 if (sessionStage == nullptr || eventChannel == nullptr || surfaceNode == nullptr) {
129 WLOGFE("Failed to read scene session stage object or event channel object!");
130 return ERR_INVALID_DATA;
131 }
132
133 sptr<WindowSessionProperty> property = nullptr;
134 if (data.ReadBool()) {
135 property = data.ReadStrongParcelable<WindowSessionProperty>();
136 } else {
137 WLOGFW("Property not exist!");
138 }
139
140 sptr<IRemoteObject> token = nullptr;
141 if (property && property->GetTokenState()) {
142 token = data.ReadRemoteObject();
143 } else {
144 WLOGI("accept token is nullptr");
145 }
146
147 auto persistentId = INVALID_SESSION_ID;
148 sptr<ISession> sceneSession;
149 CreateAndConnectSpecificSession(sessionStage, eventChannel, surfaceNode,
150 property, persistentId, sceneSession, token);
151 if (sceneSession== nullptr) {
152 return ERR_INVALID_STATE;
153 }
154 reply.WriteInt32(persistentId);
155 reply.WriteRemoteObject(sceneSession->AsObject());
156 reply.WriteUint32(static_cast<uint32_t>(WSError::WS_OK));
157 return ERR_NONE;
158 }
159
HandleDestroyAndDisconnectSpcificSession(MessageParcel & data,MessageParcel & reply)160 int SceneSessionManagerStub::HandleDestroyAndDisconnectSpcificSession(MessageParcel &data, MessageParcel &reply)
161 {
162 WLOGFI("run HandleDestroyAndDisconnectSpcificSession!");
163 auto persistentId = data.ReadInt32();
164 const WSError& ret = DestroyAndDisconnectSpecificSession(persistentId);
165 reply.WriteUint32(static_cast<uint32_t>(ret));
166 return ERR_NONE;
167 }
168
HandleUpdateProperty(MessageParcel & data,MessageParcel & reply)169 int SceneSessionManagerStub::HandleUpdateProperty(MessageParcel &data, MessageParcel &reply)
170 {
171 WLOGFI("run HandleUpdateProperty!");
172 auto action = static_cast<WSPropertyChangeAction>(data.ReadUint32());
173 sptr<WindowSessionProperty> property = nullptr;
174 if (data.ReadBool()) {
175 property = data.ReadStrongParcelable<WindowSessionProperty>();
176 } else {
177 WLOGFW("Property not exist!");
178 }
179 const WMError& ret = UpdateProperty(property, action);
180 reply.WriteInt32(static_cast<int32_t>(ret));
181 return ERR_NONE;
182 }
183
HandleRegisterWindowManagerAgent(MessageParcel & data,MessageParcel & reply)184 int SceneSessionManagerStub::HandleRegisterWindowManagerAgent(MessageParcel &data, MessageParcel &reply)
185 {
186 WLOGFI("run HandleRegisterWindowManagerAgent!");
187 auto type = static_cast<WindowManagerAgentType>(data.ReadUint32());
188 sptr<IRemoteObject> windowManagerAgentObject = data.ReadRemoteObject();
189 sptr<IWindowManagerAgent> windowManagerAgentProxy =
190 iface_cast<IWindowManagerAgent>(windowManagerAgentObject);
191 WMError errCode = RegisterWindowManagerAgent(type, windowManagerAgentProxy);
192 reply.WriteInt32(static_cast<int32_t>(errCode));
193 return ERR_NONE;
194 }
195
HandleUnregisterWindowManagerAgent(MessageParcel & data,MessageParcel & reply)196 int SceneSessionManagerStub::HandleUnregisterWindowManagerAgent(MessageParcel &data, MessageParcel &reply)
197 {
198 WLOGFI("run HandleUnregisterWindowManagerAgent!");
199 auto type = static_cast<WindowManagerAgentType>(data.ReadUint32());
200 sptr<IRemoteObject> windowManagerAgentObject = data.ReadRemoteObject();
201 sptr<IWindowManagerAgent> windowManagerAgentProxy =
202 iface_cast<IWindowManagerAgent>(windowManagerAgentObject);
203 WMError errCode = UnregisterWindowManagerAgent(type, windowManagerAgentProxy);
204 reply.WriteInt32(static_cast<int32_t>(errCode));
205 return ERR_NONE;
206 }
207
HandleGetFocusSessionInfo(MessageParcel & data,MessageParcel & reply)208 int SceneSessionManagerStub::HandleGetFocusSessionInfo(MessageParcel &data, MessageParcel &reply)
209 {
210 WLOGFI("run HandleGetFocusSessionInfo!");
211 FocusChangeInfo focusInfo;
212 GetFocusWindowInfo(focusInfo);
213 reply.WriteParcelable(&focusInfo);
214 return ERR_NONE;
215 }
216
HandleSetSessionLabel(MessageParcel & data,MessageParcel & reply)217 int SceneSessionManagerStub::HandleSetSessionLabel(MessageParcel &data, MessageParcel &reply)
218 {
219 WLOGFI("run HandleSetSessionLabel!");
220 sptr<IRemoteObject> token = data.ReadRemoteObject();
221 std::string label = data.ReadString();
222 WSError errCode = SetSessionLabel(token, label);
223 reply.WriteInt32(static_cast<int32_t>(errCode));
224 return ERR_NONE;
225 }
226
HandleSetSessionIcon(MessageParcel & data,MessageParcel & reply)227 int SceneSessionManagerStub::HandleSetSessionIcon(MessageParcel &data, MessageParcel &reply)
228 {
229 WLOGFI("run HandleSetSessionIcon!");
230 sptr<IRemoteObject> token = data.ReadRemoteObject();
231 std::shared_ptr<Media::PixelMap> icon(data.ReadParcelable<Media::PixelMap>());
232 WSError errCode = SetSessionIcon(token, icon);
233 reply.WriteInt32(static_cast<int32_t>(errCode));
234 return ERR_NONE;
235 }
236
HandleIsValidSessionIds(MessageParcel & data,MessageParcel & reply)237 int SceneSessionManagerStub::HandleIsValidSessionIds(MessageParcel &data, MessageParcel &reply)
238 {
239 WLOGFI("run HandleIsValidSessionIds!");
240 std::vector<int32_t> sessionIds;
241 data.ReadInt32Vector(&sessionIds);
242 std::vector<bool> results;
243 WSError errCode = IsValidSessionIds(sessionIds, results);
244 reply.WriteBoolVector(results);
245 return ERR_NONE;
246 }
247
HandleRegisterSessionChangeListener(MessageParcel & data,MessageParcel & reply)248 int SceneSessionManagerStub::HandleRegisterSessionChangeListener(MessageParcel &data, MessageParcel &reply)
249 {
250 WLOGFI("run HandleRegisterSessionChangeListener!");
251 sptr<ISessionChangeListener> listener = iface_cast<ISessionChangeListener>(data.ReadRemoteObject());
252 WSError errCode = RegisterSessionListener(listener);
253 reply.WriteInt32(static_cast<int32_t>(errCode));
254 return ERR_NONE;
255 }
256
HandleUnRegisterSessionChangeListener(MessageParcel & data,MessageParcel & reply)257 int SceneSessionManagerStub::HandleUnRegisterSessionChangeListener(MessageParcel &data, MessageParcel &reply)
258 {
259 WLOGFI("run HandleUnRegisterSessionChangeListener!");
260 UnregisterSessionListener();
261 return ERR_NONE;
262 }
263
HandlePendingSessionToForeground(MessageParcel & data,MessageParcel & reply)264 int SceneSessionManagerStub::HandlePendingSessionToForeground(MessageParcel &data, MessageParcel &reply)
265 {
266 WLOGFI("run HandlePendingSessionToForeground!");
267 sptr<IRemoteObject> token = data.ReadRemoteObject();
268 const WSError& errCode = PendingSessionToForeground(token);
269 reply.WriteUint32(static_cast<uint32_t>(errCode));
270 return ERR_NONE;
271 }
272
HandlePendingSessionToBackgroundForDelegator(MessageParcel & data,MessageParcel & reply)273 int SceneSessionManagerStub::HandlePendingSessionToBackgroundForDelegator(MessageParcel &data, MessageParcel &reply)
274 {
275 WLOGFI("run HandlePendingSessionToBackground!");
276 sptr<IRemoteObject> token = data.ReadRemoteObject();
277 const WSError& errCode = PendingSessionToBackgroundForDelegator(token);
278 reply.WriteInt32(static_cast<int32_t>(errCode));
279 return ERR_NONE;
280 }
281
HandleRegisterSessionListener(MessageParcel & data,MessageParcel & reply)282 int SceneSessionManagerStub::HandleRegisterSessionListener(MessageParcel& data, MessageParcel& reply)
283 {
284 WLOGFI("run HandleRegisterSessionListener!");
285 sptr<ISessionListener> listener = iface_cast<ISessionListener>(data.ReadRemoteObject());
286 WSError errCode = RegisterSessionListener(listener);
287 reply.WriteInt32(static_cast<int32_t>(errCode));
288 return ERR_NONE;
289 }
290
HandleUnRegisterSessionListener(MessageParcel & data,MessageParcel & reply)291 int SceneSessionManagerStub::HandleUnRegisterSessionListener(MessageParcel& data, MessageParcel& reply)
292 {
293 WLOGFI("run HandleUnRegisterSessionListener!");
294 sptr<ISessionListener> listener = iface_cast<ISessionListener>(data.ReadRemoteObject());
295 WSError errCode = UnRegisterSessionListener(listener);
296 reply.WriteInt32(static_cast<int32_t>(errCode));
297 return ERR_NONE;
298 }
299
HandleGetSessionInfos(MessageParcel & data,MessageParcel & reply)300 int SceneSessionManagerStub::HandleGetSessionInfos(MessageParcel& data, MessageParcel& reply)
301 {
302 WLOGFI("run HandleGetSessionInfos!");
303 std::string deviceId = Str16ToStr8(data.ReadString16());
304 int numMax = data.ReadInt32();
305 std::vector<SessionInfoBean> missionInfos;
306 WSError errCode = GetSessionInfos(deviceId, numMax, missionInfos);
307 reply.WriteInt32(missionInfos.size());
308 for (auto& it : missionInfos) {
309 if (!reply.WriteParcelable(&it)) {
310 WLOGFE("GetSessionInfos error");
311 return ERR_INVALID_DATA;
312 }
313 }
314 if (!reply.WriteInt32(static_cast<int32_t>(errCode))) {
315 return ERR_INVALID_DATA;
316 }
317 return ERR_NONE;
318 }
319
HandleGetSessionInfo(MessageParcel & data,MessageParcel & reply)320 int SceneSessionManagerStub::HandleGetSessionInfo(MessageParcel& data, MessageParcel& reply)
321 {
322 WLOGFI("run HandleGetSessionInfo!");
323 SessionInfoBean info;
324 std::string deviceId = Str16ToStr8(data.ReadString16());
325 int32_t persistentId = data.ReadInt32();
326 WSError errCode = GetSessionInfo(deviceId, persistentId, info);
327 if (!reply.WriteParcelable(&info)) {
328 WLOGFE("GetSessionInfo error");
329 return ERR_INVALID_DATA;
330 }
331
332 if (!reply.WriteInt32(static_cast<int32_t>(errCode))) {
333 WLOGFE("GetSessionInfo result error");
334 return ERR_INVALID_DATA;
335 }
336 return ERR_NONE;
337 }
338
HandleTerminateSessionNew(MessageParcel & data,MessageParcel & reply)339 int SceneSessionManagerStub::HandleTerminateSessionNew(MessageParcel& data, MessageParcel& reply)
340 {
341 WLOGFD("run HandleTerminateSessionNew");
342 sptr<AAFwk::SessionInfo> abilitySessionInfo(new AAFwk::SessionInfo());
343 std::unique_ptr<AAFwk::Want> want(data.ReadParcelable<AAFwk::Want>());
344 abilitySessionInfo->want = *want;
345 if (data.ReadBool()) {
346 abilitySessionInfo->callerToken = data.ReadRemoteObject();
347 }
348 if (data.ReadBool()) {
349 abilitySessionInfo->sessionToken = data.ReadRemoteObject();
350 }
351 bool needStartCaller = data.ReadBool();
352 abilitySessionInfo->resultCode = data.ReadInt32();
353 const WSError& errCode = TerminateSessionNew(abilitySessionInfo, needStartCaller);
354 reply.WriteUint32(static_cast<uint32_t>(errCode));
355 return ERR_NONE;
356 }
357
HandleGetFocusSessionToken(MessageParcel & data,MessageParcel & reply)358 int SceneSessionManagerStub::HandleGetFocusSessionToken(MessageParcel &data, MessageParcel &reply)
359 {
360 WLOGFI("run HandleGetFocusSessionToken!");
361 sptr<IRemoteObject> token = nullptr;
362 const WSError& errCode = GetFocusSessionToken(token);
363 reply.WriteRemoteObject(token);
364 reply.WriteInt32(static_cast<int32_t>(errCode));
365 return ERR_NONE;
366 }
367
HandleSetGestureNavigationEnabled(MessageParcel & data,MessageParcel & reply)368 int SceneSessionManagerStub::HandleSetGestureNavigationEnabled(MessageParcel &data, MessageParcel &reply)
369 {
370 WLOGFI("run HandleGetFocusSessionToken!");
371 bool enable = data.ReadBool();
372 const WMError &ret = SetGestureNavigaionEnabled(enable);
373 reply.WriteInt32(static_cast<int32_t>(ret));
374 return ERR_NONE;
375 }
376
HandleGetAccessibilityWindowInfo(MessageParcel & data,MessageParcel & reply)377 int SceneSessionManagerStub::HandleGetAccessibilityWindowInfo(MessageParcel &data, MessageParcel &reply)
378 {
379 std::vector<sptr<AccessibilityWindowInfo>> infos;
380 WMError errCode = GetAccessibilityWindowInfo(infos);
381 if (!MarshallingHelper::MarshallingVectorParcelableObj<AccessibilityWindowInfo>(reply, infos)) {
382 WLOGFE("Write window infos failed.");
383 return ERR_TRANSACTION_FAILED;
384 }
385 reply.WriteInt32(static_cast<int32_t>(errCode));
386 return ERR_NONE;
387 }
388
HandleSetSessionContinueState(MessageParcel & data,MessageParcel & reply)389 int SceneSessionManagerStub::HandleSetSessionContinueState(MessageParcel &data, MessageParcel &reply)
390 {
391 WLOGFI("HandleSetSessionContinueState");
392 sptr <IRemoteObject> token = data.ReadRemoteObject();
393 auto continueState = static_cast<ContinueState>(data.ReadInt32());
394 const WSError &ret = SetSessionContinueState(token, continueState);
395 reply.WriteUint32(static_cast<uint32_t>(ret));
396 return ERR_NONE;
397 }
398
HandleSetSessionGravity(MessageParcel & data,MessageParcel & reply)399 int SceneSessionManagerStub::HandleSetSessionGravity(MessageParcel &data, MessageParcel &reply)
400 {
401 WLOGFI("run HandleSetSessionGravity!");
402 auto persistentId = data.ReadInt32();
403 SessionGravity gravity = static_cast<SessionGravity>(data.ReadUint32());
404 uint32_t percent = data.ReadUint32();
405 WSError ret = SetSessionGravity(persistentId, gravity, percent);
406 reply.WriteInt32(static_cast<int32_t>(ret));
407 return ERR_NONE;
408 }
409
HandleGetSessionDump(MessageParcel & data,MessageParcel & reply)410 int SceneSessionManagerStub::HandleGetSessionDump(MessageParcel &data, MessageParcel &reply)
411 {
412 WLOGFI("run HandleGetSessionDump");
413 std::vector<std::string> params;
414 if (!data.ReadStringVector(¶ms)) {
415 WLOGFE("Fail to read params");
416 return -1;
417 }
418 std::string dumpInfo;
419 WSError errCode = GetSessionDumpInfo(params, dumpInfo);
420 reply.WriteString(dumpInfo);
421 reply.WriteInt32(static_cast<int32_t>(errCode));
422 return ERR_NONE;
423 }
424
HandleUpdateSessionAvoidAreaListener(MessageParcel & data,MessageParcel & reply)425 int SceneSessionManagerStub::HandleUpdateSessionAvoidAreaListener(MessageParcel& data, MessageParcel& reply)
426 {
427 auto persistentId = data.ReadInt32();
428 bool haveAvoidAreaListener = data.ReadBool();
429 WSError errCode = UpdateSessionAvoidAreaListener(persistentId, haveAvoidAreaListener);
430 reply.WriteUint32(static_cast<uint32_t>(errCode));
431 return ERR_NONE;
432 }
433
HandleBindDialogTarget(MessageParcel & data,MessageParcel & reply)434 int SceneSessionManagerStub::HandleBindDialogTarget(MessageParcel &data, MessageParcel &reply)
435 {
436 WLOGFI("run HandleBindDialogTarget!");
437 auto persistentId = data.ReadUint64();
438 sptr<IRemoteObject> remoteObject = data.ReadRemoteObject();
439 const WSError& ret = BindDialogTarget(persistentId, remoteObject);
440 reply.WriteUint32(static_cast<uint32_t>(ret));
441 return ERR_NONE;
442 }
443
HandleGetSessionSnapshot(MessageParcel & data,MessageParcel & reply)444 int SceneSessionManagerStub::HandleGetSessionSnapshot(MessageParcel &data, MessageParcel &reply)
445 {
446 WLOGFI("run HandleGetSessionSnapshot!");
447 std::string deviceId = Str16ToStr8(data.ReadString16());
448 int32_t persistentId = data.ReadInt32();
449 bool isLowResolution = data.ReadBool();
450 std::shared_ptr<Media::PixelMap> snapshot = std::make_shared<Media::PixelMap>();
451 const WSError& ret = GetSessionSnapshot(deviceId, persistentId, snapshot, isLowResolution);
452 reply.WriteParcelable(snapshot.get());
453 reply.WriteUint32(static_cast<uint32_t>(ret));
454 return ERR_NONE;
455 }
456
HandleNotifyDumpInfoResult(MessageParcel & data,MessageParcel & reply)457 int SceneSessionManagerStub::HandleNotifyDumpInfoResult(MessageParcel &data, MessageParcel &reply)
458 {
459 WLOGFI("HandleNotifyDumpInfoResult");
460 std::vector<std::string> info;
461 data.ReadStringVector(&info);
462 NotifyDumpInfoResult(info);
463 return ERR_NONE;
464 }
465
HandleClearSession(MessageParcel & data,MessageParcel & reply)466 int SceneSessionManagerStub::HandleClearSession(MessageParcel &data, MessageParcel &reply)
467 {
468 WLOGFI("run HandleClearSession!");
469 int32_t persistentId = data.ReadInt32();
470 const WSError& ret = ClearSession(persistentId);
471 reply.WriteUint32(static_cast<uint32_t>(ret));
472 return ERR_NONE;
473 }
474
HandleClearAllSessions(MessageParcel & data,MessageParcel & reply)475 int SceneSessionManagerStub::HandleClearAllSessions(MessageParcel &data, MessageParcel &reply)
476 {
477 WLOGFI("run HandleClearAllSessions!");
478 const WSError& ret = ClearAllSessions();
479 reply.WriteUint32(static_cast<uint32_t>(ret));
480 return ERR_NONE;
481 }
482
HandleRegisterCollaborator(MessageParcel & data,MessageParcel & reply)483 int SceneSessionManagerStub::HandleRegisterCollaborator(MessageParcel &data, MessageParcel &reply)
484 {
485 WLOGFI("run HandleRegisterCollaborator!");
486 int32_t type = data.ReadInt32();
487 sptr<AAFwk::IAbilityManagerCollaborator> collaborator = iface_cast<AAFwk::IAbilityManagerCollaborator>(data.ReadRemoteObject());
488 const WSError& ret = RegisterIAbilityManagerCollaborator(type, collaborator);
489 reply.WriteUint32(static_cast<uint32_t>(ret));
490 return ERR_NONE;
491 }
492
HandleUnregisterCollaborator(MessageParcel & data,MessageParcel & reply)493 int SceneSessionManagerStub::HandleUnregisterCollaborator(MessageParcel &data, MessageParcel &reply)
494 {
495 WLOGFI("run HandleUnregisterCollaborator!");
496 int32_t type = data.ReadInt32();
497 const WSError& ret = UnregisterIAbilityManagerCollaborator(type);
498 reply.WriteUint32(static_cast<uint32_t>(ret));
499 return ERR_NONE;
500 }
501 } // namespace OHOS::Rosen
502