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 "ability_manager_stub.h"
17
18 #include "errors.h"
19 #include "string_ex.h"
20
21 #include "ability_connect_callback_proxy.h"
22 #include "ability_connect_callback_stub.h"
23 #include "ability_manager_errors.h"
24 #include "ability_scheduler_proxy.h"
25 #include "ability_scheduler_stub.h"
26
27 namespace OHOS {
28 namespace AAFwk {
AbilityManagerStub()29 AbilityManagerStub::AbilityManagerStub()
30 {
31 FirstStepInit();
32 SecondStepInit();
33 ThirdStepInit();
34 }
35
~AbilityManagerStub()36 AbilityManagerStub::~AbilityManagerStub()
37 {
38 requestFuncMap_.clear();
39 }
40
FirstStepInit()41 void AbilityManagerStub::FirstStepInit()
42 {
43 requestFuncMap_[TERMINATE_ABILITY] = &AbilityManagerStub::TerminateAbilityInner;
44 requestFuncMap_[TERMINATE_ABILITY_BY_CALLER] = &AbilityManagerStub::TerminateAbilityByCallerInner;
45 requestFuncMap_[MINIMIZE_ABILITY] = &AbilityManagerStub::MinimizeAbilityInner;
46 requestFuncMap_[ATTACH_ABILITY_THREAD] = &AbilityManagerStub::AttachAbilityThreadInner;
47 requestFuncMap_[ABILITY_TRANSITION_DONE] = &AbilityManagerStub::AbilityTransitionDoneInner;
48 requestFuncMap_[CONNECT_ABILITY_DONE] = &AbilityManagerStub::ScheduleConnectAbilityDoneInner;
49 requestFuncMap_[DISCONNECT_ABILITY_DONE] = &AbilityManagerStub::ScheduleDisconnectAbilityDoneInner;
50 requestFuncMap_[TERMINATE_ABILITY_RESULT] = &AbilityManagerStub::TerminateAbilityResultInner;
51 requestFuncMap_[COMMAND_ABILITY_DONE] = &AbilityManagerStub::ScheduleCommandAbilityDoneInner;
52 requestFuncMap_[ACQUIRE_DATA_ABILITY] = &AbilityManagerStub::AcquireDataAbilityInner;
53 requestFuncMap_[RELEASE_DATA_ABILITY] = &AbilityManagerStub::ReleaseDataAbilityInner;
54 requestFuncMap_[KILL_PROCESS] = &AbilityManagerStub::KillProcessInner;
55 requestFuncMap_[UNINSTALL_APP] = &AbilityManagerStub::UninstallAppInner;
56 requestFuncMap_[START_ABILITY] = &AbilityManagerStub::StartAbilityInner;
57 requestFuncMap_[START_ABILITY_ADD_CALLER] = &AbilityManagerStub::StartAbilityAddCallerInner;
58 requestFuncMap_[CONNECT_ABILITY] = &AbilityManagerStub::ConnectAbilityInner;
59 requestFuncMap_[DISCONNECT_ABILITY] = &AbilityManagerStub::DisconnectAbilityInner;
60 requestFuncMap_[STOP_SERVICE_ABILITY] = &AbilityManagerStub::StopServiceAbilityInner;
61 requestFuncMap_[DUMP_STATE] = &AbilityManagerStub::DumpStateInner;
62 requestFuncMap_[DUMPSYS_STATE] = &AbilityManagerStub::DumpSysStateInner;
63 requestFuncMap_[START_ABILITY_FOR_SETTINGS] = &AbilityManagerStub::StartAbilityForSettingsInner;
64 requestFuncMap_[CONTINUE_MISSION] = &AbilityManagerStub::ContinueMissionInner;
65 requestFuncMap_[CONTINUE_ABILITY] = &AbilityManagerStub::ContinueAbilityInner;
66 requestFuncMap_[START_CONTINUATION] = &AbilityManagerStub::StartContinuationInner;
67 requestFuncMap_[NOTIFY_COMPLETE_CONTINUATION] = &AbilityManagerStub::NotifyCompleteContinuationInner;
68 requestFuncMap_[NOTIFY_CONTINUATION_RESULT] = &AbilityManagerStub::NotifyContinuationResultInner;
69 requestFuncMap_[SEND_RESULT_TO_ABILITY] = &AbilityManagerStub::SendResultToAbilityInner;
70 requestFuncMap_[REGISTER_REMOTE_MISSION_LISTENER] = &AbilityManagerStub::RegisterRemoteMissionListenerInner;
71 requestFuncMap_[UNREGISTER_REMOTE_MISSION_LISTENER] = &AbilityManagerStub::UnRegisterRemoteMissionListenerInner;
72 requestFuncMap_[START_ABILITY_FOR_OPTIONS] = &AbilityManagerStub::StartAbilityForOptionsInner;
73 requestFuncMap_[START_SYNC_MISSIONS] = &AbilityManagerStub::StartSyncRemoteMissionsInner;
74 requestFuncMap_[STOP_SYNC_MISSIONS] = &AbilityManagerStub::StopSyncRemoteMissionsInner;
75 #ifdef ABILITY_COMMAND_FOR_TEST
76 requestFuncMap_[FORCE_TIMEOUT] = &AbilityManagerStub::ForceTimeoutForTestInner;
77 #endif
78 requestFuncMap_[FREE_INSTALL_ABILITY_FROM_REMOTE] = &AbilityManagerStub::FreeInstallAbilityFromRemoteInner;
79 requestFuncMap_[CONNECT_ABILITY_WITH_TYPE] = &AbilityManagerStub::ConnectAbilityWithTypeInner;
80 requestFuncMap_[ABILITY_RECOVERY] = &AbilityManagerStub::ScheduleRecoverAbilityInner;
81 requestFuncMap_[ABILITY_RECOVERY_ENABLE] = &AbilityManagerStub::EnableRecoverAbilityInner;
82 }
83
SecondStepInit()84 void AbilityManagerStub::SecondStepInit()
85 {
86 requestFuncMap_[GET_PENDING_WANT_SENDER] = &AbilityManagerStub::GetWantSenderInner;
87 requestFuncMap_[SEND_PENDING_WANT_SENDER] = &AbilityManagerStub::SendWantSenderInner;
88 requestFuncMap_[CANCEL_PENDING_WANT_SENDER] = &AbilityManagerStub::CancelWantSenderInner;
89 requestFuncMap_[GET_PENDING_WANT_UID] = &AbilityManagerStub::GetPendingWantUidInner;
90 requestFuncMap_[GET_PENDING_WANT_USERID] = &AbilityManagerStub::GetPendingWantUserIdInner;
91 requestFuncMap_[GET_PENDING_WANT_BUNDLENAME] = &AbilityManagerStub::GetPendingWantBundleNameInner;
92 requestFuncMap_[GET_PENDING_WANT_CODE] = &AbilityManagerStub::GetPendingWantCodeInner;
93 requestFuncMap_[GET_PENDING_WANT_TYPE] = &AbilityManagerStub::GetPendingWantTypeInner;
94 requestFuncMap_[REGISTER_CANCEL_LISTENER] = &AbilityManagerStub::RegisterCancelListenerInner;
95 requestFuncMap_[UNREGISTER_CANCEL_LISTENER] = &AbilityManagerStub::UnregisterCancelListenerInner;
96 requestFuncMap_[GET_PENDING_REQUEST_WANT] = &AbilityManagerStub::GetPendingRequestWantInner;
97 requestFuncMap_[GET_PENDING_WANT_SENDER_INFO] = &AbilityManagerStub::GetPendingRequestWantInner;
98 requestFuncMap_[GET_APP_MEMORY_SIZE] = &AbilityManagerStub::GetAppMemorySizeInner;
99 requestFuncMap_[IS_RAM_CONSTRAINED_DEVICE] = &AbilityManagerStub::IsRamConstrainedDeviceInner;
100 requestFuncMap_[CLEAR_UP_APPLICATION_DATA] = &AbilityManagerStub::ClearUpApplicationDataInner;
101 requestFuncMap_[LOCK_MISSION_FOR_CLEANUP] = &AbilityManagerStub::LockMissionForCleanupInner;
102 requestFuncMap_[UNLOCK_MISSION_FOR_CLEANUP] = &AbilityManagerStub::UnlockMissionForCleanupInner;
103 requestFuncMap_[REGISTER_MISSION_LISTENER] = &AbilityManagerStub::RegisterMissionListenerInner;
104 requestFuncMap_[UNREGISTER_MISSION_LISTENER] = &AbilityManagerStub::UnRegisterMissionListenerInner;
105 requestFuncMap_[GET_MISSION_INFOS] = &AbilityManagerStub::GetMissionInfosInner;
106 requestFuncMap_[GET_MISSION_INFO_BY_ID] = &AbilityManagerStub::GetMissionInfoInner;
107 requestFuncMap_[CLEAN_MISSION] = &AbilityManagerStub::CleanMissionInner;
108 requestFuncMap_[CLEAN_ALL_MISSIONS] = &AbilityManagerStub::CleanAllMissionsInner;
109 requestFuncMap_[MOVE_MISSION_TO_FRONT] = &AbilityManagerStub::MoveMissionToFrontInner;
110 requestFuncMap_[MOVE_MISSION_TO_FRONT_BY_OPTIONS] = &AbilityManagerStub::MoveMissionToFrontByOptionsInner;
111 requestFuncMap_[START_CALL_ABILITY] = &AbilityManagerStub::StartAbilityByCallInner;
112 requestFuncMap_[CALL_REQUEST_DONE] = &AbilityManagerStub::CallRequestDoneInner;
113 requestFuncMap_[RELEASE_CALL_ABILITY] = &AbilityManagerStub::ReleaseCallInner;
114 requestFuncMap_[START_USER] = &AbilityManagerStub::StartUserInner;
115 requestFuncMap_[STOP_USER] = &AbilityManagerStub::StopUserInner;
116 requestFuncMap_[GET_ABILITY_RUNNING_INFO] = &AbilityManagerStub::GetAbilityRunningInfosInner;
117 requestFuncMap_[GET_EXTENSION_RUNNING_INFO] = &AbilityManagerStub::GetExtensionRunningInfosInner;
118 requestFuncMap_[GET_PROCESS_RUNNING_INFO] = &AbilityManagerStub::GetProcessRunningInfosInner;
119 requestFuncMap_[SET_ABILITY_CONTROLLER] = &AbilityManagerStub::SetAbilityControllerInner;
120 requestFuncMap_[GET_MISSION_SNAPSHOT_INFO] = &AbilityManagerStub::GetMissionSnapshotInfoInner;
121 requestFuncMap_[IS_USER_A_STABILITY_TEST] = &AbilityManagerStub::IsRunningInStabilityTestInner;
122 requestFuncMap_[SEND_APP_NOT_RESPONSE_PROCESS_ID] = &AbilityManagerStub::SendANRProcessIDInner;
123 #ifdef ABILITY_COMMAND_FOR_TEST
124 requestFuncMap_[BLOCK_ABILITY] = &AbilityManagerStub::BlockAbilityInner;
125 requestFuncMap_[BLOCK_AMS_SERVICE] = &AbilityManagerStub::BlockAmsServiceInner;
126 requestFuncMap_[BLOCK_APP_SERVICE] = &AbilityManagerStub::BlockAppServiceInner;
127 #endif
128 }
129
ThirdStepInit()130 void AbilityManagerStub::ThirdStepInit()
131 {
132 requestFuncMap_[START_USER_TEST] = &AbilityManagerStub::StartUserTestInner;
133 requestFuncMap_[FINISH_USER_TEST] = &AbilityManagerStub::FinishUserTestInner;
134 requestFuncMap_[GET_TOP_ABILITY_TOKEN] = &AbilityManagerStub::GetTopAbilityTokenInner;
135 requestFuncMap_[DELEGATOR_DO_ABILITY_FOREGROUND] = &AbilityManagerStub::DelegatorDoAbilityForegroundInner;
136 requestFuncMap_[DELEGATOR_DO_ABILITY_BACKGROUND] = &AbilityManagerStub::DelegatorDoAbilityBackgroundInner;
137 requestFuncMap_[DO_ABILITY_FOREGROUND] = &AbilityManagerStub::DoAbilityForegroundInner;
138 requestFuncMap_[DO_ABILITY_BACKGROUND] = &AbilityManagerStub::DoAbilityBackgroundInner;
139 requestFuncMap_[GET_MISSION_ID_BY_ABILITY_TOKEN] = &AbilityManagerStub::GetMissionIdByTokenInner;
140 requestFuncMap_[GET_TOP_ABILITY] = &AbilityManagerStub::GetTopAbilityInner;
141 requestFuncMap_[DUMP_ABILITY_INFO_DONE] = &AbilityManagerStub::DumpAbilityInfoDoneInner;
142 requestFuncMap_[START_EXTENSION_ABILITY] = &AbilityManagerStub::StartExtensionAbilityInner;
143 requestFuncMap_[STOP_EXTENSION_ABILITY] = &AbilityManagerStub::StopExtensionAbilityInner;
144 requestFuncMap_[UPDATE_MISSION_SNAPSHOT] = &AbilityManagerStub::UpdateMissionSnapShotInner;
145 requestFuncMap_[REGISTER_CONNECTION_OBSERVER] = &AbilityManagerStub::RegisterConnectionObserverInner;
146 requestFuncMap_[UNREGISTER_CONNECTION_OBSERVER] = &AbilityManagerStub::UnregisterConnectionObserverInner;
147 requestFuncMap_[GET_DLP_CONNECTION_INFOS] = &AbilityManagerStub::GetDlpConnectionInfosInner;
148 #ifdef SUPPORT_GRAPHICS
149 requestFuncMap_[SET_MISSION_LABEL] = &AbilityManagerStub::SetMissionLabelInner;
150 requestFuncMap_[SET_MISSION_ICON] = &AbilityManagerStub::SetMissionIconInner;
151 requestFuncMap_[REGISTER_WMS_HANDLER] = &AbilityManagerStub::RegisterWindowManagerServiceHandlerInner;
152 requestFuncMap_[COMPLETEFIRSTFRAMEDRAWING] = &AbilityManagerStub::CompleteFirstFrameDrawingInner;
153 #endif
154 requestFuncMap_[SET_COMPONENT_INTERCEPTION] = &AbilityManagerStub::SetComponentInterceptionInner;
155 requestFuncMap_[SEND_ABILITY_RESULT_BY_TOKEN] = &AbilityManagerStub::SendResultToAbilityByTokenInner;
156 }
157
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)158 int AbilityManagerStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
159 {
160 std::u16string descriptor = AbilityManagerStub::GetDescriptor();
161 std::u16string remoteDescriptor = data.ReadInterfaceToken();
162 if (descriptor != remoteDescriptor) {
163 HILOG_INFO("local descriptor is not equal to remote");
164 return ERR_INVALID_STATE;
165 }
166
167 auto itFunc = requestFuncMap_.find(code);
168 if (itFunc != requestFuncMap_.end()) {
169 auto requestFunc = itFunc->second;
170 if (requestFunc != nullptr) {
171 return (this->*requestFunc)(data, reply);
172 }
173 }
174 HILOG_WARN("default case, need check.");
175 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
176 }
177
GetTopAbilityInner(MessageParcel & data,MessageParcel & reply)178 int AbilityManagerStub::GetTopAbilityInner(MessageParcel &data, MessageParcel &reply)
179 {
180 AppExecFwk::ElementName result = GetTopAbility();
181 if (result.GetDeviceID().empty()) {
182 HILOG_DEBUG("GetTopAbilityInner is nullptr");
183 }
184 reply.WriteParcelable(&result);
185 return NO_ERROR;
186 }
187
TerminateAbilityInner(MessageParcel & data,MessageParcel & reply)188 int AbilityManagerStub::TerminateAbilityInner(MessageParcel &data, MessageParcel &reply)
189 {
190 sptr<IRemoteObject> token = nullptr;
191 if (data.ReadBool()) {
192 token = data.ReadRemoteObject();
193 }
194 int resultCode = data.ReadInt32();
195 Want *resultWant = data.ReadParcelable<Want>();
196 bool flag = data.ReadBool();
197 int32_t result;
198 if (flag) {
199 result = TerminateAbility(token, resultCode, resultWant);
200 } else {
201 result = CloseAbility(token, resultCode, resultWant);
202 }
203 reply.WriteInt32(result);
204 if (resultWant != nullptr) {
205 delete resultWant;
206 }
207 return NO_ERROR;
208 }
209
SendResultToAbilityInner(MessageParcel & data,MessageParcel & reply)210 int AbilityManagerStub::SendResultToAbilityInner(MessageParcel &data, MessageParcel &reply)
211 {
212 int requestCode = data.ReadInt32();
213 int resultCode = data.ReadInt32();
214 Want *resultWant = data.ReadParcelable<Want>();
215 if (resultWant == nullptr) {
216 HILOG_ERROR("resultWant is nullptr");
217 return ERR_INVALID_VALUE;
218 }
219 int32_t result = SendResultToAbility(requestCode, resultCode, *resultWant);
220 reply.WriteInt32(result);
221 if (resultWant != nullptr) {
222 delete resultWant;
223 }
224 return NO_ERROR;
225 }
226
TerminateAbilityByCallerInner(MessageParcel & data,MessageParcel & reply)227 int AbilityManagerStub::TerminateAbilityByCallerInner(MessageParcel &data, MessageParcel &reply)
228 {
229 sptr<IRemoteObject> callerToken = nullptr;
230 if (data.ReadBool()) {
231 callerToken = data.ReadRemoteObject();
232 }
233 int requestCode = data.ReadInt32();
234 int32_t result = TerminateAbilityByCaller(callerToken, requestCode);
235 reply.WriteInt32(result);
236 return NO_ERROR;
237 }
238
MinimizeAbilityInner(MessageParcel & data,MessageParcel & reply)239 int AbilityManagerStub::MinimizeAbilityInner(MessageParcel &data, MessageParcel &reply)
240 {
241 auto token = data.ReadRemoteObject();
242 auto fromUser = data.ReadBool();
243 int32_t result = MinimizeAbility(token, fromUser);
244 reply.WriteInt32(result);
245 return NO_ERROR;
246 }
247
AttachAbilityThreadInner(MessageParcel & data,MessageParcel & reply)248 int AbilityManagerStub::AttachAbilityThreadInner(MessageParcel &data, MessageParcel &reply)
249 {
250 auto scheduler = iface_cast<IAbilityScheduler>(data.ReadRemoteObject());
251 auto token = data.ReadRemoteObject();
252 int32_t result = AttachAbilityThread(scheduler, token);
253 reply.WriteInt32(result);
254 return NO_ERROR;
255 }
256
AbilityTransitionDoneInner(MessageParcel & data,MessageParcel & reply)257 int AbilityManagerStub::AbilityTransitionDoneInner(MessageParcel &data, MessageParcel &reply)
258 {
259 auto token = data.ReadRemoteObject();
260 int targetState = data.ReadInt32();
261 std::unique_ptr<PacMap> saveData(data.ReadParcelable<PacMap>());
262 if (!saveData) {
263 HILOG_INFO("save data is nullptr");
264 return ERR_INVALID_VALUE;
265 }
266 int32_t result = AbilityTransitionDone(token, targetState, *saveData);
267 reply.WriteInt32(result);
268 return NO_ERROR;
269 }
270
ScheduleConnectAbilityDoneInner(MessageParcel & data,MessageParcel & reply)271 int AbilityManagerStub::ScheduleConnectAbilityDoneInner(MessageParcel &data, MessageParcel &reply)
272 {
273 sptr<IRemoteObject> token = nullptr;
274 sptr<IRemoteObject> remoteObject = nullptr;
275 if (data.ReadBool()) {
276 token = data.ReadRemoteObject();
277 }
278 if (data.ReadBool()) {
279 remoteObject = data.ReadRemoteObject();
280 }
281 int32_t result = ScheduleConnectAbilityDone(token, remoteObject);
282 reply.WriteInt32(result);
283 return NO_ERROR;
284 }
285
ScheduleDisconnectAbilityDoneInner(MessageParcel & data,MessageParcel & reply)286 int AbilityManagerStub::ScheduleDisconnectAbilityDoneInner(MessageParcel &data, MessageParcel &reply)
287 {
288 auto token = data.ReadRemoteObject();
289 int32_t result = ScheduleDisconnectAbilityDone(token);
290 reply.WriteInt32(result);
291 return NO_ERROR;
292 }
293
TerminateAbilityResultInner(MessageParcel & data,MessageParcel & reply)294 int AbilityManagerStub::TerminateAbilityResultInner(MessageParcel &data, MessageParcel &reply)
295 {
296 sptr<IRemoteObject> token = data.ReadRemoteObject();
297 int startId = data.ReadInt32();
298 int32_t result = TerminateAbilityResult(token, startId);
299 reply.WriteInt32(result);
300 return NO_ERROR;
301 }
302
ScheduleCommandAbilityDoneInner(MessageParcel & data,MessageParcel & reply)303 int AbilityManagerStub::ScheduleCommandAbilityDoneInner(MessageParcel &data, MessageParcel &reply)
304 {
305 auto token = data.ReadRemoteObject();
306 int32_t result = ScheduleCommandAbilityDone(token);
307 reply.WriteInt32(result);
308 return NO_ERROR;
309 }
310
AcquireDataAbilityInner(MessageParcel & data,MessageParcel & reply)311 int AbilityManagerStub::AcquireDataAbilityInner(MessageParcel &data, MessageParcel &reply)
312 {
313 std::unique_ptr<Uri> uri(new Uri(data.ReadString()));
314 bool tryBind = data.ReadBool();
315 sptr<IRemoteObject> callerToken = data.ReadRemoteObject();
316 sptr<IAbilityScheduler> result = AcquireDataAbility(*uri, tryBind, callerToken);
317 HILOG_DEBUG("acquire data ability %{public}s", result ? "ok" : "failed");
318 if (result) {
319 reply.WriteRemoteObject(result->AsObject());
320 } else {
321 reply.WriteParcelable(nullptr);
322 }
323 return NO_ERROR;
324 }
325
ReleaseDataAbilityInner(MessageParcel & data,MessageParcel & reply)326 int AbilityManagerStub::ReleaseDataAbilityInner(MessageParcel &data, MessageParcel &reply)
327 {
328 auto scheduler = iface_cast<IAbilityScheduler>(data.ReadRemoteObject());
329 auto callerToken = data.ReadRemoteObject();
330 int32_t result = ReleaseDataAbility(scheduler, callerToken);
331 HILOG_DEBUG("release data ability ret = %d", result);
332 reply.WriteInt32(result);
333 return NO_ERROR;
334 }
335
KillProcessInner(MessageParcel & data,MessageParcel & reply)336 int AbilityManagerStub::KillProcessInner(MessageParcel &data, MessageParcel &reply)
337 {
338 std::string bundleName = Str16ToStr8(data.ReadString16());
339 int result = KillProcess(bundleName);
340 if (!reply.WriteInt32(result)) {
341 HILOG_ERROR("remove stack error");
342 return ERR_INVALID_VALUE;
343 }
344 return NO_ERROR;
345 }
346
ClearUpApplicationDataInner(MessageParcel & data,MessageParcel & reply)347 int AbilityManagerStub::ClearUpApplicationDataInner(MessageParcel &data, MessageParcel &reply)
348 {
349 std::string bundleName = Str16ToStr8(data.ReadString16());
350 int result = ClearUpApplicationData(bundleName);
351 if (!reply.WriteInt32(result)) {
352 HILOG_ERROR("ClearUpApplicationData error");
353 return ERR_INVALID_VALUE;
354 }
355 return NO_ERROR;
356 }
357
UninstallAppInner(MessageParcel & data,MessageParcel & reply)358 int AbilityManagerStub::UninstallAppInner(MessageParcel &data, MessageParcel &reply)
359 {
360 std::string bundleName = Str16ToStr8(data.ReadString16());
361 int32_t uid = data.ReadInt32();
362 int result = UninstallApp(bundleName, uid);
363 if (!reply.WriteInt32(result)) {
364 HILOG_ERROR("remove stack error");
365 return ERR_INVALID_VALUE;
366 }
367 return NO_ERROR;
368 }
369
StartAbilityInner(MessageParcel & data,MessageParcel & reply)370 int AbilityManagerStub::StartAbilityInner(MessageParcel &data, MessageParcel &reply)
371 {
372 Want *want = data.ReadParcelable<Want>();
373 if (want == nullptr) {
374 HILOG_ERROR("want is nullptr");
375 return ERR_INVALID_VALUE;
376 }
377 int32_t userId = data.ReadInt32();
378 int requestCode = data.ReadInt32();
379 int32_t result = StartAbility(*want, userId, requestCode);
380 reply.WriteInt32(result);
381 delete want;
382 return NO_ERROR;
383 }
384
StartExtensionAbilityInner(MessageParcel & data,MessageParcel & reply)385 int AbilityManagerStub::StartExtensionAbilityInner(MessageParcel &data, MessageParcel &reply)
386 {
387 Want *want = data.ReadParcelable<Want>();
388 if (want == nullptr) {
389 HILOG_ERROR("want is nullptr");
390 return ERR_INVALID_VALUE;
391 }
392 sptr<IRemoteObject> callerToken = nullptr;
393 if (data.ReadBool()) {
394 callerToken = data.ReadRemoteObject();
395 }
396 int32_t userId = data.ReadInt32();
397 int32_t extensionType = data.ReadInt32();
398 int32_t result = StartExtensionAbility(*want, callerToken, userId,
399 static_cast<AppExecFwk::ExtensionAbilityType>(extensionType));
400 reply.WriteInt32(result);
401 delete want;
402 return NO_ERROR;
403 }
404
StopExtensionAbilityInner(MessageParcel & data,MessageParcel & reply)405 int AbilityManagerStub::StopExtensionAbilityInner(MessageParcel& data, MessageParcel& reply)
406 {
407 Want* want = data.ReadParcelable<Want>();
408 if (want == nullptr) {
409 HILOG_ERROR("want is nullptr");
410 return ERR_INVALID_VALUE;
411 }
412 sptr<IRemoteObject> callerToken = nullptr;
413 if (data.ReadBool()) {
414 callerToken = data.ReadRemoteObject();
415 }
416 int32_t userId = data.ReadInt32();
417 int32_t extensionType = data.ReadInt32();
418 int32_t result =
419 StopExtensionAbility(*want, callerToken, userId, static_cast<AppExecFwk::ExtensionAbilityType>(extensionType));
420 reply.WriteInt32(result);
421 delete want;
422 return NO_ERROR;
423 }
424
StartAbilityAddCallerInner(MessageParcel & data,MessageParcel & reply)425 int AbilityManagerStub::StartAbilityAddCallerInner(MessageParcel &data, MessageParcel &reply)
426 {
427 Want *want = data.ReadParcelable<Want>();
428 if (want == nullptr) {
429 HILOG_ERROR("want is nullptr");
430 return ERR_INVALID_VALUE;
431 }
432
433 sptr<IRemoteObject> callerToken = nullptr;
434 if (data.ReadBool()) {
435 callerToken = data.ReadRemoteObject();
436 }
437
438 int32_t userId = data.ReadInt32();
439 int requestCode = data.ReadInt32();
440 int32_t result = StartAbility(*want, callerToken, userId, requestCode);
441 reply.WriteInt32(result);
442 delete want;
443 return NO_ERROR;
444 }
445
ConnectAbilityInner(MessageParcel & data,MessageParcel & reply)446 int AbilityManagerStub::ConnectAbilityInner(MessageParcel &data, MessageParcel &reply)
447 {
448 Want *want = data.ReadParcelable<Want>();
449 if (want == nullptr) {
450 HILOG_ERROR("want is nullptr");
451 return ERR_INVALID_VALUE;
452 }
453 sptr<IAbilityConnection> callback = nullptr;
454 sptr<IRemoteObject> token = nullptr;
455 if (data.ReadBool()) {
456 callback = iface_cast<IAbilityConnection>(data.ReadRemoteObject());
457 }
458 if (data.ReadBool()) {
459 token = data.ReadRemoteObject();
460 }
461 int32_t userId = data.ReadInt32();
462 int32_t result = ConnectAbilityCommon(*want, callback, token, AppExecFwk::ExtensionAbilityType::SERVICE, userId);
463 reply.WriteInt32(result);
464 if (want != nullptr) {
465 delete want;
466 }
467 return NO_ERROR;
468 }
469
ConnectAbilityWithTypeInner(MessageParcel & data,MessageParcel & reply)470 int AbilityManagerStub::ConnectAbilityWithTypeInner(MessageParcel &data, MessageParcel &reply)
471 {
472 Want *want = data.ReadParcelable<Want>();
473 if (want == nullptr) {
474 HILOG_ERROR("%{public}s, want is nullptr", __func__);
475 return ERR_INVALID_VALUE;
476 }
477 sptr<IAbilityConnection> callback = nullptr;
478 sptr<IRemoteObject> token = nullptr;
479 if (data.ReadBool()) {
480 callback = iface_cast<IAbilityConnection>(data.ReadRemoteObject());
481 }
482 if (data.ReadBool()) {
483 token = data.ReadRemoteObject();
484 }
485 int32_t userId = data.ReadInt32();
486 AppExecFwk::ExtensionAbilityType extensionType = static_cast<AppExecFwk::ExtensionAbilityType>(data.ReadInt32());
487 int32_t result = ConnectAbilityCommon(*want, callback, token, extensionType, userId);
488 reply.WriteInt32(result);
489 if (want != nullptr) {
490 delete want;
491 }
492 return NO_ERROR;
493 }
494
DisconnectAbilityInner(MessageParcel & data,MessageParcel & reply)495 int AbilityManagerStub::DisconnectAbilityInner(MessageParcel &data, MessageParcel &reply)
496 {
497 auto callback = iface_cast<IAbilityConnection>(data.ReadRemoteObject());
498 int32_t result = DisconnectAbility(callback);
499 HILOG_DEBUG("disconnect ability ret = %d", result);
500 reply.WriteInt32(result);
501 return NO_ERROR;
502 }
503
StopServiceAbilityInner(MessageParcel & data,MessageParcel & reply)504 int AbilityManagerStub::StopServiceAbilityInner(MessageParcel &data, MessageParcel &reply)
505 {
506 Want *want = data.ReadParcelable<Want>();
507 if (want == nullptr) {
508 HILOG_ERROR("want is nullptr");
509 return ERR_INVALID_VALUE;
510 }
511 int32_t userId = data.ReadInt32();
512 int32_t result = StopServiceAbility(*want, userId);
513 reply.WriteInt32(result);
514 delete want;
515 return NO_ERROR;
516 }
517
DumpSysStateInner(MessageParcel & data,MessageParcel & reply)518 int AbilityManagerStub::DumpSysStateInner(MessageParcel &data, MessageParcel &reply)
519 {
520 std::vector<std::string> result;
521 std::string args = Str16ToStr8(data.ReadString16());
522 std::vector<std::string> argList;
523
524 auto isClient = data.ReadBool();
525 auto isUserID = data.ReadBool();
526 auto UserID = data.ReadInt32();
527 SplitStr(args, " ", argList);
528 if (argList.empty()) {
529 return ERR_INVALID_VALUE;
530 }
531 DumpSysState(args, result, isClient, isUserID, UserID);
532 reply.WriteInt32(result.size());
533 for (auto stack : result) {
534 reply.WriteString16(Str8ToStr16(stack));
535 }
536 return NO_ERROR;
537 }
538
DumpStateInner(MessageParcel & data,MessageParcel & reply)539 int AbilityManagerStub::DumpStateInner(MessageParcel &data, MessageParcel &reply)
540 {
541 std::vector<std::string> result;
542 std::string args = Str16ToStr8(data.ReadString16());
543 std::vector<std::string> argList;
544 SplitStr(args, " ", argList);
545 if (argList.empty()) {
546 return ERR_INVALID_VALUE;
547 }
548 DumpState(args, result);
549 reply.WriteInt32(result.size());
550 for (auto stack : result) {
551 reply.WriteString16(Str8ToStr16(stack));
552 }
553 return NO_ERROR;
554 }
555
StartAbilityForSettingsInner(MessageParcel & data,MessageParcel & reply)556 int AbilityManagerStub::StartAbilityForSettingsInner(MessageParcel &data, MessageParcel &reply)
557 {
558 Want *want = data.ReadParcelable<Want>();
559 if (want == nullptr) {
560 HILOG_ERROR("want is nullptr");
561 return ERR_INVALID_VALUE;
562 }
563 AbilityStartSetting *abilityStartSetting = data.ReadParcelable<AbilityStartSetting>();
564 if (abilityStartSetting == nullptr) {
565 HILOG_ERROR("abilityStartSetting is nullptr");
566 delete want;
567 return ERR_INVALID_VALUE;
568 }
569 sptr<IRemoteObject> callerToken = nullptr;
570 if (data.ReadBool()) {
571 callerToken = data.ReadRemoteObject();
572 }
573 int32_t userId = data.ReadInt32();
574 int requestCode = data.ReadInt32();
575 int32_t result = StartAbility(*want, *abilityStartSetting, callerToken, userId, requestCode);
576 reply.WriteInt32(result);
577 delete want;
578 delete abilityStartSetting;
579 return NO_ERROR;
580 }
581
StartAbilityForOptionsInner(MessageParcel & data,MessageParcel & reply)582 int AbilityManagerStub::StartAbilityForOptionsInner(MessageParcel &data, MessageParcel &reply)
583 {
584 Want *want = data.ReadParcelable<Want>();
585 if (want == nullptr) {
586 HILOG_ERROR("want is nullptr");
587 return ERR_INVALID_VALUE;
588 }
589 StartOptions *startOptions = data.ReadParcelable<StartOptions>();
590 if (startOptions == nullptr) {
591 HILOG_ERROR("startOptions is nullptr");
592 delete want;
593 return ERR_INVALID_VALUE;
594 }
595 sptr<IRemoteObject> callerToken = nullptr;
596 if (data.ReadBool()) {
597 callerToken = data.ReadRemoteObject();
598 }
599 int32_t userId = data.ReadInt32();
600 int requestCode = data.ReadInt32();
601 int32_t result = StartAbility(*want, *startOptions, callerToken, userId, requestCode);
602 reply.WriteInt32(result);
603 delete want;
604 delete startOptions;
605 return NO_ERROR;
606 }
607
GetWantSenderInner(MessageParcel & data,MessageParcel & reply)608 int AbilityManagerStub::GetWantSenderInner(MessageParcel &data, MessageParcel &reply)
609 {
610 std::unique_ptr<WantSenderInfo> wantSenderInfo(data.ReadParcelable<WantSenderInfo>());
611 if (wantSenderInfo == nullptr) {
612 HILOG_ERROR("wantSenderInfo is nullptr");
613 return ERR_INVALID_VALUE;
614 }
615 sptr<IRemoteObject> callerToken = nullptr;
616 if (data.ReadBool()) {
617 callerToken = data.ReadRemoteObject();
618 }
619 sptr<IWantSender> wantSender = GetWantSender(*wantSenderInfo, callerToken);
620 if (!reply.WriteRemoteObject(((wantSender == nullptr) ? nullptr : wantSender->AsObject()))) {
621 HILOG_ERROR("failed to reply wantSender instance to client, for write parcel error");
622 return ERR_INVALID_VALUE;
623 }
624 return NO_ERROR;
625 }
626
SendWantSenderInner(MessageParcel & data,MessageParcel & reply)627 int AbilityManagerStub::SendWantSenderInner(MessageParcel &data, MessageParcel &reply)
628 {
629 sptr<IWantSender> wantSender = iface_cast<IWantSender>(data.ReadRemoteObject());
630 if (wantSender == nullptr) {
631 HILOG_ERROR("wantSender is nullptr");
632 return ERR_INVALID_VALUE;
633 }
634 std::unique_ptr<SenderInfo> senderInfo(data.ReadParcelable<SenderInfo>());
635 if (senderInfo == nullptr) {
636 HILOG_ERROR("senderInfo is nullptr");
637 return ERR_INVALID_VALUE;
638 }
639 int32_t result = SendWantSender(wantSender, *senderInfo);
640 reply.WriteInt32(result);
641 return NO_ERROR;
642 }
643
CancelWantSenderInner(MessageParcel & data,MessageParcel & reply)644 int AbilityManagerStub::CancelWantSenderInner(MessageParcel &data, MessageParcel &reply)
645 {
646 sptr<IWantSender> wantSender = iface_cast<IWantSender>(data.ReadRemoteObject());
647 if (wantSender == nullptr) {
648 HILOG_ERROR("wantSender is nullptr");
649 return ERR_INVALID_VALUE;
650 }
651 CancelWantSender(wantSender);
652 return NO_ERROR;
653 }
654
GetPendingWantUidInner(MessageParcel & data,MessageParcel & reply)655 int AbilityManagerStub::GetPendingWantUidInner(MessageParcel &data, MessageParcel &reply)
656 {
657 sptr<IWantSender> wantSender = iface_cast<IWantSender>(data.ReadRemoteObject());
658 if (wantSender == nullptr) {
659 HILOG_ERROR("wantSender is nullptr");
660 return ERR_INVALID_VALUE;
661 }
662
663 int32_t uid = GetPendingWantUid(wantSender);
664 reply.WriteInt32(uid);
665 return NO_ERROR;
666 }
667
GetPendingWantUserIdInner(MessageParcel & data,MessageParcel & reply)668 int AbilityManagerStub::GetPendingWantUserIdInner(MessageParcel &data, MessageParcel &reply)
669 {
670 sptr<IWantSender> wantSender = iface_cast<IWantSender>(data.ReadRemoteObject());
671 if (wantSender == nullptr) {
672 HILOG_ERROR("wantSender is nullptr");
673 return ERR_INVALID_VALUE;
674 }
675
676 int32_t userId = GetPendingWantUserId(wantSender);
677 reply.WriteInt32(userId);
678 return NO_ERROR;
679 }
680
GetPendingWantBundleNameInner(MessageParcel & data,MessageParcel & reply)681 int AbilityManagerStub::GetPendingWantBundleNameInner(MessageParcel &data, MessageParcel &reply)
682 {
683 sptr<IWantSender> wantSender = iface_cast<IWantSender>(data.ReadRemoteObject());
684 if (wantSender == nullptr) {
685 HILOG_ERROR("wantSender is nullptr");
686 return ERR_INVALID_VALUE;
687 }
688
689 std::string bundleName = GetPendingWantBundleName(wantSender);
690 reply.WriteString16(Str8ToStr16(bundleName));
691 return NO_ERROR;
692 }
693
GetPendingWantCodeInner(MessageParcel & data,MessageParcel & reply)694 int AbilityManagerStub::GetPendingWantCodeInner(MessageParcel &data, MessageParcel &reply)
695 {
696 sptr<IWantSender> wantSender = iface_cast<IWantSender>(data.ReadRemoteObject());
697 if (wantSender == nullptr) {
698 HILOG_ERROR("wantSender is nullptr");
699 return ERR_INVALID_VALUE;
700 }
701
702 int32_t code = GetPendingWantCode(wantSender);
703 reply.WriteInt32(code);
704 return NO_ERROR;
705 }
706
GetPendingWantTypeInner(MessageParcel & data,MessageParcel & reply)707 int AbilityManagerStub::GetPendingWantTypeInner(MessageParcel &data, MessageParcel &reply)
708 {
709 sptr<IWantSender> wantSender = iface_cast<IWantSender>(data.ReadRemoteObject());
710 if (wantSender == nullptr) {
711 HILOG_ERROR("wantSender is nullptr");
712 return ERR_INVALID_VALUE;
713 }
714
715 int32_t type = GetPendingWantType(wantSender);
716 reply.WriteInt32(type);
717 return NO_ERROR;
718 }
719
RegisterCancelListenerInner(MessageParcel & data,MessageParcel & reply)720 int AbilityManagerStub::RegisterCancelListenerInner(MessageParcel &data, MessageParcel &reply)
721 {
722 sptr<IWantSender> sender = iface_cast<IWantSender>(data.ReadRemoteObject());
723 if (sender == nullptr) {
724 HILOG_ERROR("sender is nullptr");
725 return ERR_INVALID_VALUE;
726 }
727 sptr<IWantReceiver> receiver = iface_cast<IWantReceiver>(data.ReadRemoteObject());
728 if (receiver == nullptr) {
729 HILOG_ERROR("receiver is nullptr");
730 return ERR_INVALID_VALUE;
731 }
732 RegisterCancelListener(sender, receiver);
733 return NO_ERROR;
734 }
735
UnregisterCancelListenerInner(MessageParcel & data,MessageParcel & reply)736 int AbilityManagerStub::UnregisterCancelListenerInner(MessageParcel &data, MessageParcel &reply)
737 {
738 sptr<IWantSender> sender = iface_cast<IWantSender>(data.ReadRemoteObject());
739 if (sender == nullptr) {
740 HILOG_ERROR("sender is nullptr");
741 return ERR_INVALID_VALUE;
742 }
743 sptr<IWantReceiver> receiver = iface_cast<IWantReceiver>(data.ReadRemoteObject());
744 if (receiver == nullptr) {
745 HILOG_ERROR("receiver is nullptr");
746 return ERR_INVALID_VALUE;
747 }
748 UnregisterCancelListener(sender, receiver);
749 return NO_ERROR;
750 }
751
GetPendingRequestWantInner(MessageParcel & data,MessageParcel & reply)752 int AbilityManagerStub::GetPendingRequestWantInner(MessageParcel &data, MessageParcel &reply)
753 {
754 sptr<IWantSender> wantSender = iface_cast<IWantSender>(data.ReadRemoteObject());
755 if (wantSender == nullptr) {
756 HILOG_ERROR("wantSender is nullptr");
757 return ERR_INVALID_VALUE;
758 }
759
760 std::shared_ptr<Want> want(data.ReadParcelable<Want>());
761 int32_t result = GetPendingRequestWant(wantSender, want);
762 if (result != NO_ERROR) {
763 HILOG_ERROR("GetPendingRequestWant is failed");
764 return ERR_INVALID_VALUE;
765 }
766 reply.WriteParcelable(want.get());
767 return NO_ERROR;
768 }
769
GetWantSenderInfoInner(MessageParcel & data,MessageParcel & reply)770 int AbilityManagerStub::GetWantSenderInfoInner(MessageParcel &data, MessageParcel &reply)
771 {
772 sptr<IWantSender> wantSender = iface_cast<IWantSender>(data.ReadRemoteObject());
773 if (wantSender == nullptr) {
774 HILOG_ERROR("wantSender is nullptr");
775 return ERR_INVALID_VALUE;
776 }
777
778 std::shared_ptr<WantSenderInfo> info(data.ReadParcelable<WantSenderInfo>());
779 int32_t result = GetWantSenderInfo(wantSender, info);
780 if (result != NO_ERROR) {
781 HILOG_ERROR("GetWantSenderInfo is failed");
782 return ERR_INVALID_VALUE;
783 }
784 reply.WriteParcelable(info.get());
785 return NO_ERROR;
786 }
787
GetAppMemorySizeInner(MessageParcel & data,MessageParcel & reply)788 int AbilityManagerStub::GetAppMemorySizeInner(MessageParcel &data, MessageParcel &reply)
789 {
790 int32_t result = GetAppMemorySize();
791 HILOG_INFO("GetAppMemorySizeInner result %{public}d", result);
792 if (!reply.WriteInt32(result)) {
793 HILOG_ERROR("GetAppMemorySize error");
794 return ERR_INVALID_VALUE;
795 }
796 return NO_ERROR;
797 }
798
IsRamConstrainedDeviceInner(MessageParcel & data,MessageParcel & reply)799 int AbilityManagerStub::IsRamConstrainedDeviceInner(MessageParcel &data, MessageParcel &reply)
800 {
801 auto result = IsRamConstrainedDevice();
802 if (!reply.WriteBool(result)) {
803 HILOG_ERROR("reply write failed.");
804 return ERR_INVALID_VALUE;
805 }
806 return NO_ERROR;
807 }
808
ContinueMissionInner(MessageParcel & data,MessageParcel & reply)809 int AbilityManagerStub::ContinueMissionInner(MessageParcel &data, MessageParcel &reply)
810 {
811 std::string srcDeviceId = data.ReadString();
812 std::string dstDeviceId = data.ReadString();
813 int32_t missionId = data.ReadInt32();
814 sptr<IRemoteObject> callback = data.ReadRemoteObject();
815 if (callback == nullptr) {
816 HILOG_ERROR("ContinueMissionInner callback readParcelable failed!");
817 return ERR_NULL_OBJECT;
818 }
819 std::unique_ptr<WantParams> wantParams(data.ReadParcelable<WantParams>());
820 if (wantParams == nullptr) {
821 HILOG_ERROR("ContinueMissionInner wantParams readParcelable failed!");
822 return ERR_NULL_OBJECT;
823 }
824 int32_t result = ContinueMission(srcDeviceId, dstDeviceId, missionId, callback, *wantParams);
825 HILOG_INFO("ContinueMissionInner result = %{public}d", result);
826 return result;
827 }
828
ContinueAbilityInner(MessageParcel & data,MessageParcel & reply)829 int AbilityManagerStub::ContinueAbilityInner(MessageParcel &data, MessageParcel &reply)
830 {
831 std::string deviceId = data.ReadString();
832 int32_t missionId = data.ReadInt32();
833 uint32_t versionCode = data.ReadUint32();
834 int32_t result = ContinueAbility(deviceId, missionId, versionCode);
835 HILOG_INFO("ContinueAbilityInner result = %{public}d", result);
836 return result;
837 }
838
StartContinuationInner(MessageParcel & data,MessageParcel & reply)839 int AbilityManagerStub::StartContinuationInner(MessageParcel &data, MessageParcel &reply)
840 {
841 std::unique_ptr<Want> want(data.ReadParcelable<Want>());
842 if (want == nullptr) {
843 HILOG_ERROR("StartContinuationInner want readParcelable failed!");
844 return ERR_NULL_OBJECT;
845 }
846
847 sptr<IRemoteObject> abilityToken = data.ReadRemoteObject();
848 if (abilityToken == nullptr) {
849 HILOG_ERROR("Get abilityToken failed!");
850 return ERR_NULL_OBJECT;
851 }
852 int32_t status = data.ReadInt32();
853 int32_t result = StartContinuation(*want, abilityToken, status);
854 HILOG_INFO("StartContinuationInner result = %{public}d", result);
855
856 return result;
857 }
858
NotifyCompleteContinuationInner(MessageParcel & data,MessageParcel & reply)859 int AbilityManagerStub::NotifyCompleteContinuationInner(MessageParcel &data, MessageParcel &reply)
860 {
861 std::string devId = data.ReadString();
862 int32_t sessionId = data.ReadInt32();
863 bool isSuccess = data.ReadBool();
864
865 NotifyCompleteContinuation(devId, sessionId, isSuccess);
866 HILOG_INFO("NotifyCompleteContinuationInner end");
867 return NO_ERROR;
868 }
869
NotifyContinuationResultInner(MessageParcel & data,MessageParcel & reply)870 int AbilityManagerStub::NotifyContinuationResultInner(MessageParcel &data, MessageParcel &reply)
871 {
872 int32_t missionId = data.ReadInt32();
873 int32_t continuationResult = data.ReadInt32();
874
875 int32_t result = NotifyContinuationResult(missionId, continuationResult);
876 HILOG_INFO("StartContinuationInner result = %{public}d", result);
877 return result;
878 }
879
LockMissionForCleanupInner(MessageParcel & data,MessageParcel & reply)880 int AbilityManagerStub::LockMissionForCleanupInner(MessageParcel &data, MessageParcel &reply)
881 {
882 int32_t id = data.ReadInt32();
883 int result = LockMissionForCleanup(id);
884 if (!reply.WriteInt32(result)) {
885 HILOG_ERROR("AbilityManagerStub: lock mission failed.");
886 return ERR_INVALID_VALUE;
887 }
888 return NO_ERROR;
889 }
890
UnlockMissionForCleanupInner(MessageParcel & data,MessageParcel & reply)891 int AbilityManagerStub::UnlockMissionForCleanupInner(MessageParcel &data, MessageParcel &reply)
892 {
893 int32_t id = data.ReadInt32();
894 int result = UnlockMissionForCleanup(id);
895 if (!reply.WriteInt32(result)) {
896 HILOG_ERROR("AbilityManagerStub: unlock mission failed.");
897 return ERR_INVALID_VALUE;
898 }
899 return NO_ERROR;
900 }
901
RegisterMissionListenerInner(MessageParcel & data,MessageParcel & reply)902 int AbilityManagerStub::RegisterMissionListenerInner(MessageParcel &data, MessageParcel &reply)
903 {
904 sptr<IMissionListener> listener = iface_cast<IMissionListener>(data.ReadRemoteObject());
905 if (listener == nullptr) {
906 HILOG_ERROR("stub register mission listener, listener is nullptr.");
907 return ERR_INVALID_VALUE;
908 }
909
910 int32_t result = RegisterMissionListener(listener);
911 reply.WriteInt32(result);
912 return NO_ERROR;
913 }
914
UnRegisterMissionListenerInner(MessageParcel & data,MessageParcel & reply)915 int AbilityManagerStub::UnRegisterMissionListenerInner(MessageParcel &data, MessageParcel &reply)
916 {
917 sptr<IMissionListener> listener = iface_cast<IMissionListener>(data.ReadRemoteObject());
918 if (listener == nullptr) {
919 HILOG_ERROR("stub unregister mission listener, listener is nullptr.");
920 return ERR_INVALID_VALUE;
921 }
922
923 int32_t result = UnRegisterMissionListener(listener);
924 reply.WriteInt32(result);
925 return NO_ERROR;
926 }
927
GetMissionInfosInner(MessageParcel & data,MessageParcel & reply)928 int AbilityManagerStub::GetMissionInfosInner(MessageParcel &data, MessageParcel &reply)
929 {
930 std::string deviceId = Str16ToStr8(data.ReadString16());
931 int numMax = data.ReadInt32();
932 std::vector<MissionInfo> missionInfos;
933 int32_t result = GetMissionInfos(deviceId, numMax, missionInfos);
934 reply.WriteInt32(missionInfos.size());
935 for (auto &it : missionInfos) {
936 if (!reply.WriteParcelable(&it)) {
937 return ERR_INVALID_VALUE;
938 }
939 }
940 if (!reply.WriteInt32(result)) {
941 return ERR_INVALID_VALUE;
942 }
943 return result;
944 }
945
GetMissionInfoInner(MessageParcel & data,MessageParcel & reply)946 int AbilityManagerStub::GetMissionInfoInner(MessageParcel &data, MessageParcel &reply)
947 {
948 MissionInfo info;
949 std::string deviceId = Str16ToStr8(data.ReadString16());
950 int32_t missionId = data.ReadInt32();
951 int result = GetMissionInfo(deviceId, missionId, info);
952 if (!reply.WriteParcelable(&info)) {
953 HILOG_ERROR("GetMissionInfo error");
954 return ERR_INVALID_VALUE;
955 }
956
957 if (!reply.WriteInt32(result)) {
958 HILOG_ERROR("GetMissionInfo result error");
959 return ERR_INVALID_VALUE;
960 }
961 return NO_ERROR;
962 }
963
CleanMissionInner(MessageParcel & data,MessageParcel & reply)964 int AbilityManagerStub::CleanMissionInner(MessageParcel &data, MessageParcel &reply)
965 {
966 int32_t missionId = data.ReadInt32();
967 int result = CleanMission(missionId);
968 if (!reply.WriteInt32(result)) {
969 HILOG_ERROR("CleanMission failed.");
970 return ERR_INVALID_VALUE;
971 }
972 return NO_ERROR;
973 }
974
CleanAllMissionsInner(MessageParcel & data,MessageParcel & reply)975 int AbilityManagerStub::CleanAllMissionsInner(MessageParcel &data, MessageParcel &reply)
976 {
977 int result = CleanAllMissions();
978 if (!reply.WriteInt32(result)) {
979 HILOG_ERROR("CleanAllMissions failed.");
980 return ERR_INVALID_VALUE;
981 }
982 return NO_ERROR;
983 }
984
MoveMissionToFrontInner(MessageParcel & data,MessageParcel & reply)985 int AbilityManagerStub::MoveMissionToFrontInner(MessageParcel &data, MessageParcel &reply)
986 {
987 int32_t missionId = data.ReadInt32();
988 int result = MoveMissionToFront(missionId);
989 if (!reply.WriteInt32(result)) {
990 HILOG_ERROR("MoveMissionToFront failed.");
991 return ERR_INVALID_VALUE;
992 }
993 return NO_ERROR;
994 }
995
GetMissionIdByTokenInner(MessageParcel & data,MessageParcel & reply)996 int AbilityManagerStub::GetMissionIdByTokenInner(MessageParcel &data, MessageParcel &reply)
997 {
998 sptr<IRemoteObject> token = data.ReadRemoteObject();
999 int32_t missionId = GetMissionIdByToken(token);
1000 if (!reply.WriteInt32(missionId)) {
1001 HILOG_ERROR("GetMissionIdByToken write missionId failed.");
1002 return ERR_INVALID_VALUE;
1003 }
1004 return NO_ERROR;
1005 }
1006
MoveMissionToFrontByOptionsInner(MessageParcel & data,MessageParcel & reply)1007 int AbilityManagerStub::MoveMissionToFrontByOptionsInner(MessageParcel &data, MessageParcel &reply)
1008 {
1009 int32_t missionId = data.ReadInt32();
1010 std::unique_ptr<StartOptions> startOptions(data.ReadParcelable<StartOptions>());
1011 if (startOptions == nullptr) {
1012 HILOG_ERROR("startOptions is nullptr");
1013 return ERR_INVALID_VALUE;
1014 }
1015 int result = MoveMissionToFront(missionId, *startOptions);
1016 if (!reply.WriteInt32(result)) {
1017 HILOG_ERROR("MoveMissionToFront failed.");
1018 return ERR_INVALID_VALUE;
1019 }
1020 return NO_ERROR;
1021 }
1022
StartAbilityByCallInner(MessageParcel & data,MessageParcel & reply)1023 int AbilityManagerStub::StartAbilityByCallInner(MessageParcel &data, MessageParcel &reply)
1024 {
1025 HILOG_DEBUG("AbilityManagerStub::StartAbilityByCallInner begin.");
1026 Want *want = data.ReadParcelable<Want>();
1027 if (want == nullptr) {
1028 HILOG_ERROR("want is nullptr");
1029 return ERR_INVALID_VALUE;
1030 }
1031
1032 auto callback = iface_cast<IAbilityConnection>(data.ReadRemoteObject());
1033 sptr<IRemoteObject> callerToken = nullptr;
1034 if (data.ReadBool()) {
1035 callerToken = data.ReadRemoteObject();
1036 }
1037 int32_t result = StartAbilityByCall(*want, callback, callerToken);
1038
1039 HILOG_DEBUG("resolve call ability ret = %d", result);
1040
1041 reply.WriteInt32(result);
1042 delete want;
1043
1044 HILOG_DEBUG("AbilityManagerStub::StartAbilityByCallInner end.");
1045
1046 return NO_ERROR;
1047 }
1048
CallRequestDoneInner(MessageParcel & data,MessageParcel & reply)1049 int AbilityManagerStub::CallRequestDoneInner(MessageParcel &data, MessageParcel &reply)
1050 {
1051 sptr<IRemoteObject> token = data.ReadRemoteObject();
1052 sptr<IRemoteObject> callStub = data.ReadRemoteObject();
1053 CallRequestDone(token, callStub);
1054 return NO_ERROR;
1055 }
1056
ReleaseCallInner(MessageParcel & data,MessageParcel & reply)1057 int AbilityManagerStub::ReleaseCallInner(MessageParcel &data, MessageParcel &reply)
1058 {
1059 auto callback = iface_cast<IAbilityConnection>(data.ReadRemoteObject());
1060 if (callback == nullptr) {
1061 HILOG_ERROR("callback is nullptr");
1062 return ERR_INVALID_VALUE;
1063 }
1064
1065 std::unique_ptr<AppExecFwk::ElementName> element(data.ReadParcelable<AppExecFwk::ElementName>());
1066 if (element == nullptr) {
1067 HILOG_ERROR("callback stub receive element is nullptr");
1068 return ERR_INVALID_VALUE;
1069 }
1070 int32_t result = ReleaseCall(callback, *element);
1071
1072 HILOG_DEBUG("release call ability ret = %d", result);
1073
1074 reply.WriteInt32(result);
1075
1076 return NO_ERROR;
1077 }
1078
StartUserInner(MessageParcel & data,MessageParcel & reply)1079 int AbilityManagerStub::StartUserInner(MessageParcel &data, MessageParcel &reply)
1080 {
1081 int32_t userId = data.ReadInt32();
1082 int result = StartUser(userId);
1083 if (!reply.WriteInt32(result)) {
1084 HILOG_ERROR("StartUser failed.");
1085 return ERR_INVALID_VALUE;
1086 }
1087 return NO_ERROR;
1088 }
1089
StopUserInner(MessageParcel & data,MessageParcel & reply)1090 int AbilityManagerStub::StopUserInner(MessageParcel &data, MessageParcel &reply)
1091 {
1092 int32_t userId = data.ReadInt32();
1093 sptr<IStopUserCallback> callback = nullptr;
1094 if (data.ReadBool()) {
1095 callback = iface_cast<IStopUserCallback>(data.ReadRemoteObject());
1096 }
1097 int result = StopUser(userId, callback);
1098 if (!reply.WriteInt32(result)) {
1099 HILOG_ERROR("StopUser failed.");
1100 return ERR_INVALID_VALUE;
1101 }
1102 return NO_ERROR;
1103 }
1104
GetAbilityRunningInfosInner(MessageParcel & data,MessageParcel & reply)1105 int AbilityManagerStub::GetAbilityRunningInfosInner(MessageParcel &data, MessageParcel &reply)
1106 {
1107 std::vector<AbilityRunningInfo> abilityRunningInfos;
1108 auto result = GetAbilityRunningInfos(abilityRunningInfos);
1109 reply.WriteInt32(abilityRunningInfos.size());
1110 for (auto &it : abilityRunningInfos) {
1111 if (!reply.WriteParcelable(&it)) {
1112 return ERR_INVALID_VALUE;
1113 }
1114 }
1115 if (!reply.WriteInt32(result)) {
1116 return ERR_INVALID_VALUE;
1117 }
1118 return result;
1119 }
1120
GetExtensionRunningInfosInner(MessageParcel & data,MessageParcel & reply)1121 int AbilityManagerStub::GetExtensionRunningInfosInner(MessageParcel &data, MessageParcel &reply)
1122 {
1123 auto upperLimit = data.ReadInt32();
1124 std::vector<ExtensionRunningInfo> infos;
1125 auto result = GetExtensionRunningInfos(upperLimit, infos);
1126 reply.WriteInt32(infos.size());
1127 for (auto &it : infos) {
1128 if (!reply.WriteParcelable(&it)) {
1129 return ERR_INVALID_VALUE;
1130 }
1131 }
1132 if (!reply.WriteInt32(result)) {
1133 return ERR_INVALID_VALUE;
1134 }
1135 return result;
1136 }
1137
GetProcessRunningInfosInner(MessageParcel & data,MessageParcel & reply)1138 int AbilityManagerStub::GetProcessRunningInfosInner(MessageParcel &data, MessageParcel &reply)
1139 {
1140 std::vector<AppExecFwk::RunningProcessInfo> infos;
1141 auto result = GetProcessRunningInfos(infos);
1142 reply.WriteInt32(infos.size());
1143 for (auto &it : infos) {
1144 if (!reply.WriteParcelable(&it)) {
1145 return ERR_INVALID_VALUE;
1146 }
1147 }
1148 if (!reply.WriteInt32(result)) {
1149 return ERR_INVALID_VALUE;
1150 }
1151 return NO_ERROR;
1152 }
1153
StartSyncRemoteMissionsInner(MessageParcel & data,MessageParcel & reply)1154 int AbilityManagerStub::StartSyncRemoteMissionsInner(MessageParcel &data, MessageParcel &reply)
1155 {
1156 std::string deviceId = data.ReadString();
1157 bool fixConflict = data.ReadBool();
1158 int64_t tag = data.ReadInt64();
1159 int result = StartSyncRemoteMissions(deviceId, fixConflict, tag);
1160 if (!reply.WriteInt32(result)) {
1161 HILOG_ERROR("StartSyncRemoteMissionsInner failed.");
1162 return ERR_INVALID_VALUE;
1163 }
1164 return NO_ERROR;
1165 }
1166
StopSyncRemoteMissionsInner(MessageParcel & data,MessageParcel & reply)1167 int AbilityManagerStub::StopSyncRemoteMissionsInner(MessageParcel &data, MessageParcel &reply)
1168 {
1169 int result = StopSyncRemoteMissions(data.ReadString());
1170 if (!reply.WriteInt32(result)) {
1171 HILOG_ERROR("StopSyncRemoteMissionsInner failed.");
1172 return ERR_INVALID_VALUE;
1173 }
1174 return NO_ERROR;
1175 }
1176
RegisterRemoteMissionListenerInner(MessageParcel & data,MessageParcel & reply)1177 int AbilityManagerStub::RegisterRemoteMissionListenerInner(MessageParcel &data, MessageParcel &reply)
1178 {
1179 std::string deviceId = data.ReadString();
1180 if (deviceId.empty()) {
1181 HILOG_ERROR("AbilityManagerStub: RegisterRemoteMissionListenerInner deviceId empty!");
1182 return ERR_NULL_OBJECT;
1183 }
1184 sptr<IRemoteMissionListener> listener = iface_cast<IRemoteMissionListener>(data.ReadRemoteObject());
1185 if (listener == nullptr) {
1186 HILOG_ERROR("AbilityManagerStub: RegisterRemoteMissionListenerInner listener readParcelable failed!");
1187 return ERR_NULL_OBJECT;
1188 }
1189 int32_t result = RegisterMissionListener(deviceId, listener);
1190 HILOG_INFO("AbilityManagerStub: RegisterRemoteMissionListenerInner result = %{public}d", result);
1191 return result;
1192 }
1193
UnRegisterRemoteMissionListenerInner(MessageParcel & data,MessageParcel & reply)1194 int AbilityManagerStub::UnRegisterRemoteMissionListenerInner(MessageParcel &data, MessageParcel &reply)
1195 {
1196 std::string deviceId = data.ReadString();
1197 if (deviceId.empty()) {
1198 HILOG_ERROR("AbilityManagerStub: UnRegisterRemoteMissionListenerInner deviceId empty!");
1199 return ERR_NULL_OBJECT;
1200 }
1201 sptr<IRemoteMissionListener> listener = iface_cast<IRemoteMissionListener>(data.ReadRemoteObject());
1202 if (listener == nullptr) {
1203 HILOG_ERROR("AbilityManagerStub: UnRegisterRemoteMissionListenerInner listener readParcelable failed!");
1204 return ERR_NULL_OBJECT;
1205 }
1206 int32_t result = UnRegisterMissionListener(deviceId, listener);
1207 HILOG_INFO("AbilityManagerStub: UnRegisterRemoteMissionListenerInner result = %{public}d", result);
1208 return result;
1209 }
1210
RegisterSnapshotHandlerInner(MessageParcel & data,MessageParcel & reply)1211 int AbilityManagerStub::RegisterSnapshotHandlerInner(MessageParcel &data, MessageParcel &reply)
1212 {
1213 sptr<ISnapshotHandler> handler = iface_cast<ISnapshotHandler>(data.ReadRemoteObject());
1214 if (handler == nullptr) {
1215 HILOG_ERROR("snapshot: AbilityManagerStub read snapshot handler failed!");
1216 return ERR_NULL_OBJECT;
1217 }
1218 int32_t result = RegisterSnapshotHandler(handler);
1219 HILOG_INFO("snapshot: AbilityManagerStub register snapshot handler result = %{public}d", result);
1220 return result;
1221 }
1222
GetMissionSnapshotInfoInner(MessageParcel & data,MessageParcel & reply)1223 int AbilityManagerStub::GetMissionSnapshotInfoInner(MessageParcel &data, MessageParcel &reply)
1224 {
1225 std::string deviceId = data.ReadString();
1226 int32_t missionId = data.ReadInt32();
1227 bool isLowResolution = data.ReadBool();
1228 MissionSnapshot missionSnapshot;
1229 int32_t result = GetMissionSnapshot(deviceId, missionId, missionSnapshot, isLowResolution);
1230 HILOG_INFO("snapshot: AbilityManagerStub get snapshot result = %{public}d", result);
1231 if (!reply.WriteParcelable(&missionSnapshot)) {
1232 HILOG_ERROR("GetMissionSnapshot error");
1233 return ERR_INVALID_VALUE;
1234 }
1235 if (!reply.WriteInt32(result)) {
1236 HILOG_ERROR("GetMissionSnapshot result error");
1237 return ERR_INVALID_VALUE;
1238 }
1239 return NO_ERROR;
1240 }
1241
SetAbilityControllerInner(MessageParcel & data,MessageParcel & reply)1242 int AbilityManagerStub::SetAbilityControllerInner(MessageParcel &data, MessageParcel &reply)
1243 {
1244 sptr<AppExecFwk::IAbilityController> controller =
1245 iface_cast<AppExecFwk::IAbilityController>(data.ReadRemoteObject());
1246 if (controller == nullptr) {
1247 HILOG_ERROR("AbilityManagerStub: setAbilityControllerInner controller readParcelable failed!");
1248 return ERR_NULL_OBJECT;
1249 }
1250 bool imAStabilityTest = data.ReadBool();
1251 int32_t result = SetAbilityController(controller, imAStabilityTest);
1252 HILOG_INFO("AbilityManagerStub: setAbilityControllerInner result = %{public}d", result);
1253 if (!reply.WriteInt32(result)) {
1254 HILOG_ERROR("setAbilityControllerInner failed.");
1255 return ERR_INVALID_VALUE;
1256 }
1257 return NO_ERROR;
1258 }
1259
SetComponentInterceptionInner(MessageParcel & data,MessageParcel & reply)1260 int AbilityManagerStub::SetComponentInterceptionInner(MessageParcel &data, MessageParcel &reply)
1261 {
1262 sptr<AppExecFwk::IComponentInterception> componentInterception =
1263 iface_cast<AppExecFwk::IComponentInterception>(data.ReadRemoteObject());
1264 if (componentInterception == nullptr) {
1265 HILOG_ERROR("AbilityManagerStub: SetComponentInterceptionInner readParcelable failed!");
1266 return ERR_NULL_OBJECT;
1267 }
1268 int32_t result = SetComponentInterception(componentInterception);
1269 HILOG_INFO("AbilityManagerStub: SetComponentInterceptionInner result = %{public}d", result);
1270 if (!reply.WriteInt32(result)) {
1271 HILOG_ERROR("SetComponentInterceptionInner failed.");
1272 return ERR_INVALID_VALUE;
1273 }
1274 return NO_ERROR;
1275 }
1276
SendResultToAbilityByTokenInner(MessageParcel & data,MessageParcel & reply)1277 int AbilityManagerStub::SendResultToAbilityByTokenInner(MessageParcel &data, MessageParcel &reply)
1278 {
1279 Want *want = data.ReadParcelable<Want>();
1280 if (want == nullptr) {
1281 HILOG_ERROR("want is nullptr");
1282 return ERR_INVALID_VALUE;
1283 }
1284 sptr<IRemoteObject> abilityToken = data.ReadRemoteObject();
1285 int32_t requestCode = data.ReadInt32();
1286 int32_t resultCode = data.ReadInt32();
1287 int32_t userId = data.ReadInt32();
1288 int32_t result = SendResultToAbilityByToken(*want, abilityToken, requestCode, resultCode, userId);
1289 reply.WriteInt32(result);
1290 return NO_ERROR;
1291 }
1292
IsRunningInStabilityTestInner(MessageParcel & data,MessageParcel & reply)1293 int AbilityManagerStub::IsRunningInStabilityTestInner(MessageParcel &data, MessageParcel &reply)
1294 {
1295 bool result = IsRunningInStabilityTest();
1296 HILOG_INFO("AbilityManagerStub: IsRunningInStabilityTest result = %{public}d", result);
1297 if (!reply.WriteBool(result)) {
1298 HILOG_ERROR("IsRunningInStabilityTest failed.");
1299 return ERR_INVALID_VALUE;
1300 }
1301 return NO_ERROR;
1302 }
1303
StartUserTestInner(MessageParcel & data,MessageParcel & reply)1304 int AbilityManagerStub::StartUserTestInner(MessageParcel &data, MessageParcel &reply)
1305 {
1306 std::unique_ptr<Want> want(data.ReadParcelable<Want>());
1307 if (want == nullptr) {
1308 HILOG_ERROR("want is nullptr");
1309 return ERR_INVALID_VALUE;
1310 }
1311 auto observer = data.ReadRemoteObject();
1312 int32_t result = StartUserTest(*want, observer);
1313 reply.WriteInt32(result);
1314 return result;
1315 }
1316
FinishUserTestInner(MessageParcel & data,MessageParcel & reply)1317 int AbilityManagerStub::FinishUserTestInner(MessageParcel &data, MessageParcel &reply)
1318 {
1319 std::string msg = data.ReadString();
1320 int64_t resultCode = data.ReadInt64();
1321 std::string bundleName = data.ReadString();
1322 int32_t result = FinishUserTest(msg, resultCode, bundleName);
1323 reply.WriteInt32(result);
1324 return result;
1325 }
1326
GetTopAbilityTokenInner(MessageParcel & data,MessageParcel & reply)1327 int AbilityManagerStub::GetTopAbilityTokenInner(MessageParcel &data, MessageParcel &reply)
1328 {
1329 sptr<IRemoteObject> token;
1330 auto result = GetTopAbility(token);
1331 if (!reply.WriteRemoteObject(token)) {
1332 HILOG_ERROR("data write failed.");
1333 return ERR_INVALID_VALUE;
1334 }
1335 reply.WriteInt32(result);
1336
1337 return NO_ERROR;
1338 }
1339
DelegatorDoAbilityForegroundInner(MessageParcel & data,MessageParcel & reply)1340 int AbilityManagerStub::DelegatorDoAbilityForegroundInner(MessageParcel &data, MessageParcel &reply)
1341 {
1342 sptr<IRemoteObject> token = data.ReadRemoteObject();
1343 auto result = DelegatorDoAbilityForeground(token);
1344 reply.WriteInt32(result);
1345
1346 return NO_ERROR;
1347 }
1348
DelegatorDoAbilityBackgroundInner(MessageParcel & data,MessageParcel & reply)1349 int AbilityManagerStub::DelegatorDoAbilityBackgroundInner(MessageParcel &data, MessageParcel &reply)
1350 {
1351 sptr<IRemoteObject> token = data.ReadRemoteObject();
1352 auto result = DelegatorDoAbilityBackground(token);
1353 reply.WriteInt32(result);
1354 return NO_ERROR;
1355 }
1356
DoAbilityForeground(const sptr<IRemoteObject> & token,uint32_t flag)1357 int AbilityManagerStub::DoAbilityForeground(const sptr<IRemoteObject> &token, uint32_t flag)
1358 {
1359 return 0;
1360 }
1361
DoAbilityBackground(const sptr<IRemoteObject> & token,uint32_t flag)1362 int AbilityManagerStub::DoAbilityBackground(const sptr<IRemoteObject> &token, uint32_t flag)
1363 {
1364 return 0;
1365 }
1366
DoAbilityForegroundInner(MessageParcel & data,MessageParcel & reply)1367 int AbilityManagerStub::DoAbilityForegroundInner(MessageParcel &data, MessageParcel &reply)
1368 {
1369 sptr<IRemoteObject> token = data.ReadRemoteObject();
1370 uint32_t flag = data.ReadUint32();
1371 auto result = DoAbilityForeground(token, flag);
1372 reply.WriteInt32(result);
1373
1374 return NO_ERROR;
1375 }
1376
DoAbilityBackgroundInner(MessageParcel & data,MessageParcel & reply)1377 int AbilityManagerStub::DoAbilityBackgroundInner(MessageParcel &data, MessageParcel &reply)
1378 {
1379 sptr<IRemoteObject> token = data.ReadRemoteObject();
1380 uint32_t flag = data.ReadUint32();
1381 auto result = DoAbilityBackground(token, flag);
1382 reply.WriteInt32(result);
1383 return NO_ERROR;
1384 }
1385
SendANRProcessIDInner(MessageParcel & data,MessageParcel & reply)1386 int AbilityManagerStub::SendANRProcessIDInner(MessageParcel &data, MessageParcel &reply)
1387 {
1388 int32_t pid = data.ReadInt32();
1389 int32_t result = SendANRProcessID(pid);
1390 if (!reply.WriteInt32(result)) {
1391 HILOG_ERROR("reply write failed.");
1392 return ERR_INVALID_VALUE;
1393 }
1394 return NO_ERROR;
1395 }
1396
RegisterObserver(const sptr<AbilityRuntime::IConnectionObserver> & observer)1397 int AbilityManagerStub::RegisterObserver(const sptr<AbilityRuntime::IConnectionObserver> &observer)
1398 {
1399 // should implement in child.
1400 return NO_ERROR;
1401 }
1402
UnregisterObserver(const sptr<AbilityRuntime::IConnectionObserver> & observer)1403 int AbilityManagerStub::UnregisterObserver(const sptr<AbilityRuntime::IConnectionObserver> &observer)
1404 {
1405 // should implement in child
1406 return NO_ERROR;
1407 }
1408
GetDlpConnectionInfos(std::vector<AbilityRuntime::DlpConnectionInfo> & infos)1409 int AbilityManagerStub::GetDlpConnectionInfos(std::vector<AbilityRuntime::DlpConnectionInfo> &infos)
1410 {
1411 // should implement in child
1412 return NO_ERROR;
1413 }
1414
1415 #ifdef ABILITY_COMMAND_FOR_TEST
ForceTimeoutForTestInner(MessageParcel & data,MessageParcel & reply)1416 int AbilityManagerStub::ForceTimeoutForTestInner(MessageParcel &data, MessageParcel &reply)
1417 {
1418 std::string abilityName = Str16ToStr8(data.ReadString16());
1419 std::string state = Str16ToStr8(data.ReadString16());
1420 int result = ForceTimeoutForTest(abilityName, state);
1421 if (!reply.WriteInt32(result)) {
1422 HILOG_ERROR("force ability timeout error");
1423 return ERR_INVALID_VALUE;
1424 }
1425 return NO_ERROR;
1426 }
1427
BlockAbilityInner(MessageParcel & data,MessageParcel & reply)1428 int AbilityManagerStub::BlockAbilityInner(MessageParcel &data, MessageParcel &reply)
1429 {
1430 int32_t abilityRecordId = data.ReadInt32();
1431 int32_t result = BlockAbility(abilityRecordId);
1432 if (!reply.WriteInt32(result)) {
1433 HILOG_ERROR("reply write failed.");
1434 return ERR_INVALID_VALUE;
1435 }
1436 return NO_ERROR;
1437 }
1438
BlockAmsServiceInner(MessageParcel & data,MessageParcel & reply)1439 int AbilityManagerStub::BlockAmsServiceInner(MessageParcel &data, MessageParcel &reply)
1440 {
1441 int32_t result = BlockAmsService();
1442 if (!reply.WriteInt32(result)) {
1443 HILOG_ERROR("reply write failed.");
1444 return ERR_INVALID_VALUE;
1445 }
1446 return NO_ERROR;
1447 }
1448
BlockAppServiceInner(MessageParcel & data,MessageParcel & reply)1449 int AbilityManagerStub::BlockAppServiceInner(MessageParcel &data, MessageParcel &reply)
1450 {
1451 int32_t result = BlockAppService();
1452 if (!reply.WriteInt32(result)) {
1453 HILOG_ERROR("reply write failed.");
1454 return ERR_INVALID_VALUE;
1455 }
1456 return NO_ERROR;
1457 }
1458 #endif
1459
FreeInstallAbilityFromRemoteInner(MessageParcel & data,MessageParcel & reply)1460 int AbilityManagerStub::FreeInstallAbilityFromRemoteInner(MessageParcel &data, MessageParcel &reply)
1461 {
1462 std::unique_ptr<AAFwk::Want> want(data.ReadParcelable<AAFwk::Want>());
1463 if (want == nullptr) {
1464 HILOG_ERROR("want is nullptr");
1465 return ERR_INVALID_VALUE;
1466 }
1467 want->SetParam(FROM_REMOTE_KEY, true);
1468
1469 auto callback = data.ReadRemoteObject();
1470 if (callback == nullptr) {
1471 HILOG_ERROR("callback is nullptr");
1472 return ERR_INVALID_VALUE;
1473 }
1474
1475 int32_t userId = data.ReadInt32();
1476 int32_t requestCode = data.ReadInt32();
1477 int32_t result = FreeInstallAbilityFromRemote(*want, callback, userId, requestCode);
1478 if (!reply.WriteInt32(result)) {
1479 HILOG_ERROR("reply write failed.");
1480 return ERR_INVALID_VALUE;
1481 }
1482 return NO_ERROR;
1483 }
1484
DumpAbilityInfoDoneInner(MessageParcel & data,MessageParcel & reply)1485 int AbilityManagerStub::DumpAbilityInfoDoneInner(MessageParcel &data, MessageParcel &reply)
1486 {
1487 std::vector<std::string> infos;
1488 data.ReadStringVector(&infos);
1489 sptr<IRemoteObject> callerToken = data.ReadRemoteObject();
1490 int32_t result = DumpAbilityInfoDone(infos, callerToken);
1491 if (!reply.WriteInt32(result)) {
1492 HILOG_ERROR("reply write failed.");
1493 return ERR_INVALID_VALUE;
1494 }
1495 return NO_ERROR;
1496 }
1497
UpdateMissionSnapShotInner(MessageParcel & data,MessageParcel & reply)1498 int AbilityManagerStub::UpdateMissionSnapShotInner(MessageParcel &data, MessageParcel &reply)
1499 {
1500 sptr<IRemoteObject> token = data.ReadRemoteObject();
1501 if (!token) {
1502 HILOG_ERROR("UpdateMissionSnapShot read ability token failed.");
1503 return ERR_NULL_OBJECT;
1504 }
1505 UpdateMissionSnapShot(token);
1506 return NO_ERROR;
1507 }
1508
EnableRecoverAbilityInner(MessageParcel & data,MessageParcel & reply)1509 int AbilityManagerStub::EnableRecoverAbilityInner(MessageParcel &data, MessageParcel &reply)
1510 {
1511 sptr<IRemoteObject> token = data.ReadRemoteObject();
1512 if (!token) {
1513 HILOG_ERROR("EnableRecoverAbilityInner read ability token failed.");
1514 return ERR_NULL_OBJECT;
1515 }
1516 EnableRecoverAbility(token);
1517 return NO_ERROR;
1518 }
1519
ScheduleRecoverAbilityInner(MessageParcel & data,MessageParcel & reply)1520 int AbilityManagerStub::ScheduleRecoverAbilityInner(MessageParcel &data, MessageParcel &reply)
1521 {
1522 sptr<IRemoteObject> token = data.ReadRemoteObject();
1523 if (!token) {
1524 HILOG_ERROR("ScheduleRecoverAbility read ability token failed.");
1525 return ERR_NULL_OBJECT;
1526 }
1527
1528 int reason = data.ReadInt32();
1529 ScheduleRecoverAbility(token, reason);
1530 return NO_ERROR;
1531 }
1532
RegisterConnectionObserverInner(MessageParcel & data,MessageParcel & reply)1533 int AbilityManagerStub::RegisterConnectionObserverInner(MessageParcel &data, MessageParcel &reply)
1534 {
1535 sptr<AbilityRuntime::IConnectionObserver> observer = iface_cast<AbilityRuntime::IConnectionObserver>(
1536 data.ReadRemoteObject());
1537 if (!observer) {
1538 HILOG_ERROR("RegisterConnectionObserverInner read observer failed.");
1539 return ERR_NULL_OBJECT;
1540 }
1541
1542 return RegisterObserver(observer);
1543 }
1544
UnregisterConnectionObserverInner(MessageParcel & data,MessageParcel & reply)1545 int AbilityManagerStub::UnregisterConnectionObserverInner(MessageParcel &data, MessageParcel &reply)
1546 {
1547 sptr<AbilityRuntime::IConnectionObserver> observer = iface_cast<AbilityRuntime::IConnectionObserver>(
1548 data.ReadRemoteObject());
1549 if (!observer) {
1550 HILOG_ERROR("UnregisterConnectionObserverInner read observer failed.");
1551 return ERR_NULL_OBJECT;
1552 }
1553
1554 return UnregisterObserver(observer);
1555 }
1556
GetDlpConnectionInfosInner(MessageParcel & data,MessageParcel & reply)1557 int AbilityManagerStub::GetDlpConnectionInfosInner(MessageParcel &data, MessageParcel &reply)
1558 {
1559 std::vector<AbilityRuntime::DlpConnectionInfo> infos;
1560 auto result = GetDlpConnectionInfos(infos);
1561 if (!reply.WriteInt32(result)) {
1562 HILOG_ERROR("write result failed");
1563 return ERR_INVALID_VALUE;
1564 }
1565
1566 if (!reply.WriteInt32(infos.size())) {
1567 HILOG_ERROR("write infos size failed");
1568 return ERR_INVALID_VALUE;
1569 }
1570
1571 for (auto &item : infos) {
1572 if (!reply.WriteParcelable(&item)) {
1573 HILOG_ERROR("write info item failed");
1574 return ERR_INVALID_VALUE;
1575 }
1576 }
1577
1578 return ERR_OK;
1579 }
1580
1581 #ifdef SUPPORT_GRAPHICS
SetMissionLabelInner(MessageParcel & data,MessageParcel & reply)1582 int AbilityManagerStub::SetMissionLabelInner(MessageParcel &data, MessageParcel &reply)
1583 {
1584 sptr<IRemoteObject> token = data.ReadRemoteObject();
1585 if (!token) {
1586 HILOG_ERROR("SetMissionLabelInner read ability token failed.");
1587 return ERR_NULL_OBJECT;
1588 }
1589
1590 std::string label = Str16ToStr8(data.ReadString16());
1591 int result = SetMissionLabel(token, label);
1592 if (!reply.WriteInt32(result)) {
1593 HILOG_ERROR("SetMissionLabel failed.");
1594 return ERR_INVALID_VALUE;
1595 }
1596 return NO_ERROR;
1597 }
1598
SetMissionIconInner(MessageParcel & data,MessageParcel & reply)1599 int AbilityManagerStub::SetMissionIconInner(MessageParcel &data, MessageParcel &reply)
1600 {
1601 sptr<IRemoteObject> token = data.ReadRemoteObject();
1602 if (!token) {
1603 HILOG_ERROR("SetMissionIconInner read ability token failed.");
1604 return ERR_NULL_OBJECT;
1605 }
1606
1607 std::shared_ptr<Media::PixelMap> icon(data.ReadParcelable<Media::PixelMap>());
1608 if (!icon) {
1609 HILOG_ERROR("SetMissionIconInner read icon failed.");
1610 return ERR_NULL_OBJECT;
1611 }
1612
1613 int result = SetMissionIcon(token, icon);
1614 if (!reply.WriteInt32(result)) {
1615 HILOG_ERROR("SetMissionIcon failed.");
1616 return ERR_INVALID_VALUE;
1617 }
1618 return NO_ERROR;
1619 }
1620
RegisterWindowManagerServiceHandlerInner(MessageParcel & data,MessageParcel & reply)1621 int AbilityManagerStub::RegisterWindowManagerServiceHandlerInner(MessageParcel &data, MessageParcel &reply)
1622 {
1623 sptr<IWindowManagerServiceHandler> handler = iface_cast<IWindowManagerServiceHandler>(data.ReadRemoteObject());
1624 if (handler == nullptr) {
1625 HILOG_ERROR("%{public}s read WMS handler failed!", __func__);
1626 return ERR_NULL_OBJECT;
1627 }
1628 return RegisterWindowManagerServiceHandler(handler);
1629 }
1630
CompleteFirstFrameDrawingInner(MessageParcel & data,MessageParcel & reply)1631 int AbilityManagerStub::CompleteFirstFrameDrawingInner(MessageParcel &data, MessageParcel &reply)
1632 {
1633 HILOG_DEBUG("%{public}s is called.", __func__);
1634 sptr<IRemoteObject> abilityToken = data.ReadRemoteObject();
1635 if (abilityToken == nullptr) {
1636 HILOG_ERROR("%{public}s read abilityToken failed!", __func__);
1637 return ERR_NULL_OBJECT;
1638 }
1639 CompleteFirstFrameDrawing(abilityToken);
1640 return 0;
1641 }
1642 #endif
1643 } // namespace AAFwk
1644 } // namespace OHOS
1645