1 /*
2 * Copyright (c) 2023-2024 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_client.h"
17
18 #ifdef WITH_DLP
19 #include "dlp_file_kits.h"
20 #endif // WITH_DLP
21 #include "hilog_tag_wrapper.h"
22 #include "hitrace_meter.h"
23 #include "iservice_registry.h"
24 #include "scene_board_judgement.h"
25 #include "session_manager_lite.h"
26 #include "status_bar_delegate_interface.h"
27 #include "system_ability_definition.h"
28
29 namespace OHOS {
30 namespace AAFwk {
31 namespace {
32 static std::unordered_map<Rosen::WSError, int32_t> SCB_TO_MISSION_ERROR_CODE_MAP {
33 { Rosen::WSError::WS_ERROR_INVALID_PERMISSION, CHECK_PERMISSION_FAILED },
34 { Rosen::WSError::WS_ERROR_NOT_SYSTEM_APP, ERR_NOT_SYSTEM_APP },
35 { Rosen::WSError::WS_ERROR_INVALID_PARAM, INVALID_PARAMETERS_ERR },
36 };
37 }
38
39 using OHOS::Rosen::SessionManagerLite;
40 std::shared_ptr<AbilityManagerClient> AbilityManagerClient::instance_ = nullptr;
41 std::once_flag AbilityManagerClient::singletonFlag_;
42 #ifdef WITH_DLP
43 const std::string DLP_PARAMS_SANDBOX = "ohos.dlp.params.sandbox";
44 #endif // WITH_DLP
45
46 #define CHECK_POINTER_RETURN(object) \
47 if (!object) { \
48 TAG_LOGE(AAFwkTag::ABILITYMGR, "proxy is nullptr"); \
49 return; \
50 }
51
52 #define CHECK_POINTER_RETURN_NOT_CONNECTED(object) \
53 if (!object) { \
54 TAG_LOGE(AAFwkTag::ABILITYMGR, "proxy is nullptr."); \
55 return ABILITY_SERVICE_NOT_CONNECTED; \
56 }
57
58 #define CHECK_POINTER_RETURN_INVALID_VALUE(object) \
59 if (!object) { \
60 TAG_LOGE(AAFwkTag::ABILITYMGR, "proxy is nullptr."); \
61 return ERR_INVALID_VALUE; \
62 }
63
GetInstance()64 std::shared_ptr<AbilityManagerClient> AbilityManagerClient::GetInstance()
65 {
66 std::call_once(singletonFlag_, [] () {
67 instance_ = std::shared_ptr<AbilityManagerClient>(new AbilityManagerClient());
68 });
69 return instance_;
70 }
71
AbilityManagerClient()72 AbilityManagerClient::AbilityManagerClient()
73 {}
74
~AbilityManagerClient()75 AbilityManagerClient::~AbilityManagerClient()
76 {
77 TAG_LOGI(AAFwkTag::ABILITYMGR, "Remove DeathRecipient");
78 RemoveDeathRecipient();
79 }
80
AttachAbilityThread(sptr<IAbilityScheduler> scheduler,sptr<IRemoteObject> token)81 ErrCode AbilityManagerClient::AttachAbilityThread(
82 sptr<IAbilityScheduler> scheduler, sptr<IRemoteObject> token)
83 {
84 auto abms = GetAbilityManager();
85 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
86 return abms->AttachAbilityThread(scheduler, token);
87 }
88
AbilityTransitionDone(sptr<IRemoteObject> token,int state,const PacMap & saveData)89 ErrCode AbilityManagerClient::AbilityTransitionDone(sptr<IRemoteObject> token, int state, const PacMap &saveData)
90 {
91 auto abms = GetAbilityManager();
92 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
93 return abms->AbilityTransitionDone(token, state, saveData);
94 }
95
ScheduleConnectAbilityDone(sptr<IRemoteObject> token,sptr<IRemoteObject> remoteObject)96 ErrCode AbilityManagerClient::ScheduleConnectAbilityDone(
97 sptr<IRemoteObject> token, sptr<IRemoteObject> remoteObject)
98 {
99 auto abms = GetAbilityManager();
100 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
101 return abms->ScheduleConnectAbilityDone(token, remoteObject);
102 }
103
ScheduleDisconnectAbilityDone(sptr<IRemoteObject> token)104 ErrCode AbilityManagerClient::ScheduleDisconnectAbilityDone(sptr<IRemoteObject> token)
105 {
106 auto abms = GetAbilityManager();
107 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
108 return abms->ScheduleDisconnectAbilityDone(token);
109 }
110
ScheduleCommandAbilityDone(sptr<IRemoteObject> token)111 ErrCode AbilityManagerClient::ScheduleCommandAbilityDone(sptr<IRemoteObject> token)
112 {
113 auto abms = GetAbilityManager();
114 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
115 return abms->ScheduleCommandAbilityDone(token);
116 }
117
ScheduleCommandAbilityWindowDone(sptr<IRemoteObject> token,sptr<SessionInfo> sessionInfo,WindowCommand winCmd,AbilityCommand abilityCmd)118 ErrCode AbilityManagerClient::ScheduleCommandAbilityWindowDone(
119 sptr<IRemoteObject> token,
120 sptr<SessionInfo> sessionInfo,
121 WindowCommand winCmd,
122 AbilityCommand abilityCmd)
123 {
124 auto abms = GetAbilityManager();
125 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
126 return abms->ScheduleCommandAbilityWindowDone(token, sessionInfo, winCmd, abilityCmd);
127 }
128
StartAbility(const Want & want,int requestCode,int32_t userId)129 ErrCode AbilityManagerClient::StartAbility(const Want &want, int requestCode, int32_t userId)
130 {
131 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
132 auto abms = GetAbilityManager();
133 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
134 HandleDlpApp(const_cast<Want &>(want));
135 return abms->StartAbility(want, userId, requestCode);
136 }
137
StartAbility(const Want & want,sptr<IRemoteObject> callerToken,int requestCode,int32_t userId)138 ErrCode AbilityManagerClient::StartAbility(
139 const Want &want, sptr<IRemoteObject> callerToken, int requestCode, int32_t userId)
140 {
141 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
142 auto abms = GetAbilityManager();
143 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
144 TAG_LOGD(AAFwkTag::ABILITYMGR, "ability:%{public}s, userId:%{public}d",
145 want.GetElement().GetAbilityName().c_str(), userId);
146 HandleDlpApp(const_cast<Want &>(want));
147 return abms->StartAbility(want, callerToken, userId, requestCode);
148 }
149
StartAbilityByInsightIntent(const Want & want,sptr<IRemoteObject> callerToken,uint64_t intentId,int32_t userId)150 ErrCode AbilityManagerClient::StartAbilityByInsightIntent(
151 const Want &want, sptr<IRemoteObject> callerToken, uint64_t intentId, int32_t userId)
152 {
153 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
154 auto abms = GetAbilityManager();
155 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
156 TAG_LOGD(AAFwkTag::ABILITYMGR, "ability:%{public}s, bundle:%{public}s, intentId:%{public}" PRIu64,
157 want.GetElement().GetAbilityName().c_str(), want.GetElement().GetBundleName().c_str(), intentId);
158 HandleDlpApp(const_cast<Want &>(want));
159 return abms->StartAbilityByInsightIntent(want, callerToken, intentId, userId);
160 }
161
StartAbility(const Want & want,const AbilityStartSetting & abilityStartSetting,sptr<IRemoteObject> callerToken,int requestCode,int32_t userId)162 ErrCode AbilityManagerClient::StartAbility(const Want &want, const AbilityStartSetting &abilityStartSetting,
163 sptr<IRemoteObject> callerToken, int requestCode, int32_t userId)
164 {
165 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
166 auto abms = GetAbilityManager();
167 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
168 HandleDlpApp(const_cast<Want &>(want));
169 return abms->StartAbility(want, abilityStartSetting, callerToken, userId, requestCode);
170 }
171
StartAbility(const Want & want,const StartOptions & startOptions,sptr<IRemoteObject> callerToken,int requestCode,int32_t userId)172 ErrCode AbilityManagerClient::StartAbility(const Want &want, const StartOptions &startOptions,
173 sptr<IRemoteObject> callerToken, int requestCode, int32_t userId)
174 {
175 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
176 auto abms = GetAbilityManager();
177 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
178 TAG_LOGI(AAFwkTag::ABILITYMGR, "abilityName:%{public}s, userId:%{public}d.",
179 want.GetElement().GetAbilityName().c_str(), userId);
180 HandleDlpApp(const_cast<Want &>(want));
181 return abms->StartAbility(want, startOptions, callerToken, userId, requestCode);
182 }
183
StartAbilityAsCaller(const Want & want,sptr<IRemoteObject> callerToken,sptr<IRemoteObject> asCallerSourceToken,int requestCode,int32_t userId)184 ErrCode AbilityManagerClient::StartAbilityAsCaller(
185 const Want &want, sptr<IRemoteObject> callerToken,
186 sptr<IRemoteObject> asCallerSourceToken, int requestCode, int32_t userId)
187 {
188 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
189 auto abms = GetAbilityManager();
190 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
191 TAG_LOGI(AAFwkTag::ABILITYMGR,
192 "ability:%{public}s, userId:%{public}d.", want.GetElement().GetAbilityName().c_str(), userId);
193 HandleDlpApp(const_cast<Want &>(want));
194 return abms->StartAbilityAsCaller(want, callerToken, asCallerSourceToken, userId, requestCode);
195 }
196
StartAbilityAsCaller(const Want & want,const StartOptions & startOptions,sptr<IRemoteObject> callerToken,sptr<IRemoteObject> asCallerSourceToken,int requestCode,int32_t userId)197 ErrCode AbilityManagerClient::StartAbilityAsCaller(const Want &want, const StartOptions &startOptions,
198 sptr<IRemoteObject> callerToken, sptr<IRemoteObject> asCallerSourceToken,
199 int requestCode, int32_t userId)
200 {
201 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
202 auto abms = GetAbilityManager();
203 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
204 TAG_LOGI(AAFwkTag::ABILITYMGR, "abilityName:%{public}s, userId:%{public}d",
205 want.GetElement().GetAbilityName().c_str(), userId);
206 HandleDlpApp(const_cast<Want &>(want));
207 return abms->StartAbilityAsCaller(want, startOptions, callerToken, asCallerSourceToken, userId, requestCode);
208 }
209
StartAbilityForResultAsCaller(const Want & want,sptr<IRemoteObject> callerToken,int requestCode,int32_t userId)210 ErrCode AbilityManagerClient::StartAbilityForResultAsCaller(
211 const Want &want, sptr<IRemoteObject> callerToken, int requestCode, int32_t userId)
212 {
213 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
214 auto abms = GetAbilityManager();
215 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
216 TAG_LOGD(AAFwkTag::ABILITYMGR, "The abilityName:%{public}s, userId:%{public}d",
217 want.GetElement().GetAbilityName().c_str(), userId);
218 HandleDlpApp(const_cast<Want &>(want));
219 return abms->StartAbilityForResultAsCaller(want, callerToken, requestCode, userId);
220 }
221
StartAbilityForResultAsCaller(const Want & want,const StartOptions & startOptions,sptr<IRemoteObject> callerToken,int requestCode,int32_t userId)222 ErrCode AbilityManagerClient::StartAbilityForResultAsCaller(const Want &want, const StartOptions &startOptions,
223 sptr<IRemoteObject> callerToken, int requestCode, int32_t userId)
224 {
225 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
226 auto abms = GetAbilityManager();
227 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
228 TAG_LOGD(AAFwkTag::ABILITYMGR, "The abilityName:%{public}s, userId:%{public}d",
229 want.GetElement().GetAbilityName().c_str(), userId);
230 HandleDlpApp(const_cast<Want &>(want));
231 return abms->StartAbilityForResultAsCaller(want, startOptions, callerToken, requestCode, userId);
232 }
233
StartAbilityByUIContentSession(const Want & want,const StartOptions & startOptions,sptr<IRemoteObject> callerToken,sptr<AAFwk::SessionInfo> sessionInfo,int requestCode,int32_t userId)234 ErrCode AbilityManagerClient::StartAbilityByUIContentSession(const Want &want, const StartOptions &startOptions,
235 sptr<IRemoteObject> callerToken, sptr<AAFwk::SessionInfo> sessionInfo,
236 int requestCode, int32_t userId)
237 {
238 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
239 auto abms = GetAbilityManager();
240 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
241 TAG_LOGI(AAFwkTag::ABILITYMGR, "abilityName:%{public}s, userId:%{public}d.",
242 want.GetElement().GetAbilityName().c_str(), userId);
243 HandleDlpApp(const_cast<Want &>(want));
244 return abms->StartAbilityByUIContentSession(want, startOptions, callerToken, sessionInfo, userId, requestCode);
245 }
246
StartAbilityByUIContentSession(const Want & want,sptr<IRemoteObject> callerToken,sptr<AAFwk::SessionInfo> sessionInfo,int requestCode,int32_t userId)247 ErrCode AbilityManagerClient::StartAbilityByUIContentSession(const Want &want, sptr<IRemoteObject> callerToken,
248 sptr<AAFwk::SessionInfo> sessionInfo, int requestCode, int32_t userId)
249 {
250 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
251 auto abms = GetAbilityManager();
252 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
253 TAG_LOGI(AAFwkTag::ABILITYMGR, "ability:%{public}s, userId:%{public}d",
254 want.GetElement().GetAbilityName().c_str(), userId);
255 HandleDlpApp(const_cast<Want &>(want));
256 return abms->StartAbilityByUIContentSession(want, callerToken, sessionInfo, userId, requestCode);
257 }
258
StartAbilityOnlyUIAbility(const Want & want,sptr<IRemoteObject> callerToken,uint32_t specifyTokenId)259 ErrCode AbilityManagerClient::StartAbilityOnlyUIAbility(const Want &want, sptr<IRemoteObject> callerToken,
260 uint32_t specifyTokenId)
261 {
262 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
263 auto abms = GetAbilityManager();
264 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
265 TAG_LOGI(AAFwkTag::ABILITYMGR, "ability:%{public}s",
266 want.GetElement().GetAbilityName().c_str());
267 HandleDlpApp(const_cast<Want &>(want));
268 return abms->StartAbilityOnlyUIAbility(want, callerToken, specifyTokenId);
269 }
270
SendResultToAbility(int requestCode,int resultCode,Want & resultWant)271 ErrCode AbilityManagerClient::SendResultToAbility(int requestCode, int resultCode, Want& resultWant)
272 {
273 auto abms = GetAbilityManager();
274 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
275 TAG_LOGI(AAFwkTag::ABILITYMGR, "call");
276 return abms->SendResultToAbility(requestCode, resultCode, resultWant);
277 }
278
StartExtensionAbility(const Want & want,sptr<IRemoteObject> callerToken,int32_t userId,AppExecFwk::ExtensionAbilityType extensionType)279 ErrCode AbilityManagerClient::StartExtensionAbility(const Want &want, sptr<IRemoteObject> callerToken,
280 int32_t userId, AppExecFwk::ExtensionAbilityType extensionType)
281 {
282 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
283 auto abms = GetAbilityManager();
284 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
285 TAG_LOGI(AAFwkTag::ABILITYMGR, "name:%{public}s %{public}s, userId=%{public}d.",
286 want.GetElement().GetAbilityName().c_str(), want.GetElement().GetBundleName().c_str(), userId);
287 return abms->StartExtensionAbility(want, callerToken, userId, extensionType);
288 }
289
RequestModalUIExtension(const Want & want)290 ErrCode AbilityManagerClient::RequestModalUIExtension(const Want &want)
291 {
292 auto abms = GetAbilityManager();
293 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
294 return abms->RequestModalUIExtension(want);
295 }
296
PreloadUIExtensionAbility(const Want & want,std::string & hostBundleName,int32_t userId)297 ErrCode AbilityManagerClient::PreloadUIExtensionAbility(const Want &want, std::string &hostBundleName, int32_t userId)
298 {
299 auto abms = GetAbilityManager();
300 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
301 TAG_LOGD(AAFwkTag::ABILITYMGR, "elementName:%{public}s, hostBundleName:%{public}s.",
302 want.GetElement().GetURI().c_str(), hostBundleName.c_str());
303 return abms->PreloadUIExtensionAbility(want, hostBundleName, userId);
304 }
305
ChangeAbilityVisibility(sptr<IRemoteObject> token,bool isShow)306 ErrCode AbilityManagerClient::ChangeAbilityVisibility(sptr<IRemoteObject> token, bool isShow)
307 {
308 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
309 auto abms = GetAbilityManager();
310 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
311 return abms->ChangeAbilityVisibility(token, isShow);
312 }
313
ChangeUIAbilityVisibilityBySCB(sptr<SessionInfo> sessionInfo,bool isShow)314 ErrCode AbilityManagerClient::ChangeUIAbilityVisibilityBySCB(sptr<SessionInfo> sessionInfo, bool isShow)
315 {
316 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
317 if (sessionInfo == nullptr) {
318 TAG_LOGE(AAFwkTag::ABILITYMGR, "sessionInfo is nullptr");
319 return ERR_INVALID_VALUE;
320 }
321 auto abms = GetAbilityManager();
322 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
323 TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, ChangeUIAbilityVisibilityBySCB abilityName: %{public}s,"
324 "isShow: %{public}d", sessionInfo->want.GetElement().GetAbilityName().c_str(), isShow);
325 return abms->ChangeUIAbilityVisibilityBySCB(sessionInfo, isShow);
326 }
327
StartUIExtensionAbility(sptr<SessionInfo> extensionSessionInfo,int32_t userId)328 ErrCode AbilityManagerClient::StartUIExtensionAbility(sptr<SessionInfo> extensionSessionInfo, int32_t userId)
329 {
330 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
331 auto abms = GetAbilityManager();
332 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
333 CHECK_POINTER_RETURN_INVALID_VALUE(extensionSessionInfo);
334 TAG_LOGI(AAFwkTag::ABILITYMGR, "name: %{public}s %{public}s, persistentId: %{public}d, userId: %{public}d.",
335 extensionSessionInfo->want.GetElement().GetAbilityName().c_str(),
336 extensionSessionInfo->want.GetElement().GetBundleName().c_str(), extensionSessionInfo->persistentId, userId);
337 return abms->StartUIExtensionAbility(extensionSessionInfo, userId);
338 }
339
StartUIAbilityBySCB(sptr<SessionInfo> sessionInfo,bool & isColdStart,uint32_t sceneFlag)340 ErrCode AbilityManagerClient::StartUIAbilityBySCB(sptr<SessionInfo> sessionInfo, bool &isColdStart, uint32_t sceneFlag)
341 {
342 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
343 if (sessionInfo == nullptr) {
344 TAG_LOGE(AAFwkTag::ABILITYMGR, "sessionInfo is nullptr");
345 return ERR_INVALID_VALUE;
346 }
347 auto abms = GetAbilityManager();
348 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
349 TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, StartUIAbilityBySCB target: %{public}s.",
350 sessionInfo->want.GetElement().GetURI().c_str());
351 return abms->StartUIAbilityBySCB(sessionInfo, isColdStart, sceneFlag);
352 }
353
StopExtensionAbility(const Want & want,sptr<IRemoteObject> callerToken,int32_t userId,AppExecFwk::ExtensionAbilityType extensionType)354 ErrCode AbilityManagerClient::StopExtensionAbility(const Want &want, sptr<IRemoteObject> callerToken,
355 int32_t userId, AppExecFwk::ExtensionAbilityType extensionType)
356 {
357 auto abms = GetAbilityManager();
358 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
359 TAG_LOGI(AAFwkTag::ABILITYMGR, "name:%{public}s %{public}s, userId=%{public}d.",
360 want.GetElement().GetAbilityName().c_str(), want.GetElement().GetBundleName().c_str(), userId);
361 return abms->StopExtensionAbility(want, callerToken, userId, extensionType);
362 }
363
TerminateAbility(sptr<IRemoteObject> token,int resultCode,const Want * resultWant)364 ErrCode AbilityManagerClient::TerminateAbility(sptr<IRemoteObject> token, int resultCode, const Want *resultWant)
365 {
366 auto abms = GetAbilityManager();
367 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
368 TAG_LOGD(AAFwkTag::ABILITYMGR, "call");
369 return abms->TerminateAbility(token, resultCode, resultWant);
370 }
371
BackToCallerAbilityWithResult(const sptr<IRemoteObject> & token,int resultCode,const Want * resultWant,int64_t callerRequestCode)372 ErrCode AbilityManagerClient::BackToCallerAbilityWithResult(const sptr<IRemoteObject> &token, int resultCode,
373 const Want *resultWant, int64_t callerRequestCode)
374 {
375 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
376 auto abms = GetAbilityManager();
377 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
378 return abms->BackToCallerAbilityWithResult(token, resultCode, resultWant, callerRequestCode);
379 }
380
TerminateUIExtensionAbility(sptr<SessionInfo> extensionSessionInfo,int resultCode,const Want * resultWant)381 ErrCode AbilityManagerClient::TerminateUIExtensionAbility(sptr<SessionInfo> extensionSessionInfo,
382 int resultCode, const Want *resultWant)
383 {
384 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
385 auto abms = GetAbilityManager();
386 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
387 CHECK_POINTER_RETURN_INVALID_VALUE(extensionSessionInfo);
388 TAG_LOGI(AAFwkTag::ABILITYMGR, "name: %{public}s %{public}s, persistentId: %{public}d",
389 extensionSessionInfo->want.GetElement().GetAbilityName().c_str(),
390 extensionSessionInfo->want.GetElement().GetBundleName().c_str(), extensionSessionInfo->persistentId);
391 return abms->TerminateUIExtensionAbility(extensionSessionInfo, resultCode, resultWant);
392 }
393
MoveAbilityToBackground(sptr<IRemoteObject> token)394 ErrCode AbilityManagerClient::MoveAbilityToBackground(sptr<IRemoteObject> token)
395 {
396 TAG_LOGI(AAFwkTag::ABILITYMGR, "call");
397 auto abms = GetAbilityManager();
398 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
399 return abms->MoveAbilityToBackground(token);
400 }
401
MoveUIAbilityToBackground(const sptr<IRemoteObject> token)402 ErrCode AbilityManagerClient::MoveUIAbilityToBackground(const sptr<IRemoteObject> token)
403 {
404 TAG_LOGI(AAFwkTag::ABILITYMGR, "MoveUIAbilityToBackground call");
405 auto abms = GetAbilityManager();
406 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
407 return abms->MoveUIAbilityToBackground(token);
408 }
409
CloseAbility(sptr<IRemoteObject> token,int resultCode,const Want * resultWant)410 ErrCode AbilityManagerClient::CloseAbility(sptr<IRemoteObject> token, int resultCode, const Want *resultWant)
411 {
412 if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
413 auto sceneSessionManager = SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy();
414 CHECK_POINTER_RETURN_INVALID_VALUE(sceneSessionManager);
415 sptr<AAFwk::SessionInfo> info = new AAFwk::SessionInfo();
416 info->want = *resultWant;
417 info->resultCode = resultCode;
418 info->sessionToken = token;
419 TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, CloseAbility");
420 auto ret = static_cast<int>(sceneSessionManager->TerminateSessionNew(info, false));
421 if (ret != ERR_OK) {
422 TAG_LOGE(AAFwkTag::ABILITYMGR, "scb call, CloseAbility err: %{public}d", ret);
423 }
424 return ret;
425 }
426 auto abms = GetAbilityManager();
427 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
428 TAG_LOGI(AAFwkTag::ABILITYMGR, "call");
429 return abms->CloseAbility(token, resultCode, resultWant);
430 }
431
CloseUIAbilityBySCB(sptr<SessionInfo> sessionInfo)432 ErrCode AbilityManagerClient::CloseUIAbilityBySCB(sptr<SessionInfo> sessionInfo)
433 {
434 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
435 if (sessionInfo == nullptr) {
436 TAG_LOGE(AAFwkTag::ABILITYMGR, "failed, sessionInfo is nullptr");
437 return ERR_INVALID_VALUE;
438 }
439 auto abms = GetAbilityManager();
440 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
441 TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, CloseUIAbilityBySCB");
442 return abms->CloseUIAbilityBySCB(sessionInfo);
443 }
444
MinimizeAbility(sptr<IRemoteObject> token,bool fromUser)445 ErrCode AbilityManagerClient::MinimizeAbility(sptr<IRemoteObject> token, bool fromUser)
446 {
447 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
448 auto abms = GetAbilityManager();
449 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
450 TAG_LOGI(AAFwkTag::ABILITYMGR, "fromUser:%{public}d.", fromUser);
451 return abms->MinimizeAbility(token, fromUser);
452 }
453
MinimizeUIExtensionAbility(sptr<SessionInfo> extensionSessionInfo,bool fromUser)454 ErrCode AbilityManagerClient::MinimizeUIExtensionAbility(sptr<SessionInfo> extensionSessionInfo, bool fromUser)
455 {
456 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
457 auto abms = GetAbilityManager();
458 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
459 CHECK_POINTER_RETURN_INVALID_VALUE(extensionSessionInfo);
460 TAG_LOGI(AAFwkTag::ABILITYMGR, "name: %{public}s %{public}s, persistentId: %{public}d, fromUser: %{public}d",
461 extensionSessionInfo->want.GetElement().GetAbilityName().c_str(),
462 extensionSessionInfo->want.GetElement().GetBundleName().c_str(), extensionSessionInfo->persistentId, fromUser);
463 return abms->MinimizeUIExtensionAbility(extensionSessionInfo, fromUser);
464 }
465
MinimizeUIAbilityBySCB(sptr<SessionInfo> sessionInfo,bool fromUser,uint32_t sceneFlag)466 ErrCode AbilityManagerClient::MinimizeUIAbilityBySCB(sptr<SessionInfo> sessionInfo, bool fromUser, uint32_t sceneFlag)
467 {
468 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
469 if (sessionInfo == nullptr) {
470 TAG_LOGE(AAFwkTag::ABILITYMGR, "failed, sessionInfo is nullptr");
471 return ERR_INVALID_VALUE;
472 }
473 auto abms = GetAbilityManager();
474 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
475 TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, MinimizeUIAbilityBySCB target: %{public}s",
476 sessionInfo->want.GetElement().GetURI().c_str());
477 return abms->MinimizeUIAbilityBySCB(sessionInfo, fromUser, sceneFlag);
478 }
479
ConnectAbility(const Want & want,sptr<IAbilityConnection> connect,int32_t userId)480 ErrCode AbilityManagerClient::ConnectAbility(const Want &want, sptr<IAbilityConnection> connect, int32_t userId)
481 {
482 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
483 auto abms = GetAbilityManager();
484 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
485 TAG_LOGI(AAFwkTag::ABILITYMGR, "name:%{public}s %{public}s, userId:%{public}d",
486 want.GetElement().GetBundleName().c_str(), want.GetElement().GetAbilityName().c_str(), userId);
487 return abms->ConnectAbilityCommon(want, connect, nullptr, AppExecFwk::ExtensionAbilityType::SERVICE, userId);
488 }
489
ConnectAbility(const Want & want,sptr<IAbilityConnection> connect,sptr<IRemoteObject> callerToken,int32_t userId)490 ErrCode AbilityManagerClient::ConnectAbility(
491 const Want &want, sptr<IAbilityConnection> connect, sptr<IRemoteObject> callerToken, int32_t userId)
492 {
493 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
494 auto abms = GetAbilityManager();
495 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
496 TAG_LOGI(AAFwkTag::ABILITYMGR, "name:%{public}s %{public}s, userId:%{public}d.",
497 want.GetElement().GetBundleName().c_str(), want.GetElement().GetAbilityName().c_str(), userId);
498 return abms->ConnectAbilityCommon(want, connect, callerToken, AppExecFwk::ExtensionAbilityType::SERVICE, userId);
499 }
500
ConnectDataShareExtensionAbility(const Want & want,sptr<IAbilityConnection> connect,int32_t userId)501 ErrCode AbilityManagerClient::ConnectDataShareExtensionAbility(const Want &want,
502 sptr<IAbilityConnection> connect, int32_t userId)
503 {
504 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
505 auto abms = GetAbilityManager();
506 if (abms == nullptr) {
507 TAG_LOGE(AAFwkTag::ABILITYMGR, "Connect failed, bundleName:%{public}s, abilityName:%{public}s, uri:%{public}s.",
508 want.GetElement().GetBundleName().c_str(), want.GetElement().GetAbilityName().c_str(),
509 want.GetUriString().c_str());
510 return ABILITY_SERVICE_NOT_CONNECTED;
511 }
512
513 TAG_LOGI(AAFwkTag::ABILITYMGR, "name:%{public}s %{public}s, uri:%{public}s.",
514 want.GetElement().GetBundleName().c_str(), want.GetElement().GetAbilityName().c_str(),
515 want.GetUriString().c_str());
516 return abms->ConnectAbilityCommon(want, connect, nullptr, AppExecFwk::ExtensionAbilityType::DATASHARE, userId);
517 }
518
ConnectExtensionAbility(const Want & want,sptr<IAbilityConnection> connect,int32_t userId)519 ErrCode AbilityManagerClient::ConnectExtensionAbility(const Want &want, sptr<IAbilityConnection> connect,
520 int32_t userId)
521 {
522 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
523 auto abms = GetAbilityManager();
524 if (abms == nullptr) {
525 TAG_LOGE(AAFwkTag::ABILITYMGR, "Connect failed, bundleName:%{public}s, abilityName:%{public}s",
526 want.GetElement().GetBundleName().c_str(), want.GetElement().GetAbilityName().c_str());
527 return ABILITY_SERVICE_NOT_CONNECTED;
528 }
529
530 TAG_LOGI(AAFwkTag::ABILITYMGR, "name:%{public}s %{public}s, userId:%{public}d.",
531 want.GetElement().GetBundleName().c_str(), want.GetElement().GetAbilityName().c_str(), userId);
532 return abms->ConnectAbilityCommon(want, connect, nullptr, AppExecFwk::ExtensionAbilityType::UNSPECIFIED, userId);
533 }
534
ConnectUIExtensionAbility(const Want & want,sptr<IAbilityConnection> connect,sptr<SessionInfo> sessionInfo,int32_t userId,sptr<UIExtensionAbilityConnectInfo> connectInfo)535 ErrCode AbilityManagerClient::ConnectUIExtensionAbility(const Want &want, sptr<IAbilityConnection> connect,
536 sptr<SessionInfo> sessionInfo, int32_t userId, sptr<UIExtensionAbilityConnectInfo> connectInfo)
537 {
538 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
539 auto abms = GetAbilityManager();
540 if (abms == nullptr) {
541 TAG_LOGE(AAFwkTag::ABILITYMGR, "Connect failed, bundleName:%{public}s, abilityName:%{public}s, uri:%{public}s.",
542 want.GetElement().GetBundleName().c_str(), want.GetElement().GetAbilityName().c_str(),
543 want.GetUriString().c_str());
544 return ABILITY_SERVICE_NOT_CONNECTED;
545 }
546
547 TAG_LOGI(AAFwkTag::ABILITYMGR, "name:%{public}s %{public}s, uri:%{public}s.",
548 want.GetElement().GetBundleName().c_str(), want.GetElement().GetAbilityName().c_str(),
549 want.GetUriString().c_str());
550 return abms->ConnectUIExtensionAbility(want, connect, sessionInfo, userId, connectInfo);
551 }
552
DisconnectAbility(sptr<IAbilityConnection> connect)553 ErrCode AbilityManagerClient::DisconnectAbility(sptr<IAbilityConnection> connect)
554 {
555 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
556 auto abms = GetAbilityManager();
557 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
558 TAG_LOGI(AAFwkTag::ABILITYMGR, "DisconnectAbility call");
559 return abms->DisconnectAbility(connect);
560 }
561
AcquireDataAbility(const Uri & uri,bool tryBind,sptr<IRemoteObject> callerToken)562 sptr<IAbilityScheduler> AbilityManagerClient::AcquireDataAbility(
563 const Uri &uri, bool tryBind, sptr<IRemoteObject> callerToken)
564 {
565 auto abms = GetAbilityManager();
566 if (!abms) {
567 return nullptr;
568 }
569 return abms->AcquireDataAbility(uri, tryBind, callerToken);
570 }
571
ReleaseDataAbility(sptr<IAbilityScheduler> dataAbilityScheduler,sptr<IRemoteObject> callerToken)572 ErrCode AbilityManagerClient::ReleaseDataAbility(
573 sptr<IAbilityScheduler> dataAbilityScheduler, sptr<IRemoteObject> callerToken)
574 {
575 auto abms = GetAbilityManager();
576 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
577 return abms->ReleaseDataAbility(dataAbilityScheduler, callerToken);
578 }
579
DumpState(const std::string & args,std::vector<std::string> & state)580 ErrCode AbilityManagerClient::DumpState(const std::string &args, std::vector<std::string> &state)
581 {
582 auto abms = GetAbilityManager();
583 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
584 abms->DumpState(args, state);
585 return ERR_OK;
586 }
587
DumpSysState(const std::string & args,std::vector<std::string> & state,bool isClient,bool isUserID,int UserID)588 ErrCode AbilityManagerClient::DumpSysState(
589 const std::string& args, std::vector<std::string>& state, bool isClient, bool isUserID, int UserID)
590 {
591 auto abms = GetAbilityManager();
592 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
593 abms->DumpSysState(args, state, isClient, isUserID, UserID);
594 return ERR_OK;
595 }
596
Connect()597 ErrCode AbilityManagerClient::Connect()
598 {
599 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
600 std::lock_guard<std::recursive_mutex> lock(mutex_);
601 if (proxy_ != nullptr) {
602 return ERR_OK;
603 }
604 sptr<ISystemAbilityManager> systemManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
605 if (systemManager == nullptr) {
606 TAG_LOGE(AAFwkTag::ABILITYMGR, "Fail to get registry.");
607 return GET_ABILITY_SERVICE_FAILED;
608 }
609 sptr<IRemoteObject> remoteObj = systemManager->GetSystemAbility(ABILITY_MGR_SERVICE_ID);
610 if (remoteObj == nullptr) {
611 TAG_LOGE(AAFwkTag::ABILITYMGR, "Fail to connect ability manager service.");
612 return GET_ABILITY_SERVICE_FAILED;
613 }
614
615 deathRecipient_ = sptr<IRemoteObject::DeathRecipient>(new AbilityMgrDeathRecipient());
616 if (deathRecipient_ == nullptr) {
617 TAG_LOGE(AAFwkTag::ABILITYMGR, "Failed to create AbilityMgrDeathRecipient!");
618 return GET_ABILITY_SERVICE_FAILED;
619 }
620 if ((remoteObj->IsProxyObject()) && (!remoteObj->AddDeathRecipient(deathRecipient_))) {
621 TAG_LOGE(AAFwkTag::ABILITYMGR, "Add death recipient to AbilityManagerService failed.");
622 return GET_ABILITY_SERVICE_FAILED;
623 }
624
625 proxy_ = iface_cast<IAbilityManager>(remoteObj);
626 TAG_LOGD(AAFwkTag::ABILITYMGR, "Connect ability manager service success.");
627 return ERR_OK;
628 }
629
RemoveDeathRecipient()630 void AbilityManagerClient::RemoveDeathRecipient()
631 {
632 TAG_LOGI(AAFwkTag::ABILITYMGR, "RemoveDeathRecipient");
633 std::lock_guard<std::recursive_mutex> lock(mutex_);
634 if (proxy_ == nullptr) {
635 TAG_LOGI(AAFwkTag::ABILITYMGR, "AbilityMgrProxy do not exist");
636 return;
637 }
638 if (deathRecipient_ == nullptr) {
639 TAG_LOGI(AAFwkTag::ABILITYMGR, "AbilityMgrDeathRecipient do not exist");
640 return;
641 }
642 auto serviceRemote = proxy_->AsObject();
643 if (serviceRemote != nullptr && serviceRemote->RemoveDeathRecipient(deathRecipient_)) {
644 proxy_ = nullptr;
645 deathRecipient_ = nullptr;
646 TAG_LOGI(AAFwkTag::ABILITYMGR, "Remove DeathRecipient success");
647 }
648 }
649
StopServiceAbility(const Want & want,sptr<IRemoteObject> token)650 ErrCode AbilityManagerClient::StopServiceAbility(const Want &want, sptr<IRemoteObject> token)
651 {
652 TAG_LOGI(AAFwkTag::ABILITYMGR, "call");
653 auto abms = GetAbilityManager();
654 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
655 return abms->StopServiceAbility(want, -1, token);
656 }
657
KillProcess(const std::string & bundleName)658 ErrCode AbilityManagerClient::KillProcess(const std::string &bundleName)
659 {
660 TAG_LOGI(AAFwkTag::ABILITYMGR, "enter");
661 auto abms = GetAbilityManager();
662 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
663 return abms->KillProcess(bundleName);
664 }
665
666 #ifdef ABILITY_COMMAND_FOR_TEST
ForceTimeoutForTest(const std::string & abilityName,const std::string & state)667 ErrCode AbilityManagerClient::ForceTimeoutForTest(const std::string &abilityName, const std::string &state)
668 {
669 TAG_LOGD(AAFwkTag::ABILITYMGR, "enter");
670 auto abms = GetAbilityManager();
671 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
672 return abms->ForceTimeoutForTest(abilityName, state);
673 }
674 #endif
675
ContinueMission(const std::string & srcDeviceId,const std::string & dstDeviceId,int32_t missionId,sptr<IRemoteObject> callback,AAFwk::WantParams & wantParams)676 ErrCode AbilityManagerClient::ContinueMission(const std::string &srcDeviceId, const std::string &dstDeviceId,
677 int32_t missionId, sptr<IRemoteObject> callback, AAFwk::WantParams &wantParams)
678 {
679 if (srcDeviceId.empty() || dstDeviceId.empty() || callback == nullptr) {
680 TAG_LOGE(AAFwkTag::ABILITYMGR, "srcDeviceId or dstDeviceId or callback is null!");
681 return ERR_INVALID_VALUE;
682 }
683
684 auto abms = GetAbilityManager();
685 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
686 int result = abms->ContinueMission(srcDeviceId, dstDeviceId, missionId, callback, wantParams);
687 return result;
688 }
689
ContinueMission(AAFwk::ContinueMissionInfo continueMissionInfo,const sptr<IRemoteObject> & callback)690 ErrCode AbilityManagerClient::ContinueMission(AAFwk::ContinueMissionInfo continueMissionInfo,
691 const sptr<IRemoteObject> &callback)
692
693 {
694 if (continueMissionInfo.srcDeviceId.empty() || continueMissionInfo.dstDeviceId.empty() || callback == nullptr) {
695 TAG_LOGE(AAFwkTag::ABILITYMGR, "srcDeviceId or dstDeviceId or callback is null!");
696 return ERR_INVALID_VALUE;
697 }
698
699 auto abms = GetAbilityManager();
700 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
701 int result = abms->ContinueMission(continueMissionInfo, callback);
702 return result;
703 }
704
StartContinuation(const Want & want,sptr<IRemoteObject> abilityToken,int32_t status)705 ErrCode AbilityManagerClient::StartContinuation(const Want &want, sptr<IRemoteObject> abilityToken,
706 int32_t status)
707 {
708 auto abms = GetAbilityManager();
709 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
710 int result = abms->StartContinuation(want, abilityToken, status);
711 return result;
712 }
713
NotifyCompleteContinuation(const std::string & deviceId,int32_t sessionId,bool isSuccess)714 void AbilityManagerClient::NotifyCompleteContinuation(const std::string &deviceId,
715 int32_t sessionId, bool isSuccess)
716 {
717 auto abms = GetAbilityManager();
718 CHECK_POINTER_RETURN(abms);
719 abms->NotifyCompleteContinuation(deviceId, sessionId, isSuccess);
720 }
721
ContinueAbility(const std::string & deviceId,int32_t missionId,uint32_t versionCode)722 ErrCode AbilityManagerClient::ContinueAbility(const std::string &deviceId, int32_t missionId, uint32_t versionCode)
723 {
724 auto abms = GetAbilityManager();
725 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
726 return abms->ContinueAbility(deviceId, missionId, versionCode);
727 }
728
NotifyContinuationResult(int32_t missionId,int32_t result)729 ErrCode AbilityManagerClient::NotifyContinuationResult(int32_t missionId, int32_t result)
730 {
731 auto abms = GetAbilityManager();
732 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
733 return abms->NotifyContinuationResult(missionId, result);
734 }
735
LockMissionForCleanup(int32_t missionId)736 ErrCode AbilityManagerClient::LockMissionForCleanup(int32_t missionId)
737 {
738 if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
739 auto sceneSessionManager = SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy();
740 CHECK_POINTER_RETURN_INVALID_VALUE(sceneSessionManager);
741 TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, LockMissionForCleanup");
742 auto err = sceneSessionManager->LockSession(missionId);
743 if (SCB_TO_MISSION_ERROR_CODE_MAP.count(err)) {
744 TAG_LOGE(AAFwkTag::ABILITYMGR, "scb call, LockMissionForCleanup err");
745 return SCB_TO_MISSION_ERROR_CODE_MAP[err];
746 }
747 return static_cast<int>(err);
748 }
749 auto abms = GetAbilityManager();
750 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
751 return abms->LockMissionForCleanup(missionId);
752 }
753
UnlockMissionForCleanup(int32_t missionId)754 ErrCode AbilityManagerClient::UnlockMissionForCleanup(int32_t missionId)
755 {
756 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
757 if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
758 auto sceneSessionManager = SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy();
759 CHECK_POINTER_RETURN_INVALID_VALUE(sceneSessionManager);
760 TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, UnlockMissionForCleanup");
761 auto err = sceneSessionManager->UnlockSession(missionId);
762 if (SCB_TO_MISSION_ERROR_CODE_MAP.count(err)) {
763 TAG_LOGE(AAFwkTag::ABILITYMGR, "scb call, UnlockMissionForCleanup err");
764 return SCB_TO_MISSION_ERROR_CODE_MAP[err];
765 }
766 return static_cast<int>(err);
767 }
768 auto abms = GetAbilityManager();
769 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
770 return abms->UnlockMissionForCleanup(missionId);
771 }
772
SetLockedState(int32_t sessionId,bool lockedState)773 void AbilityManagerClient::SetLockedState(int32_t sessionId, bool lockedState)
774 {
775 auto abms = GetAbilityManager();
776 CHECK_POINTER_RETURN(abms);
777 abms->SetLockedState(sessionId, lockedState);
778 }
779
RegisterMissionListener(sptr<IMissionListener> listener)780 ErrCode AbilityManagerClient::RegisterMissionListener(sptr<IMissionListener> listener)
781 {
782 if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
783 auto sceneSessionManager = SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy();
784 CHECK_POINTER_RETURN_INVALID_VALUE(sceneSessionManager);
785 TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, RegisterMissionListener");
786 auto err = sceneSessionManager->RegisterSessionListener(listener);
787 if (SCB_TO_MISSION_ERROR_CODE_MAP.count(err)) {
788 TAG_LOGE(AAFwkTag::ABILITYMGR, "scb call, RegisterMissionListener err");
789 return SCB_TO_MISSION_ERROR_CODE_MAP[err];
790 }
791 return static_cast<int>(err);
792 }
793 auto abms = GetAbilityManager();
794 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
795 return abms->RegisterMissionListener(listener);
796 }
797
UnRegisterMissionListener(sptr<IMissionListener> listener)798 ErrCode AbilityManagerClient::UnRegisterMissionListener(sptr<IMissionListener> listener)
799 {
800 if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
801 auto sceneSessionManager = SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy();
802 CHECK_POINTER_RETURN_INVALID_VALUE(sceneSessionManager);
803 TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, UnRegisterMissionListener");
804 auto err = sceneSessionManager->UnRegisterSessionListener(listener);
805 if (SCB_TO_MISSION_ERROR_CODE_MAP.count(err)) {
806 TAG_LOGE(AAFwkTag::ABILITYMGR, "scb call, UnRegisterMissionListener err");
807 return SCB_TO_MISSION_ERROR_CODE_MAP[err];
808 }
809 return static_cast<int>(err);
810 }
811 auto abms = GetAbilityManager();
812 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
813 return abms->UnRegisterMissionListener(listener);
814 }
815
RegisterMissionListener(const std::string & deviceId,sptr<IRemoteMissionListener> listener)816 ErrCode AbilityManagerClient::RegisterMissionListener(const std::string &deviceId,
817 sptr<IRemoteMissionListener> listener)
818 {
819 auto abms = GetAbilityManager();
820 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
821 return abms->RegisterMissionListener(deviceId, listener);
822 }
823
RegisterOnListener(const std::string & type,sptr<IRemoteOnListener> listener)824 ErrCode AbilityManagerClient::RegisterOnListener(const std::string &type,
825 sptr<IRemoteOnListener> listener)
826 {
827 auto abms = GetAbilityManager();
828 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
829 return abms->RegisterOnListener(type, listener);
830 }
831
RegisterOffListener(const std::string & type,sptr<IRemoteOnListener> listener)832 ErrCode AbilityManagerClient::RegisterOffListener(const std::string &type,
833 sptr<IRemoteOnListener> listener)
834 {
835 auto abms = GetAbilityManager();
836 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
837 return abms->RegisterOffListener(type, listener);
838 }
839
UnRegisterMissionListener(const std::string & deviceId,sptr<IRemoteMissionListener> listener)840 ErrCode AbilityManagerClient::UnRegisterMissionListener(const std::string &deviceId,
841 sptr<IRemoteMissionListener> listener)
842 {
843 auto abms = GetAbilityManager();
844 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
845 return abms->UnRegisterMissionListener(deviceId, listener);
846 }
847
GetMissionInfos(const std::string & deviceId,int32_t numMax,std::vector<MissionInfo> & missionInfos)848 ErrCode AbilityManagerClient::GetMissionInfos(const std::string& deviceId, int32_t numMax,
849 std::vector<MissionInfo> &missionInfos)
850 {
851 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
852 if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
853 auto sceneSessionManager = SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy();
854 CHECK_POINTER_RETURN_INVALID_VALUE(sceneSessionManager);
855 TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, GetMissionInfos");
856 auto err = sceneSessionManager->GetSessionInfos(deviceId, numMax, missionInfos);
857 if (SCB_TO_MISSION_ERROR_CODE_MAP.count(err)) {
858 TAG_LOGE(AAFwkTag::ABILITYMGR, "scb call, GetMissionInfos err");
859 return SCB_TO_MISSION_ERROR_CODE_MAP[err];
860 }
861 return static_cast<int>(err);
862 }
863 auto abms = GetAbilityManager();
864 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
865 return abms->GetMissionInfos(deviceId, numMax, missionInfos);
866 }
867
GetMissionInfo(const std::string & deviceId,int32_t missionId,MissionInfo & missionInfo)868 ErrCode AbilityManagerClient::GetMissionInfo(const std::string& deviceId, int32_t missionId,
869 MissionInfo &missionInfo)
870 {
871 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
872 if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
873 auto sceneSessionManager = SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy();
874 CHECK_POINTER_RETURN_INVALID_VALUE(sceneSessionManager);
875 TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, GetMissionInfo");
876 auto err = sceneSessionManager->GetSessionInfo(deviceId, missionId, missionInfo);
877 if (SCB_TO_MISSION_ERROR_CODE_MAP.count(err)) {
878 TAG_LOGE(AAFwkTag::ABILITYMGR, "scb call, GetMissionInfo err");
879 return SCB_TO_MISSION_ERROR_CODE_MAP[err];
880 }
881 return static_cast<int>(err);
882 }
883 auto abms = GetAbilityManager();
884 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
885 return abms->GetMissionInfo(deviceId, missionId, missionInfo);
886 }
887
CleanMission(int32_t missionId)888 ErrCode AbilityManagerClient::CleanMission(int32_t missionId)
889 {
890 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
891 if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
892 auto sceneSessionManager = SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy();
893 CHECK_POINTER_RETURN_INVALID_VALUE(sceneSessionManager);
894 TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, CleanMission");
895 auto err = sceneSessionManager->ClearSession(missionId);
896 if (SCB_TO_MISSION_ERROR_CODE_MAP.count(err)) {
897 TAG_LOGE(AAFwkTag::ABILITYMGR, "scb call, CleanMission err");
898 return SCB_TO_MISSION_ERROR_CODE_MAP[err];
899 }
900 return static_cast<int>(err);
901 }
902 auto abms = GetAbilityManager();
903 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
904 return abms->CleanMission(missionId);
905 }
906
CleanAllMissions()907 ErrCode AbilityManagerClient::CleanAllMissions()
908 {
909 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
910 if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
911 auto sceneSessionManager = SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy();
912 CHECK_POINTER_RETURN_INVALID_VALUE(sceneSessionManager);
913 TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, CleanAllMissions");
914 auto err = sceneSessionManager->ClearAllSessions();
915 if (SCB_TO_MISSION_ERROR_CODE_MAP.count(err)) {
916 TAG_LOGE(AAFwkTag::ABILITYMGR, "scb call, CleanAllMissions err");
917 return SCB_TO_MISSION_ERROR_CODE_MAP[err];
918 }
919 return static_cast<int>(err);
920 }
921 auto abms = GetAbilityManager();
922 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
923 return abms->CleanAllMissions();
924 }
925
MoveMissionToFront(int32_t missionId)926 ErrCode AbilityManagerClient::MoveMissionToFront(int32_t missionId)
927 {
928 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
929 auto abms = GetAbilityManager();
930 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
931 return abms->MoveMissionToFront(missionId);
932 }
933
MoveMissionToFront(int32_t missionId,const StartOptions & startOptions)934 ErrCode AbilityManagerClient::MoveMissionToFront(int32_t missionId, const StartOptions &startOptions)
935 {
936 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
937 auto abms = GetAbilityManager();
938 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
939 return abms->MoveMissionToFront(missionId, startOptions);
940 }
941
MoveMissionsToForeground(const std::vector<int32_t> & missionIds,int32_t topMissionId)942 ErrCode AbilityManagerClient::MoveMissionsToForeground(const std::vector<int32_t>& missionIds, int32_t topMissionId)
943 {
944 TAG_LOGI(AAFwkTag::ABILITYMGR, "MoveMissionsToForeground begin, topMissionId:%{public}d", topMissionId);
945 if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
946 auto sceneSessionManager = SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy();
947 CHECK_POINTER_RETURN_INVALID_VALUE(sceneSessionManager);
948 TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, MoveMissionsToForeground");
949 auto err = sceneSessionManager->MoveSessionsToForeground(missionIds, topMissionId);
950 if (SCB_TO_MISSION_ERROR_CODE_MAP.count(err)) {
951 TAG_LOGE(AAFwkTag::ABILITYMGR, "scb call, MoveMissionsToForeground err");
952 return SCB_TO_MISSION_ERROR_CODE_MAP[err];
953 }
954 auto abms = GetAbilityManager();
955 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
956 if (missionIds.empty()) {
957 return ERR_INVALID_VALUE;
958 }
959 int32_t missionId = topMissionId;
960 if (topMissionId > 0) {
961 missionId = topMissionId;
962 } else {
963 missionId = missionIds[0];
964 }
965 auto errAMS = abms->MoveMissionToFront(missionId);
966 return static_cast<int>(errAMS);
967 }
968 auto abms = GetAbilityManager();
969 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
970 return abms->MoveMissionsToForeground(missionIds, topMissionId);
971 }
972
MoveMissionsToBackground(const std::vector<int32_t> & missionIds,std::vector<int32_t> & result)973 ErrCode AbilityManagerClient::MoveMissionsToBackground(const std::vector<int32_t>& missionIds,
974 std::vector<int32_t>& result)
975 {
976 TAG_LOGI(AAFwkTag::ABILITYMGR, "MoveMissionsToBackground begin.");
977 if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
978 auto sceneSessionManager = SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy();
979 CHECK_POINTER_RETURN_INVALID_VALUE(sceneSessionManager);
980 TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, MoveMissionsToBackground");
981 auto err = sceneSessionManager->MoveSessionsToBackground(missionIds, result);
982 if (SCB_TO_MISSION_ERROR_CODE_MAP.count(err)) {
983 TAG_LOGE(AAFwkTag::ABILITYMGR, "scb call, MoveMissionsToBackground err");
984 return SCB_TO_MISSION_ERROR_CODE_MAP[err];
985 }
986 return static_cast<int>(err);
987 }
988 auto abms = GetAbilityManager();
989 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
990 return abms->MoveMissionsToBackground(missionIds, result);
991 }
992
GetMissionIdByToken(sptr<IRemoteObject> token,int32_t & missionId)993 ErrCode AbilityManagerClient::GetMissionIdByToken(sptr<IRemoteObject> token, int32_t &missionId)
994 {
995 auto abms = GetAbilityManager();
996 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
997 missionId = abms->GetMissionIdByToken(token);
998 if (missionId <= 0) {
999 TAG_LOGE(AAFwkTag::ABILITYMGR, "get missionid by token failed!");
1000 return MISSION_NOT_FOUND;
1001 }
1002 return ERR_OK;
1003 }
1004
StartAbilityByCall(const Want & want,sptr<IAbilityConnection> connect)1005 ErrCode AbilityManagerClient::StartAbilityByCall(const Want &want, sptr<IAbilityConnection> connect)
1006 {
1007 auto abms = GetAbilityManager();
1008 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1009 TAG_LOGD(AAFwkTag::ABILITYMGR, "called");
1010 return abms->StartAbilityByCall(want, connect, nullptr, DEFAULT_INVAL_VALUE);
1011 }
1012
StartAbilityByCall(const Want & want,sptr<IAbilityConnection> connect,sptr<IRemoteObject> callToken,int32_t accountId)1013 ErrCode AbilityManagerClient::StartAbilityByCall(const Want &want, sptr<IAbilityConnection> connect,
1014 sptr<IRemoteObject> callToken, int32_t accountId)
1015 {
1016 auto abms = GetAbilityManager();
1017 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1018 TAG_LOGD(AAFwkTag::ABILITYMGR, "called");
1019 return abms->StartAbilityByCall(want, connect, callToken, accountId);
1020 }
1021
CallRequestDone(sptr<IRemoteObject> token,sptr<IRemoteObject> callStub)1022 void AbilityManagerClient::CallRequestDone(sptr<IRemoteObject> token, sptr<IRemoteObject> callStub)
1023 {
1024 auto abms = GetAbilityManager();
1025 CHECK_POINTER_RETURN(abms);
1026 abms->CallRequestDone(token, callStub);
1027 }
1028
GetAbilityTokenByCalleeObj(sptr<IRemoteObject> callStub,sptr<IRemoteObject> & token)1029 void AbilityManagerClient::GetAbilityTokenByCalleeObj(sptr<IRemoteObject> callStub, sptr<IRemoteObject> &token)
1030 {
1031 auto abms = GetAbilityManager();
1032 CHECK_POINTER_RETURN(abms);
1033 abms->GetAbilityTokenByCalleeObj(callStub, token);
1034 }
1035
ReleaseCall(sptr<IAbilityConnection> connect,const AppExecFwk::ElementName & element)1036 ErrCode AbilityManagerClient::ReleaseCall(
1037 sptr<IAbilityConnection> connect, const AppExecFwk::ElementName &element)
1038 {
1039 auto abms = GetAbilityManager();
1040 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1041 return abms->ReleaseCall(connect, element);
1042 }
1043
GetAbilityRunningInfos(std::vector<AbilityRunningInfo> & info)1044 ErrCode AbilityManagerClient::GetAbilityRunningInfos(std::vector<AbilityRunningInfo> &info)
1045 {
1046 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1047 auto abms = GetAbilityManager();
1048 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1049 return abms->GetAbilityRunningInfos(info);
1050 }
1051
GetExtensionRunningInfos(int upperLimit,std::vector<ExtensionRunningInfo> & info)1052 ErrCode AbilityManagerClient::GetExtensionRunningInfos(int upperLimit, std::vector<ExtensionRunningInfo> &info)
1053 {
1054 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1055 auto abms = GetAbilityManager();
1056 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1057 return abms->GetExtensionRunningInfos(upperLimit, info);
1058 }
1059
GetProcessRunningInfos(std::vector<AppExecFwk::RunningProcessInfo> & info)1060 ErrCode AbilityManagerClient::GetProcessRunningInfos(std::vector<AppExecFwk::RunningProcessInfo> &info)
1061 {
1062 auto abms = GetAbilityManager();
1063 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1064 return abms->GetProcessRunningInfos(info);
1065 }
1066
RequestDialogService(const Want & want,sptr<IRemoteObject> callerToken)1067 ErrCode AbilityManagerClient::RequestDialogService(
1068 const Want &want, sptr<IRemoteObject> callerToken)
1069 {
1070 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1071 auto abms = GetAbilityManager();
1072 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1073 TAG_LOGI(AAFwkTag::ABILITYMGR, "request is:%{public}s.", want.GetElement().GetURI().c_str());
1074 HandleDlpApp(const_cast<Want &>(want));
1075 return abms->RequestDialogService(want, callerToken);
1076 }
1077
ReportDrawnCompleted(sptr<IRemoteObject> callerToken)1078 ErrCode AbilityManagerClient::ReportDrawnCompleted(sptr<IRemoteObject> callerToken)
1079 {
1080 TAG_LOGD(AAFwkTag::ABILITYMGR, "called");
1081 auto abilityMgr = GetAbilityManager();
1082 CHECK_POINTER_RETURN_NOT_CONNECTED(abilityMgr);
1083 return abilityMgr->ReportDrawnCompleted(callerToken);
1084 }
1085
1086 /**
1087 * Start synchronizing remote device mission
1088 * @param devId, deviceId.
1089 * @param fixConflict, resolve synchronizing conflicts flag.
1090 * @param tag, call tag.
1091 * @return Returns ERR_OK on success, others on failure.
1092 */
StartSyncRemoteMissions(const std::string & devId,bool fixConflict,int64_t tag)1093 ErrCode AbilityManagerClient::StartSyncRemoteMissions(const std::string &devId, bool fixConflict, int64_t tag)
1094 {
1095 auto abms = GetAbilityManager();
1096 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1097 return abms->StartSyncRemoteMissions(devId, fixConflict, tag);
1098 }
1099
StopSyncRemoteMissions(const std::string & devId)1100 ErrCode AbilityManagerClient::StopSyncRemoteMissions(const std::string &devId)
1101 {
1102 auto abms = GetAbilityManager();
1103 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1104 return abms->StopSyncRemoteMissions(devId);
1105 }
1106
StartUser(int accountId,sptr<IUserCallback> callback)1107 ErrCode AbilityManagerClient::StartUser(int accountId, sptr<IUserCallback> callback)
1108 {
1109 TAG_LOGI(AAFwkTag::ABILITYMGR, "StartUser in client:%{public}d.", accountId);
1110 auto abms = GetAbilityManager();
1111 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1112 return abms->StartUser(accountId, callback);
1113 }
1114
StopUser(int accountId,sptr<IUserCallback> callback)1115 ErrCode AbilityManagerClient::StopUser(int accountId, sptr<IUserCallback> callback)
1116 {
1117 TAG_LOGI(AAFwkTag::ABILITYMGR, "StopUser in client:%{public}d.", accountId);
1118 auto abms = GetAbilityManager();
1119 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1120 return abms->StopUser(accountId, callback);
1121 }
1122
LogoutUser(int32_t accountId)1123 ErrCode AbilityManagerClient::LogoutUser(int32_t accountId)
1124 {
1125 auto abms = GetAbilityManager();
1126 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1127 return abms->LogoutUser(accountId);
1128 }
1129
RegisterSnapshotHandler(sptr<ISnapshotHandler> handler)1130 ErrCode AbilityManagerClient::RegisterSnapshotHandler(sptr<ISnapshotHandler> handler)
1131 {
1132 auto abms = GetAbilityManager();
1133 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1134 return abms->RegisterSnapshotHandler(handler);
1135 }
1136
GetMissionSnapshot(const std::string & deviceId,int32_t missionId,MissionSnapshot & snapshot,bool isLowResolution)1137 ErrCode AbilityManagerClient::GetMissionSnapshot(const std::string& deviceId, int32_t missionId,
1138 MissionSnapshot& snapshot, bool isLowResolution)
1139 {
1140 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1141 if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
1142 auto sceneSessionManager = SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy();
1143 CHECK_POINTER_RETURN_INVALID_VALUE(sceneSessionManager);
1144 TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, GetMissionSnapshot");
1145 auto err = sceneSessionManager->GetSessionSnapshot(deviceId, missionId, snapshot, isLowResolution);
1146 if (SCB_TO_MISSION_ERROR_CODE_MAP.count(err)) {
1147 TAG_LOGE(AAFwkTag::ABILITYMGR, "scb call, GetMissionSnapshot err");
1148 return SCB_TO_MISSION_ERROR_CODE_MAP[err];
1149 }
1150 return static_cast<int>(err);
1151 }
1152 auto abms = GetAbilityManager();
1153 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1154 return abms->GetMissionSnapshot(deviceId, missionId, snapshot, isLowResolution);
1155 }
1156
StartUserTest(const Want & want,sptr<IRemoteObject> observer)1157 ErrCode AbilityManagerClient::StartUserTest(const Want &want, sptr<IRemoteObject> observer)
1158 {
1159 auto abms = GetAbilityManager();
1160 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1161 return abms->StartUserTest(want, observer);
1162 }
1163
FinishUserTest(const std::string & msg,const int64_t & resultCode,const std::string & bundleName)1164 ErrCode AbilityManagerClient::FinishUserTest(
1165 const std::string &msg, const int64_t &resultCode, const std::string &bundleName)
1166 {
1167 auto abms = GetAbilityManager();
1168 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1169 return abms->FinishUserTest(msg, resultCode, bundleName);
1170 }
1171
GetTopAbility(sptr<IRemoteObject> & token)1172 ErrCode AbilityManagerClient::GetTopAbility(sptr<IRemoteObject> &token)
1173 {
1174 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1175 if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
1176 auto sceneSessionManager = SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy();
1177 CHECK_POINTER_RETURN_INVALID_VALUE(sceneSessionManager);
1178 TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, GetTopAbility");
1179 auto ret = static_cast<int>(sceneSessionManager->GetFocusSessionToken(token));
1180 if (ret != ERR_OK) {
1181 TAG_LOGE(AAFwkTag::ABILITYMGR, "scb call, GetTopAbility err: %{public}d", ret);
1182 }
1183 return ret;
1184 }
1185 auto abms = GetAbilityManager();
1186 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1187 return abms->GetTopAbility(token);
1188 }
1189
GetElementNameByToken(sptr<IRemoteObject> token,bool isNeedLocalDeviceId)1190 AppExecFwk::ElementName AbilityManagerClient::GetElementNameByToken(sptr<IRemoteObject> token,
1191 bool isNeedLocalDeviceId)
1192 {
1193 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1194 auto abms = GetAbilityManager();
1195 if (abms == nullptr) {
1196 TAG_LOGE(AAFwkTag::ABILITYMGR, "abms == nullptr");
1197 return {};
1198 }
1199 return abms->GetElementNameByToken(token, isNeedLocalDeviceId);
1200 }
1201
CheckUIExtensionIsFocused(uint32_t uiExtensionTokenId,bool & isFocused)1202 ErrCode AbilityManagerClient::CheckUIExtensionIsFocused(uint32_t uiExtensionTokenId, bool& isFocused)
1203 {
1204 auto abms = GetAbilityManager();
1205 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1206 return abms->CheckUIExtensionIsFocused(uiExtensionTokenId, isFocused);
1207 }
1208
DelegatorDoAbilityForeground(sptr<IRemoteObject> token)1209 ErrCode AbilityManagerClient::DelegatorDoAbilityForeground(sptr<IRemoteObject> token)
1210 {
1211 if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
1212 auto sceneSessionManager = SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy();
1213 CHECK_POINTER_RETURN_INVALID_VALUE(sceneSessionManager);
1214 TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, DelegatorDoAbilityForeground");
1215 sceneSessionManager->PendingSessionToForeground(token);
1216 }
1217 auto abms = GetAbilityManager();
1218 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1219 return abms->DelegatorDoAbilityForeground(token);
1220 }
1221
DelegatorDoAbilityBackground(sptr<IRemoteObject> token)1222 ErrCode AbilityManagerClient::DelegatorDoAbilityBackground(sptr<IRemoteObject> token)
1223 {
1224 if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
1225 auto sceneSessionManager = SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy();
1226 CHECK_POINTER_RETURN_INVALID_VALUE(sceneSessionManager);
1227 TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, DelegatorDoAbilityBackground");
1228 sceneSessionManager->PendingSessionToBackgroundForDelegator(token);
1229 }
1230 auto abms = GetAbilityManager();
1231 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1232 return abms->DelegatorDoAbilityBackground(token);
1233 }
1234
SetMissionContinueState(sptr<IRemoteObject> token,const AAFwk::ContinueState & state,sptr<IRemoteObject> sessionToken)1235 ErrCode AbilityManagerClient::SetMissionContinueState(sptr<IRemoteObject> token,
1236 const AAFwk::ContinueState &state, sptr<IRemoteObject> sessionToken)
1237 {
1238 TAG_LOGI(AAFwkTag::ABILITYMGR,
1239 "SetMissionContinueState called. state: %{public}d", state);
1240 if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
1241 auto sceneSessionManager = SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy();
1242 CHECK_POINTER_RETURN_INVALID_VALUE(sceneSessionManager);
1243 uint32_t value = static_cast<uint32_t>(state);
1244 Rosen::ContinueState continueState = static_cast<Rosen::ContinueState>(value);
1245 TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, SetMissionContinueState");
1246 auto ret = static_cast<int>(sceneSessionManager->SetSessionContinueState(sessionToken, continueState));
1247 if (ret != ERR_OK) {
1248 TAG_LOGE(AAFwkTag::ABILITYMGR, "scb call, SetMissionContinueState err");
1249 }
1250 return ret;
1251 }
1252 auto abms = GetAbilityManager();
1253 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1254 return abms->SetMissionContinueState(token, state);
1255 }
1256
1257 #ifdef SUPPORT_GRAPHICS
SetMissionLabel(sptr<IRemoteObject> token,const std::string & label)1258 ErrCode AbilityManagerClient::SetMissionLabel(sptr<IRemoteObject> token, const std::string& label)
1259 {
1260 if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
1261 auto sceneSessionManager = SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy();
1262 CHECK_POINTER_RETURN_INVALID_VALUE(sceneSessionManager);
1263 TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, SetMissionLabel");
1264 auto err = sceneSessionManager->SetSessionLabel(token, label);
1265 if (SCB_TO_MISSION_ERROR_CODE_MAP.count(err)) {
1266 TAG_LOGE(AAFwkTag::ABILITYMGR, "scb call, SetMissionLabel err");
1267 return SCB_TO_MISSION_ERROR_CODE_MAP[err];
1268 }
1269 return static_cast<int>(err);
1270 }
1271 auto abms = GetAbilityManager();
1272 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1273 return abms->SetMissionLabel(token, label);
1274 }
1275
SetMissionIcon(sptr<IRemoteObject> abilityToken,std::shared_ptr<OHOS::Media::PixelMap> icon)1276 ErrCode AbilityManagerClient::SetMissionIcon(
1277 sptr<IRemoteObject> abilityToken, std::shared_ptr<OHOS::Media::PixelMap> icon)
1278 {
1279 if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
1280 auto sceneSessionManager = SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy();
1281 CHECK_POINTER_RETURN_INVALID_VALUE(sceneSessionManager);
1282 TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, SetMissionIcon");
1283 auto err = sceneSessionManager->SetSessionIcon(abilityToken, icon);
1284 if (SCB_TO_MISSION_ERROR_CODE_MAP.count(err)) {
1285 TAG_LOGE(AAFwkTag::ABILITYMGR, "scb call, SetMissionIcon err");
1286 return SCB_TO_MISSION_ERROR_CODE_MAP[err];
1287 }
1288 return static_cast<int>(err);
1289 }
1290 auto abms = GetAbilityManager();
1291 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1292 return abms->SetMissionIcon(abilityToken, icon);
1293 }
1294
RegisterWindowManagerServiceHandler(sptr<IWindowManagerServiceHandler> handler,bool animationEnabled)1295 ErrCode AbilityManagerClient::RegisterWindowManagerServiceHandler(sptr<IWindowManagerServiceHandler> handler,
1296 bool animationEnabled)
1297 {
1298 auto abms = GetAbilityManager();
1299 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1300 return abms->RegisterWindowManagerServiceHandler(handler, animationEnabled);
1301 }
1302
CompleteFirstFrameDrawing(sptr<IRemoteObject> abilityToken)1303 void AbilityManagerClient::CompleteFirstFrameDrawing(sptr<IRemoteObject> abilityToken)
1304 {
1305 auto abms = GetAbilityManager();
1306 CHECK_POINTER_RETURN(abms);
1307 abms->CompleteFirstFrameDrawing(abilityToken);
1308 }
1309
CompleteFirstFrameDrawing(int32_t sessionId)1310 void AbilityManagerClient::CompleteFirstFrameDrawing(int32_t sessionId)
1311 {
1312 auto abms = GetAbilityManager();
1313 CHECK_POINTER_RETURN(abms);
1314 abms->CompleteFirstFrameDrawing(sessionId);
1315 }
1316
PrepareTerminateAbility(sptr<IRemoteObject> token,sptr<IPrepareTerminateCallback> callback)1317 ErrCode AbilityManagerClient::PrepareTerminateAbility(sptr<IRemoteObject> token,
1318 sptr<IPrepareTerminateCallback> callback)
1319 {
1320 if (callback == nullptr) {
1321 TAG_LOGE(AAFwkTag::ABILITYMGR, "callback is nullptr.");
1322 return ERR_INVALID_VALUE;
1323 }
1324 auto abms = GetAbilityManager();
1325 if (abms == nullptr) {
1326 TAG_LOGE(AAFwkTag::ABILITYMGR, "abms is nullptr.");
1327 return ERR_INVALID_VALUE;
1328 }
1329 return abms->PrepareTerminateAbility(token, callback);
1330 }
1331
GetDialogSessionInfo(const std::string & dialogSessionId,sptr<DialogSessionInfo> & info)1332 ErrCode AbilityManagerClient::GetDialogSessionInfo(const std::string &dialogSessionId, sptr<DialogSessionInfo> &info)
1333 {
1334 auto abms = GetAbilityManager();
1335 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1336 return abms->GetDialogSessionInfo(dialogSessionId, info);
1337 }
1338
SendDialogResult(const Want & want,const std::string & dialogSessionId,const bool isAllow)1339 ErrCode AbilityManagerClient::SendDialogResult(const Want &want, const std::string &dialogSessionId, const bool isAllow)
1340 {
1341 auto abms = GetAbilityManager();
1342 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1343 return abms->SendDialogResult(want, dialogSessionId, isAllow);
1344 }
1345 #endif
1346
DoAbilityForeground(sptr<IRemoteObject> token,uint32_t flag)1347 ErrCode AbilityManagerClient::DoAbilityForeground(sptr<IRemoteObject> token, uint32_t flag)
1348 {
1349 auto abms = GetAbilityManager();
1350 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1351 return abms->DoAbilityForeground(token, flag);
1352 }
1353
DoAbilityBackground(sptr<IRemoteObject> token,uint32_t flag)1354 ErrCode AbilityManagerClient::DoAbilityBackground(sptr<IRemoteObject> token, uint32_t flag)
1355 {
1356 auto abms = GetAbilityManager();
1357 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1358 return abms->DoAbilityBackground(token, flag);
1359 }
1360
SetAbilityController(sptr<AppExecFwk::IAbilityController> abilityController,bool imAStabilityTest)1361 ErrCode AbilityManagerClient::SetAbilityController(sptr<AppExecFwk::IAbilityController> abilityController,
1362 bool imAStabilityTest)
1363 {
1364 auto abms = GetAbilityManager();
1365 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1366 return abms->SetAbilityController(abilityController, imAStabilityTest);
1367 }
1368
UpdateMissionSnapShot(sptr<IRemoteObject> token,std::shared_ptr<Media::PixelMap> pixelMap)1369 void AbilityManagerClient::UpdateMissionSnapShot(sptr<IRemoteObject> token,
1370 std::shared_ptr<Media::PixelMap> pixelMap)
1371 {
1372 auto abms = GetAbilityManager();
1373 CHECK_POINTER_RETURN(abms);
1374 return abms->UpdateMissionSnapShot(token, pixelMap);
1375 }
1376
EnableRecoverAbility(sptr<IRemoteObject> token)1377 void AbilityManagerClient::EnableRecoverAbility(sptr<IRemoteObject> token)
1378 {
1379 auto abms = GetAbilityManager();
1380 CHECK_POINTER_RETURN(abms);
1381 return abms->EnableRecoverAbility(token);
1382 }
1383
ScheduleRecoverAbility(sptr<IRemoteObject> token,int32_t reason,const Want * want)1384 void AbilityManagerClient::ScheduleRecoverAbility(sptr<IRemoteObject> token, int32_t reason, const Want *want)
1385 {
1386 TAG_LOGI(AAFwkTag::ABILITYMGR, "call");
1387 auto abms = GetAbilityManager();
1388 CHECK_POINTER_RETURN(abms);
1389 return abms->ScheduleRecoverAbility(token, reason, want);
1390 }
1391
GetAbilityManager()1392 sptr<IAbilityManager> AbilityManagerClient::GetAbilityManager()
1393 {
1394 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1395 std::lock_guard<std::recursive_mutex> lock(mutex_);
1396 if (!proxy_) {
1397 (void)Connect();
1398 }
1399
1400 return proxy_;
1401 }
1402
ResetProxy(wptr<IRemoteObject> remote)1403 void AbilityManagerClient::ResetProxy(wptr<IRemoteObject> remote)
1404 {
1405 std::lock_guard<std::recursive_mutex> lock(mutex_);
1406 if (!proxy_) {
1407 return;
1408 }
1409
1410 auto serviceRemote = proxy_->AsObject();
1411 if ((serviceRemote != nullptr) && (serviceRemote == remote.promote())) {
1412 TAG_LOGD(AAFwkTag::ABILITYMGR, "To remove death recipient.");
1413 serviceRemote->RemoveDeathRecipient(deathRecipient_);
1414 proxy_ = nullptr;
1415 }
1416 }
1417
OnRemoteDied(const wptr<IRemoteObject> & remote)1418 void AbilityManagerClient::AbilityMgrDeathRecipient::OnRemoteDied(const wptr<IRemoteObject>& remote)
1419 {
1420 TAG_LOGD(AAFwkTag::ABILITYMGR, "AbilityMgrDeathRecipient handle remote died.");
1421 AbilityManagerClient::GetInstance()->ResetProxy(remote);
1422 }
1423
FreeInstallAbilityFromRemote(const Want & want,sptr<IRemoteObject> callback,int32_t userId,int requestCode)1424 ErrCode AbilityManagerClient::FreeInstallAbilityFromRemote(const Want &want, sptr<IRemoteObject> callback,
1425 int32_t userId, int requestCode)
1426 {
1427 TAG_LOGI(AAFwkTag::ABILITYMGR, "enter");
1428 auto abms = GetAbilityManager();
1429 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1430 return abms->FreeInstallAbilityFromRemote(want, callback, userId, requestCode);
1431 }
1432
GetTopAbility(bool isNeedLocalDeviceId)1433 AppExecFwk::ElementName AbilityManagerClient::GetTopAbility(bool isNeedLocalDeviceId)
1434 {
1435 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1436 {
1437 std::lock_guard<std::mutex> lock_l(topAbilityMutex_);
1438 if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
1439 AppExecFwk::ElementName elementName = {};
1440 auto sceneSessionManager = SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy();
1441 if (sceneSessionManager == nullptr) {
1442 TAG_LOGE(AAFwkTag::ABILITYMGR, "Failed to get sceneSessionManager.");
1443 return elementName;
1444 }
1445 TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, GetTopAbility element");
1446 (void)sceneSessionManager->GetFocusSessionElement(elementName);
1447 return elementName;
1448 }
1449 }
1450 TAG_LOGD(AAFwkTag::ABILITYMGR, "enter.");
1451 auto abms = GetAbilityManager();
1452 if (abms == nullptr) {
1453 TAG_LOGE(AAFwkTag::ABILITYMGR, "abms == nullptr");
1454 return {};
1455 }
1456
1457 return abms->GetTopAbility(isNeedLocalDeviceId);
1458 }
1459
DumpAbilityInfoDone(std::vector<std::string> & infos,sptr<IRemoteObject> callerToken)1460 ErrCode AbilityManagerClient::DumpAbilityInfoDone(std::vector<std::string> &infos,
1461 sptr<IRemoteObject> callerToken)
1462 {
1463 TAG_LOGI(AAFwkTag::ABILITYMGR, "call");
1464 auto abms = GetAbilityManager();
1465 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1466 return abms->DumpAbilityInfoDone(infos, callerToken);
1467 }
1468
HandleDlpApp(Want & want)1469 void AbilityManagerClient::HandleDlpApp(Want &want)
1470 {
1471 #ifdef WITH_DLP
1472 if (!want.GetParams().HasParam(DLP_PARAMS_SANDBOX)) {
1473 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, "Security::DlpPermission::DlpFileKits::GetSandboxFlag");
1474 bool sandboxFlag = Security::DlpPermission::DlpFileKits::GetSandboxFlag(want);
1475 want.SetParam(DLP_PARAMS_SANDBOX, sandboxFlag);
1476 }
1477 #endif // WITH_DLP
1478 }
1479
AddFreeInstallObserver(const sptr<IRemoteObject> callerToken,const sptr<AbilityRuntime::IFreeInstallObserver> observer)1480 ErrCode AbilityManagerClient::AddFreeInstallObserver(const sptr<IRemoteObject> callerToken,
1481 const sptr<AbilityRuntime::IFreeInstallObserver> observer)
1482 {
1483 TAG_LOGI(AAFwkTag::ABILITYMGR, "call");
1484 auto abms = GetAbilityManager();
1485 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1486 return abms->AddFreeInstallObserver(callerToken, observer);
1487 }
1488
IsValidMissionIds(const std::vector<int32_t> & missionIds,std::vector<MissionValidResult> & results)1489 int32_t AbilityManagerClient::IsValidMissionIds(
1490 const std::vector<int32_t> &missionIds, std::vector<MissionValidResult> &results)
1491 {
1492 TAG_LOGI(AAFwkTag::ABILITYMGR, "call");
1493 if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
1494 auto sceneSessionManager = SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy();
1495 CHECK_POINTER_RETURN_INVALID_VALUE(sceneSessionManager);
1496 std::vector<bool> isValidList;
1497 auto err = sceneSessionManager->IsValidSessionIds(missionIds, isValidList);
1498 TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, IsValidSessionIds: %{public}d, size: %{public}d",
1499 static_cast<int>(err), static_cast<int32_t>(isValidList.size()));
1500 for (auto i = 0; i < static_cast<int32_t>(isValidList.size()); ++i) {
1501 MissionValidResult missionResult = {};
1502 missionResult.missionId = missionIds.at(i);
1503 missionResult.isValid = isValidList.at(i);
1504 results.push_back(missionResult);
1505 }
1506 return static_cast<int>(err);
1507 }
1508 auto abms = GetAbilityManager();
1509 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1510 return abms->IsValidMissionIds(missionIds, results);
1511 }
1512
VerifyPermission(const std::string & permission,int pid,int uid)1513 ErrCode AbilityManagerClient::VerifyPermission(const std::string &permission, int pid, int uid)
1514 {
1515 TAG_LOGI(AAFwkTag::ABILITYMGR, "call");
1516 auto abms = GetAbilityManager();
1517 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1518 return abms->VerifyPermission(permission, pid, uid);
1519 }
1520
AcquireShareData(int32_t missionId,sptr<IAcquireShareDataCallback> shareData)1521 ErrCode AbilityManagerClient::AcquireShareData(
1522 int32_t missionId, sptr<IAcquireShareDataCallback> shareData)
1523 {
1524 TAG_LOGI(AAFwkTag::ABILITYMGR, "call");
1525 auto abms = GetAbilityManager();
1526 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1527 return abms->AcquireShareData(missionId, shareData);
1528 }
1529
ShareDataDone(sptr<IRemoteObject> token,int32_t resultCode,int32_t uniqueId,WantParams & wantParam)1530 ErrCode AbilityManagerClient::ShareDataDone(
1531 sptr<IRemoteObject> token, int32_t resultCode, int32_t uniqueId, WantParams &wantParam)
1532 {
1533 TAG_LOGI(AAFwkTag::ABILITYMGR, "call");
1534 auto abms = GetAbilityManager();
1535 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1536 return abms->ShareDataDone(token, resultCode, uniqueId, wantParam);
1537 }
1538
ForceExitApp(const int32_t pid,const ExitReason & exitReason)1539 ErrCode AbilityManagerClient::ForceExitApp(const int32_t pid, const ExitReason &exitReason)
1540 {
1541 TAG_LOGI(AAFwkTag::ABILITYMGR, "begin.");
1542 auto abms = GetAbilityManager();
1543 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1544 return abms->ForceExitApp(pid, exitReason);
1545 }
1546
RecordAppExitReason(const ExitReason & exitReason)1547 ErrCode AbilityManagerClient::RecordAppExitReason(const ExitReason &exitReason)
1548 {
1549 TAG_LOGD(AAFwkTag::ABILITYMGR, "RecordAppExitReason reason:%{public}d, exitMsg: %{public}s", exitReason.reason,
1550 exitReason.exitMsg.c_str());
1551 auto abms = GetAbilityManager();
1552 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1553 return abms->RecordAppExitReason(exitReason);
1554 }
1555
RecordProcessExitReason(const int32_t pid,const ExitReason & exitReason)1556 ErrCode AbilityManagerClient::RecordProcessExitReason(const int32_t pid, const ExitReason &exitReason)
1557 {
1558 TAG_LOGD(AAFwkTag::ABILITYMGR, "RecordProcessExitReason pid:%{public}d, reason:%{public}d, exitMsg: %{public}s",
1559 pid, exitReason.reason, exitReason.exitMsg.c_str());
1560 auto abms = GetAbilityManager();
1561 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1562 return abms->RecordProcessExitReason(pid, exitReason);
1563 }
1564
SetRootSceneSession(sptr<IRemoteObject> rootSceneSession)1565 void AbilityManagerClient::SetRootSceneSession(sptr<IRemoteObject> rootSceneSession)
1566 {
1567 TAG_LOGI(AAFwkTag::ABILITYMGR, "call");
1568 auto abms = GetAbilityManager();
1569 CHECK_POINTER_RETURN(abms);
1570 abms->SetRootSceneSession(rootSceneSession);
1571 }
1572
CallUIAbilityBySCB(sptr<SessionInfo> sessionInfo,bool & isColdStart)1573 void AbilityManagerClient::CallUIAbilityBySCB(sptr<SessionInfo> sessionInfo, bool &isColdStart)
1574 {
1575 auto abms = GetAbilityManager();
1576 CHECK_POINTER_RETURN(abms);
1577 TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, CallUIAbilityBySCB target: %{public}s",
1578 sessionInfo->want.GetElement().GetURI().c_str());
1579 abms->CallUIAbilityBySCB(sessionInfo, isColdStart);
1580 TAG_LOGD(AAFwkTag::ABILITYMGR, "scb call, CallUIAbilityBySCB, isColdStart: %{public}d", isColdStart);
1581 }
1582
StartSpecifiedAbilityBySCB(const Want & want)1583 void AbilityManagerClient::StartSpecifiedAbilityBySCB(const Want &want)
1584 {
1585 auto abms = GetAbilityManager();
1586 CHECK_POINTER_RETURN(abms);
1587 TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, StartSpecifiedAbilityBySCB, target: %{public}s",
1588 want.GetElement().GetURI().c_str());
1589 abms->StartSpecifiedAbilityBySCB(want);
1590 }
1591
NotifySaveAsResult(const Want & want,int resultCode,int requestCode)1592 ErrCode AbilityManagerClient::NotifySaveAsResult(const Want &want, int resultCode, int requestCode)
1593 {
1594 TAG_LOGD(AAFwkTag::ABILITYMGR, "call.");
1595 auto abms = GetAbilityManager();
1596 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1597 return abms->NotifySaveAsResult(want, resultCode, requestCode);
1598 }
1599
SetSessionManagerService(sptr<IRemoteObject> sessionManagerService)1600 ErrCode AbilityManagerClient::SetSessionManagerService(sptr<IRemoteObject> sessionManagerService)
1601 {
1602 TAG_LOGI(AAFwkTag::ABILITYMGR, "AbilityManagerClient::SetSessionManagerService call");
1603 auto abms = GetAbilityManager();
1604 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1605 return abms->SetSessionManagerService(sessionManagerService);
1606 }
1607
RegisterIAbilityManagerCollaborator(int32_t type,sptr<IAbilityManagerCollaborator> impl)1608 ErrCode AbilityManagerClient::RegisterIAbilityManagerCollaborator(
1609 int32_t type, sptr<IAbilityManagerCollaborator> impl)
1610 {
1611 TAG_LOGI(AAFwkTag::ABILITYMGR, "call");
1612 auto abms = GetAbilityManager();
1613 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1614 return abms->RegisterIAbilityManagerCollaborator(type, impl);
1615 }
1616
UnregisterIAbilityManagerCollaborator(int32_t type)1617 ErrCode AbilityManagerClient::UnregisterIAbilityManagerCollaborator(int32_t type)
1618 {
1619 TAG_LOGI(AAFwkTag::ABILITYMGR, "call");
1620 auto abms = GetAbilityManager();
1621 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1622 return abms->UnregisterIAbilityManagerCollaborator(type);
1623 }
1624
RegisterStatusBarDelegate(sptr<AbilityRuntime::IStatusBarDelegate> delegate)1625 ErrCode AbilityManagerClient::RegisterStatusBarDelegate(sptr<AbilityRuntime::IStatusBarDelegate> delegate)
1626 {
1627 TAG_LOGI(AAFwkTag::ABILITYMGR, "called");
1628 auto abms = GetAbilityManager();
1629 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1630 return abms->RegisterStatusBarDelegate(delegate);
1631 }
1632
KillProcessWithPrepareTerminate(const std::vector<int32_t> & pids)1633 ErrCode AbilityManagerClient::KillProcessWithPrepareTerminate(const std::vector<int32_t>& pids)
1634 {
1635 TAG_LOGI(AAFwkTag::ABILITYMGR, "called");
1636 auto abms = GetAbilityManager();
1637 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1638 return abms->KillProcessWithPrepareTerminate(pids);
1639 }
1640
RegisterAutoStartupSystemCallback(sptr<IRemoteObject> callback)1641 ErrCode AbilityManagerClient::RegisterAutoStartupSystemCallback(sptr<IRemoteObject> callback)
1642 {
1643 TAG_LOGD(AAFwkTag::ABILITYMGR, "called");
1644 auto abms = GetAbilityManager();
1645 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1646 return abms->RegisterAutoStartupSystemCallback(callback);
1647 }
1648
UnregisterAutoStartupSystemCallback(sptr<IRemoteObject> callback)1649 ErrCode AbilityManagerClient::UnregisterAutoStartupSystemCallback(sptr<IRemoteObject> callback)
1650 {
1651 TAG_LOGD(AAFwkTag::ABILITYMGR, "called");
1652 auto abms = GetAbilityManager();
1653 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1654 return abms->UnregisterAutoStartupSystemCallback(callback);
1655 }
1656
SetApplicationAutoStartup(const AutoStartupInfo & info)1657 ErrCode AbilityManagerClient::SetApplicationAutoStartup(const AutoStartupInfo &info)
1658 {
1659 TAG_LOGD(AAFwkTag::ABILITYMGR, "called");
1660 auto abms = GetAbilityManager();
1661 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1662 return abms->SetApplicationAutoStartup(info);
1663 }
1664
CancelApplicationAutoStartup(const AutoStartupInfo & info)1665 ErrCode AbilityManagerClient::CancelApplicationAutoStartup(const AutoStartupInfo &info)
1666 {
1667 TAG_LOGD(AAFwkTag::ABILITYMGR, "called");
1668 auto abms = GetAbilityManager();
1669 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1670 return abms->CancelApplicationAutoStartup(info);
1671 }
1672
QueryAllAutoStartupApplications(std::vector<AutoStartupInfo> & infoList)1673 ErrCode AbilityManagerClient::QueryAllAutoStartupApplications(std::vector<AutoStartupInfo> &infoList)
1674 {
1675 TAG_LOGD(AAFwkTag::ABILITYMGR, "called");
1676 auto abms = GetAbilityManager();
1677 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1678 return abms->QueryAllAutoStartupApplications(infoList);
1679 }
1680
PrepareTerminateAbilityBySCB(sptr<SessionInfo> sessionInfo,bool & isPrepareTerminate)1681 ErrCode AbilityManagerClient::PrepareTerminateAbilityBySCB(sptr<SessionInfo> sessionInfo,
1682 bool &isPrepareTerminate)
1683 {
1684 auto abms = GetAbilityManager();
1685 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1686 TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, PrepareTerminateAbilityBySCB");
1687 return abms->PrepareTerminateAbilityBySCB(sessionInfo, isPrepareTerminate);
1688 }
1689
RegisterSessionHandler(sptr<IRemoteObject> object)1690 ErrCode AbilityManagerClient::RegisterSessionHandler(sptr<IRemoteObject> object)
1691 {
1692 TAG_LOGD(AAFwkTag::ABILITYMGR, "call");
1693 auto abms = GetAbilityManager();
1694 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1695 return abms->RegisterSessionHandler(object);
1696 }
1697
RegisterAppDebugListener(sptr<AppExecFwk::IAppDebugListener> listener)1698 ErrCode AbilityManagerClient::RegisterAppDebugListener(sptr<AppExecFwk::IAppDebugListener> listener)
1699 {
1700 TAG_LOGD(AAFwkTag::ABILITYMGR, "called");
1701 auto abms = GetAbilityManager();
1702 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1703 return abms->RegisterAppDebugListener(listener);
1704 }
1705
UnregisterAppDebugListener(sptr<AppExecFwk::IAppDebugListener> listener)1706 ErrCode AbilityManagerClient::UnregisterAppDebugListener(sptr<AppExecFwk::IAppDebugListener> listener)
1707 {
1708 TAG_LOGD(AAFwkTag::ABILITYMGR, "called");
1709 auto abms = GetAbilityManager();
1710 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1711 return abms->UnregisterAppDebugListener(listener);
1712 }
1713
AttachAppDebug(const std::string & bundleName)1714 ErrCode AbilityManagerClient::AttachAppDebug(const std::string &bundleName)
1715 {
1716 TAG_LOGD(AAFwkTag::ABILITYMGR, "called");
1717 auto abms = GetAbilityManager();
1718 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1719 return abms->AttachAppDebug(bundleName);
1720 }
1721
DetachAppDebug(const std::string & bundleName)1722 ErrCode AbilityManagerClient::DetachAppDebug(const std::string &bundleName)
1723 {
1724 TAG_LOGD(AAFwkTag::ABILITYMGR, "called");
1725 auto abms = GetAbilityManager();
1726 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1727 return abms->DetachAppDebug(bundleName);
1728 }
1729
ExecuteIntent(uint64_t key,sptr<IRemoteObject> callerToken,const InsightIntentExecuteParam & param)1730 ErrCode AbilityManagerClient::ExecuteIntent(uint64_t key, sptr<IRemoteObject> callerToken,
1731 const InsightIntentExecuteParam ¶m)
1732 {
1733 TAG_LOGD(AAFwkTag::ABILITYMGR, "called");
1734 auto abms = GetAbilityManager();
1735 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1736 return abms->ExecuteIntent(key, callerToken, param);
1737 }
1738
IsAbilityControllerStart(const Want & want)1739 bool AbilityManagerClient::IsAbilityControllerStart(const Want &want)
1740 {
1741 TAG_LOGD(AAFwkTag::ABILITYMGR, "call");
1742 auto abms = GetAbilityManager();
1743 if (abms == nullptr) {
1744 TAG_LOGE(AAFwkTag::ABILITYMGR, "abms is nullptr.");
1745 return true;
1746 }
1747 return abms->IsAbilityControllerStart(want);
1748 }
1749
ExecuteInsightIntentDone(sptr<IRemoteObject> token,uint64_t intentId,const InsightIntentExecuteResult & result)1750 ErrCode AbilityManagerClient::ExecuteInsightIntentDone(sptr<IRemoteObject> token, uint64_t intentId,
1751 const InsightIntentExecuteResult &result)
1752 {
1753 TAG_LOGD(AAFwkTag::ABILITYMGR, "called");
1754 auto abms = GetAbilityManager();
1755 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1756 return abms->ExecuteInsightIntentDone(token, intentId, result);
1757 }
1758
GetForegroundUIAbilities(std::vector<AppExecFwk::AbilityStateData> & list)1759 int32_t AbilityManagerClient::GetForegroundUIAbilities(std::vector<AppExecFwk::AbilityStateData> &list)
1760 {
1761 TAG_LOGD(AAFwkTag::ABILITYMGR, "called");
1762 auto abms = GetAbilityManager();
1763 CHECK_POINTER_RETURN_INVALID_VALUE(abms);
1764 return abms->GetForegroundUIAbilities(list);
1765 }
1766
OpenFile(const Uri & uri,uint32_t flag)1767 int32_t AbilityManagerClient::OpenFile(const Uri& uri, uint32_t flag)
1768 {
1769 TAG_LOGD(AAFwkTag::ABILITYMGR, "call OpenFile");
1770 auto abms = GetAbilityManager();
1771 if (abms == nullptr) {
1772 TAG_LOGE(AAFwkTag::ABILITYMGR, "abms is nullptr.");
1773 return true;
1774 }
1775 return abms->OpenFile(uri, flag);
1776 }
1777
RequestAssertFaultDialog(const sptr<IRemoteObject> & callback,const AAFwk::WantParams & wantParams)1778 int32_t AbilityManagerClient::RequestAssertFaultDialog(
1779 const sptr<IRemoteObject> &callback, const AAFwk::WantParams &wantParams)
1780 {
1781 TAG_LOGD(AAFwkTag::ABILITYMGR, "Request to display assert fault dialog.");
1782 auto abms = GetAbilityManager();
1783 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1784 return abms->RequestAssertFaultDialog(callback, wantParams);
1785 }
1786
NotifyDebugAssertResult(uint64_t assertFaultSessionId,AAFwk::UserStatus userStatus)1787 int32_t AbilityManagerClient::NotifyDebugAssertResult(uint64_t assertFaultSessionId, AAFwk::UserStatus userStatus)
1788 {
1789 TAG_LOGD(AAFwkTag::ABILITYMGR, "Notify user action result to assert fault callback.");
1790 auto abms = GetAbilityManager();
1791 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1792 return abms->NotifyDebugAssertResult(assertFaultSessionId, userStatus);
1793 }
1794
UpdateSessionInfoBySCB(std::list<SessionInfo> & sessionInfos,int32_t userId,std::vector<int32_t> & sessionIds)1795 int32_t AbilityManagerClient::UpdateSessionInfoBySCB(std::list<SessionInfo> &sessionInfos, int32_t userId,
1796 std::vector<int32_t> &sessionIds)
1797 {
1798 auto abms = GetAbilityManager();
1799 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1800 TAG_LOGD(AAFwkTag::ABILITYMGR, "scb call, UpdateSessionInfoBySCB");
1801 return abms->UpdateSessionInfoBySCB(sessionInfos, userId, sessionIds);
1802 }
1803
GetUIExtensionSessionInfo(const sptr<IRemoteObject> token,UIExtensionSessionInfo & uiExtensionSessionInfo,int32_t userId)1804 ErrCode AbilityManagerClient::GetUIExtensionSessionInfo(const sptr<IRemoteObject> token,
1805 UIExtensionSessionInfo &uiExtensionSessionInfo, int32_t userId)
1806 {
1807 TAG_LOGD(AAFwkTag::ABILITYMGR, "Get ui extension session info.");
1808 auto abms = GetAbilityManager();
1809 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1810 return abms->GetUIExtensionSessionInfo(token, uiExtensionSessionInfo, userId);
1811 }
1812
RestartApp(const AAFwk::Want & want)1813 int32_t AbilityManagerClient::RestartApp(const AAFwk::Want &want)
1814 {
1815 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1816 TAG_LOGI(AAFwkTag::ABILITYMGR, "called");
1817 auto abms = GetAbilityManager();
1818 CHECK_POINTER_RETURN_INVALID_VALUE(abms);
1819 return abms->RestartApp(want);
1820 }
1821
GetUIExtensionRootHostInfo(const sptr<IRemoteObject> token,UIExtensionHostInfo & hostInfo,int32_t userId)1822 ErrCode AbilityManagerClient::GetUIExtensionRootHostInfo(const sptr<IRemoteObject> token,
1823 UIExtensionHostInfo &hostInfo, int32_t userId)
1824 {
1825 TAG_LOGD(AAFwkTag::ABILITYMGR, "Get ui extension host info.");
1826 auto abms = GetAbilityManager();
1827 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1828 return abms->GetUIExtensionRootHostInfo(token, hostInfo, userId);
1829 }
1830
OpenAtomicService(Want & want,const StartOptions & options,sptr<IRemoteObject> callerToken,int32_t requestCode,int32_t userId)1831 int32_t AbilityManagerClient::OpenAtomicService(Want& want, const StartOptions &options,
1832 sptr<IRemoteObject> callerToken, int32_t requestCode, int32_t userId)
1833 {
1834 TAG_LOGD(AAFwkTag::ABILITYMGR, "called");
1835 auto abms = GetAbilityManager();
1836 CHECK_POINTER_RETURN_INVALID_VALUE(abms);
1837 return abms->OpenAtomicService(want, options, callerToken, requestCode, userId);
1838 }
1839
SetResidentProcessEnabled(const std::string & bundleName,bool enable)1840 int32_t AbilityManagerClient::SetResidentProcessEnabled(const std::string &bundleName, bool enable)
1841 {
1842 TAG_LOGD(AAFwkTag::ABILITYMGR, "called");
1843 auto abms = GetAbilityManager();
1844 CHECK_POINTER_RETURN_INVALID_VALUE(abms);
1845 return abms->SetResidentProcessEnabled(bundleName, enable);
1846 }
1847
IsEmbeddedOpenAllowed(sptr<IRemoteObject> callerToken,const std::string & appId)1848 bool AbilityManagerClient::IsEmbeddedOpenAllowed(sptr<IRemoteObject> callerToken, const std::string &appId)
1849 {
1850 TAG_LOGD(AAFwkTag::ABILITYMGR, "Get ui extension host info.");
1851 auto abms = GetAbilityManager();
1852 if (abms == nullptr) {
1853 TAG_LOGE(AAFwkTag::ABILITYMGR, "abms is nullptr.");
1854 return false;
1855 }
1856 return abms->IsEmbeddedOpenAllowed(callerToken, appId);
1857 }
1858
StartShortcut(const Want & want,const StartOptions & startOptions)1859 int32_t AbilityManagerClient::StartShortcut(const Want &want, const StartOptions &startOptions)
1860 {
1861 TAG_LOGD(AAFwkTag::ABILITYMGR, "start short cut.");
1862 auto abms = GetAbilityManager();
1863 CHECK_POINTER_RETURN_INVALID_VALUE(abms);
1864 return abms->StartShortcut(want, startOptions);
1865 }
1866
GetAbilityStateByPersistentId(int32_t persistentId,bool & state)1867 int32_t AbilityManagerClient::GetAbilityStateByPersistentId(int32_t persistentId, bool &state)
1868 {
1869 TAG_LOGD(AAFwkTag::ABILITYMGR, "called");
1870 auto abms = GetAbilityManager();
1871 CHECK_POINTER_RETURN_INVALID_VALUE(abms);
1872 return abms->GetAbilityStateByPersistentId(persistentId, state);
1873 }
1874
TransferAbilityResultForExtension(const sptr<IRemoteObject> & callerToken,int32_t resultCode,const Want & want)1875 int32_t AbilityManagerClient::TransferAbilityResultForExtension(const sptr<IRemoteObject> &callerToken,
1876 int32_t resultCode, const Want &want)
1877 {
1878 auto abms = GetAbilityManager();
1879 CHECK_POINTER_RETURN_INVALID_VALUE(abms);
1880 return abms->TransferAbilityResultForExtension(callerToken, resultCode, want);
1881 }
1882
NotifyFrozenProcessByRSS(const std::vector<int32_t> & pidList,int32_t uid)1883 void AbilityManagerClient::NotifyFrozenProcessByRSS(const std::vector<int32_t> &pidList, int32_t uid)
1884 {
1885 auto abms = GetAbilityManager();
1886 CHECK_POINTER_RETURN(abms);
1887 return abms->NotifyFrozenProcessByRSS(pidList, uid);
1888 }
1889
CleanUIAbilityBySCB(sptr<SessionInfo> sessionInfo)1890 ErrCode AbilityManagerClient::CleanUIAbilityBySCB(sptr<SessionInfo> sessionInfo)
1891 {
1892 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1893 if (sessionInfo == nullptr) {
1894 TAG_LOGE(AAFwkTag::ABILITYMGR, "sessionInfo is invalid.");
1895 return ERR_INVALID_VALUE;
1896 }
1897 auto abms = GetAbilityManager();
1898 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1899 TAG_LOGD(AAFwkTag::ABILITYMGR, "scb call, CleanUIAbilityBySCB");
1900 return abms->CleanUIAbilityBySCB(sessionInfo);
1901 }
1902
PreStartMission(const std::string & bundleName,const std::string & moduleName,const std::string & abilityName,const std::string & startTime)1903 ErrCode AbilityManagerClient::PreStartMission(const std::string& bundleName, const std::string& moduleName,
1904 const std::string& abilityName, const std::string& startTime)
1905 {
1906 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1907 auto abms = GetAbilityManager();
1908 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1909 return abms->PreStartMission(bundleName, moduleName, abilityName, startTime);
1910 }
1911
OpenLink(const Want & want,sptr<IRemoteObject> callerToken,int32_t userId,int requestCode)1912 ErrCode AbilityManagerClient::OpenLink(const Want& want, sptr<IRemoteObject> callerToken,
1913 int32_t userId, int requestCode)
1914 {
1915 auto abms = GetAbilityManager();
1916 CHECK_POINTER_RETURN_INVALID_VALUE(abms);
1917 return abms->OpenLink(want, callerToken, userId, requestCode);
1918 }
1919
TerminateMission(int32_t missionId)1920 ErrCode AbilityManagerClient::TerminateMission(int32_t missionId)
1921 {
1922 #ifdef SUPPORT_SCREEN
1923 if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
1924 auto sceneSessionManager = SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy();
1925 CHECK_POINTER_RETURN_INVALID_VALUE(sceneSessionManager);
1926 TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, TerminateMission");
1927 auto err = sceneSessionManager->TerminateSessionByPersistentId(missionId);
1928 if (err != OHOS::Rosen::WMError::WM_OK) {
1929 TAG_LOGE(AAFwkTag::ABILITYMGR, "scb call, TerminateMission err: %{public}d.", static_cast<int32_t>(err));
1930 }
1931 if (err == Rosen::WMError::WM_ERROR_INVALID_PERMISSION) {
1932 return CHECK_PERMISSION_FAILED;
1933 }
1934 if (err == Rosen::WMError::WM_ERROR_NOT_SYSTEM_APP) {
1935 return ERR_NOT_SYSTEM_APP;
1936 }
1937 return static_cast<int32_t>(err);
1938 }
1939 #endif //SUPPORT_SCREEN
1940 auto abms = GetAbilityManager();
1941 CHECK_POINTER_RETURN_INVALID_VALUE(abms);
1942 int32_t ret = abms->TerminateMission(missionId);
1943 if (ret != ERR_OK) {
1944 TAG_LOGE(AAFwkTag::ABILITYMGR, "TerminateMission failed, err: %{public}d.", ret);
1945 }
1946 return ret;
1947 }
1948
UpdateAssociateConfigList(const std::map<std::string,std::list<std::string>> & configs,const std::list<std::string> & exportConfigs,int32_t flag)1949 ErrCode AbilityManagerClient::UpdateAssociateConfigList(const std::map<std::string, std::list<std::string>>& configs,
1950 const std::list<std::string>& exportConfigs, int32_t flag)
1951 {
1952 TAG_LOGD(AAFwkTag::ABILITYMGR, "call.");
1953 auto abms = GetAbilityManager();
1954 CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
1955 return abms->UpdateAssociateConfigList(configs, exportConfigs, flag);
1956 }
1957 } // namespace AAFwk
1958 } // namespace OHOS
1959