1 /*
2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "ability_manager_service.h"
17 #include "accesstoken_kit.h"
18
19 #include <chrono>
20 #include <fstream>
21 #include <functional>
22 #include <getopt.h>
23 #include <memory>
24 #include <nlohmann/json.hpp>
25 #include <string>
26 #include <thread>
27 #include <unistd.h>
28 #include <unordered_set>
29 #include <csignal>
30 #include <cstdlib>
31
32 #include "ability_info.h"
33 #include "ability_interceptor.h"
34 #include "ability_manager_errors.h"
35 #include "ability_util.h"
36 #include "application_util.h"
37 #include "hitrace_meter.h"
38 #include "bundle_mgr_client.h"
39 #include "distributed_client.h"
40 #include "dlp_utils.h"
41 #include "hilog_wrapper.h"
42 #include "if_system_ability_manager.h"
43 #include "in_process_call_wrapper.h"
44 #include "ipc_skeleton.h"
45 #include "iservice_registry.h"
46 #include "itest_observer.h"
47 #include "mission_info_mgr.h"
48 #include "sa_mgr_client.h"
49 #include "system_ability_token_callback.h"
50 #include "softbus_bus_center.h"
51 #include "string_ex.h"
52 #include "system_ability_definition.h"
53 #include "os_account_manager_wrapper.h"
54 #include "permission_constants.h"
55 #include "uri_permission_manager_client.h"
56 #include "xcollie/watchdog.h"
57 #include "hisysevent.h"
58 #include "connection_state_manager.h"
59
60 #ifdef SUPPORT_GRAPHICS
61 #include "display_manager.h"
62 #include "input_manager.h"
63 #include "png.h"
64 #include "ui_service_mgr_client.h"
65 #endif
66
67 #ifdef EFFICIENCY_MANAGER_ENABLE
68 #include "suspend_manager_client.h"
69 #endif // EFFICIENCY_MANAGER_ENABLE
70
71 #ifdef RESOURCE_SCHEDULE_SERVICE_ENABLE
72 #include "res_sched_client.h"
73 #include "res_type.h"
74 #endif // RESOURCE_SCHEDULE_SERVICE_ENABLE
75 #include "container_manager_client.h"
76
77 #include "ability_bundle_event_callback.h"
78
79 using OHOS::AppExecFwk::ElementName;
80 using OHOS::Security::AccessToken::AccessTokenKit;
81
82 namespace OHOS {
83 namespace AAFwk {
84 namespace {
85 const std::string ARGS_USER_ID = "-u";
86 const std::string ARGS_CLIENT = "-c";
87 const std::string ILLEGAL_INFOMATION = "The arguments are illegal and you can enter '-h' for help.";
88
89 constexpr int32_t NEW_RULE_VALUE_SIZE = 6;
90 constexpr int64_t APP_ALIVE_TIME_MS = 1000; // Allow background startup within 1 second after application startup
91 const std::string IS_DELEGATOR_CALL = "isDelegatorCall";
92 // Startup rule switch
93 const std::string COMPONENT_STARTUP_NEW_RULES = "component.startup.newRules";
94 const std::string NEW_RULES_EXCEPT_LAUNCHER_SYSTEMUI = "component.startup.newRules.except.LauncherSystemUI";
95 const std::string BACKGROUND_JUDGE_FLAG = "component.startup.backgroundJudge.flag";
96 const std::string WHITE_LIST_NORMAL_FLAG = "component.startup.whitelist.normal";
97 const std::string WHITE_LIST_ASS_WAKEUP_FLAG = "component.startup.whitelist.associatedWakeUp";
98 // White list app
99 const std::string BUNDLE_NAME_LAUNCHER = "com.ohos.launcher";
100 const std::string BUNDLE_NAME_SYSTEMUI = "com.ohos.systemui";
101 const std::string BUNDLE_NAME_SETTINGSDATA = "com.ohos.settingsdata";
102 const std::string BUNDLE_NAME_SERVICE_TEST = "com.amsst.stserviceabilityclient";
103 const std::string BUNDLE_NAME_SERVICE_SERVER_TEST = "com.amsst.stserviceabilityserver";
104 const std::string BUNDLE_NAME_SERVICE_SERVER2_TEST = "com.amsst.stserviceabilityserversecond";
105
106 // White list
107 const std::unordered_set<std::string> WHITE_LIST_NORMAL_SET = { BUNDLE_NAME_SERVICE_TEST,
108 BUNDLE_NAME_SERVICE_SERVER_TEST,
109 BUNDLE_NAME_SERVICE_SERVER2_TEST };
110 const std::unordered_set<std::string> WHITE_LIST_ASS_WAKEUP_SET = { BUNDLE_NAME_SETTINGSDATA };
111 } // namespace
112
113 using namespace std::chrono;
114 using namespace std::chrono_literals;
115 #ifdef BGTASKMGR_CONTINUOUS_TASK_ENABLE
116 using namespace BackgroundTaskMgr;
117 #endif
118 const bool CONCURRENCY_MODE_FALSE = false;
119 const int32_t MAIN_USER_ID = 100;
120 const int32_t U0_USER_ID = 0;
121 constexpr int32_t INVALID_USER_ID = -1;
122 constexpr auto DATA_ABILITY_START_TIMEOUT = 5s;
123 constexpr int32_t NON_ANONYMIZE_LENGTH = 6;
124 constexpr uint32_t SCENE_FLAG_NORMAL = 0;
125 const int32_t MAX_NUMBER_OF_DISTRIBUTED_MISSIONS = 20;
126 const int32_t SWITCH_ACCOUNT_TRY = 3;
127 #ifdef ABILITY_COMMAND_FOR_TEST
128 const int32_t BLOCK_AMS_SERVICE_TIME = 65;
129 #endif
130 const std::string EMPTY_DEVICE_ID = "";
131 const int32_t APP_MEMORY_SIZE = 512;
132 const int32_t GET_PARAMETER_INCORRECT = -9;
133 const int32_t GET_PARAMETER_OTHER = -1;
134 const int32_t SIZE_10 = 10;
135 const int32_t ACCOUNT_MGR_SERVICE_UID = 3058;
136 const std::string BUNDLE_NAME_KEY = "bundleName";
137 const std::string DM_PKG_NAME = "ohos.distributedhardware.devicemanager";
138 const std::string ACTION_CHOOSE = "ohos.want.action.select";
139 const std::string HIGHEST_PRIORITY_ABILITY_ENTITY = "flag.home.intent.from.system";
140 const std::string DMS_API_VERSION = "dmsApiVersion";
141 const std::string DMS_IS_CALLER_BACKGROUND = "dmsIsCallerBackGround";
142 const std::string DMS_PROCESS_NAME = "distributedsched";
143 const std::string DMS_MISSION_ID = "dmsMissionId";
144 const std::string DLP_INDEX = "ohos.dlp.params.index";
145 const std::string BOOTEVENT_APPFWK_READY = "bootevent.appfwk.ready";
146 const std::string BOOTEVENT_BOOT_COMPLETED = "bootevent.boot.completed";
147 const std::string BOOTEVENT_BOOT_ANIMATION_STARTED = "bootevent.bootanimation.started";
148 const std::string NEED_STARTINGWINDOW = "ohos.ability.NeedStartingWindow";
149 const int DEFAULT_DMS_MISSION_ID = -1;
150 const std::map<std::string, AbilityManagerService::DumpKey> AbilityManagerService::dumpMap = {
151 std::map<std::string, AbilityManagerService::DumpKey>::value_type("--all", KEY_DUMP_ALL),
152 std::map<std::string, AbilityManagerService::DumpKey>::value_type("-a", KEY_DUMP_ALL),
153 std::map<std::string, AbilityManagerService::DumpKey>::value_type("--stack-list", KEY_DUMP_STACK_LIST),
154 std::map<std::string, AbilityManagerService::DumpKey>::value_type("-l", KEY_DUMP_STACK_LIST),
155 std::map<std::string, AbilityManagerService::DumpKey>::value_type("--stack", KEY_DUMP_STACK),
156 std::map<std::string, AbilityManagerService::DumpKey>::value_type("-s", KEY_DUMP_STACK),
157 std::map<std::string, AbilityManagerService::DumpKey>::value_type("--mission", KEY_DUMP_MISSION),
158 std::map<std::string, AbilityManagerService::DumpKey>::value_type("-m", KEY_DUMP_MISSION),
159 std::map<std::string, AbilityManagerService::DumpKey>::value_type("--top", KEY_DUMP_TOP_ABILITY),
160 std::map<std::string, AbilityManagerService::DumpKey>::value_type("-t", KEY_DUMP_TOP_ABILITY),
161 std::map<std::string, AbilityManagerService::DumpKey>::value_type("--waiting-queue", KEY_DUMP_WAIT_QUEUE),
162 std::map<std::string, AbilityManagerService::DumpKey>::value_type("-w", KEY_DUMP_WAIT_QUEUE),
163 std::map<std::string, AbilityManagerService::DumpKey>::value_type("--serv", KEY_DUMP_SERVICE),
164 std::map<std::string, AbilityManagerService::DumpKey>::value_type("-e", KEY_DUMP_SERVICE),
165 std::map<std::string, AbilityManagerService::DumpKey>::value_type("--data", KEY_DUMP_DATA),
166 std::map<std::string, AbilityManagerService::DumpKey>::value_type("-d", KEY_DUMP_DATA),
167 std::map<std::string, AbilityManagerService::DumpKey>::value_type("-focus", KEY_DUMP_FOCUS_ABILITY),
168 std::map<std::string, AbilityManagerService::DumpKey>::value_type("-f", KEY_DUMP_FOCUS_ABILITY),
169 std::map<std::string, AbilityManagerService::DumpKey>::value_type("--win-mode", KEY_DUMP_WINDOW_MODE),
170 std::map<std::string, AbilityManagerService::DumpKey>::value_type("-z", KEY_DUMP_WINDOW_MODE),
171 std::map<std::string, AbilityManagerService::DumpKey>::value_type("--mission-list", KEY_DUMP_MISSION_LIST),
172 std::map<std::string, AbilityManagerService::DumpKey>::value_type("-L", KEY_DUMP_MISSION_LIST),
173 std::map<std::string, AbilityManagerService::DumpKey>::value_type("--mission-infos", KEY_DUMP_MISSION_INFOS),
174 std::map<std::string, AbilityManagerService::DumpKey>::value_type("-S", KEY_DUMP_MISSION_INFOS),
175 };
176
177 const std::map<std::string, AbilityManagerService::DumpsysKey> AbilityManagerService::dumpsysMap = {
178 std::map<std::string, AbilityManagerService::DumpsysKey>::value_type("--all", KEY_DUMPSYS_ALL),
179 std::map<std::string, AbilityManagerService::DumpsysKey>::value_type("-a", KEY_DUMPSYS_ALL),
180 std::map<std::string, AbilityManagerService::DumpsysKey>::value_type("--mission-list", KEY_DUMPSYS_MISSION_LIST),
181 std::map<std::string, AbilityManagerService::DumpsysKey>::value_type("-l", KEY_DUMPSYS_MISSION_LIST),
182 std::map<std::string, AbilityManagerService::DumpsysKey>::value_type("--ability", KEY_DUMPSYS_ABILITY),
183 std::map<std::string, AbilityManagerService::DumpsysKey>::value_type("-i", KEY_DUMPSYS_ABILITY),
184 std::map<std::string, AbilityManagerService::DumpsysKey>::value_type("--extension", KEY_DUMPSYS_SERVICE),
185 std::map<std::string, AbilityManagerService::DumpsysKey>::value_type("-e", KEY_DUMPSYS_SERVICE),
186 std::map<std::string, AbilityManagerService::DumpsysKey>::value_type("--pending", KEY_DUMPSYS_PENDING),
187 std::map<std::string, AbilityManagerService::DumpsysKey>::value_type("-p", KEY_DUMPSYS_PENDING),
188 std::map<std::string, AbilityManagerService::DumpsysKey>::value_type("--process", KEY_DUMPSYS_PROCESS),
189 std::map<std::string, AbilityManagerService::DumpsysKey>::value_type("-r", KEY_DUMPSYS_PROCESS),
190 std::map<std::string, AbilityManagerService::DumpsysKey>::value_type("--data", KEY_DUMPSYS_DATA),
191 std::map<std::string, AbilityManagerService::DumpsysKey>::value_type("-d", KEY_DUMPSYS_DATA),
192 };
193
194 const std::map<int32_t, AppExecFwk::SupportWindowMode> AbilityManagerService::windowModeMap = {
195 std::map<int32_t, AppExecFwk::SupportWindowMode>::value_type(MULTI_WINDOW_DISPLAY_FULLSCREEN,
196 AppExecFwk::SupportWindowMode::FULLSCREEN),
197 std::map<int32_t, AppExecFwk::SupportWindowMode>::value_type(MULTI_WINDOW_DISPLAY_PRIMARY,
198 AppExecFwk::SupportWindowMode::SPLIT),
199 std::map<int32_t, AppExecFwk::SupportWindowMode>::value_type(MULTI_WINDOW_DISPLAY_SECONDARY,
200 AppExecFwk::SupportWindowMode::SPLIT),
201 std::map<int32_t, AppExecFwk::SupportWindowMode>::value_type(MULTI_WINDOW_DISPLAY_FLOATING,
202 AppExecFwk::SupportWindowMode::FLOATING),
203 };
204
205 const bool REGISTER_RESULT =
206 SystemAbility::MakeAndRegisterAbility(DelayedSingleton<AbilityManagerService>::GetInstance().get());
207 sptr<AbilityManagerService> AbilityManagerService::instance_;
208
AbilityManagerService()209 AbilityManagerService::AbilityManagerService()
210 : SystemAbility(ABILITY_MGR_SERVICE_ID, true),
211 eventLoop_(nullptr),
212 handler_(nullptr),
213 state_(ServiceRunningState::STATE_NOT_START),
214 iBundleManager_(nullptr)
215 {
216 DumpFuncInit();
217 DumpSysFuncInit();
218 }
219
~AbilityManagerService()220 AbilityManagerService::~AbilityManagerService()
221 {}
222
OnStart()223 void AbilityManagerService::OnStart()
224 {
225 if (state_ == ServiceRunningState::STATE_RUNNING) {
226 HILOG_INFO("AMS has already started.");
227 return;
228 }
229 HILOG_INFO("AMS starting.");
230 if (!Init()) {
231 HILOG_ERROR("Failed to init AMS.");
232 return;
233 }
234 state_ = ServiceRunningState::STATE_RUNNING;
235 eventLoop_->Run();
236 /* Publish service maybe failed, so we need call this function at the last,
237 * so it can't affect the TDD test program */
238 instance_ = DelayedSingleton<AbilityManagerService>::GetInstance().get();
239 if (instance_ == nullptr) {
240 HILOG_ERROR("AMS enter OnStart, but instance_ is nullptr!");
241 return;
242 }
243 bool ret = Publish(instance_);
244 if (!ret) {
245 HILOG_ERROR("Publish AMS failed!");
246 return;
247 }
248
249 SetParameter(BOOTEVENT_APPFWK_READY.c_str(), "true");
250
251 WatchParameter(BOOTEVENT_BOOT_COMPLETED.c_str(), AAFwk::ApplicationUtil::AppFwkBootEventCallback, nullptr);
252
253 HILOG_INFO("AMS start success.");
254 }
255
Init()256 bool AbilityManagerService::Init()
257 {
258 eventLoop_ = AppExecFwk::EventRunner::Create(AbilityConfig::NAME_ABILITY_MGR_SERVICE);
259 CHECK_POINTER_RETURN_BOOL(eventLoop_);
260
261 handler_ = std::make_shared<AbilityEventHandler>(eventLoop_, weak_from_this());
262 CHECK_POINTER_RETURN_BOOL(handler_);
263
264 freeInstallManager_ = std::make_shared<FreeInstallManager>(weak_from_this());
265 CHECK_POINTER_RETURN_BOOL(freeInstallManager_);
266
267 // init user controller.
268 userController_ = std::make_shared<UserController>();
269 userController_->Init();
270
271 InitConnectManager(MAIN_USER_ID, true);
272 InitDataAbilityManager(MAIN_USER_ID, true);
273 InitPendWantManager(MAIN_USER_ID, true);
274 systemDataAbilityManager_ = std::make_shared<DataAbilityManager>();
275
276 amsConfigResolver_ = std::make_shared<AmsConfigurationParameter>();
277 amsConfigResolver_->Parse();
278 HILOG_INFO("ams config parse");
279 InitMissionListManager(MAIN_USER_ID, true);
280 SwitchManagers(U0_USER_ID, false);
281 int amsTimeOut = amsConfigResolver_->GetAMSTimeOutTime();
282 HILOG_INFO("amsTimeOut is %{public}d", amsTimeOut);
283 std::string threadName = std::string(AbilityConfig::NAME_ABILITY_MGR_SERVICE) + "(" +
284 std::to_string(eventLoop_->GetThreadId()) + ")";
285 #ifdef SUPPORT_ASAN
286 constexpr int32_t timeout = 5 * 60 * 1000; // 5 min
287 if (HiviewDFX::Watchdog::GetInstance().AddThread(threadName, handler_, timeout) != 0) {
288 HILOG_ERROR("HiviewDFX::Watchdog::GetInstance AddThread Fail");
289 }
290 #else
291 if (HiviewDFX::Watchdog::GetInstance().AddThread(threadName, handler_) != 0) {
292 HILOG_ERROR("HiviewDFX::Watchdog::GetInstance AddThread Fail");
293 }
294 #endif
295 #ifdef SUPPORT_GRAPHICS
296 anrListener_ = std::make_shared<ApplicationAnrListener>();
297 MMI::InputManager::GetInstance()->SetAnrObserver(anrListener_);
298 DelayedSingleton<SystemDialogScheduler>::GetInstance()->SetDeviceType(amsConfigResolver_->GetDeviceType());
299 implicitStartProcessor_ = std::make_shared<ImplicitStartProcessor>();
300 #endif
301
302 interceptorExecuter_ = std::make_shared<AbilityInterceptorExecuter>();
303 interceptorExecuter_->AddInterceptor(std::make_shared<CrowdTestInterceptor>());
304 interceptorExecuter_->AddInterceptor(std::make_shared<ControlInterceptor>());
305
306 auto startResidentAppsTask = [aams = shared_from_this()]() { aams->StartResidentApps(); };
307 handler_->PostTask(startResidentAppsTask, "StartResidentApps");
308
309 SubscribeBackgroundTask();
310 DelayedSingleton<ConnectionStateManager>::GetInstance()->Init();
311 auto initStartupFlagTask = [aams = shared_from_this()]() { aams->InitStartupFlag(); };
312 handler_->PostTask(initStartupFlagTask, "InitStartupFlag");
313
314 // Register abilityBundleEventCallback to receive hap updates
315 HILOG_INFO("Register abilityBundleEventCallback to receive hap updates.");
316 sptr<AbilityBundleEventCallback> abilityBundleEventCallback_ =
317 new (std::nothrow) AbilityBundleEventCallback(handler_);
318 auto bms = GetBundleManager();
319 if (bms && abilityBundleEventCallback_) {
320 bool re = bms->RegisterBundleEventCallback(abilityBundleEventCallback_);
321 if (!re) {
322 HILOG_ERROR("RegisterBundleEventCallback failed!");
323 }
324 } else {
325 HILOG_ERROR("Get BundleManager or abilieyBundleEventCallback failed!");
326 }
327
328 HILOG_INFO("Init success.");
329 return true;
330 }
331
InitStartupFlag()332 void AbilityManagerService::InitStartupFlag()
333 {
334 startUpNewRule_ = CheckNewRuleSwitchState(COMPONENT_STARTUP_NEW_RULES);
335 newRuleExceptLauncherSystemUI_ = CheckNewRuleSwitchState(NEW_RULES_EXCEPT_LAUNCHER_SYSTEMUI);
336 backgroundJudgeFlag_ = CheckNewRuleSwitchState(BACKGROUND_JUDGE_FLAG);
337 whiteListNormalFlag_ = CheckNewRuleSwitchState(WHITE_LIST_NORMAL_FLAG);
338 whiteListassociatedWakeUpFlag_ = CheckNewRuleSwitchState(WHITE_LIST_ASS_WAKEUP_FLAG);
339 }
340
OnStop()341 void AbilityManagerService::OnStop()
342 {
343 HILOG_INFO("Stop AMS.");
344 eventLoop_.reset();
345 handler_.reset();
346 state_ = ServiceRunningState::STATE_NOT_START;
347 }
348
QueryServiceState() const349 ServiceRunningState AbilityManagerService::QueryServiceState() const
350 {
351 return state_;
352 }
353
StartAbility(const Want & want,int32_t userId,int requestCode)354 int AbilityManagerService::StartAbility(const Want &want, int32_t userId, int requestCode)
355 {
356 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
357 HILOG_INFO("%{public}s coldStart:%{public}d", __func__, want.GetBoolParam("coldStart", false));
358 EventInfo eventInfo = BuildEventInfo(want, userId);
359 EventReport::SendAbilityEvent(EventName::START_ABILITY, HiSysEventType::BEHAVIOR, eventInfo);
360 int32_t ret = StartAbilityInner(want, nullptr, requestCode, -1, userId);
361 if (ret != ERR_OK) {
362 eventInfo.errCode = ret;
363 EventReport::SendAbilityEvent(EventName::START_ABILITY_ERROR, HiSysEventType::FAULT, eventInfo);
364 }
365 return ret;
366 }
367
StartAbility(const Want & want,const sptr<IRemoteObject> & callerToken,int32_t userId,int requestCode)368 int AbilityManagerService::StartAbility(const Want &want, const sptr<IRemoteObject> &callerToken,
369 int32_t userId, int requestCode)
370 {
371 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
372 auto flags = want.GetFlags();
373 EventInfo eventInfo = BuildEventInfo(want, userId);
374 EventReport::SendAbilityEvent(EventName::START_ABILITY, HiSysEventType::BEHAVIOR, eventInfo);
375 if ((flags & Want::FLAG_ABILITY_CONTINUATION) == Want::FLAG_ABILITY_CONTINUATION) {
376 HILOG_ERROR("StartAbility with continuation flags is not allowed!");
377 eventInfo.errCode = ERR_INVALID_VALUE;
378 EventReport::SendAbilityEvent(EventName::START_ABILITY_ERROR, HiSysEventType::FAULT, eventInfo);
379 return ERR_INVALID_CONTINUATION_FLAG;
380 }
381
382 HILOG_INFO("Start ability come, ability is %{public}s, userId is %{public}d",
383 want.GetElement().GetAbilityName().c_str(), userId);
384
385 int32_t ret = StartAbilityInner(want, callerToken, requestCode, -1, userId);
386 if (ret != ERR_OK) {
387 eventInfo.errCode = ret;
388 EventReport::SendAbilityEvent(EventName::START_ABILITY_ERROR, HiSysEventType::FAULT, eventInfo);
389 }
390 return ret;
391 }
392
StartAbilityInner(const Want & want,const sptr<IRemoteObject> & callerToken,int requestCode,int callerUid,int32_t userId)393 int AbilityManagerService::StartAbilityInner(const Want &want, const sptr<IRemoteObject> &callerToken,
394 int requestCode, int callerUid, int32_t userId)
395 {
396 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
397 {
398 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, "CHECK_DLP");
399 if (!DlpUtils::OtherAppsAccessDlpCheck(callerToken, want) ||
400 VerifyAccountPermission(userId) == CHECK_PERMISSION_FAILED ||
401 !DlpUtils::DlpAccessOtherAppsCheck(callerToken, want)) {
402 HILOG_ERROR("%{public}s: Permission verification failed.", __func__);
403 return CHECK_PERMISSION_FAILED;
404 }
405
406 if (AbilityUtil::HandleDlpApp(const_cast<Want &>(want))) {
407 return StartExtensionAbility(want, callerToken, userId, AppExecFwk::ExtensionAbilityType::SERVICE);
408 }
409 }
410
411 if (callerToken != nullptr && !VerificationAllToken(callerToken)) {
412 auto isSpecificSA = AAFwk::PermissionVerification::GetInstance()->
413 CheckSpecificSystemAbilityAccessPermission();
414 if (!isSpecificSA) {
415 HILOG_ERROR("%{public}s VerificationAllToken failed.", __func__);
416 return ERR_INVALID_CALLER;
417 }
418 HILOG_INFO("%{public}s: Caller is specific system ability.", __func__);
419 }
420
421 auto result = interceptorExecuter_ == nullptr ? ERR_INVALID_VALUE :
422 interceptorExecuter_->DoProcess(want, requestCode, GetUserId(), true);
423 if (result != ERR_OK) {
424 HILOG_ERROR("interceptorExecuter_ is nullptr or DoProcess return error.");
425 return result;
426 }
427
428 int32_t oriValidUserId = GetValidUserId(userId);
429 int32_t validUserId = oriValidUserId;
430
431 if (callerToken != nullptr && CheckIfOperateRemote(want)) {
432 HILOG_INFO("%{public}s: try to StartRemoteAbility", __func__);
433 return StartRemoteAbility(want, requestCode, validUserId, callerToken);
434 }
435 if (AbilityUtil::IsStartFreeInstall(want)) {
436 if (freeInstallManager_ == nullptr) {
437 return ERR_INVALID_VALUE;
438 }
439 Want localWant = want;
440 if (!localWant.GetDeviceId().empty()) {
441 localWant.SetDeviceId("");
442 }
443 int32_t ret = freeInstallManager_->StartFreeInstall(localWant, validUserId, requestCode, callerToken);
444 if (ret != ERR_OK) {
445 HILOG_DEBUG("StartFreeInstall ret : %{public}d", ret);
446 return ret;
447 }
448 }
449
450 if (!JudgeMultiUserConcurrency(validUserId)) {
451 HILOG_ERROR("Multi-user non-concurrent mode is not satisfied.");
452 return ERR_CROSS_USER;
453 }
454
455 AbilityRequest abilityRequest;
456 #ifdef SUPPORT_GRAPHICS
457 if (ImplicitStartProcessor::IsImplicitStartAction(want)) {
458 ComponentRequest componentRequest = initComponentRequest(callerToken, requestCode, result);
459 if (!IsComponentInterceptionStart(want, componentRequest, abilityRequest)) {
460 return componentRequest.requestResult;
461 }
462 abilityRequest.Voluation(want, requestCode, callerToken);
463 CHECK_POINTER_AND_RETURN(implicitStartProcessor_, ERR_IMPLICIT_START_ABILITY_FAIL);
464 return implicitStartProcessor_->ImplicitStartAbility(abilityRequest, validUserId);
465 }
466 #endif
467 result = GenerateAbilityRequest(want, requestCode, abilityRequest, callerToken, validUserId);
468 ComponentRequest componentRequest = initComponentRequest(callerToken, requestCode, result);
469 if (result != ERR_OK && !IsComponentInterceptionStart(want, componentRequest, abilityRequest)) {
470 return componentRequest.requestResult;
471 }
472
473 if (result != ERR_OK) {
474 HILOG_ERROR("Generate ability request local error.");
475 return result;
476 }
477
478 auto abilityInfo = abilityRequest.abilityInfo;
479 validUserId = abilityInfo.applicationInfo.singleton ? U0_USER_ID : validUserId;
480 HILOG_DEBUG("userId is : %{public}d, singleton is : %{public}d",
481 validUserId, static_cast<int>(abilityInfo.applicationInfo.singleton));
482
483 result = CheckStaticCfgPermission(abilityInfo);
484 if (result != AppExecFwk::Constants::PERMISSION_GRANTED) {
485 HILOG_ERROR("CheckStaticCfgPermission error, result is %{public}d.", result);
486 return ERR_STATIC_CFG_PERMISSION;
487 }
488
489 auto type = abilityInfo.type;
490 if (type == AppExecFwk::AbilityType::DATA) {
491 HILOG_ERROR("Cannot start data ability, use 'AcquireDataAbility()' instead.");
492 return ERR_WRONG_INTERFACE_CALL;
493 } else if (type == AppExecFwk::AbilityType::SERVICE || type == AppExecFwk::AbilityType::EXTENSION) {
494 HILOG_DEBUG("Check call service or extension permission, name is %{public}s.", abilityInfo.name.c_str());
495 result = CheckCallServicePermission(abilityRequest);
496 if (result != ERR_OK) {
497 HILOG_ERROR("Check permission failed");
498 return result;
499 }
500 } else {
501 HILOG_DEBUG("Check call ability permission, name is %{public}s.", abilityInfo.name.c_str());
502 result = CheckCallAbilityPermission(abilityRequest);
503 if (result != ERR_OK) {
504 HILOG_ERROR("Check permission failed");
505 return result;
506 }
507 }
508
509 if (!AbilityUtil::IsSystemDialogAbility(abilityInfo.bundleName, abilityInfo.name)) {
510 HILOG_DEBUG("PreLoadAppDataAbilities:%{public}s.", abilityInfo.bundleName.c_str());
511 result = PreLoadAppDataAbilities(abilityInfo.bundleName, validUserId);
512 if (result != ERR_OK) {
513 HILOG_ERROR("StartAbility: App data ability preloading failed, '%{public}s', %{public}d.",
514 abilityInfo.bundleName.c_str(), result);
515 return result;
516 }
517 }
518
519 UpdateCallerInfo(abilityRequest.want);
520 if (type == AppExecFwk::AbilityType::SERVICE || type == AppExecFwk::AbilityType::EXTENSION) {
521 auto connectManager = GetConnectManagerByUserId(validUserId);
522 if (!connectManager) {
523 HILOG_ERROR("connectManager is nullptr. userId=%{public}d", validUserId);
524 return ERR_INVALID_VALUE;
525 }
526 HILOG_DEBUG("Start service or extension, name is %{public}s.", abilityInfo.name.c_str());
527 ReportEventToSuspendManager(abilityInfo);
528 return connectManager->StartAbility(abilityRequest);
529 }
530
531 if (!IsComponentInterceptionStart(want, componentRequest, abilityRequest)) {
532 return componentRequest.requestResult;
533 }
534 if (!IsAbilityControllerStart(want, abilityInfo.bundleName)) {
535 HILOG_ERROR("IsAbilityControllerStart failed: %{public}s.", abilityInfo.bundleName.c_str());
536 return ERR_WOULD_BLOCK;
537 }
538 auto missionListManager = GetListManagerByUserId(oriValidUserId);
539 if (missionListManager == nullptr) {
540 HILOG_ERROR("missionListManager is nullptr. userId=%{public}d", validUserId);
541 return ERR_INVALID_VALUE;
542 }
543 ReportAbilitStartInfoToRSS(abilityInfo);
544 ReportEventToSuspendManager(abilityInfo);
545 HILOG_DEBUG("Start ability, name is %{public}s.", abilityInfo.name.c_str());
546 return missionListManager->StartAbility(abilityRequest);
547 }
548
StartAbility(const Want & want,const AbilityStartSetting & abilityStartSetting,const sptr<IRemoteObject> & callerToken,int32_t userId,int requestCode)549 int AbilityManagerService::StartAbility(const Want &want, const AbilityStartSetting &abilityStartSetting,
550 const sptr<IRemoteObject> &callerToken, int32_t userId, int requestCode)
551 {
552 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
553 HILOG_DEBUG("Start ability setting.");
554 EventInfo eventInfo = BuildEventInfo(want, userId);
555 EventReport::SendAbilityEvent(EventName::START_ABILITY, HiSysEventType::BEHAVIOR, eventInfo);
556
557 if (!DlpUtils::OtherAppsAccessDlpCheck(callerToken, want) ||
558 VerifyAccountPermission(userId) == CHECK_PERMISSION_FAILED ||
559 !DlpUtils::DlpAccessOtherAppsCheck(callerToken, want)) {
560 HILOG_ERROR("%{public}s: Permission verification failed", __func__);
561 eventInfo.errCode = CHECK_PERMISSION_FAILED;
562 EventReport::SendAbilityEvent(EventName::START_ABILITY_ERROR, HiSysEventType::FAULT, eventInfo);
563 return CHECK_PERMISSION_FAILED;
564 }
565
566 if (callerToken != nullptr && !VerificationAllToken(callerToken)) {
567 eventInfo.errCode = ERR_INVALID_VALUE;
568 EventReport::SendAbilityEvent(EventName::START_ABILITY_ERROR, HiSysEventType::FAULT, eventInfo);
569 return ERR_INVALID_CALLER;
570 }
571
572 auto result = interceptorExecuter_ == nullptr ? ERR_INVALID_VALUE :
573 interceptorExecuter_->DoProcess(want, requestCode, GetUserId(), true);
574 if (result != ERR_OK) {
575 HILOG_ERROR("interceptorExecuter_ is nullptr or DoProcess return error.");
576 return result;
577 }
578
579 int32_t oriValidUserId = GetValidUserId(userId);
580 int32_t validUserId = oriValidUserId;
581
582 if (AbilityUtil::IsStartFreeInstall(want)) {
583 if (CheckIfOperateRemote(want) || freeInstallManager_ == nullptr) {
584 HILOG_ERROR("can not start remote free install");
585 return ERR_INVALID_VALUE;
586 }
587 int32_t ret = freeInstallManager_->StartFreeInstall(want, validUserId, requestCode, callerToken);
588 if (ret != ERR_OK) {
589 HILOG_DEBUG("StartFreeInstall ret : %{public}d", ret);
590 return ret;
591 }
592 }
593
594 if (!JudgeMultiUserConcurrency(validUserId)) {
595 HILOG_ERROR("Multi-user non-concurrent mode is not satisfied.");
596 eventInfo.errCode = ERR_INVALID_VALUE;
597 EventReport::SendAbilityEvent(EventName::START_ABILITY_ERROR, HiSysEventType::FAULT, eventInfo);
598 return ERR_CROSS_USER;
599 }
600
601 AbilityRequest abilityRequest;
602 #ifdef SUPPORT_GRAPHICS
603 if (ImplicitStartProcessor::IsImplicitStartAction(want)) {
604 ComponentRequest componentRequest = initComponentRequest(callerToken, requestCode);
605 if (!IsComponentInterceptionStart(want, componentRequest, abilityRequest)) {
606 return componentRequest.requestResult;
607 }
608 abilityRequest.Voluation(
609 want, requestCode, callerToken, std::make_shared<AbilityStartSetting>(abilityStartSetting));
610 abilityRequest.callType = AbilityCallType::START_SETTINGS_TYPE;
611 CHECK_POINTER_AND_RETURN(implicitStartProcessor_, ERR_IMPLICIT_START_ABILITY_FAIL);
612 result = implicitStartProcessor_->ImplicitStartAbility(abilityRequest, validUserId);
613 if (result != ERR_OK) {
614 HILOG_ERROR("implicit start ability error.");
615 eventInfo.errCode = result;
616 EventReport::SendAbilityEvent(EventName::START_ABILITY_ERROR, HiSysEventType::FAULT, eventInfo);
617 }
618 return result;
619 }
620 #endif
621 result = GenerateAbilityRequest(want, requestCode, abilityRequest, callerToken, validUserId);
622 ComponentRequest componentRequest = initComponentRequest(callerToken, requestCode, result);
623 if (result != ERR_OK && !IsComponentInterceptionStart(want, componentRequest, abilityRequest)) {
624 return componentRequest.requestResult;
625 }
626 if (result != ERR_OK) {
627 HILOG_ERROR("Generate ability request local error.");
628 eventInfo.errCode = result;
629 EventReport::SendAbilityEvent(EventName::START_ABILITY_ERROR, HiSysEventType::FAULT, eventInfo);
630 return result;
631 }
632 auto abilityInfo = abilityRequest.abilityInfo;
633 validUserId = abilityInfo.applicationInfo.singleton ? U0_USER_ID : validUserId;
634 HILOG_DEBUG("userId : %{public}d, singleton is : %{public}d",
635 validUserId, static_cast<int>(abilityInfo.applicationInfo.singleton));
636
637 result = CheckStaticCfgPermission(abilityInfo);
638 if (result != AppExecFwk::Constants::PERMISSION_GRANTED) {
639 HILOG_ERROR("CheckStaticCfgPermission error, result is %{public}d.", result);
640 eventInfo.errCode = result;
641 EventReport::SendAbilityEvent(EventName::START_ABILITY_ERROR, HiSysEventType::FAULT, eventInfo);
642 return ERR_STATIC_CFG_PERMISSION;
643 }
644 result = CheckCallAbilityPermission(abilityRequest);
645 if (result != ERR_OK) {
646 HILOG_ERROR("%{public}s CheckCallAbilityPermission error.", __func__);
647 eventInfo.errCode = result;
648 EventReport::SendAbilityEvent(EventName::START_ABILITY_ERROR, HiSysEventType::FAULT, eventInfo);
649 return result;
650 }
651
652 abilityRequest.startSetting = std::make_shared<AbilityStartSetting>(abilityStartSetting);
653
654 if (abilityInfo.type == AppExecFwk::AbilityType::DATA) {
655 HILOG_ERROR("Cannot start data ability, use 'AcquireDataAbility()' instead.");
656 eventInfo.errCode = ERR_INVALID_VALUE;
657 EventReport::SendAbilityEvent(EventName::START_ABILITY_ERROR, HiSysEventType::FAULT, eventInfo);
658 return ERR_WRONG_INTERFACE_CALL;
659 }
660
661 if (!AbilityUtil::IsSystemDialogAbility(abilityInfo.bundleName, abilityInfo.name)) {
662 result = PreLoadAppDataAbilities(abilityInfo.bundleName, validUserId);
663 if (result != ERR_OK) {
664 HILOG_ERROR("StartAbility: App data ability preloading failed, '%{public}s', %{public}d",
665 abilityInfo.bundleName.c_str(),
666 result);
667 eventInfo.errCode = result;
668 EventReport::SendAbilityEvent(EventName::START_ABILITY_ERROR, HiSysEventType::FAULT, eventInfo);
669 return result;
670 }
671 }
672 #ifdef SUPPORT_GRAPHICS
673 if (abilityInfo.type != AppExecFwk::AbilityType::PAGE) {
674 HILOG_ERROR("Only support for page type ability.");
675 eventInfo.errCode = ERR_INVALID_VALUE;
676 EventReport::SendAbilityEvent(EventName::START_ABILITY_ERROR, HiSysEventType::FAULT, eventInfo);
677 return ERR_WRONG_INTERFACE_CALL;
678 }
679 #endif
680 if (!IsComponentInterceptionStart(want, componentRequest, abilityRequest)) {
681 return componentRequest.requestResult;
682 }
683 if (!IsAbilityControllerStart(want, abilityInfo.bundleName)) {
684 eventInfo.errCode = ERR_WOULD_BLOCK;
685 EventReport::SendAbilityEvent(EventName::START_ABILITY_ERROR, HiSysEventType::FAULT, eventInfo);
686 return ERR_WOULD_BLOCK;
687 }
688 auto missionListManager = GetListManagerByUserId(oriValidUserId);
689 if (missionListManager == nullptr) {
690 HILOG_ERROR("missionListManager is Null. userId=%{public}d", validUserId);
691 eventInfo.errCode = ERR_INVALID_VALUE;
692 EventReport::SendAbilityEvent(EventName::START_ABILITY_ERROR, HiSysEventType::FAULT, eventInfo);
693 return ERR_INVALID_VALUE;
694 }
695 UpdateCallerInfo(abilityRequest.want);
696 auto ret = missionListManager->StartAbility(abilityRequest);
697 if (ret != ERR_OK) {
698 eventInfo.errCode = ret;
699 EventReport::SendAbilityEvent(EventName::START_ABILITY_ERROR, HiSysEventType::FAULT, eventInfo);
700 }
701 return ret;
702 }
703
StartAbility(const Want & want,const StartOptions & startOptions,const sptr<IRemoteObject> & callerToken,int32_t userId,int requestCode)704 int AbilityManagerService::StartAbility(const Want &want, const StartOptions &startOptions,
705 const sptr<IRemoteObject> &callerToken, int32_t userId, int requestCode)
706 {
707 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
708 HILOG_DEBUG("Start ability options.");
709 EventInfo eventInfo = BuildEventInfo(want, userId);
710 EventReport::SendAbilityEvent(EventName::START_ABILITY, HiSysEventType::BEHAVIOR, eventInfo);
711
712 if (!DlpUtils::OtherAppsAccessDlpCheck(callerToken, want) ||
713 VerifyAccountPermission(userId) == CHECK_PERMISSION_FAILED ||
714 !DlpUtils::DlpAccessOtherAppsCheck(callerToken, want)) {
715 HILOG_ERROR("%{public}s: Permission verification failed", __func__);
716 eventInfo.errCode = CHECK_PERMISSION_FAILED;
717 EventReport::SendAbilityEvent(EventName::START_ABILITY_ERROR, HiSysEventType::FAULT, eventInfo);
718 return CHECK_PERMISSION_FAILED;
719 }
720
721 if (callerToken != nullptr && !VerificationAllToken(callerToken)) {
722 eventInfo.errCode = ERR_INVALID_VALUE;
723 EventReport::SendAbilityEvent(EventName::START_ABILITY_ERROR, HiSysEventType::FAULT, eventInfo);
724 return ERR_INVALID_CALLER;
725 }
726
727 auto result = interceptorExecuter_ == nullptr ? ERR_INVALID_VALUE :
728 interceptorExecuter_->DoProcess(want, requestCode, GetUserId(), true);
729 if (result != ERR_OK) {
730 HILOG_ERROR("interceptorExecuter_ is nullptr or DoProcess return error.");
731 return result;
732 }
733
734 int32_t oriValidUserId = GetValidUserId(userId);
735 int32_t validUserId = oriValidUserId;
736
737 if (AbilityUtil::IsStartFreeInstall(want)) {
738 if (CheckIfOperateRemote(want) || freeInstallManager_ == nullptr) {
739 HILOG_ERROR("can not start remote free install");
740 return ERR_INVALID_VALUE;
741 }
742 int32_t ret = freeInstallManager_->StartFreeInstall(want, validUserId, requestCode, callerToken);
743 if (ret != ERR_OK) {
744 HILOG_DEBUG("StartFreeInstall ret : %{public}d", ret);
745 return ret;
746 }
747 }
748 if (!JudgeMultiUserConcurrency(validUserId)) {
749 HILOG_ERROR("Multi-user non-concurrent mode is not satisfied.");
750 eventInfo.errCode = ERR_INVALID_VALUE;
751 EventReport::SendAbilityEvent(EventName::START_ABILITY_ERROR, HiSysEventType::FAULT, eventInfo);
752 return ERR_CROSS_USER;
753 }
754
755 AbilityRequest abilityRequest;
756 #ifdef SUPPORT_GRAPHICS
757 if (ImplicitStartProcessor::IsImplicitStartAction(want)) {
758 ComponentRequest componentRequest = initComponentRequest(callerToken, requestCode);
759 if (!IsComponentInterceptionStart(want, componentRequest, abilityRequest)) {
760 return componentRequest.requestResult;
761 }
762 abilityRequest.Voluation(want, requestCode, callerToken);
763 abilityRequest.want.SetParam(Want::PARAM_RESV_DISPLAY_ID, startOptions.GetDisplayID());
764 abilityRequest.want.SetParam(Want::PARAM_RESV_WINDOW_MODE, startOptions.GetWindowMode());
765 abilityRequest.callType = AbilityCallType::START_OPTIONS_TYPE;
766 CHECK_POINTER_AND_RETURN(implicitStartProcessor_, ERR_IMPLICIT_START_ABILITY_FAIL);
767 result = implicitStartProcessor_->ImplicitStartAbility(abilityRequest, validUserId);
768 if (result != ERR_OK) {
769 HILOG_ERROR("implicit start ability error.");
770 eventInfo.errCode = result;
771 EventReport::SendAbilityEvent(EventName::START_ABILITY_ERROR, HiSysEventType::FAULT, eventInfo);
772 }
773 return result;
774 }
775 #endif
776 result = GenerateAbilityRequest(want, requestCode, abilityRequest, callerToken, validUserId);
777 ComponentRequest componentRequest = initComponentRequest(callerToken, requestCode, result);
778 if (result != ERR_OK && !IsComponentInterceptionStart(want, componentRequest, abilityRequest)) {
779 return componentRequest.requestResult;
780 }
781 if (result != ERR_OK) {
782 HILOG_ERROR("Generate ability request local error.");
783 eventInfo.errCode = result;
784 EventReport::SendAbilityEvent(EventName::START_ABILITY_ERROR, HiSysEventType::FAULT, eventInfo);
785 return result;
786 }
787
788 auto abilityInfo = abilityRequest.abilityInfo;
789 validUserId = abilityInfo.applicationInfo.singleton ? U0_USER_ID : validUserId;
790 HILOG_DEBUG("userId : %{public}d, singleton is : %{public}d",
791 validUserId, static_cast<int>(abilityInfo.applicationInfo.singleton));
792
793 result = CheckStaticCfgPermission(abilityInfo);
794 if (result != AppExecFwk::Constants::PERMISSION_GRANTED) {
795 HILOG_ERROR("CheckStaticCfgPermission error, result is %{public}d.", result);
796 eventInfo.errCode = result;
797 EventReport::SendAbilityEvent(EventName::START_ABILITY_ERROR, HiSysEventType::FAULT, eventInfo);
798 return ERR_STATIC_CFG_PERMISSION;
799 }
800 result = CheckCallAbilityPermission(abilityRequest);
801 if (result != ERR_OK) {
802 HILOG_ERROR("%{public}s CheckCallAbilityPermission error.", __func__);
803 eventInfo.errCode = result;
804 EventReport::SendAbilityEvent(EventName::START_ABILITY_ERROR, HiSysEventType::FAULT, eventInfo);
805 return result;
806 }
807
808 if (abilityInfo.type != AppExecFwk::AbilityType::PAGE) {
809 HILOG_ERROR("Only support for page type ability.");
810 eventInfo.errCode = ERR_INVALID_VALUE;
811 EventReport::SendAbilityEvent(EventName::START_ABILITY_ERROR, HiSysEventType::FAULT, eventInfo);
812 return ERR_INVALID_VALUE;
813 }
814
815 if (!AbilityUtil::IsSystemDialogAbility(abilityInfo.bundleName, abilityInfo.name)) {
816 result = PreLoadAppDataAbilities(abilityInfo.bundleName, validUserId);
817 if (result != ERR_OK) {
818 HILOG_ERROR("StartAbility: App data ability preloading failed, '%{public}s', %{public}d",
819 abilityInfo.bundleName.c_str(),
820 result);
821 eventInfo.errCode = result;
822 EventReport::SendAbilityEvent(EventName::START_ABILITY_ERROR, HiSysEventType::FAULT, eventInfo);
823 return result;
824 }
825 }
826
827 if (!IsComponentInterceptionStart(want, componentRequest, abilityRequest)) {
828 return componentRequest.requestResult;
829 }
830 if (!IsAbilityControllerStart(want, abilityInfo.bundleName)) {
831 eventInfo.errCode = ERR_WOULD_BLOCK;
832 EventReport::SendAbilityEvent(EventName::START_ABILITY_ERROR, HiSysEventType::FAULT, eventInfo);
833 return ERR_WOULD_BLOCK;
834 }
835 abilityRequest.want.SetParam(Want::PARAM_RESV_DISPLAY_ID, startOptions.GetDisplayID());
836 abilityRequest.want.SetParam(Want::PARAM_RESV_WINDOW_MODE, startOptions.GetWindowMode());
837 auto missionListManager = GetListManagerByUserId(oriValidUserId);
838 if (missionListManager == nullptr) {
839 HILOG_ERROR("missionListManager is Null. userId=%{public}d", oriValidUserId);
840 eventInfo.errCode = ERR_INVALID_VALUE;
841 EventReport::SendAbilityEvent(EventName::START_ABILITY_ERROR, HiSysEventType::FAULT, eventInfo);
842 return ERR_INVALID_VALUE;
843 }
844
845 #ifdef SUPPORT_GRAPHICS
846 if (abilityInfo.isStageBasedModel && !CheckWindowMode(startOptions.GetWindowMode(), abilityInfo.windowModes)) {
847 return ERR_AAFWK_INVALID_WINDOW_MODE;
848 }
849 #endif
850 UpdateCallerInfo(abilityRequest.want);
851 auto ret = missionListManager->StartAbility(abilityRequest);
852 if (ret != ERR_OK) {
853 eventInfo.errCode = ret;
854 EventReport::SendAbilityEvent(EventName::START_ABILITY_ERROR, HiSysEventType::FAULT, eventInfo);
855 }
856 return ret;
857 }
858
IsBackgroundTaskUid(const int uid)859 bool AbilityManagerService::IsBackgroundTaskUid(const int uid)
860 {
861 #ifdef BGTASKMGR_CONTINUOUS_TASK_ENABLE
862 return bgtaskObserver_->IsBackgroundTaskUid(uid);
863 #else
864 return false;
865 #endif
866 }
867
CheckOptExtensionAbility(const Want & want,AbilityRequest & abilityRequest,int32_t validUserId,AppExecFwk::ExtensionAbilityType extensionType)868 int AbilityManagerService::CheckOptExtensionAbility(const Want &want, AbilityRequest &abilityRequest,
869 int32_t validUserId, AppExecFwk::ExtensionAbilityType extensionType)
870 {
871 auto abilityInfo = abilityRequest.abilityInfo;
872 auto type = abilityInfo.type;
873 if (type != AppExecFwk::AbilityType::EXTENSION) {
874 HILOG_ERROR("Not extension ability, not allowed.");
875 return ERR_WRONG_INTERFACE_CALL;
876 }
877 if (extensionType != AppExecFwk::ExtensionAbilityType::UNSPECIFIED &&
878 extensionType != abilityInfo.extensionAbilityType) {
879 HILOG_ERROR("Extension ability type not match, set type: %{public}d, real type: %{public}d",
880 static_cast<int32_t>(extensionType), static_cast<int32_t>(abilityInfo.extensionAbilityType));
881 return ERR_WRONG_INTERFACE_CALL;
882 }
883
884 auto result = CheckStaticCfgPermission(abilityInfo);
885 if (result != AppExecFwk::Constants::PERMISSION_GRANTED) {
886 HILOG_ERROR("CheckStaticCfgPermission error, result is %{public}d.", result);
887 return ERR_STATIC_CFG_PERMISSION;
888 }
889
890 if (extensionType == AppExecFwk::ExtensionAbilityType::DATASHARE ||
891 extensionType == AppExecFwk::ExtensionAbilityType::SERVICE) {
892 result = CheckCallServiceExtensionPermission(abilityRequest);
893 if (result != ERR_OK) {
894 return result;
895 }
896 } else {
897 result = CheckCallOtherExtensionPermission(abilityRequest);
898 if (result != ERR_OK) {
899 return result;
900 }
901 }
902
903 UpdateCallerInfo(abilityRequest.want);
904 return ERR_OK;
905 }
906
SubscribeBackgroundTask()907 void AbilityManagerService::SubscribeBackgroundTask()
908 {
909 #ifdef BGTASKMGR_CONTINUOUS_TASK_ENABLE
910 if (bgtaskObserver_) {
911 return ;
912 }
913 bgtaskObserver_ = std::make_shared<BackgroundTaskObserver>();
914 auto subscribeBackgroundTask = [aams = shared_from_this()]() {
915 int attemptNums = 0;
916 while ((BackgroundTaskMgrHelper::SubscribeBackgroundTask(
917 *(aams->bgtaskObserver_))) != ERR_OK) {
918 ++attemptNums;
919 if (attemptNums > SUBSCRIBE_BACKGROUND_TASK_TRY) {
920 HILOG_ERROR("subscribeBackgroundTask fail, attemptNums:%{public}d", attemptNums);
921 return;
922 }
923 usleep(REPOLL_TIME_MICRO_SECONDS);
924 }
925 };
926 handler_->PostTask(subscribeBackgroundTask, "SubscribeBackgroundTask");
927 #endif
928 }
929
ReportAbilitStartInfoToRSS(const AppExecFwk::AbilityInfo & abilityInfo)930 void AbilityManagerService::ReportAbilitStartInfoToRSS(const AppExecFwk::AbilityInfo &abilityInfo)
931 {
932 #ifdef RESOURCE_SCHEDULE_SERVICE_ENABLE
933 if (abilityInfo.type == AppExecFwk::AbilityType::PAGE &&
934 abilityInfo.launchMode != AppExecFwk::LaunchMode::SPECIFIED) {
935 std::vector<AppExecFwk::RunningProcessInfo> runningProcessInfos;
936 if (IN_PROCESS_CALL(GetProcessRunningInfos(runningProcessInfos)) != ERR_OK) {
937 return;
938 }
939 bool isColdStart = true;
940 int32_t pid = 0;
941 for (auto const &info : runningProcessInfos) {
942 if (info.uid_ == abilityInfo.applicationInfo.uid) {
943 isColdStart = false;
944 pid = info.pid_;
945 break;
946 }
947 }
948 std::unordered_map<std::string, std::string> eventParams {
949 { "name", "ability_start" },
950 { "uid", std::to_string(abilityInfo.applicationInfo.uid) },
951 { "bundleName", abilityInfo.applicationInfo.bundleName },
952 { "abilityName", abilityInfo.name },
953 { "pid", std::to_string(pid) }
954 };
955 ResourceSchedule::ResSchedClient::GetInstance().ReportData(
956 ResourceSchedule::ResType::RES_TYPE_APP_ABILITY_START, isColdStart ? 1 : 0, eventParams);
957 }
958 #endif
959 }
960
ReportEventToSuspendManager(const AppExecFwk::AbilityInfo & abilityInfo)961 void AbilityManagerService::ReportEventToSuspendManager(const AppExecFwk::AbilityInfo &abilityInfo)
962 {
963 #ifdef EFFICIENCY_MANAGER_ENABLE
964 std::string reason = (abilityInfo.type == AppExecFwk::AbilityType::PAGE) ?
965 "THAW_BY_START_PAGE_ABILITY" : "THAW_BY_START_NOT_PAGE_ABILITY";
966 SuspendManager::SuspendManagerClient::GetInstance().ThawOneApplication(
967 abilityInfo.applicationInfo.uid,
968 abilityInfo.applicationInfo.bundleName, reason);
969 #endif // EFFICIENCY_MANAGER_ENABLE
970 }
971
StartExtensionAbility(const Want & want,const sptr<IRemoteObject> & callerToken,int32_t userId,AppExecFwk::ExtensionAbilityType extensionType)972 int AbilityManagerService::StartExtensionAbility(const Want &want, const sptr<IRemoteObject> &callerToken,
973 int32_t userId, AppExecFwk::ExtensionAbilityType extensionType)
974 {
975 HILOG_INFO("Start extension ability come, bundlename: %{public}s, ability is %{public}s, userId is %{public}d",
976 want.GetElement().GetBundleName().c_str(), want.GetElement().GetAbilityName().c_str(), userId);
977 EventInfo eventInfo = BuildEventInfo(want, userId);
978 eventInfo.extensionType = (int32_t)(extensionType);
979 EventReport::SendExtensionEvent(EventName::START_SERVICE, HiSysEventType::BEHAVIOR, eventInfo);
980 if (!DlpUtils::OtherAppsAccessDlpCheck(callerToken, want) ||
981 VerifyAccountPermission(userId) == CHECK_PERMISSION_FAILED ||
982 !DlpUtils::DlpAccessOtherAppsCheck(callerToken, want)) {
983 HILOG_ERROR("%{public}s: Permission verification failed.", __func__);
984 eventInfo.errCode = CHECK_PERMISSION_FAILED;
985 EventReport::SendExtensionEvent(EventName::START_EXTENSION_ERROR, HiSysEventType::FAULT, eventInfo);
986 return CHECK_PERMISSION_FAILED;
987 }
988
989 if (callerToken != nullptr && !VerificationAllToken(callerToken)) {
990 HILOG_ERROR("%{public}s VerificationAllToken failed.", __func__);
991 eventInfo.errCode = ERR_INVALID_VALUE;
992 EventReport::SendExtensionEvent(EventName::START_EXTENSION_ERROR, HiSysEventType::FAULT, eventInfo);
993 return ERR_INVALID_CALLER;
994 }
995
996 auto result = interceptorExecuter_ == nullptr ? ERR_INVALID_VALUE :
997 interceptorExecuter_->DoProcess(want, 0, GetUserId(), false);
998 if (result != ERR_OK) {
999 HILOG_ERROR("interceptorExecuter_ is nullptr or DoProcess return error.");
1000 return result;
1001 }
1002
1003 int32_t validUserId = GetValidUserId(userId);
1004 if (!JudgeMultiUserConcurrency(validUserId)) {
1005 HILOG_ERROR("Multi-user non-concurrent mode is not satisfied.");
1006 eventInfo.errCode = ERR_INVALID_VALUE;
1007 EventReport::SendExtensionEvent(EventName::START_EXTENSION_ERROR, HiSysEventType::FAULT, eventInfo);
1008 return ERR_CROSS_USER;
1009 }
1010
1011 AbilityRequest abilityRequest;
1012 #ifdef SUPPORT_GRAPHICS
1013 if (ImplicitStartProcessor::IsImplicitStartAction(want)) {
1014 abilityRequest.Voluation(want, DEFAULT_INVAL_VALUE, callerToken);
1015 abilityRequest.callType = AbilityCallType::START_EXTENSION_TYPE;
1016 abilityRequest.extensionType = extensionType;
1017 CHECK_POINTER_AND_RETURN(implicitStartProcessor_, ERR_IMPLICIT_START_ABILITY_FAIL);
1018 result = implicitStartProcessor_->ImplicitStartAbility(abilityRequest, validUserId);
1019 if (result != ERR_OK) {
1020 HILOG_ERROR("implicit start ability error.");
1021 eventInfo.errCode = result;
1022 EventReport::SendExtensionEvent(EventName::START_EXTENSION_ERROR, HiSysEventType::FAULT, eventInfo);
1023 }
1024 return result;
1025 }
1026 #endif
1027 result = GenerateExtensionAbilityRequest(want, abilityRequest, callerToken, validUserId);
1028 if (result != ERR_OK) {
1029 HILOG_ERROR("Generate ability request local error.");
1030 eventInfo.errCode = result;
1031 EventReport::SendExtensionEvent(EventName::START_EXTENSION_ERROR, HiSysEventType::FAULT, eventInfo);
1032 return result;
1033 }
1034
1035 auto abilityInfo = abilityRequest.abilityInfo;
1036 validUserId = abilityInfo.applicationInfo.singleton ? U0_USER_ID : validUserId;
1037 HILOG_DEBUG("userId is : %{public}d, singleton is : %{public}d",
1038 validUserId, static_cast<int>(abilityInfo.applicationInfo.singleton));
1039
1040 result = CheckOptExtensionAbility(want, abilityRequest, validUserId, extensionType);
1041 if (result != ERR_OK) {
1042 HILOG_ERROR("CheckOptExtensionAbility error.");
1043 eventInfo.errCode = result;
1044 EventReport::SendExtensionEvent(EventName::START_EXTENSION_ERROR, HiSysEventType::FAULT, eventInfo);
1045 return result;
1046 }
1047
1048 auto connectManager = GetConnectManagerByUserId(validUserId);
1049 if (!connectManager) {
1050 HILOG_ERROR("connectManager is nullptr. userId=%{public}d", validUserId);
1051 eventInfo.errCode = ERR_INVALID_VALUE;
1052 EventReport::SendExtensionEvent(EventName::START_EXTENSION_ERROR, HiSysEventType::FAULT, eventInfo);
1053 return ERR_INVALID_VALUE;
1054 }
1055 HILOG_INFO("Start extension begin, name is %{public}s.", abilityInfo.name.c_str());
1056 eventInfo.errCode = connectManager->StartAbility(abilityRequest);
1057 if (eventInfo.errCode != ERR_OK) {
1058 EventReport::SendExtensionEvent(EventName::START_EXTENSION_ERROR, HiSysEventType::FAULT, eventInfo);
1059 }
1060 return eventInfo.errCode;
1061 }
1062
StopExtensionAbility(const Want & want,const sptr<IRemoteObject> & callerToken,int32_t userId,AppExecFwk::ExtensionAbilityType extensionType)1063 int AbilityManagerService::StopExtensionAbility(const Want &want, const sptr<IRemoteObject> &callerToken,
1064 int32_t userId, AppExecFwk::ExtensionAbilityType extensionType)
1065 {
1066 HILOG_INFO("Stop extension ability come, bundlename: %{public}s, ability is %{public}s, userId is %{public}d",
1067 want.GetElement().GetBundleName().c_str(), want.GetElement().GetAbilityName().c_str(), userId);
1068 EventInfo eventInfo = BuildEventInfo(want, userId);
1069 eventInfo.extensionType = (int32_t)(extensionType);
1070 EventReport::SendExtensionEvent(EventName::STOP_SERVICE, HiSysEventType::BEHAVIOR, eventInfo);
1071 if (!DlpUtils::OtherAppsAccessDlpCheck(callerToken, want) ||
1072 VerifyAccountPermission(userId) == CHECK_PERMISSION_FAILED ||
1073 !DlpUtils::DlpAccessOtherAppsCheck(callerToken, want)) {
1074 HILOG_ERROR("%{public}s: Permission verification failed.", __func__);
1075 eventInfo.errCode = CHECK_PERMISSION_FAILED;
1076 EventReport::SendExtensionEvent(EventName::STOP_EXTENSION_ERROR, HiSysEventType::FAULT, eventInfo);
1077 return CHECK_PERMISSION_FAILED;
1078 }
1079
1080 if (callerToken != nullptr && !VerificationAllToken(callerToken)) {
1081 HILOG_ERROR("%{public}s VerificationAllToken failed.", __func__);
1082 eventInfo.errCode = ERR_INVALID_VALUE;
1083 EventReport::SendExtensionEvent(EventName::STOP_EXTENSION_ERROR, HiSysEventType::FAULT, eventInfo);
1084 return ERR_INVALID_CALLER;
1085 }
1086 int32_t validUserId = GetValidUserId(userId);
1087 if (!JudgeMultiUserConcurrency(validUserId)) {
1088 HILOG_ERROR("Multi-user non-concurrent mode is not satisfied.");
1089 eventInfo.errCode = ERR_INVALID_VALUE;
1090 EventReport::SendExtensionEvent(EventName::STOP_EXTENSION_ERROR, HiSysEventType::FAULT, eventInfo);
1091 return ERR_CROSS_USER;
1092 }
1093
1094 AbilityRequest abilityRequest;
1095 auto result = GenerateExtensionAbilityRequest(want, abilityRequest, callerToken, validUserId);
1096 if (result != ERR_OK) {
1097 HILOG_ERROR("Generate ability request local error.");
1098 eventInfo.errCode = result;
1099 EventReport::SendExtensionEvent(EventName::STOP_EXTENSION_ERROR, HiSysEventType::FAULT, eventInfo);
1100 return result;
1101 }
1102
1103 auto abilityInfo = abilityRequest.abilityInfo;
1104 validUserId = abilityInfo.applicationInfo.singleton ? U0_USER_ID : validUserId;
1105 HILOG_DEBUG("userId is : %{public}d, singleton is : %{public}d",
1106 validUserId, static_cast<int>(abilityInfo.applicationInfo.singleton));
1107
1108 result = CheckOptExtensionAbility(want, abilityRequest, validUserId, extensionType);
1109 if (result != ERR_OK) {
1110 HILOG_ERROR("CheckOptExtensionAbility error.");
1111 eventInfo.errCode = result;
1112 EventReport::SendExtensionEvent(EventName::STOP_EXTENSION_ERROR, HiSysEventType::FAULT, eventInfo);
1113 return result;
1114 }
1115
1116 auto connectManager = GetConnectManagerByUserId(validUserId);
1117 if (!connectManager) {
1118 HILOG_ERROR("connectManager is nullptr. userId=%{public}d", validUserId);
1119 eventInfo.errCode = ERR_INVALID_VALUE;
1120 EventReport::SendExtensionEvent(EventName::STOP_EXTENSION_ERROR, HiSysEventType::FAULT, eventInfo);
1121 return ERR_INVALID_VALUE;
1122 }
1123 HILOG_INFO("Stop extension begin, name is %{public}s.", abilityInfo.name.c_str());
1124 eventInfo.errCode = connectManager->StopServiceAbility(abilityRequest);
1125 if (eventInfo.errCode != ERR_OK) {
1126 EventReport::SendExtensionEvent(EventName::STOP_EXTENSION_ERROR, HiSysEventType::FAULT, eventInfo);
1127 }
1128 return eventInfo.errCode;
1129 }
1130
TerminateAbility(const sptr<IRemoteObject> & token,int resultCode,const Want * resultWant)1131 int AbilityManagerService::TerminateAbility(const sptr<IRemoteObject> &token, int resultCode, const Want *resultWant)
1132 {
1133 auto abilityRecord = Token::GetAbilityRecordByToken(token);
1134 if (!abilityRecord) {
1135 HILOG_ERROR("abilityRecord is Null.");
1136 return ERR_INVALID_VALUE;
1137 }
1138 return TerminateAbilityWithFlag(token, resultCode, resultWant, true);
1139 }
1140
CloseAbility(const sptr<IRemoteObject> & token,int resultCode,const Want * resultWant)1141 int AbilityManagerService::CloseAbility(const sptr<IRemoteObject> &token, int resultCode, const Want *resultWant)
1142 {
1143 EventInfo eventInfo;
1144 EventReport::SendAbilityEvent(EventName::CLOSE_ABILITY, HiSysEventType::BEHAVIOR, eventInfo);
1145 return TerminateAbilityWithFlag(token, resultCode, resultWant, false);
1146 }
1147
TerminateAbilityWithFlag(const sptr<IRemoteObject> & token,int resultCode,const Want * resultWant,bool flag)1148 int AbilityManagerService::TerminateAbilityWithFlag(const sptr<IRemoteObject> &token, int resultCode,
1149 const Want *resultWant, bool flag)
1150 {
1151 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1152 HILOG_DEBUG("Terminate ability begin, flag:%{public}d.", flag);
1153 if (!VerificationAllToken(token)) {
1154 HILOG_ERROR("%{public}s VerificationAllToken failed.", __func__);
1155 return ERR_INVALID_VALUE;
1156 }
1157
1158 auto abilityRecord = Token::GetAbilityRecordByToken(token);
1159 CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE);
1160 if (!JudgeSelfCalled(abilityRecord)) {
1161 return CHECK_PERMISSION_FAILED;
1162 }
1163
1164 int result = JudgeAbilityVisibleControl(abilityRecord->GetAbilityInfo());
1165 if (result != ERR_OK) {
1166 HILOG_ERROR("%{public}s JudgeAbilityVisibleControl error.", __func__);
1167 return result;
1168 }
1169
1170 if (IsSystemUiApp(abilityRecord->GetAbilityInfo())) {
1171 HILOG_ERROR("System ui not allow terminate.");
1172 return ERR_INVALID_VALUE;
1173 }
1174
1175 auto userId = abilityRecord->GetApplicationInfo().uid / BASE_USER_RANGE;
1176 auto type = abilityRecord->GetAbilityInfo().type;
1177 if (type == AppExecFwk::AbilityType::SERVICE || type == AppExecFwk::AbilityType::EXTENSION) {
1178 auto connectManager = GetConnectManagerByUserId(userId);
1179 if (!connectManager) {
1180 HILOG_ERROR("connectManager is nullptr. userId=%{public}d", userId);
1181 return ERR_INVALID_VALUE;
1182 }
1183 return connectManager->TerminateAbility(token);
1184 }
1185
1186 if (type == AppExecFwk::AbilityType::DATA) {
1187 HILOG_ERROR("Cannot terminate data ability, use 'ReleaseDataAbility()' instead.");
1188 return ERR_WRONG_INTERFACE_CALL;
1189 }
1190
1191 if (!IsAbilityControllerForeground(abilityRecord->GetAbilityInfo().bundleName)) {
1192 return ERR_WOULD_BLOCK;
1193 }
1194
1195 auto ownerUserId = abilityRecord->GetOwnerMissionUserId();
1196 auto missionListManager = GetListManagerByUserId(ownerUserId);
1197 if (missionListManager == nullptr) {
1198 HILOG_ERROR("missionListManager is Null. ownerUserId=%{public}d", ownerUserId);
1199 return ERR_INVALID_VALUE;
1200 }
1201 NotifyHandleAbilityStateChange(token, TERMINATE_ABILITY_CODE);
1202 return missionListManager->TerminateAbility(abilityRecord, resultCode, resultWant, flag);
1203 }
1204
SendResultToAbility(int32_t requestCode,int32_t resultCode,Want & resultWant)1205 int AbilityManagerService::SendResultToAbility(int32_t requestCode, int32_t resultCode, Want &resultWant)
1206 {
1207 HILOG_INFO("%{public}s", __func__);
1208 Security::AccessToken::NativeTokenInfo nativeTokenInfo;
1209 uint32_t accessToken = IPCSkeleton::GetCallingTokenID();
1210 auto tokenType = Security::AccessToken::AccessTokenKit::GetTokenTypeFlag(accessToken);
1211 int32_t result = Security::AccessToken::AccessTokenKit::GetNativeTokenInfo(accessToken, nativeTokenInfo);
1212 if (tokenType != Security::AccessToken::ATokenTypeEnum::TOKEN_NATIVE ||
1213 result != ERR_OK || nativeTokenInfo.processName != DMS_PROCESS_NAME) {
1214 HILOG_ERROR("Check processName failed");
1215 return ERR_INVALID_VALUE;
1216 }
1217 int missionId = resultWant.GetIntParam(DMS_MISSION_ID, DEFAULT_DMS_MISSION_ID);
1218 resultWant.RemoveParam(DMS_MISSION_ID);
1219 if (missionId == DEFAULT_DMS_MISSION_ID) {
1220 HILOG_ERROR("MissionId is empty");
1221 return ERR_INVALID_VALUE;
1222 }
1223 sptr<IRemoteObject> abilityToken = GetAbilityTokenByMissionId(missionId);
1224 CHECK_POINTER_AND_RETURN(abilityToken, ERR_INVALID_VALUE);
1225
1226 auto abilityRecord = Token::GetAbilityRecordByToken(abilityToken);
1227 CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE);
1228
1229 abilityRecord->SetResult(std::make_shared<AbilityResult>(requestCode, resultCode, resultWant));
1230 abilityRecord->SendResult();
1231 return ERR_OK;
1232 }
1233
StartRemoteAbility(const Want & want,int requestCode,int32_t validUserId,const sptr<IRemoteObject> & callerToken)1234 int AbilityManagerService::StartRemoteAbility(const Want &want, int requestCode, int32_t validUserId,
1235 const sptr<IRemoteObject> &callerToken)
1236 {
1237 HILOG_INFO("%{public}s", __func__);
1238 Want remoteWant = want;
1239 if (AddStartControlParam(remoteWant, callerToken) != ERR_OK) {
1240 HILOG_ERROR("%{public}s AddStartControlParam failed.", __func__);
1241 return ERR_INVALID_VALUE;
1242 }
1243 if (AbilityUtil::IsStartFreeInstall(remoteWant)) {
1244 return freeInstallManager_ == nullptr ? ERR_INVALID_VALUE :
1245 freeInstallManager_->StartRemoteFreeInstall(remoteWant, requestCode, validUserId, callerToken);
1246 }
1247 if (remoteWant.GetBoolParam(Want::PARAM_RESV_FOR_RESULT, false)) {
1248 HILOG_INFO("%{public}s: try to StartAbilityForResult", __func__);
1249 int32_t missionId = GetMissionIdByAbilityToken(callerToken);
1250 if (missionId < 0) {
1251 return ERR_INVALID_VALUE;
1252 }
1253 remoteWant.SetParam(DMS_MISSION_ID, missionId);
1254 }
1255
1256 int32_t callerUid = IPCSkeleton::GetCallingUid();
1257 uint32_t accessToken = IPCSkeleton::GetCallingTokenID();
1258 DistributedClient dmsClient;
1259 HILOG_DEBUG("get callerUid = %d, AccessTokenID = %u", callerUid, accessToken);
1260 int result = dmsClient.StartRemoteAbility(remoteWant, callerUid, requestCode, accessToken);
1261 if (result != ERR_NONE) {
1262 HILOG_ERROR("AbilityManagerService::StartRemoteAbility failed, result = %{public}d", result);
1263 }
1264 return result;
1265 }
1266
CheckIsRemote(const std::string & deviceId)1267 bool AbilityManagerService::CheckIsRemote(const std::string& deviceId)
1268 {
1269 if (deviceId.empty()) {
1270 HILOG_INFO("CheckIsRemote: deviceId is empty.");
1271 return false;
1272 }
1273 std::string localDeviceId;
1274 if (!GetLocalDeviceId(localDeviceId)) {
1275 HILOG_ERROR("CheckIsRemote: get local deviceId failed");
1276 return false;
1277 }
1278 if (localDeviceId == deviceId) {
1279 HILOG_INFO("CheckIsRemote: deviceId is local.");
1280 return false;
1281 }
1282 HILOG_DEBUG("CheckIsRemote, deviceId = %{public}s", AnonymizeDeviceId(deviceId).c_str());
1283 return true;
1284 }
1285
CheckIfOperateRemote(const Want & want)1286 bool AbilityManagerService::CheckIfOperateRemote(const Want &want)
1287 {
1288 std::string deviceId = want.GetElement().GetDeviceID();
1289 if (deviceId.empty() || want.GetElement().GetBundleName().empty() ||
1290 want.GetElement().GetAbilityName().empty()) {
1291 HILOG_DEBUG("CheckIfOperateRemote: DeviceId or BundleName or GetAbilityName empty");
1292 return false;
1293 }
1294 return CheckIsRemote(deviceId);
1295 }
1296
GetLocalDeviceId(std::string & localDeviceId)1297 bool AbilityManagerService::GetLocalDeviceId(std::string& localDeviceId)
1298 {
1299 auto localNode = std::make_unique<NodeBasicInfo>();
1300 int32_t errCode = GetLocalNodeDeviceInfo(DM_PKG_NAME.c_str(), localNode.get());
1301 if (errCode != ERR_OK) {
1302 HILOG_ERROR("AbilityManagerService::GetLocalNodeDeviceInfo errCode = %{public}d", errCode);
1303 return false;
1304 }
1305 if (localNode != nullptr) {
1306 localDeviceId = localNode->networkId;
1307 HILOG_DEBUG("get local deviceId, deviceId = %{public}s",
1308 AnonymizeDeviceId(localDeviceId).c_str());
1309 return true;
1310 }
1311 HILOG_ERROR("AbilityManagerService::GetLocalDeviceId localDeviceId null");
1312 return false;
1313 }
1314
AnonymizeDeviceId(const std::string & deviceId)1315 std::string AbilityManagerService::AnonymizeDeviceId(const std::string& deviceId)
1316 {
1317 if (deviceId.length() < NON_ANONYMIZE_LENGTH) {
1318 return EMPTY_DEVICE_ID;
1319 }
1320 std::string anonDeviceId = deviceId.substr(0, NON_ANONYMIZE_LENGTH);
1321 anonDeviceId.append("******");
1322 return anonDeviceId;
1323 }
1324
TerminateAbilityByCaller(const sptr<IRemoteObject> & callerToken,int requestCode)1325 int AbilityManagerService::TerminateAbilityByCaller(const sptr<IRemoteObject> &callerToken, int requestCode)
1326 {
1327 HILOG_INFO("Terminate ability by caller.");
1328 if (!VerificationAllToken(callerToken)) {
1329 return ERR_INVALID_VALUE;
1330 }
1331
1332 auto abilityRecord = Token::GetAbilityRecordByToken(callerToken);
1333 CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE);
1334 if (!JudgeSelfCalled(abilityRecord)) {
1335 return CHECK_PERMISSION_FAILED;
1336 }
1337 #ifdef SUPPORT_GRAPHICS
1338 if (IsSystemUiApp(abilityRecord->GetAbilityInfo())) {
1339 HILOG_ERROR("System ui not allow terminate.");
1340 return ERR_INVALID_VALUE;
1341 }
1342 #endif
1343
1344 auto userId = abilityRecord->GetApplicationInfo().uid / BASE_USER_RANGE;
1345 auto type = abilityRecord->GetAbilityInfo().type;
1346 auto missionListManager = GetListManagerByUserId(userId);
1347 auto connectManager = GetConnectManagerByUserId(userId);
1348 switch (type) {
1349 case AppExecFwk::AbilityType::SERVICE:
1350 case AppExecFwk::AbilityType::EXTENSION: {
1351 if (!connectManager) {
1352 HILOG_ERROR("connectManager is nullptr.");
1353 return ERR_INVALID_VALUE;
1354 }
1355 auto result = connectManager->TerminateAbility(abilityRecord, requestCode);
1356 if (result == NO_FOUND_ABILITY_BY_CALLER) {
1357 if (!IsAbilityControllerForeground(abilityRecord->GetAbilityInfo().bundleName)) {
1358 return ERR_WOULD_BLOCK;
1359 }
1360
1361 if (!missionListManager) {
1362 HILOG_ERROR("missionListManager is nullptr. userId=%{public}d", userId);
1363 return ERR_INVALID_VALUE;
1364 }
1365 return missionListManager->TerminateAbility(abilityRecord, requestCode);
1366 }
1367 return result;
1368 }
1369 #ifdef SUPPORT_GRAPHICS
1370 case AppExecFwk::AbilityType::PAGE: {
1371 if (!IsAbilityControllerForeground(abilityRecord->GetAbilityInfo().bundleName)) {
1372 return ERR_WOULD_BLOCK;
1373 }
1374 if (!missionListManager) {
1375 HILOG_ERROR("missionListManager is nullptr.");
1376 return ERR_INVALID_VALUE;
1377 }
1378 auto result = missionListManager->TerminateAbility(abilityRecord, requestCode);
1379 if (result == NO_FOUND_ABILITY_BY_CALLER) {
1380 if (!connectManager) {
1381 HILOG_ERROR("connectManager is nullptr.");
1382 return ERR_INVALID_VALUE;
1383 }
1384 return connectManager->TerminateAbility(abilityRecord, requestCode);
1385 }
1386 return result;
1387 }
1388 #endif
1389 default:
1390 return ERR_INVALID_VALUE;
1391 }
1392 }
1393
MinimizeAbility(const sptr<IRemoteObject> & token,bool fromUser)1394 int AbilityManagerService::MinimizeAbility(const sptr<IRemoteObject> &token, bool fromUser)
1395 {
1396 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1397 HILOG_INFO("Minimize ability, fromUser:%{public}d.", fromUser);
1398 if (!VerificationAllToken(token)) {
1399 return ERR_INVALID_VALUE;
1400 }
1401
1402 auto abilityRecord = Token::GetAbilityRecordByToken(token);
1403 CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE);
1404 if (!JudgeSelfCalled(abilityRecord)) {
1405 return CHECK_PERMISSION_FAILED;
1406 }
1407
1408 int result = JudgeAbilityVisibleControl(abilityRecord->GetAbilityInfo());
1409 if (result != ERR_OK) {
1410 HILOG_ERROR("%{public}s JudgeAbilityVisibleControl error.", __func__);
1411 return result;
1412 }
1413
1414 auto type = abilityRecord->GetAbilityInfo().type;
1415 if (type != AppExecFwk::AbilityType::PAGE) {
1416 HILOG_ERROR("Cannot minimize except page ability.");
1417 return ERR_WRONG_INTERFACE_CALL;
1418 }
1419
1420 if (!IsAbilityControllerForeground(abilityRecord->GetAbilityInfo().bundleName)) {
1421 return ERR_WOULD_BLOCK;
1422 }
1423
1424 auto missionListManager = GetListManagerByUserId(abilityRecord->GetOwnerMissionUserId());
1425 if (!missionListManager) {
1426 HILOG_ERROR("missionListManager is Null.");
1427 return ERR_INVALID_VALUE;
1428 }
1429 return missionListManager->MinimizeAbility(token, fromUser);
1430 }
1431
ConnectAbility(const Want & want,const sptr<IAbilityConnection> & connect,const sptr<IRemoteObject> & callerToken,int32_t userId)1432 int AbilityManagerService::ConnectAbility(
1433 const Want &want, const sptr<IAbilityConnection> &connect, const sptr<IRemoteObject> &callerToken, int32_t userId)
1434 {
1435 return ConnectAbilityCommon(want, connect, callerToken, AppExecFwk::ExtensionAbilityType::SERVICE, userId);
1436 }
1437
ConnectAbilityCommon(const Want & want,const sptr<IAbilityConnection> & connect,const sptr<IRemoteObject> & callerToken,AppExecFwk::ExtensionAbilityType extensionType,int32_t userId)1438 int AbilityManagerService::ConnectAbilityCommon(
1439 const Want &want, const sptr<IAbilityConnection> &connect, const sptr<IRemoteObject> &callerToken,
1440 AppExecFwk::ExtensionAbilityType extensionType, int32_t userId)
1441 {
1442 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1443 HILOG_DEBUG("Connect ability called, element uri: %{public}s.", want.GetElement().GetURI().c_str());
1444 CHECK_POINTER_AND_RETURN(connect, ERR_INVALID_VALUE);
1445 CHECK_POINTER_AND_RETURN(connect->AsObject(), ERR_INVALID_VALUE);
1446 EventInfo eventInfo = BuildEventInfo(want, userId);
1447 EventReport::SendExtensionEvent(EventName::CONNECT_SERVICE, HiSysEventType::BEHAVIOR, eventInfo);
1448
1449 if (!DlpUtils::OtherAppsAccessDlpCheck(callerToken, want) ||
1450 VerifyAccountPermission(userId) == CHECK_PERMISSION_FAILED ||
1451 !DlpUtils::DlpAccessOtherAppsCheck(callerToken, want)) {
1452 HILOG_ERROR("%{public}s: Permission verification failed", __func__);
1453 eventInfo.errCode = CHECK_PERMISSION_FAILED;
1454 EventReport::SendExtensionEvent(EventName::CONNECT_SERVICE_ERROR, HiSysEventType::FAULT, eventInfo);
1455 return CHECK_PERMISSION_FAILED;
1456 }
1457
1458 auto result = interceptorExecuter_ == nullptr ? ERR_INVALID_VALUE :
1459 interceptorExecuter_->DoProcess(want, 0, GetUserId(), false);
1460 if (result != ERR_OK) {
1461 HILOG_ERROR("interceptorExecuter_ is nullptr or DoProcess return error.");
1462 return result;
1463 }
1464
1465 int32_t validUserId = GetValidUserId(userId);
1466
1467 if (AbilityUtil::IsStartFreeInstall(want) && freeInstallManager_ != nullptr) {
1468 std::string localDeviceId;
1469 if (!GetLocalDeviceId(localDeviceId)) {
1470 HILOG_ERROR("%{public}s: Get Local DeviceId failed", __func__);
1471 eventInfo.errCode = ERR_INVALID_VALUE;
1472 EventReport::SendExtensionEvent(EventName::CONNECT_SERVICE_ERROR, HiSysEventType::FAULT, eventInfo);
1473 return ERR_INVALID_VALUE;
1474 }
1475 result = freeInstallManager_->ConnectFreeInstall(want, validUserId, callerToken, localDeviceId);
1476 if (result != ERR_OK) {
1477 eventInfo.errCode = result;
1478 EventReport::SendExtensionEvent(EventName::CONNECT_SERVICE_ERROR, HiSysEventType::FAULT, eventInfo);
1479 return result;
1480 }
1481 }
1482
1483 Want abilityWant = want;
1484 std::string uri = abilityWant.GetUri().ToString();
1485 if (!uri.empty()) {
1486 // if the want include uri, it may only has uri information. it is probably a datashare extension.
1487 HILOG_INFO("%{public}s called. uri:%{public}s, userId %{public}d", __func__, uri.c_str(), validUserId);
1488 AppExecFwk::ExtensionAbilityInfo extensionInfo;
1489 auto bms = GetBundleManager();
1490 CHECK_POINTER_AND_RETURN(bms, ERR_INVALID_VALUE);
1491
1492 AbilityRequest abilityRequest;
1493 abilityWant.SetParam("abilityConnectionObj", connect->AsObject());
1494 ComponentRequest componentRequest = initComponentRequest(callerToken);
1495 if (!IsComponentInterceptionStart(abilityWant, componentRequest, abilityRequest)) {
1496 return componentRequest.requestResult;
1497 }
1498 abilityWant.RemoveParam("abilityConnectionObj");
1499
1500 bool queryResult = IN_PROCESS_CALL(bms->QueryExtensionAbilityInfoByUri(uri, validUserId, extensionInfo));
1501 if (!queryResult || extensionInfo.name.empty() || extensionInfo.bundleName.empty()) {
1502 HILOG_ERROR("Invalid extension ability info.");
1503 eventInfo.errCode = ERR_INVALID_VALUE;
1504 EventReport::SendExtensionEvent(EventName::CONNECT_SERVICE_ERROR, HiSysEventType::FAULT, eventInfo);
1505 return ERR_INVALID_VALUE;
1506 }
1507 abilityWant.SetElementName(extensionInfo.bundleName, extensionInfo.name);
1508 }
1509
1510 if (CheckIfOperateRemote(abilityWant)) {
1511 HILOG_INFO("AbilityManagerService::ConnectAbility. try to ConnectRemoteAbility");
1512 eventInfo.errCode = ConnectRemoteAbility(abilityWant, callerToken, connect->AsObject());
1513 if (eventInfo.errCode != ERR_OK) {
1514 EventReport::SendExtensionEvent(EventName::CONNECT_SERVICE_ERROR, HiSysEventType::FAULT, eventInfo);
1515 }
1516 return eventInfo.errCode;
1517 }
1518
1519 if (callerToken != nullptr && callerToken->GetObjectDescriptor() != u"ohos.aafwk.AbilityToken") {
1520 HILOG_INFO("%{public}s invalid Token.", __func__);
1521 eventInfo.errCode = ConnectLocalAbility(abilityWant, validUserId, connect, nullptr, extensionType);
1522 if (eventInfo.errCode != ERR_OK) {
1523 EventReport::SendExtensionEvent(EventName::CONNECT_SERVICE_ERROR, HiSysEventType::FAULT, eventInfo);
1524 }
1525 return eventInfo.errCode;
1526 }
1527 eventInfo.errCode = ConnectLocalAbility(abilityWant, validUserId, connect, callerToken, extensionType);
1528 if (eventInfo.errCode != ERR_OK) {
1529 EventReport::SendExtensionEvent(EventName::CONNECT_SERVICE_ERROR, HiSysEventType::FAULT, eventInfo);
1530 }
1531 return eventInfo.errCode;
1532 }
1533
BuildEventInfo(const Want & want,int32_t userId)1534 EventInfo AbilityManagerService::BuildEventInfo(const Want &want, int32_t userId)
1535 {
1536 EventInfo eventInfo;
1537 eventInfo.userId = userId;
1538 eventInfo.bundleName = want.GetElement().GetBundleName();
1539 eventInfo.moduleName = want.GetElement().GetModuleName();
1540 eventInfo.abilityName = want.GetElement().GetAbilityName();
1541 return eventInfo;
1542 }
1543
DisconnectAbility(const sptr<IAbilityConnection> & connect)1544 int AbilityManagerService::DisconnectAbility(const sptr<IAbilityConnection> &connect)
1545 {
1546 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1547 HILOG_DEBUG("Disconnect ability begin.");
1548 EventInfo eventInfo;
1549 EventReport::SendExtensionEvent(EventName::DISCONNECT_SERVICE, HiSysEventType::BEHAVIOR, eventInfo);
1550 CHECK_POINTER_AND_RETURN(connect, ERR_INVALID_VALUE);
1551 CHECK_POINTER_AND_RETURN(connect->AsObject(), ERR_INVALID_VALUE);
1552
1553 if (ERR_OK != DisconnectLocalAbility(connect) &&
1554 ERR_OK != DisconnectRemoteAbility(connect->AsObject())) {
1555 eventInfo.errCode = INNER_ERR;
1556 EventReport::SendExtensionEvent(EventName::DISCONNECT_SERVICE_ERROR, HiSysEventType::FAULT, eventInfo);
1557 }
1558 return ERR_OK;
1559 }
1560
ConnectLocalAbility(const Want & want,const int32_t userId,const sptr<IAbilityConnection> & connect,const sptr<IRemoteObject> & callerToken,AppExecFwk::ExtensionAbilityType extensionType)1561 int AbilityManagerService::ConnectLocalAbility(const Want &want, const int32_t userId,
1562 const sptr<IAbilityConnection> &connect, const sptr<IRemoteObject> &callerToken,
1563 AppExecFwk::ExtensionAbilityType extensionType)
1564 {
1565 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1566 HILOG_INFO("Connect local ability begin.");
1567 if (!JudgeMultiUserConcurrency(userId)) {
1568 HILOG_ERROR("Multi-user non-concurrent mode is not satisfied.");
1569 return ERR_CROSS_USER;
1570 }
1571
1572 AbilityRequest abilityRequest;
1573 ErrCode result = GenerateAbilityRequest(want, DEFAULT_INVAL_VALUE, abilityRequest, callerToken, userId);
1574
1575 Want requestWant = want;
1576 requestWant.SetParam("abilityConnectionObj", connect->AsObject());
1577 ComponentRequest componentRequest = initComponentRequest(callerToken);
1578 if (!IsComponentInterceptionStart(requestWant, componentRequest, abilityRequest)) {
1579 return componentRequest.requestResult;
1580 }
1581
1582 if (result != ERR_OK) {
1583 HILOG_ERROR("Generate ability request error.");
1584 return result;
1585 }
1586
1587 if (abilityRequest.abilityInfo.isStageBasedModel) {
1588 bool isService = (abilityRequest.abilityInfo.extensionAbilityType == AppExecFwk::ExtensionAbilityType::SERVICE);
1589 if (isService && extensionType != AppExecFwk::ExtensionAbilityType::SERVICE) {
1590 HILOG_ERROR("Service extension type, please use ConnectAbility.");
1591 return ERR_WRONG_INTERFACE_CALL;
1592 }
1593 }
1594 auto abilityInfo = abilityRequest.abilityInfo;
1595 int32_t validUserId = abilityInfo.applicationInfo.singleton ? U0_USER_ID : userId;
1596 HILOG_DEBUG("validUserId : %{public}d, singleton is : %{public}d",
1597 validUserId, static_cast<int>(abilityInfo.applicationInfo.singleton));
1598
1599 result = CheckStaticCfgPermission(abilityInfo);
1600 if (result != AppExecFwk::Constants::PERMISSION_GRANTED) {
1601 HILOG_ERROR("CheckStaticCfgPermission error, result is %{public}d.", result);
1602 return ERR_STATIC_CFG_PERMISSION;
1603 }
1604
1605 auto type = abilityInfo.type;
1606 if (type != AppExecFwk::AbilityType::SERVICE && type != AppExecFwk::AbilityType::EXTENSION) {
1607 HILOG_ERROR("Connect ability failed, target ability is not Service.");
1608 return TARGET_ABILITY_NOT_SERVICE;
1609 }
1610 result = CheckCallServicePermission(abilityRequest);
1611 if (result != ERR_OK) {
1612 HILOG_ERROR("%{public}s CheckCallServicePermission error.", __func__);
1613 return result;
1614 }
1615 result = PreLoadAppDataAbilities(abilityInfo.bundleName, validUserId);
1616 if (result != ERR_OK) {
1617 HILOG_ERROR("ConnectAbility: App data ability preloading failed, '%{public}s', %{public}d",
1618 abilityInfo.bundleName.c_str(),
1619 result);
1620 return result;
1621 }
1622
1623 auto connectManager = GetConnectManagerByUserId(validUserId);
1624 if (connectManager == nullptr) {
1625 HILOG_ERROR("connectManager is nullptr. userId=%{public}d", validUserId);
1626 return ERR_INVALID_VALUE;
1627 }
1628
1629 ReportEventToSuspendManager(abilityInfo);
1630 return connectManager->ConnectAbilityLocked(abilityRequest, connect, callerToken);
1631 }
1632
ConnectRemoteAbility(Want & want,const sptr<IRemoteObject> & callerToken,const sptr<IRemoteObject> & connect)1633 int AbilityManagerService::ConnectRemoteAbility(Want &want, const sptr<IRemoteObject> &callerToken,
1634 const sptr<IRemoteObject> &connect)
1635 {
1636 HILOG_INFO("%{public}s begin ConnectAbilityRemote", __func__);
1637 if (AddStartControlParam(want, callerToken) != ERR_OK) {
1638 HILOG_ERROR("%{public}s AddStartControlParam failed.", __func__);
1639 return ERR_INVALID_VALUE;
1640 }
1641 DistributedClient dmsClient;
1642 return dmsClient.ConnectRemoteAbility(want, connect);
1643 }
1644
DisconnectLocalAbility(const sptr<IAbilityConnection> & connect)1645 int AbilityManagerService::DisconnectLocalAbility(const sptr<IAbilityConnection> &connect)
1646 {
1647 HILOG_INFO("Disconnect local ability begin.");
1648 CHECK_POINTER_AND_RETURN(connectManager_, ERR_NO_INIT);
1649 if (connectManager_->DisconnectAbilityLocked(connect) == ERR_OK) {
1650 return ERR_OK;
1651 }
1652 // If current connectManager_ does not exist connect, then try connectManagerU0
1653 auto connectManagerU0 = GetConnectManagerByUserId(U0_USER_ID);
1654 CHECK_POINTER_AND_RETURN(connectManagerU0, ERR_NO_INIT);
1655 return connectManagerU0->DisconnectAbilityLocked(connect);
1656 }
1657
DisconnectRemoteAbility(const sptr<IRemoteObject> & connect)1658 int AbilityManagerService::DisconnectRemoteAbility(const sptr<IRemoteObject> &connect)
1659 {
1660 HILOG_INFO("%{public}s begin DisconnectAbilityRemote", __func__);
1661 int32_t callerUid = IPCSkeleton::GetCallingUid();
1662 uint32_t accessToken = IPCSkeleton::GetCallingTokenID();
1663 DistributedClient dmsClient;
1664 return dmsClient.DisconnectRemoteAbility(connect, callerUid, accessToken);
1665 }
1666
ContinueMission(const std::string & srcDeviceId,const std::string & dstDeviceId,int32_t missionId,const sptr<IRemoteObject> & callBack,AAFwk::WantParams & wantParams)1667 int AbilityManagerService::ContinueMission(const std::string &srcDeviceId, const std::string &dstDeviceId,
1668 int32_t missionId, const sptr<IRemoteObject> &callBack, AAFwk::WantParams &wantParams)
1669 {
1670 HILOG_INFO("ContinueMission missionId: %{public}d", missionId);
1671 if (!PermissionVerification::GetInstance()->VerifyMissionPermission()) {
1672 HILOG_ERROR("%{public}s: Permission verification failed", __func__);
1673 return CHECK_PERMISSION_FAILED;
1674 }
1675
1676 DistributedClient dmsClient;
1677 return dmsClient.ContinueMission(srcDeviceId, dstDeviceId, missionId, callBack, wantParams);
1678 }
1679
ContinueAbility(const std::string & deviceId,int32_t missionId,uint32_t versionCode)1680 int AbilityManagerService::ContinueAbility(const std::string &deviceId, int32_t missionId, uint32_t versionCode)
1681 {
1682 HILOG_INFO("ContinueAbility missionId = %{public}d, version = %{public}u.", missionId, versionCode);
1683
1684 sptr<IRemoteObject> abilityToken = GetAbilityTokenByMissionId(missionId);
1685 CHECK_POINTER_AND_RETURN(abilityToken, ERR_INVALID_VALUE);
1686
1687 auto abilityRecord = Token::GetAbilityRecordByToken(abilityToken);
1688 CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE);
1689
1690 abilityRecord->ContinueAbility(deviceId, versionCode);
1691 return ERR_OK;
1692 }
1693
StartContinuation(const Want & want,const sptr<IRemoteObject> & abilityToken,int32_t status)1694 int AbilityManagerService::StartContinuation(const Want &want, const sptr<IRemoteObject> &abilityToken, int32_t status)
1695 {
1696 HILOG_INFO("Start Continuation.");
1697 if (!CheckIfOperateRemote(want)) {
1698 HILOG_ERROR("deviceId or bundle name or abilityName empty");
1699 return ERR_INVALID_VALUE;
1700 }
1701 CHECK_POINTER_AND_RETURN(abilityToken, ERR_INVALID_VALUE);
1702
1703 int32_t appUid = IPCSkeleton::GetCallingUid();
1704 uint32_t accessToken = IPCSkeleton::GetCallingTokenID();
1705 HILOG_INFO("AbilityManagerService::Try to StartContinuation, AccessTokenID = %{public}u", accessToken);
1706 int32_t missionId = GetMissionIdByAbilityToken(abilityToken);
1707 if (missionId == -1) {
1708 HILOG_ERROR("AbilityManagerService::StartContinuation failed to get missionId.");
1709 return ERR_INVALID_VALUE;
1710 }
1711 DistributedClient dmsClient;
1712 auto result = dmsClient.StartContinuation(want, missionId, appUid, status, accessToken);
1713 if (result != ERR_OK) {
1714 HILOG_ERROR("StartContinuation failed, result = %{public}d, notify caller", result);
1715 NotifyContinuationResult(missionId, result);
1716 }
1717 return result;
1718 }
1719
NotifyCompleteContinuation(const std::string & deviceId,int32_t sessionId,bool isSuccess)1720 void AbilityManagerService::NotifyCompleteContinuation(const std::string &deviceId,
1721 int32_t sessionId, bool isSuccess)
1722 {
1723 HILOG_INFO("NotifyCompleteContinuation.");
1724 DistributedClient dmsClient;
1725 dmsClient.NotifyCompleteContinuation(Str8ToStr16(deviceId), sessionId, isSuccess);
1726 }
1727
NotifyContinuationResult(int32_t missionId,int32_t result)1728 int AbilityManagerService::NotifyContinuationResult(int32_t missionId, int32_t result)
1729 {
1730 HILOG_INFO("Notify Continuation Result : %{public}d.", result);
1731
1732 auto abilityToken = GetAbilityTokenByMissionId(missionId);
1733 CHECK_POINTER_AND_RETURN(abilityToken, ERR_INVALID_VALUE);
1734
1735 auto abilityRecord = Token::GetAbilityRecordByToken(abilityToken);
1736 CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE);
1737
1738 abilityRecord->NotifyContinuationResult(result);
1739 return ERR_OK;
1740 }
1741
StartSyncRemoteMissions(const std::string & devId,bool fixConflict,int64_t tag)1742 int AbilityManagerService::StartSyncRemoteMissions(const std::string& devId, bool fixConflict, int64_t tag)
1743 {
1744 if (!PermissionVerification::GetInstance()->VerifyMissionPermission()) {
1745 HILOG_ERROR("%{public}s: Permission verification failed", __func__);
1746 return CHECK_PERMISSION_FAILED;
1747 }
1748 DistributedClient dmsClient;
1749 return dmsClient.StartSyncRemoteMissions(devId, fixConflict, tag);
1750 }
1751
StopSyncRemoteMissions(const std::string & devId)1752 int AbilityManagerService::StopSyncRemoteMissions(const std::string& devId)
1753 {
1754 if (!PermissionVerification::GetInstance()->VerifyMissionPermission()) {
1755 HILOG_ERROR("%{public}s: Permission verification failed", __func__);
1756 return CHECK_PERMISSION_FAILED;
1757 }
1758 DistributedClient dmsClient;
1759 return dmsClient.StopSyncRemoteMissions(devId);
1760 }
1761
RegisterObserver(const sptr<AbilityRuntime::IConnectionObserver> & observer)1762 int AbilityManagerService::RegisterObserver(const sptr<AbilityRuntime::IConnectionObserver> &observer)
1763 {
1764 return DelayedSingleton<ConnectionStateManager>::GetInstance()->RegisterObserver(observer);
1765 }
1766
UnregisterObserver(const sptr<AbilityRuntime::IConnectionObserver> & observer)1767 int AbilityManagerService::UnregisterObserver(const sptr<AbilityRuntime::IConnectionObserver> &observer)
1768 {
1769 return DelayedSingleton<ConnectionStateManager>::GetInstance()->UnregisterObserver(observer);
1770 }
1771
GetDlpConnectionInfos(std::vector<AbilityRuntime::DlpConnectionInfo> & infos)1772 int AbilityManagerService::GetDlpConnectionInfos(std::vector<AbilityRuntime::DlpConnectionInfo> &infos)
1773 {
1774 if (!AAFwk::PermissionVerification::GetInstance()->IsSACall()) {
1775 HILOG_ERROR("can not get dlp connection infos if caller is not sa.");
1776 return CHECK_PERMISSION_FAILED;
1777 }
1778 DelayedSingleton<ConnectionStateManager>::GetInstance()->GetDlpConnectionInfos(infos);
1779
1780 return ERR_OK;
1781 }
1782
RegisterMissionListener(const std::string & deviceId,const sptr<IRemoteMissionListener> & listener)1783 int AbilityManagerService::RegisterMissionListener(const std::string &deviceId,
1784 const sptr<IRemoteMissionListener> &listener)
1785 {
1786 std::string localDeviceId;
1787 if (!GetLocalDeviceId(localDeviceId) || localDeviceId == deviceId) {
1788 HILOG_ERROR("RegisterMissionListener: Check DeviceId failed");
1789 return REGISTER_REMOTE_MISSION_LISTENER_FAIL;
1790 }
1791 CHECK_POINTER_AND_RETURN(listener, ERR_INVALID_VALUE);
1792 if (!PermissionVerification::GetInstance()->VerifyMissionPermission()) {
1793 HILOG_ERROR("%{public}s: Permission verification failed", __func__);
1794 return CHECK_PERMISSION_FAILED;
1795 }
1796 DistributedClient dmsClient;
1797 return dmsClient.RegisterMissionListener(Str8ToStr16(deviceId), listener->AsObject());
1798 }
1799
UnRegisterMissionListener(const std::string & deviceId,const sptr<IRemoteMissionListener> & listener)1800 int AbilityManagerService::UnRegisterMissionListener(const std::string &deviceId,
1801 const sptr<IRemoteMissionListener> &listener)
1802 {
1803 std::string localDeviceId;
1804 if (!GetLocalDeviceId(localDeviceId) || localDeviceId == deviceId) {
1805 HILOG_ERROR("RegisterMissionListener: Check DeviceId failed");
1806 return REGISTER_REMOTE_MISSION_LISTENER_FAIL;
1807 }
1808 CHECK_POINTER_AND_RETURN(listener, ERR_INVALID_VALUE);
1809 if (!PermissionVerification::GetInstance()->VerifyMissionPermission()) {
1810 HILOG_ERROR("%{public}s: Permission verification failed", __func__);
1811 return CHECK_PERMISSION_FAILED;
1812 }
1813 DistributedClient dmsClient;
1814 return dmsClient.UnRegisterMissionListener(Str8ToStr16(deviceId), listener->AsObject());
1815 }
1816
GetWantSender(const WantSenderInfo & wantSenderInfo,const sptr<IRemoteObject> & callerToken)1817 sptr<IWantSender> AbilityManagerService::GetWantSender(
1818 const WantSenderInfo &wantSenderInfo, const sptr<IRemoteObject> &callerToken)
1819 {
1820 HILOG_INFO("Get want Sender.");
1821 CHECK_POINTER_AND_RETURN(pendingWantManager_, nullptr);
1822
1823 auto bms = GetBundleManager();
1824 CHECK_POINTER_AND_RETURN(bms, nullptr);
1825
1826 int32_t callerUid = IPCSkeleton::GetCallingUid();
1827 int32_t userId = wantSenderInfo.userId;
1828 bool bundleMgrResult = false;
1829 if (userId < 0) {
1830 if (DelayedSingleton<AppExecFwk::OsAccountManagerWrapper>::GetInstance()->
1831 GetOsAccountLocalIdFromUid(callerUid, userId) != 0) {
1832 HILOG_ERROR("GetOsAccountLocalIdFromUid failed. uid=%{public}d", callerUid);
1833 return nullptr;
1834 }
1835 }
1836
1837 int32_t appUid = 0;
1838 if (!wantSenderInfo.allWants.empty()) {
1839 AppExecFwk::BundleInfo bundleInfo;
1840 std::string bundleName = wantSenderInfo.allWants.back().want.GetElement().GetBundleName();
1841 bundleMgrResult = IN_PROCESS_CALL(bms->GetBundleInfo(bundleName,
1842 AppExecFwk::BundleFlag::GET_BUNDLE_DEFAULT, bundleInfo, userId));
1843 if (bundleMgrResult) {
1844 appUid = bundleInfo.uid;
1845 }
1846 HILOG_INFO("App bundleName: %{public}s, uid: %{public}d", bundleName.c_str(), appUid);
1847 }
1848
1849 std::string apl;
1850 if (!wantSenderInfo.bundleName.empty()) {
1851 AppExecFwk::BundleInfo bundleInfo;
1852 bundleMgrResult = IN_PROCESS_CALL(bms->GetBundleInfo(wantSenderInfo.bundleName,
1853 AppExecFwk::BundleFlag::GET_BUNDLE_DEFAULT, bundleInfo, userId));
1854 if (bundleMgrResult) {
1855 apl = bundleInfo.applicationInfo.appPrivilegeLevel;
1856 }
1857 }
1858
1859 HILOG_INFO("AbilityManagerService::GetWantSender: bundleName = %{public}s", wantSenderInfo.bundleName.c_str());
1860 return pendingWantManager_->GetWantSender(callerUid, appUid, apl, wantSenderInfo, callerToken);
1861 }
1862
SendWantSender(const sptr<IWantSender> & target,const SenderInfo & senderInfo)1863 int AbilityManagerService::SendWantSender(const sptr<IWantSender> &target, const SenderInfo &senderInfo)
1864 {
1865 HILOG_INFO("Send want sender.");
1866 CHECK_POINTER_AND_RETURN(pendingWantManager_, ERR_INVALID_VALUE);
1867 CHECK_POINTER_AND_RETURN(target, ERR_INVALID_VALUE);
1868 return pendingWantManager_->SendWantSender(target, senderInfo);
1869 }
1870
CancelWantSender(const sptr<IWantSender> & sender)1871 void AbilityManagerService::CancelWantSender(const sptr<IWantSender> &sender)
1872 {
1873 HILOG_INFO("Cancel want sender.");
1874 CHECK_POINTER(pendingWantManager_);
1875 CHECK_POINTER(sender);
1876
1877 auto bms = GetBundleManager();
1878 CHECK_POINTER(bms);
1879
1880 int32_t callerUid = IPCSkeleton::GetCallingUid();
1881 sptr<PendingWantRecord> record = iface_cast<PendingWantRecord>(sender->AsObject());
1882
1883 int userId = -1;
1884 if (DelayedSingleton<AppExecFwk::OsAccountManagerWrapper>::GetInstance()->
1885 GetOsAccountLocalIdFromUid(callerUid, userId) != 0) {
1886 HILOG_ERROR("GetOsAccountLocalIdFromUid failed. uid=%{public}d", callerUid);
1887 return;
1888 }
1889 AppExecFwk::BundleInfo bundleInfo;
1890 bool bundleMgrResult = IN_PROCESS_CALL(
1891 bms->GetBundleInfo(record->GetKey()->GetBundleName(),
1892 AppExecFwk::BundleFlag::GET_BUNDLE_DEFAULT, bundleInfo, userId));
1893 if (!bundleMgrResult) {
1894 HILOG_ERROR("GetBundleInfo is fail.");
1895 return;
1896 }
1897
1898 auto apl = bundleInfo.applicationInfo.appPrivilegeLevel;
1899 pendingWantManager_->CancelWantSender(apl, sender);
1900 }
1901
GetPendingWantUid(const sptr<IWantSender> & target)1902 int AbilityManagerService::GetPendingWantUid(const sptr<IWantSender> &target)
1903 {
1904 HILOG_INFO("%{public}s:begin.", __func__);
1905
1906 if (pendingWantManager_ == nullptr) {
1907 HILOG_ERROR("%s, pendingWantManager_ is nullptr", __func__);
1908 return -1;
1909 }
1910 if (target == nullptr) {
1911 HILOG_ERROR("%s, target is nullptr", __func__);
1912 return -1;
1913 }
1914 return pendingWantManager_->GetPendingWantUid(target);
1915 }
1916
GetPendingWantUserId(const sptr<IWantSender> & target)1917 int AbilityManagerService::GetPendingWantUserId(const sptr<IWantSender> &target)
1918 {
1919 HILOG_INFO("%{public}s:begin.", __func__);
1920
1921 if (pendingWantManager_ == nullptr) {
1922 HILOG_ERROR("%s, pendingWantManager_ is nullptr", __func__);
1923 return -1;
1924 }
1925 if (target == nullptr) {
1926 HILOG_ERROR("%s, target is nullptr", __func__);
1927 return -1;
1928 }
1929 return pendingWantManager_->GetPendingWantUserId(target);
1930 }
1931
GetPendingWantBundleName(const sptr<IWantSender> & target)1932 std::string AbilityManagerService::GetPendingWantBundleName(const sptr<IWantSender> &target)
1933 {
1934 HILOG_INFO("Get pending want bundle name.");
1935 CHECK_POINTER_AND_RETURN(pendingWantManager_, "");
1936 CHECK_POINTER_AND_RETURN(target, "");
1937 return pendingWantManager_->GetPendingWantBundleName(target);
1938 }
1939
GetPendingWantCode(const sptr<IWantSender> & target)1940 int AbilityManagerService::GetPendingWantCode(const sptr<IWantSender> &target)
1941 {
1942 HILOG_INFO("%{public}s:begin.", __func__);
1943
1944 if (pendingWantManager_ == nullptr) {
1945 HILOG_ERROR("%s, pendingWantManager_ is nullptr", __func__);
1946 return -1;
1947 }
1948 if (target == nullptr) {
1949 HILOG_ERROR("%s, target is nullptr", __func__);
1950 return -1;
1951 }
1952 return pendingWantManager_->GetPendingWantCode(target);
1953 }
1954
GetPendingWantType(const sptr<IWantSender> & target)1955 int AbilityManagerService::GetPendingWantType(const sptr<IWantSender> &target)
1956 {
1957 HILOG_INFO("%{public}s:begin.", __func__);
1958
1959 if (pendingWantManager_ == nullptr) {
1960 HILOG_ERROR("%s, pendingWantManager_ is nullptr", __func__);
1961 return -1;
1962 }
1963 if (target == nullptr) {
1964 HILOG_ERROR("%s, target is nullptr", __func__);
1965 return -1;
1966 }
1967 return pendingWantManager_->GetPendingWantType(target);
1968 }
1969
RegisterCancelListener(const sptr<IWantSender> & sender,const sptr<IWantReceiver> & receiver)1970 void AbilityManagerService::RegisterCancelListener(const sptr<IWantSender> &sender,
1971 const sptr<IWantReceiver> &receiver)
1972 {
1973 HILOG_INFO("Register cancel listener.");
1974 CHECK_POINTER(pendingWantManager_);
1975 CHECK_POINTER(sender);
1976 CHECK_POINTER(receiver);
1977 pendingWantManager_->RegisterCancelListener(sender, receiver);
1978 }
1979
UnregisterCancelListener(const sptr<IWantSender> & sender,const sptr<IWantReceiver> & receiver)1980 void AbilityManagerService::UnregisterCancelListener(
1981 const sptr<IWantSender> &sender, const sptr<IWantReceiver> &receiver)
1982 {
1983 HILOG_INFO("Unregister cancel listener.");
1984 CHECK_POINTER(pendingWantManager_);
1985 CHECK_POINTER(sender);
1986 CHECK_POINTER(receiver);
1987 pendingWantManager_->UnregisterCancelListener(sender, receiver);
1988 }
1989
GetPendingRequestWant(const sptr<IWantSender> & target,std::shared_ptr<Want> & want)1990 int AbilityManagerService::GetPendingRequestWant(const sptr<IWantSender> &target, std::shared_ptr<Want> &want)
1991 {
1992 HILOG_INFO("Get pending request want.");
1993 CHECK_POINTER_AND_RETURN(pendingWantManager_, ERR_INVALID_VALUE);
1994 CHECK_POINTER_AND_RETURN(target, ERR_INVALID_VALUE);
1995 CHECK_POINTER_AND_RETURN(want, ERR_INVALID_VALUE);
1996 return pendingWantManager_->GetPendingRequestWant(target, want);
1997 }
1998
LockMissionForCleanup(int32_t missionId)1999 int AbilityManagerService::LockMissionForCleanup(int32_t missionId)
2000 {
2001 HILOG_INFO("request unlock mission for clean up all, id :%{public}d", missionId);
2002 CHECK_POINTER_AND_RETURN(currentMissionListManager_, ERR_NO_INIT);
2003
2004 if (!PermissionVerification::GetInstance()->VerifyMissionPermission()) {
2005 HILOG_ERROR("%{public}s: Permission verification failed", __func__);
2006 return CHECK_PERMISSION_FAILED;
2007 }
2008 return currentMissionListManager_->SetMissionLockedState(missionId, true);
2009 }
2010
UnlockMissionForCleanup(int32_t missionId)2011 int AbilityManagerService::UnlockMissionForCleanup(int32_t missionId)
2012 {
2013 HILOG_INFO("request unlock mission for clean up all, id :%{public}d", missionId);
2014 CHECK_POINTER_AND_RETURN(currentMissionListManager_, ERR_NO_INIT);
2015
2016 if (!PermissionVerification::GetInstance()->VerifyMissionPermission()) {
2017 HILOG_ERROR("%{public}s: Permission verification failed", __func__);
2018 return CHECK_PERMISSION_FAILED;
2019 }
2020 return currentMissionListManager_->SetMissionLockedState(missionId, false);
2021 }
2022
RegisterMissionListener(const sptr<IMissionListener> & listener)2023 int AbilityManagerService::RegisterMissionListener(const sptr<IMissionListener> &listener)
2024 {
2025 HILOG_INFO("request RegisterMissionListener ");
2026 CHECK_POINTER_AND_RETURN(currentMissionListManager_, ERR_NO_INIT);
2027
2028 if (!PermissionVerification::GetInstance()->VerifyMissionPermission()) {
2029 HILOG_ERROR("%{public}s: Permission verification failed", __func__);
2030 return CHECK_PERMISSION_FAILED;
2031 }
2032 return currentMissionListManager_->RegisterMissionListener(listener);
2033 }
2034
UnRegisterMissionListener(const sptr<IMissionListener> & listener)2035 int AbilityManagerService::UnRegisterMissionListener(const sptr<IMissionListener> &listener)
2036 {
2037 HILOG_INFO("request RegisterMissionListener ");
2038 CHECK_POINTER_AND_RETURN(currentMissionListManager_, ERR_NO_INIT);
2039
2040 if (!PermissionVerification::GetInstance()->VerifyMissionPermission()) {
2041 HILOG_ERROR("%{public}s: Permission verification failed", __func__);
2042 return CHECK_PERMISSION_FAILED;
2043 }
2044 return currentMissionListManager_->UnRegisterMissionListener(listener);
2045 }
2046
GetMissionInfos(const std::string & deviceId,int32_t numMax,std::vector<MissionInfo> & missionInfos)2047 int AbilityManagerService::GetMissionInfos(const std::string& deviceId, int32_t numMax,
2048 std::vector<MissionInfo> &missionInfos)
2049 {
2050 HILOG_INFO("request GetMissionInfos.");
2051 CHECK_POINTER_AND_RETURN(currentMissionListManager_, ERR_NO_INIT);
2052
2053 if (!PermissionVerification::GetInstance()->VerifyMissionPermission()) {
2054 HILOG_ERROR("%{public}s: Permission verification failed", __func__);
2055 return CHECK_PERMISSION_FAILED;
2056 }
2057
2058 if (CheckIsRemote(deviceId)) {
2059 return GetRemoteMissionInfos(deviceId, numMax, missionInfos);
2060 }
2061
2062 return currentMissionListManager_->GetMissionInfos(numMax, missionInfos);
2063 }
2064
GetRemoteMissionInfos(const std::string & deviceId,int32_t numMax,std::vector<MissionInfo> & missionInfos)2065 int AbilityManagerService::GetRemoteMissionInfos(const std::string& deviceId, int32_t numMax,
2066 std::vector<MissionInfo> &missionInfos)
2067 {
2068 HILOG_INFO("GetRemoteMissionInfos begin");
2069 DistributedClient dmsClient;
2070 int result = dmsClient.GetMissionInfos(deviceId, numMax, missionInfos);
2071 if (result != ERR_OK) {
2072 HILOG_ERROR("GetRemoteMissionInfos failed, result = %{public}d", result);
2073 return result;
2074 }
2075 return ERR_OK;
2076 }
2077
GetMissionInfo(const std::string & deviceId,int32_t missionId,MissionInfo & missionInfo)2078 int AbilityManagerService::GetMissionInfo(const std::string& deviceId, int32_t missionId,
2079 MissionInfo &missionInfo)
2080 {
2081 HILOG_INFO("request GetMissionInfo, missionId:%{public}d", missionId);
2082 CHECK_POINTER_AND_RETURN(currentMissionListManager_, ERR_NO_INIT);
2083
2084 if (!PermissionVerification::GetInstance()->VerifyMissionPermission()) {
2085 HILOG_ERROR("%{public}s: Permission verification failed", __func__);
2086 return CHECK_PERMISSION_FAILED;
2087 }
2088
2089 if (CheckIsRemote(deviceId)) {
2090 return GetRemoteMissionInfo(deviceId, missionId, missionInfo);
2091 }
2092
2093 return currentMissionListManager_->GetMissionInfo(missionId, missionInfo);
2094 }
2095
GetRemoteMissionInfo(const std::string & deviceId,int32_t missionId,MissionInfo & missionInfo)2096 int AbilityManagerService::GetRemoteMissionInfo(const std::string& deviceId, int32_t missionId,
2097 MissionInfo &missionInfo)
2098 {
2099 HILOG_INFO("GetMissionInfoFromDms begin");
2100 std::vector<MissionInfo> missionVector;
2101 int result = GetRemoteMissionInfos(deviceId, MAX_NUMBER_OF_DISTRIBUTED_MISSIONS, missionVector);
2102 if (result != ERR_OK) {
2103 return result;
2104 }
2105 for (auto iter = missionVector.begin(); iter != missionVector.end(); iter++) {
2106 if (iter->id == missionId) {
2107 missionInfo = *iter;
2108 return ERR_OK;
2109 }
2110 }
2111 HILOG_WARN("missionId not found");
2112 return ERR_INVALID_VALUE;
2113 }
2114
CleanMission(int32_t missionId)2115 int AbilityManagerService::CleanMission(int32_t missionId)
2116 {
2117 HILOG_INFO("request CleanMission, missionId:%{public}d", missionId);
2118 CHECK_POINTER_AND_RETURN(currentMissionListManager_, ERR_NO_INIT);
2119
2120 if (!PermissionVerification::GetInstance()->VerifyMissionPermission()) {
2121 HILOG_ERROR("%{public}s: Permission verification failed", __func__);
2122 return CHECK_PERMISSION_FAILED;
2123 }
2124
2125 return currentMissionListManager_->ClearMission(missionId);
2126 }
2127
CleanAllMissions()2128 int AbilityManagerService::CleanAllMissions()
2129 {
2130 HILOG_INFO("request CleanAllMissions ");
2131 CHECK_POINTER_AND_RETURN(currentMissionListManager_, ERR_NO_INIT);
2132
2133 if (!PermissionVerification::GetInstance()->VerifyMissionPermission()) {
2134 HILOG_ERROR("%{public}s: Permission verification failed", __func__);
2135 return CHECK_PERMISSION_FAILED;
2136 }
2137
2138 Want want;
2139 want.SetElementName(AbilityConfig::LAUNCHER_BUNDLE_NAME, AbilityConfig::LAUNCHER_ABILITY_NAME);
2140 if (!IsAbilityControllerStart(want, AbilityConfig::LAUNCHER_BUNDLE_NAME)) {
2141 HILOG_ERROR("IsAbilityControllerStart failed: %{public}s", want.GetBundle().c_str());
2142 return ERR_WOULD_BLOCK;
2143 }
2144
2145 return currentMissionListManager_->ClearAllMissions();
2146 }
2147
MoveMissionToFront(int32_t missionId)2148 int AbilityManagerService::MoveMissionToFront(int32_t missionId)
2149 {
2150 HILOG_INFO("request MoveMissionToFront, missionId:%{public}d", missionId);
2151 CHECK_POINTER_AND_RETURN(currentMissionListManager_, ERR_NO_INIT);
2152
2153 if (!PermissionVerification::GetInstance()->VerifyMissionPermission()) {
2154 HILOG_ERROR("%{public}s: Permission verification failed", __func__);
2155 return CHECK_PERMISSION_FAILED;
2156 }
2157
2158 if (!IsAbilityControllerStartById(missionId)) {
2159 HILOG_ERROR("IsAbilityControllerStart false");
2160 return ERR_WOULD_BLOCK;
2161 }
2162
2163 return currentMissionListManager_->MoveMissionToFront(missionId);
2164 }
2165
MoveMissionToFront(int32_t missionId,const StartOptions & startOptions)2166 int AbilityManagerService::MoveMissionToFront(int32_t missionId, const StartOptions &startOptions)
2167 {
2168 HILOG_INFO("request MoveMissionToFront, missionId:%{public}d", missionId);
2169 CHECK_POINTER_AND_RETURN(currentMissionListManager_, ERR_NO_INIT);
2170
2171 if (!PermissionVerification::GetInstance()->VerifyMissionPermission()) {
2172 HILOG_ERROR("%{public}s: Permission verification failed", __func__);
2173 return CHECK_PERMISSION_FAILED;
2174 }
2175
2176 if (!IsAbilityControllerStartById(missionId)) {
2177 HILOG_ERROR("IsAbilityControllerStart false");
2178 return ERR_WOULD_BLOCK;
2179 }
2180
2181 auto options = std::make_shared<StartOptions>(startOptions);
2182 return currentMissionListManager_->MoveMissionToFront(missionId, options);
2183 }
2184
GetMissionIdByToken(const sptr<IRemoteObject> & token)2185 int32_t AbilityManagerService::GetMissionIdByToken(const sptr<IRemoteObject> &token)
2186 {
2187 HILOG_INFO("request GetMissionIdByToken.");
2188 if (!token) {
2189 HILOG_ERROR("token is invalid.");
2190 return -1;
2191 }
2192
2193 return GetMissionIdByAbilityToken(token);
2194 }
2195
IsAbilityControllerStartById(int32_t missionId)2196 bool AbilityManagerService::IsAbilityControllerStartById(int32_t missionId)
2197 {
2198 InnerMissionInfo innerMissionInfo;
2199 int getMission = DelayedSingleton<MissionInfoMgr>::GetInstance()->GetInnerMissionInfoById(
2200 missionId, innerMissionInfo);
2201 if (getMission != ERR_OK) {
2202 HILOG_ERROR("cannot find mission info from MissionInfoList by missionId: %{public}d", missionId);
2203 return true;
2204 }
2205 if (!IsAbilityControllerStart(innerMissionInfo.missionInfo.want, innerMissionInfo.missionInfo.want.GetBundle())) {
2206 HILOG_ERROR("IsAbilityControllerStart failed: %{public}s",
2207 innerMissionInfo.missionInfo.want.GetBundle().c_str());
2208 return false;
2209 }
2210 return true;
2211 }
2212
GetServiceRecordByElementName(const std::string & element)2213 std::shared_ptr<AbilityRecord> AbilityManagerService::GetServiceRecordByElementName(const std::string &element)
2214 {
2215 if (!connectManager_) {
2216 HILOG_ERROR("Connect manager is nullptr.");
2217 return nullptr;
2218 }
2219 return connectManager_->GetServiceRecordByElementName(element);
2220 }
2221
GetConnectRecordListByCallback(sptr<IAbilityConnection> callback)2222 std::list<std::shared_ptr<ConnectionRecord>> AbilityManagerService::GetConnectRecordListByCallback(
2223 sptr<IAbilityConnection> callback)
2224 {
2225 if (!connectManager_) {
2226 HILOG_ERROR("Connect manager is nullptr.");
2227 std::list<std::shared_ptr<ConnectionRecord>> connectList;
2228 return connectList;
2229 }
2230 return connectManager_->GetConnectRecordListByCallback(callback);
2231 }
2232
AcquireDataAbility(const Uri & uri,bool tryBind,const sptr<IRemoteObject> & callerToken)2233 sptr<IAbilityScheduler> AbilityManagerService::AcquireDataAbility(
2234 const Uri &uri, bool tryBind, const sptr<IRemoteObject> &callerToken)
2235 {
2236 auto bms = GetBundleManager();
2237 CHECK_POINTER_AND_RETURN(bms, nullptr);
2238
2239 auto localUri(uri);
2240 if (localUri.GetScheme() != AbilityConfig::SCHEME_DATA_ABILITY) {
2241 HILOG_ERROR("Acquire data ability with invalid uri scheme.");
2242 return nullptr;
2243 }
2244 std::vector<std::string> pathSegments;
2245 localUri.GetPathSegments(pathSegments);
2246 if (pathSegments.empty()) {
2247 HILOG_ERROR("Acquire data ability with invalid uri path.");
2248 return nullptr;
2249 }
2250
2251 auto userId = GetValidUserId(INVALID_USER_ID);
2252 AbilityRequest abilityRequest;
2253 std::string dataAbilityUri = localUri.ToString();
2254 HILOG_INFO("%{public}s, called. userId %{public}d", __func__, userId);
2255 bool queryResult = IN_PROCESS_CALL(bms->QueryAbilityInfoByUri(dataAbilityUri, userId, abilityRequest.abilityInfo));
2256 if (!queryResult || abilityRequest.abilityInfo.name.empty() || abilityRequest.abilityInfo.bundleName.empty()) {
2257 HILOG_ERROR("Invalid ability info for data ability acquiring.");
2258 return nullptr;
2259 }
2260
2261 abilityRequest.callerToken = callerToken;
2262 if (CheckCallDataAbilityPermission(abilityRequest) != ERR_OK) {
2263 HILOG_ERROR("Invalid ability request info for data ability acquiring.");
2264 return nullptr;
2265 }
2266
2267 HILOG_DEBUG("Query data ability info: %{public}s|%{public}s|%{public}s",
2268 abilityRequest.appInfo.name.c_str(), abilityRequest.appInfo.bundleName.c_str(),
2269 abilityRequest.abilityInfo.name.c_str());
2270
2271 if (CheckStaticCfgPermission(abilityRequest.abilityInfo) != AppExecFwk::Constants::PERMISSION_GRANTED) {
2272 if (!VerificationAllToken(callerToken)) {
2273 HILOG_INFO("VerificationAllToken fail");
2274 return nullptr;
2275 }
2276 }
2277
2278 if (abilityRequest.abilityInfo.applicationInfo.singleton) {
2279 userId = U0_USER_ID;
2280 }
2281
2282 std::shared_ptr<DataAbilityManager> dataAbilityManager = GetDataAbilityManagerByUserId(userId);
2283 CHECK_POINTER_AND_RETURN(dataAbilityManager, nullptr);
2284 ReportEventToSuspendManager(abilityRequest.abilityInfo);
2285 auto isSaCall = AAFwk::PermissionVerification::GetInstance()->IsSACall();
2286 auto isShellCall = AAFwk::PermissionVerification::GetInstance()->IsShellCall();
2287 bool isNotHap = isSaCall || isShellCall;
2288 return dataAbilityManager->Acquire(abilityRequest, tryBind, callerToken, isNotHap);
2289 }
2290
ReleaseDataAbility(sptr<IAbilityScheduler> dataAbilityScheduler,const sptr<IRemoteObject> & callerToken)2291 int AbilityManagerService::ReleaseDataAbility(
2292 sptr<IAbilityScheduler> dataAbilityScheduler, const sptr<IRemoteObject> &callerToken)
2293 {
2294 HILOG_INFO("%{public}s, called.", __func__);
2295 if (!dataAbilityScheduler || !callerToken) {
2296 HILOG_ERROR("dataAbilitySchedule or callerToken is nullptr");
2297 return ERR_INVALID_VALUE;
2298 }
2299
2300 std::shared_ptr<DataAbilityManager> dataAbilityManager = GetDataAbilityManager(dataAbilityScheduler);
2301 if (!dataAbilityManager) {
2302 HILOG_ERROR("dataAbilityScheduler is not exists");
2303 return ERR_INVALID_VALUE;
2304 }
2305
2306 auto isSaCall = AAFwk::PermissionVerification::GetInstance()->IsSACall();
2307 auto isShellCall = AAFwk::PermissionVerification::GetInstance()->IsShellCall();
2308 bool isNotHap = isSaCall || isShellCall;
2309 return dataAbilityManager->Release(dataAbilityScheduler, callerToken, isNotHap);
2310 }
2311
AttachAbilityThread(const sptr<IAbilityScheduler> & scheduler,const sptr<IRemoteObject> & token)2312 int AbilityManagerService::AttachAbilityThread(
2313 const sptr<IAbilityScheduler> &scheduler, const sptr<IRemoteObject> &token)
2314 {
2315 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
2316 HILOG_INFO("Attach ability thread.");
2317 CHECK_POINTER_AND_RETURN(scheduler, ERR_INVALID_VALUE);
2318 if (!VerificationAllToken(token)) {
2319 return ERR_INVALID_VALUE;
2320 }
2321 auto abilityRecord = Token::GetAbilityRecordByToken(token);
2322 CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE);
2323 if (!JudgeSelfCalled(abilityRecord)) {
2324 return CHECK_PERMISSION_FAILED;
2325 }
2326
2327 auto userId = abilityRecord->GetApplicationInfo().uid / BASE_USER_RANGE;
2328 auto abilityInfo = abilityRecord->GetAbilityInfo();
2329 auto type = abilityInfo.type;
2330 // force timeout ability for test
2331 if (IsNeedTimeoutForTest(abilityInfo.name, AbilityRecord::ConvertAbilityState(AbilityState::INITIAL))) {
2332 HILOG_WARN("force timeout ability for test, state:INITIAL, ability: %{public}s",
2333 abilityInfo.name.c_str());
2334 return ERR_OK;
2335 }
2336 int returnCode = -1;
2337 if (type == AppExecFwk::AbilityType::SERVICE || type == AppExecFwk::AbilityType::EXTENSION) {
2338 auto connectManager = GetConnectManagerByUserId(userId);
2339 if (!connectManager) {
2340 HILOG_ERROR("connectManager is nullptr. userId=%{public}d", userId);
2341 return ERR_INVALID_VALUE;
2342 }
2343 returnCode = connectManager->AttachAbilityThreadLocked(scheduler, token);
2344 } else if (type == AppExecFwk::AbilityType::DATA) {
2345 auto dataAbilityManager = GetDataAbilityManagerByUserId(userId);
2346 if (!dataAbilityManager) {
2347 HILOG_ERROR("dataAbilityManager is Null. userId=%{public}d", userId);
2348 return ERR_INVALID_VALUE;
2349 }
2350 returnCode = dataAbilityManager->AttachAbilityThread(scheduler, token);
2351 } else {
2352 int32_t ownerMissionUserId = abilityRecord->GetOwnerMissionUserId();
2353 auto missionListManager = GetListManagerByUserId(ownerMissionUserId);
2354 if (!missionListManager) {
2355 HILOG_ERROR("missionListManager is Null. userId=%{public}d", ownerMissionUserId);
2356 return ERR_INVALID_VALUE;
2357 }
2358 returnCode = missionListManager->AttachAbilityThread(scheduler, token);
2359 }
2360 return returnCode;
2361 }
2362
DumpFuncInit()2363 void AbilityManagerService::DumpFuncInit()
2364 {
2365 dumpFuncMap_[KEY_DUMP_ALL] = &AbilityManagerService::DumpInner;
2366 dumpFuncMap_[KEY_DUMP_MISSION] = &AbilityManagerService::DumpMissionInner;
2367 dumpFuncMap_[KEY_DUMP_SERVICE] = &AbilityManagerService::DumpStateInner;
2368 dumpFuncMap_[KEY_DUMP_DATA] = &AbilityManagerService::DataDumpStateInner;
2369 dumpFuncMap_[KEY_DUMP_MISSION_LIST] = &AbilityManagerService::DumpMissionListInner;
2370 dumpFuncMap_[KEY_DUMP_MISSION_INFOS] = &AbilityManagerService::DumpMissionInfosInner;
2371 }
2372
DumpSysFuncInit()2373 void AbilityManagerService::DumpSysFuncInit()
2374 {
2375 dumpsysFuncMap_[KEY_DUMPSYS_ALL] = &AbilityManagerService::DumpSysInner;
2376 dumpsysFuncMap_[KEY_DUMPSYS_MISSION_LIST] = &AbilityManagerService::DumpSysMissionListInner;
2377 dumpsysFuncMap_[KEY_DUMPSYS_ABILITY] = &AbilityManagerService::DumpSysAbilityInner;
2378 dumpsysFuncMap_[KEY_DUMPSYS_SERVICE] = &AbilityManagerService::DumpSysStateInner;
2379 dumpsysFuncMap_[KEY_DUMPSYS_PENDING] = &AbilityManagerService::DumpSysPendingInner;
2380 dumpsysFuncMap_[KEY_DUMPSYS_PROCESS] = &AbilityManagerService::DumpSysProcess;
2381 dumpsysFuncMap_[KEY_DUMPSYS_DATA] = &AbilityManagerService::DataDumpSysStateInner;
2382 }
2383
DumpSysInner(const std::string & args,std::vector<std::string> & info,bool isClient,bool isUserID,int userId)2384 void AbilityManagerService::DumpSysInner(
2385 const std::string& args, std::vector<std::string>& info, bool isClient, bool isUserID, int userId)
2386 {
2387 std::vector<std::string> argList;
2388 SplitStr(args, " ", argList);
2389 if (argList.empty()) {
2390 return;
2391 }
2392 DumpSysMissionListInner(args, info, isClient, isUserID, userId);
2393 DumpSysStateInner(args, info, isClient, isUserID, userId);
2394 DumpSysPendingInner(args, info, isClient, isUserID, userId);
2395 DumpSysProcess(args, info, isClient, isUserID, userId);
2396 }
2397
DumpSysMissionListInner(const std::string & args,std::vector<std::string> & info,bool isClient,bool isUserID,int userId)2398 void AbilityManagerService::DumpSysMissionListInner(
2399 const std::string &args, std::vector<std::string> &info, bool isClient, bool isUserID, int userId)
2400 {
2401 std::shared_ptr<MissionListManager> targetManager;
2402 if (isUserID) {
2403 std::shared_lock<std::shared_mutex> lock(managersMutex_);
2404 auto it = missionListManagers_.find(userId);
2405 if (it == missionListManagers_.end()) {
2406 info.push_back("error: No user found.");
2407 return;
2408 }
2409 targetManager = it->second;
2410 } else {
2411 targetManager = currentMissionListManager_;
2412 }
2413
2414 CHECK_POINTER(targetManager);
2415
2416 std::vector<std::string> argList;
2417 SplitStr(args, " ", argList);
2418 if (argList.empty()) {
2419 return;
2420 }
2421
2422 if (argList.size() == MIN_DUMP_ARGUMENT_NUM) {
2423 targetManager->DumpMissionList(info, isClient, argList[1]);
2424 } else if (argList.size() < MIN_DUMP_ARGUMENT_NUM) {
2425 targetManager->DumpMissionList(info, isClient);
2426 } else {
2427 info.emplace_back("error: invalid argument, please see 'hidumper -s AbilityManagerService -a '-h''.");
2428 }
2429 }
DumpSysAbilityInner(const std::string & args,std::vector<std::string> & info,bool isClient,bool isUserID,int userId)2430 void AbilityManagerService::DumpSysAbilityInner(
2431 const std::string &args, std::vector<std::string> &info, bool isClient, bool isUserID, int userId)
2432 {
2433 std::shared_ptr<MissionListManager> targetManager;
2434 if (isUserID) {
2435 std::shared_lock<std::shared_mutex> lock(managersMutex_);
2436 auto it = missionListManagers_.find(userId);
2437 if (it == missionListManagers_.end()) {
2438 info.push_back("error: No user found.");
2439 return;
2440 }
2441 targetManager = it->second;
2442 } else {
2443 targetManager = currentMissionListManager_;
2444 }
2445
2446 CHECK_POINTER(targetManager);
2447
2448 std::vector<std::string> argList;
2449 SplitStr(args, " ", argList);
2450 if (argList.empty()) {
2451 return;
2452 }
2453 if (argList.size() >= MIN_DUMP_ARGUMENT_NUM) {
2454 HILOG_INFO("argList = %{public}s", argList[1].c_str());
2455 std::vector<std::string> params(argList.begin() + MIN_DUMP_ARGUMENT_NUM, argList.end());
2456 try {
2457 auto abilityId = static_cast<int32_t>(std::stoi(argList[1]));
2458 targetManager->DumpMissionListByRecordId(info, isClient, abilityId, params);
2459 } catch (...) {
2460 HILOG_WARN("stoi(%{public}s) failed", argList[1].c_str());
2461 info.emplace_back("error: invalid argument, please see 'hidumper -s AbilityManagerService -a '-h''.");
2462 }
2463 } else {
2464 info.emplace_back("error: invalid argument, please see 'hidumper -s AbilityManagerService -a '-h''.");
2465 }
2466 }
2467
DumpSysStateInner(const std::string & args,std::vector<std::string> & info,bool isClient,bool isUserID,int userId)2468 void AbilityManagerService::DumpSysStateInner(
2469 const std::string& args, std::vector<std::string>& info, bool isClient, bool isUserID, int userId)
2470 {
2471 HILOG_INFO("DumpSysStateInner begin:%{public}s", args.c_str());
2472 std::shared_ptr<AbilityConnectManager> targetManager;
2473
2474 if (isUserID) {
2475 std::shared_lock<std::shared_mutex> lock(managersMutex_);
2476 auto it = connectManagers_.find(userId);
2477 if (it == connectManagers_.end()) {
2478 info.push_back("error: No user found.");
2479 return;
2480 }
2481 targetManager = it->second;
2482 } else {
2483 targetManager = connectManager_;
2484 }
2485
2486 CHECK_POINTER(targetManager);
2487
2488 std::vector<std::string> argList;
2489 SplitStr(args, " ", argList);
2490 if (argList.empty()) {
2491 return;
2492 }
2493
2494 if (argList.size() == MIN_DUMP_ARGUMENT_NUM) {
2495 targetManager->DumpState(info, isClient, argList[1]);
2496 } else if (argList.size() < MIN_DUMP_ARGUMENT_NUM) {
2497 targetManager->DumpState(info, isClient);
2498 } else {
2499 HILOG_INFO("uri = %{public}s", argList[1].c_str());
2500 std::vector<std::string> params(argList.begin() + MIN_DUMP_ARGUMENT_NUM, argList.end());
2501 targetManager->DumpStateByUri(info, isClient, argList[1], params);
2502 }
2503 }
2504
DumpSysPendingInner(const std::string & args,std::vector<std::string> & info,bool isClient,bool isUserID,int userId)2505 void AbilityManagerService::DumpSysPendingInner(
2506 const std::string& args, std::vector<std::string>& info, bool isClient, bool isUserID, int userId)
2507 {
2508 std::shared_ptr<PendingWantManager> targetManager;
2509 if (isUserID) {
2510 std::shared_lock<std::shared_mutex> lock(managersMutex_);
2511 auto it = pendingWantManagers_.find(userId);
2512 if (it == pendingWantManagers_.end()) {
2513 info.push_back("error: No user found.");
2514 return;
2515 }
2516 targetManager = it->second;
2517 } else {
2518 targetManager = pendingWantManager_;
2519 }
2520
2521 CHECK_POINTER(targetManager);
2522
2523 std::vector<std::string> argList;
2524 SplitStr(args, " ", argList);
2525 if (argList.empty()) {
2526 return;
2527 }
2528
2529 if (argList.size() == MIN_DUMP_ARGUMENT_NUM) {
2530 targetManager->DumpByRecordId(info, argList[1]);
2531 } else if (argList.size() < MIN_DUMP_ARGUMENT_NUM) {
2532 targetManager->Dump(info);
2533 } else {
2534 info.emplace_back("error: invalid argument, please see 'hidumper -s AbilityManagerService -a '-h''.");
2535 }
2536 }
2537
DumpSysProcess(const std::string & args,std::vector<std::string> & info,bool isClient,bool isUserID,int userId)2538 void AbilityManagerService::DumpSysProcess(
2539 const std::string& args, std::vector<std::string>& info, bool isClient, bool isUserID, int userId)
2540 {
2541 std::vector<std::string> argList;
2542 SplitStr(args, " ", argList);
2543 if (argList.empty()) {
2544 return;
2545 }
2546 std::vector<AppExecFwk::RunningProcessInfo> ProcessInfos;
2547 int ret = 0;
2548 if (isUserID) {
2549 ret = GetProcessRunningInfosByUserId(ProcessInfos, userId);
2550 } else {
2551 ret = GetProcessRunningInfos(ProcessInfos);
2552 }
2553
2554 if (ret != ERR_OK || ProcessInfos.size() == 0) {
2555 return;
2556 }
2557
2558 std::string dumpInfo = " AppRunningRecords:";
2559 info.push_back(dumpInfo);
2560 auto processInfoID = 0;
2561 auto hasProcessName = (argList.size() == MIN_DUMP_ARGUMENT_NUM ? true : false);
2562 for (const auto& ProcessInfo : ProcessInfos) {
2563 if (hasProcessName && argList[1] != ProcessInfo.processName_) {
2564 continue;
2565 }
2566
2567 dumpInfo = " AppRunningRecord ID #" + std::to_string(processInfoID);
2568 processInfoID++;
2569 info.push_back(dumpInfo);
2570 dumpInfo = " process name [" + ProcessInfo.processName_ + "]";
2571 info.push_back(dumpInfo);
2572 dumpInfo = " pid #" + std::to_string(ProcessInfo.pid_) +
2573 " uid #" + std::to_string(ProcessInfo.uid_);
2574 info.push_back(dumpInfo);
2575 auto appState = static_cast<AppState>(ProcessInfo.state_);
2576 dumpInfo = " state #" + DelayedSingleton<AppScheduler>::GetInstance()->ConvertAppState(appState);
2577 info.push_back(dumpInfo);
2578 }
2579 }
2580
DataDumpSysStateInner(const std::string & args,std::vector<std::string> & info,bool isClient,bool isUserID,int userId)2581 void AbilityManagerService::DataDumpSysStateInner(
2582 const std::string& args, std::vector<std::string>& info, bool isClient, bool isUserID, int userId)
2583 {
2584 std::shared_ptr<DataAbilityManager> targetManager;
2585 if (isUserID) {
2586 std::shared_lock<std::shared_mutex> lock(managersMutex_);
2587 auto it = dataAbilityManagers_.find(userId);
2588 if (it == dataAbilityManagers_.end()) {
2589 info.push_back("error: No user found.");
2590 return;
2591 }
2592 targetManager = it->second;
2593 } else {
2594 targetManager = dataAbilityManager_;
2595 }
2596
2597 CHECK_POINTER(targetManager);
2598
2599 std::vector<std::string> argList;
2600 SplitStr(args, " ", argList);
2601 if (argList.empty()) {
2602 return;
2603 }
2604 if (argList.size() == MIN_DUMP_ARGUMENT_NUM) {
2605 targetManager->DumpSysState(info, isClient, argList[1]);
2606 } else if (argList.size() < MIN_DUMP_ARGUMENT_NUM) {
2607 targetManager->DumpSysState(info, isClient);
2608 } else {
2609 info.emplace_back("error: invalid argument, please see 'hidumper -s AbilityManagerService -a '-h''.");
2610 }
2611 }
2612
DumpInner(const std::string & args,std::vector<std::string> & info)2613 void AbilityManagerService::DumpInner(const std::string &args, std::vector<std::string> &info)
2614 {
2615 if (currentMissionListManager_) {
2616 currentMissionListManager_->Dump(info);
2617 }
2618 }
2619
DumpMissionListInner(const std::string & args,std::vector<std::string> & info)2620 void AbilityManagerService::DumpMissionListInner(const std::string &args, std::vector<std::string> &info)
2621 {
2622 if (currentMissionListManager_) {
2623 currentMissionListManager_->DumpMissionList(info, false, "");
2624 }
2625 }
2626
DumpMissionInfosInner(const std::string & args,std::vector<std::string> & info)2627 void AbilityManagerService::DumpMissionInfosInner(const std::string &args, std::vector<std::string> &info)
2628 {
2629 if (currentMissionListManager_) {
2630 currentMissionListManager_->DumpMissionInfos(info);
2631 }
2632 }
2633
DumpMissionInner(const std::string & args,std::vector<std::string> & info)2634 void AbilityManagerService::DumpMissionInner(const std::string &args, std::vector<std::string> &info)
2635 {
2636 CHECK_POINTER_LOG(currentMissionListManager_, "Current mission manager not init.");
2637 std::vector<std::string> argList;
2638 SplitStr(args, " ", argList);
2639 if (argList.empty()) {
2640 return;
2641 }
2642 if (argList.size() < MIN_DUMP_ARGUMENT_NUM) {
2643 info.push_back("error: invalid argument, please see 'ability dump -h'.");
2644 return;
2645 }
2646 int missionId = DEFAULT_INVAL_VALUE;
2647 (void)StrToInt(argList[1], missionId);
2648 currentMissionListManager_->DumpMission(missionId, info);
2649 }
2650
DumpStateInner(const std::string & args,std::vector<std::string> & info)2651 void AbilityManagerService::DumpStateInner(const std::string &args, std::vector<std::string> &info)
2652 {
2653 CHECK_POINTER_LOG(connectManager_, "Current mission manager not init.");
2654 std::vector<std::string> argList;
2655 SplitStr(args, " ", argList);
2656 if (argList.empty()) {
2657 return;
2658 }
2659 if (argList.size() == MIN_DUMP_ARGUMENT_NUM) {
2660 connectManager_->DumpState(info, false, argList[1]);
2661 } else if (argList.size() < MIN_DUMP_ARGUMENT_NUM) {
2662 connectManager_->DumpState(info, false);
2663 } else {
2664 info.emplace_back("error: invalid argument, please see 'ability dump -h'.");
2665 }
2666 }
2667
DataDumpStateInner(const std::string & args,std::vector<std::string> & info)2668 void AbilityManagerService::DataDumpStateInner(const std::string &args, std::vector<std::string> &info)
2669 {
2670 std::vector<std::string> argList;
2671 SplitStr(args, " ", argList);
2672 if (argList.empty()) {
2673 return;
2674 }
2675 if (argList.size() == MIN_DUMP_ARGUMENT_NUM) {
2676 dataAbilityManager_->DumpState(info, argList[1]);
2677 } else if (argList.size() < MIN_DUMP_ARGUMENT_NUM) {
2678 dataAbilityManager_->DumpState(info);
2679 } else {
2680 info.emplace_back("error: invalid argument, please see 'ability dump -h'.");
2681 }
2682 }
2683
DumpState(const std::string & args,std::vector<std::string> & info)2684 void AbilityManagerService::DumpState(const std::string &args, std::vector<std::string> &info)
2685 {
2686 std::vector<std::string> argList;
2687 SplitStr(args, " ", argList);
2688 if (argList.empty()) {
2689 return;
2690 }
2691 auto it = dumpMap.find(argList[0]);
2692 if (it == dumpMap.end()) {
2693 return;
2694 }
2695 DumpKey key = it->second;
2696 auto itFunc = dumpFuncMap_.find(key);
2697 if (itFunc != dumpFuncMap_.end()) {
2698 auto dumpFunc = itFunc->second;
2699 if (dumpFunc != nullptr) {
2700 (this->*dumpFunc)(args, info);
2701 return;
2702 }
2703 }
2704 info.push_back("error: invalid argument, please see 'ability dump -h'.");
2705 }
2706
DumpSysState(const std::string & args,std::vector<std::string> & info,bool isClient,bool isUserID,int userId)2707 void AbilityManagerService::DumpSysState(
2708 const std::string& args, std::vector<std::string>& info, bool isClient, bool isUserID, int userId)
2709 {
2710 HILOG_DEBUG("%{public}s begin", __func__);
2711 std::vector<std::string> argList;
2712 SplitStr(args, " ", argList);
2713 if (argList.empty()) {
2714 return;
2715 }
2716 auto it = dumpsysMap.find(argList[0]);
2717 if (it == dumpsysMap.end()) {
2718 return;
2719 }
2720 DumpsysKey key = it->second;
2721 auto itFunc = dumpsysFuncMap_.find(key);
2722 if (itFunc != dumpsysFuncMap_.end()) {
2723 auto dumpsysFunc = itFunc->second;
2724 if (dumpsysFunc != nullptr) {
2725 (this->*dumpsysFunc)(args, info, isClient, isUserID, userId);
2726 return;
2727 }
2728 }
2729 info.push_back("error: invalid argument, please see 'ability dump -h'.");
2730 }
2731
AbilityTransitionDone(const sptr<IRemoteObject> & token,int state,const PacMap & saveData)2732 int AbilityManagerService::AbilityTransitionDone(const sptr<IRemoteObject> &token, int state, const PacMap &saveData)
2733 {
2734 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
2735 HILOG_INFO("Ability transition done come, state:%{public}d.", state);
2736 if (!VerificationAllToken(token)) {
2737 return ERR_INVALID_VALUE;
2738 }
2739 auto abilityRecord = Token::GetAbilityRecordByToken(token);
2740 CHECK_POINTER_AND_RETURN_LOG(abilityRecord, ERR_INVALID_VALUE, "Ability record is nullptr.");
2741 if (!JudgeSelfCalled(abilityRecord)) {
2742 return CHECK_PERMISSION_FAILED;
2743 }
2744
2745 auto abilityInfo = abilityRecord->GetAbilityInfo();
2746 HILOG_DEBUG("Ability transition done come, state:%{public}d, name:%{public}s", state, abilityInfo.name.c_str());
2747 auto type = abilityInfo.type;
2748 auto userId = abilityRecord->GetApplicationInfo().uid / BASE_USER_RANGE;
2749 // force timeout ability for test
2750 int targetState = AbilityRecord::ConvertLifeCycleToAbilityState(static_cast<AbilityLifeCycleState>(state));
2751 bool isTerminate = abilityRecord->IsAbilityState(AbilityState::TERMINATING) && targetState == AbilityState::INITIAL;
2752 std::string tempState = isTerminate ? AbilityRecord::ConvertAbilityState(AbilityState::TERMINATING) :
2753 AbilityRecord::ConvertAbilityState(static_cast<AbilityState>(targetState));
2754 if (IsNeedTimeoutForTest(abilityInfo.name, tempState)) {
2755 HILOG_WARN("force timeout ability for test, state:%{public}s, ability: %{public}s",
2756 tempState.c_str(),
2757 abilityInfo.name.c_str());
2758 return ERR_OK;
2759 }
2760 if (type == AppExecFwk::AbilityType::SERVICE || type == AppExecFwk::AbilityType::EXTENSION) {
2761 auto connectManager = GetConnectManagerByUserId(userId);
2762 if (!connectManager) {
2763 HILOG_ERROR("connectManager is nullptr. userId=%{public}d", userId);
2764 return ERR_INVALID_VALUE;
2765 }
2766 return connectManager->AbilityTransitionDone(token, state);
2767 }
2768 if (type == AppExecFwk::AbilityType::DATA) {
2769 auto dataAbilityManager = GetDataAbilityManagerByUserId(userId);
2770 if (!dataAbilityManager) {
2771 HILOG_ERROR("dataAbilityManager is Null. userId=%{public}d", userId);
2772 return ERR_INVALID_VALUE;
2773 }
2774 return dataAbilityManager->AbilityTransitionDone(token, state);
2775 }
2776 int32_t ownerMissionUserId = abilityRecord->GetOwnerMissionUserId();
2777 auto missionListManager = GetListManagerByUserId(ownerMissionUserId);
2778 if (!missionListManager) {
2779 HILOG_ERROR("missionListManager is Null. userId=%{public}d", ownerMissionUserId);
2780 return ERR_INVALID_VALUE;
2781 }
2782 return missionListManager->AbilityTransactionDone(token, state, saveData);
2783 }
2784
ScheduleConnectAbilityDone(const sptr<IRemoteObject> & token,const sptr<IRemoteObject> & remoteObject)2785 int AbilityManagerService::ScheduleConnectAbilityDone(
2786 const sptr<IRemoteObject> &token, const sptr<IRemoteObject> &remoteObject)
2787 {
2788 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
2789 HILOG_INFO("Schedule connect ability done.");
2790 if (!VerificationAllToken(token)) {
2791 return ERR_INVALID_VALUE;
2792 }
2793
2794 auto abilityRecord = Token::GetAbilityRecordByToken(token);
2795 CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE);
2796 if (!JudgeSelfCalled(abilityRecord)) {
2797 return CHECK_PERMISSION_FAILED;
2798 }
2799
2800 auto type = abilityRecord->GetAbilityInfo().type;
2801 if (type != AppExecFwk::AbilityType::SERVICE && type != AppExecFwk::AbilityType::EXTENSION) {
2802 HILOG_ERROR("Connect ability failed, target ability is not service.");
2803 return TARGET_ABILITY_NOT_SERVICE;
2804 }
2805 auto userId = abilityRecord->GetApplicationInfo().uid / BASE_USER_RANGE;
2806 auto connectManager = GetConnectManagerByUserId(userId);
2807 if (!connectManager) {
2808 HILOG_ERROR("connectManager is nullptr. userId=%{public}d", userId);
2809 return ERR_INVALID_VALUE;
2810 }
2811 return connectManager->ScheduleConnectAbilityDoneLocked(token, remoteObject);
2812 }
2813
ScheduleDisconnectAbilityDone(const sptr<IRemoteObject> & token)2814 int AbilityManagerService::ScheduleDisconnectAbilityDone(const sptr<IRemoteObject> &token)
2815 {
2816 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
2817 HILOG_INFO("Schedule disconnect ability done.");
2818 if (!VerificationAllToken(token)) {
2819 return ERR_INVALID_VALUE;
2820 }
2821
2822 auto abilityRecord = Token::GetAbilityRecordByToken(token);
2823 CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE);
2824 if (!JudgeSelfCalled(abilityRecord)) {
2825 return CHECK_PERMISSION_FAILED;
2826 }
2827
2828 auto type = abilityRecord->GetAbilityInfo().type;
2829 if (type != AppExecFwk::AbilityType::SERVICE && type != AppExecFwk::AbilityType::EXTENSION) {
2830 HILOG_ERROR("Connect ability failed, target ability is not service.");
2831 return TARGET_ABILITY_NOT_SERVICE;
2832 }
2833 auto userId = abilityRecord->GetApplicationInfo().uid / BASE_USER_RANGE;
2834 auto connectManager = GetConnectManagerByUserId(userId);
2835 if (!connectManager) {
2836 HILOG_ERROR("connectManager is nullptr. userId=%{public}d", userId);
2837 return ERR_INVALID_VALUE;
2838 }
2839 return connectManager->ScheduleDisconnectAbilityDoneLocked(token);
2840 }
2841
ScheduleCommandAbilityDone(const sptr<IRemoteObject> & token)2842 int AbilityManagerService::ScheduleCommandAbilityDone(const sptr<IRemoteObject> &token)
2843 {
2844 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
2845 HILOG_INFO("Schedule command ability done.");
2846 if (!VerificationAllToken(token)) {
2847 return ERR_INVALID_VALUE;
2848 }
2849
2850 auto abilityRecord = Token::GetAbilityRecordByToken(token);
2851 CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE);
2852 if (!JudgeSelfCalled(abilityRecord)) {
2853 return CHECK_PERMISSION_FAILED;
2854 }
2855 // force timeout ability for test
2856 if (IsNeedTimeoutForTest(abilityRecord->GetAbilityInfo().name, std::string("COMMAND"))) {
2857 HILOG_WARN("force timeout ability for test, state:COMMAND, ability: %{public}s",
2858 abilityRecord->GetAbilityInfo().name.c_str());
2859 return ERR_OK;
2860 }
2861 auto type = abilityRecord->GetAbilityInfo().type;
2862 if (type != AppExecFwk::AbilityType::SERVICE && type != AppExecFwk::AbilityType::EXTENSION) {
2863 HILOG_ERROR("Connect ability failed, target ability is not service.");
2864 return TARGET_ABILITY_NOT_SERVICE;
2865 }
2866 auto userId = abilityRecord->GetApplicationInfo().uid / BASE_USER_RANGE;
2867 auto connectManager = GetConnectManagerByUserId(userId);
2868 if (!connectManager) {
2869 HILOG_ERROR("connectManager is nullptr. userId=%{public}d", userId);
2870 return ERR_INVALID_VALUE;
2871 }
2872 return connectManager->ScheduleCommandAbilityDoneLocked(token);
2873 }
2874
OnAbilityRequestDone(const sptr<IRemoteObject> & token,const int32_t state)2875 void AbilityManagerService::OnAbilityRequestDone(const sptr<IRemoteObject> &token, const int32_t state)
2876 {
2877 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
2878 auto abilityRecord = Token::GetAbilityRecordByToken(token);
2879 CHECK_POINTER(abilityRecord);
2880 HILOG_INFO("On ability request done, name is %{public}s", abilityRecord->GetAbilityInfo().name.c_str());
2881 auto userId = abilityRecord->GetApplicationInfo().uid / BASE_USER_RANGE;
2882
2883 auto type = abilityRecord->GetAbilityInfo().type;
2884 switch (type) {
2885 case AppExecFwk::AbilityType::DATA: {
2886 auto dataAbilityManager = GetDataAbilityManagerByUserId(userId);
2887 if (!dataAbilityManager) {
2888 HILOG_ERROR("dataAbilityManager is Null. userId=%{public}d", userId);
2889 return;
2890 }
2891 dataAbilityManager->OnAbilityRequestDone(token, state);
2892 break;
2893 }
2894 default: {
2895 int32_t ownerMissionUserId = abilityRecord->GetOwnerMissionUserId();
2896 auto missionListManager = GetListManagerByUserId(ownerMissionUserId);
2897 if (!missionListManager) {
2898 HILOG_ERROR("missionListManager is Null. userId=%{public}d", ownerMissionUserId);
2899 return;
2900 }
2901 missionListManager->OnAbilityRequestDone(token, state);
2902 break;
2903 }
2904 }
2905 }
2906
OnAppStateChanged(const AppInfo & info)2907 void AbilityManagerService::OnAppStateChanged(const AppInfo &info)
2908 {
2909 HILOG_INFO("On app state changed.");
2910 CHECK_POINTER_LOG(connectManager_, "Connect manager not init.");
2911 CHECK_POINTER_LOG(currentMissionListManager_, "Current mission list manager not init.");
2912 connectManager_->OnAppStateChanged(info);
2913 currentMissionListManager_->OnAppStateChanged(info);
2914 dataAbilityManager_->OnAppStateChanged(info);
2915 }
2916
GetEventHandler()2917 std::shared_ptr<AbilityEventHandler> AbilityManagerService::GetEventHandler()
2918 {
2919 return handler_;
2920 }
2921
InitMissionListManager(int userId,bool switchUser)2922 void AbilityManagerService::InitMissionListManager(int userId, bool switchUser)
2923 {
2924 bool find = false;
2925 {
2926 std::shared_lock<std::shared_mutex> lock(managersMutex_);
2927 auto iterator = missionListManagers_.find(userId);
2928 find = (iterator != missionListManagers_.end());
2929 if (find) {
2930 if (switchUser) {
2931 DelayedSingleton<MissionInfoMgr>::GetInstance()->Init(userId);
2932 currentMissionListManager_ = iterator->second;
2933 }
2934 }
2935 }
2936 if (!find) {
2937 auto manager = std::make_shared<MissionListManager>(userId);
2938 manager->Init();
2939 std::unique_lock<std::shared_mutex> lock(managersMutex_);
2940 missionListManagers_.emplace(userId, manager);
2941 if (switchUser) {
2942 currentMissionListManager_ = manager;
2943 }
2944 }
2945 }
2946
2947 // multi user scene
GetUserId()2948 int AbilityManagerService::GetUserId()
2949 {
2950 if (userController_) {
2951 auto userId = userController_->GetCurrentUserId();
2952 HILOG_INFO("%{public}s, userId is %{public}d", __func__, userId);
2953 return userId;
2954 }
2955 return U0_USER_ID;
2956 }
2957
StartHighestPriorityAbility(int32_t userId,bool isBoot)2958 void AbilityManagerService::StartHighestPriorityAbility(int32_t userId, bool isBoot)
2959 {
2960 HILOG_DEBUG("%{public}s", __func__);
2961 auto bms = GetBundleManager();
2962 CHECK_POINTER(bms);
2963
2964 auto func = []() {
2965 auto client = ContainerManagerClient::GetInstance();
2966 if (client != nullptr) {
2967 client->NotifyBootComplete(0);
2968 HILOG_INFO("StartSystemApplication NotifyBootComplete");
2969 }
2970 };
2971 std::thread(func).detach();
2972
2973 /* Query the highest priority ability or extension ability, and start it. usually, it is OOBE or launcher */
2974 Want want;
2975 want.AddEntity(HIGHEST_PRIORITY_ABILITY_ENTITY);
2976 AppExecFwk::AbilityInfo abilityInfo;
2977 AppExecFwk::ExtensionAbilityInfo extensionAbilityInfo;
2978 int attemptNums = 0;
2979 while (!IN_PROCESS_CALL(bms->ImplicitQueryInfoByPriority(want,
2980 AppExecFwk::AbilityInfoFlag::GET_ABILITY_INFO_DEFAULT, userId,
2981 abilityInfo, extensionAbilityInfo))) {
2982 HILOG_INFO("Waiting query highest priority ability info completed.");
2983 ++attemptNums;
2984 if (!isBoot && attemptNums > SWITCH_ACCOUNT_TRY) {
2985 HILOG_ERROR("Query highest priority ability failed.");
2986 return;
2987 }
2988 AbilityRequest abilityRequest;
2989 ComponentRequest componentRequest = initComponentRequest();
2990 if (!IsComponentInterceptionStart(want, componentRequest, abilityRequest)) {
2991 return;
2992 }
2993 usleep(REPOLL_TIME_MICRO_SECONDS);
2994 }
2995
2996 if (abilityInfo.name.empty() && extensionAbilityInfo.name.empty()) {
2997 HILOG_ERROR("Query highest priority ability failed");
2998 return;
2999 }
3000
3001 Want abilityWant; // donot use 'want' here, because the entity of 'want' is not empty
3002 if (!abilityInfo.name.empty()) {
3003 /* highest priority ability */
3004 HILOG_INFO("Start the highest priority ability. bundleName: %{public}s, ability:%{public}s",
3005 abilityInfo.bundleName.c_str(), abilityInfo.name.c_str());
3006 abilityWant.SetElementName(abilityInfo.bundleName, abilityInfo.name);
3007 } else {
3008 /* highest priority extension ability */
3009 HILOG_INFO("Start the highest priority extension ability. bundleName: %{public}s, ability:%{public}s",
3010 extensionAbilityInfo.bundleName.c_str(), extensionAbilityInfo.name.c_str());
3011 abilityWant.SetElementName(extensionAbilityInfo.bundleName, extensionAbilityInfo.name);
3012 }
3013
3014 #ifdef SUPPORT_GRAPHICS
3015 abilityWant.SetParam(NEED_STARTINGWINDOW, false);
3016 // wait BOOT_ANIMATION_STARTED to start LAUNCHER
3017 WaitParameter(BOOTEVENT_BOOT_ANIMATION_STARTED.c_str(), "true", amsConfigResolver_->GetBootAnimationTimeoutTime());
3018 #endif
3019
3020 /* note: OOBE APP need disable itself, otherwise, it will be started when restart system everytime */
3021 (void)StartAbility(abilityWant, userId, DEFAULT_INVAL_VALUE);
3022 }
3023
GenerateAbilityRequest(const Want & want,int requestCode,AbilityRequest & request,const sptr<IRemoteObject> & callerToken,int32_t userId)3024 int AbilityManagerService::GenerateAbilityRequest(
3025 const Want &want, int requestCode, AbilityRequest &request, const sptr<IRemoteObject> &callerToken, int32_t userId)
3026 {
3027 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
3028 auto abilityRecord = Token::GetAbilityRecordByToken(callerToken);
3029 if (abilityRecord && abilityRecord->GetAppIndex() != 0 &&
3030 abilityRecord->GetApplicationInfo().bundleName == want.GetElement().GetBundleName()) {
3031 (const_cast<Want &>(want)).SetParam(DLP_INDEX, abilityRecord->GetAppIndex());
3032 }
3033 request.want = want;
3034 request.requestCode = requestCode;
3035 request.callerToken = callerToken;
3036 request.startSetting = nullptr;
3037
3038 sptr<IRemoteObject> abilityInfoCallback = want.GetRemoteObject(Want::PARAM_RESV_ABILITY_INFO_CALLBACK);
3039 if (abilityInfoCallback != nullptr) {
3040 auto isPerm = AAFwk::PermissionVerification::GetInstance()->IsGatewayCall();
3041 if (isPerm) {
3042 request.abilityInfoCallback = abilityInfoCallback;
3043 }
3044 }
3045
3046 auto bms = GetBundleManager();
3047 CHECK_POINTER_AND_RETURN(bms, GET_ABILITY_SERVICE_FAILED);
3048 #ifdef SUPPORT_GRAPHICS
3049 if (want.GetAction().compare(ACTION_CHOOSE) == 0) {
3050 return ShowPickerDialog(want, userId, callerToken);
3051 }
3052 #endif
3053 auto abilityInfoFlag = (AppExecFwk::AbilityInfoFlag::GET_ABILITY_INFO_WITH_APPLICATION |
3054 AppExecFwk::AbilityInfoFlag::GET_ABILITY_INFO_WITH_PERMISSION |
3055 AppExecFwk::AbilityInfoFlag::GET_ABILITY_INFO_WITH_METADATA);
3056 HILOG_DEBUG("QueryAbilityInfo from bms, userId is %{public}d.", userId);
3057 int32_t appIndex = want.GetIntParam(DLP_INDEX, 0);
3058 if (appIndex == 0) {
3059 IN_PROCESS_CALL_WITHOUT_RET(bms->QueryAbilityInfo(want, abilityInfoFlag, userId, request.abilityInfo));
3060 } else {
3061 IN_PROCESS_CALL_WITHOUT_RET(bms->GetSandboxAbilityInfo(want, appIndex,
3062 abilityInfoFlag, userId, request.abilityInfo));
3063 }
3064 if (request.abilityInfo.name.empty() || request.abilityInfo.bundleName.empty()) {
3065 // try to find extension
3066 std::vector<AppExecFwk::ExtensionAbilityInfo> extensionInfos;
3067 if (appIndex == 0) {
3068 IN_PROCESS_CALL_WITHOUT_RET(bms->QueryExtensionAbilityInfos(want, abilityInfoFlag,
3069 userId, extensionInfos));
3070 } else {
3071 IN_PROCESS_CALL_WITHOUT_RET(bms->GetSandboxExtAbilityInfos(want, appIndex,
3072 abilityInfoFlag, userId, extensionInfos));
3073 }
3074 if (extensionInfos.size() <= 0) {
3075 HILOG_ERROR("GenerateAbilityRequest error. Get extension info failed.");
3076 return RESOLVE_ABILITY_ERR;
3077 }
3078
3079 AppExecFwk::ExtensionAbilityInfo extensionInfo = extensionInfos.front();
3080 if (extensionInfo.bundleName.empty() || extensionInfo.name.empty()) {
3081 HILOG_ERROR("extensionInfo empty.");
3082 return RESOLVE_ABILITY_ERR;
3083 }
3084 HILOG_DEBUG("Extension ability info found, name=%{public}s.",
3085 extensionInfo.name.c_str());
3086 // For compatibility translates to AbilityInfo
3087 InitAbilityInfoFromExtension(extensionInfo, request.abilityInfo);
3088 }
3089 HILOG_DEBUG("QueryAbilityInfo success, ability name: %{public}s, is stage mode: %{public}d.",
3090 request.abilityInfo.name.c_str(), request.abilityInfo.isStageBasedModel);
3091 if (request.abilityInfo.type == AppExecFwk::AbilityType::SERVICE && request.abilityInfo.isStageBasedModel) {
3092 HILOG_INFO("Stage mode, abilityInfo SERVICE type reset EXTENSION.");
3093 request.abilityInfo.type = AppExecFwk::AbilityType::EXTENSION;
3094 }
3095
3096 if (request.abilityInfo.applicationInfo.name.empty() || request.abilityInfo.applicationInfo.bundleName.empty()) {
3097 HILOG_ERROR("Get app info failed.");
3098 return RESOLVE_APP_ERR;
3099 }
3100 request.appInfo = request.abilityInfo.applicationInfo;
3101 request.uid = request.appInfo.uid;
3102 HILOG_DEBUG("GenerateAbilityRequest end, app name: %{public}s, bundle name: %{public}s, uid: %{public}d.",
3103 request.appInfo.name.c_str(), request.appInfo.bundleName.c_str(), request.uid);
3104
3105 HILOG_INFO("GenerateAbilityRequest, moduleName: %{public}s.", request.abilityInfo.moduleName.c_str());
3106 request.want.SetModuleName(request.abilityInfo.moduleName);
3107
3108 if (want.GetBoolParam(Want::PARAM_RESV_START_RECENT, false) &&
3109 AAFwk::PermissionVerification::GetInstance()->VerifyMissionPermission()) {
3110 request.startRecent = true;
3111 }
3112
3113 return ERR_OK;
3114 }
3115
GenerateExtensionAbilityRequest(const Want & want,AbilityRequest & request,const sptr<IRemoteObject> & callerToken,int32_t userId)3116 int AbilityManagerService::GenerateExtensionAbilityRequest(
3117 const Want &want, AbilityRequest &request, const sptr<IRemoteObject> &callerToken, int32_t userId)
3118 {
3119 auto abilityRecord = Token::GetAbilityRecordByToken(callerToken);
3120 if (abilityRecord && abilityRecord->GetAppIndex() != 0 &&
3121 abilityRecord->GetApplicationInfo().bundleName == want.GetElement().GetBundleName()) {
3122 (const_cast<Want &>(want)).SetParam(DLP_INDEX, abilityRecord->GetAppIndex());
3123 }
3124 request.want = want;
3125 request.callerToken = callerToken;
3126 request.startSetting = nullptr;
3127
3128 auto bms = GetBundleManager();
3129 CHECK_POINTER_AND_RETURN(bms, GET_ABILITY_SERVICE_FAILED);
3130
3131 auto abilityInfoFlag = (AppExecFwk::AbilityInfoFlag::GET_ABILITY_INFO_WITH_APPLICATION |
3132 AppExecFwk::AbilityInfoFlag::GET_ABILITY_INFO_WITH_PERMISSION |
3133 AppExecFwk::AbilityInfoFlag::GET_ABILITY_INFO_WITH_METADATA);
3134 HILOG_DEBUG("QueryExtensionAbilityInfo from bms, userId is %{public}d.", userId);
3135 // try to find extension
3136 std::vector<AppExecFwk::ExtensionAbilityInfo> extensionInfos;
3137 int32_t appIndex = want.GetIntParam(DLP_INDEX, 0);
3138 if (appIndex == 0) {
3139 IN_PROCESS_CALL_WITHOUT_RET(bms->QueryExtensionAbilityInfos(want, abilityInfoFlag, userId, extensionInfos));
3140 } else {
3141 IN_PROCESS_CALL_WITHOUT_RET(bms->GetSandboxExtAbilityInfos(want, appIndex,
3142 abilityInfoFlag, userId, extensionInfos));
3143 }
3144 if (extensionInfos.size() <= 0) {
3145 HILOG_ERROR("GenerateAbilityRequest error. Get extension info failed.");
3146 return RESOLVE_ABILITY_ERR;
3147 }
3148
3149 AppExecFwk::ExtensionAbilityInfo extensionInfo = extensionInfos.front();
3150 if (extensionInfo.bundleName.empty() || extensionInfo.name.empty()) {
3151 HILOG_ERROR("extensionInfo empty.");
3152 return RESOLVE_ABILITY_ERR;
3153 }
3154 HILOG_DEBUG("Extension ability info found, name=%{public}s.",
3155 extensionInfo.name.c_str());
3156 // For compatibility translates to AbilityInfo
3157 InitAbilityInfoFromExtension(extensionInfo, request.abilityInfo);
3158
3159 HILOG_DEBUG("QueryAbilityInfo success, ability name: %{public}s, is stage mode: %{public}d.",
3160 request.abilityInfo.name.c_str(), request.abilityInfo.isStageBasedModel);
3161
3162 if (request.abilityInfo.applicationInfo.name.empty() || request.abilityInfo.applicationInfo.bundleName.empty()) {
3163 HILOG_ERROR("Get app info failed.");
3164 return RESOLVE_APP_ERR;
3165 }
3166 request.appInfo = request.abilityInfo.applicationInfo;
3167 request.uid = request.appInfo.uid;
3168 HILOG_DEBUG("GenerateAbilityRequest end, app name: %{public}s, bundle name: %{public}s, uid: %{public}d.",
3169 request.appInfo.name.c_str(), request.appInfo.bundleName.c_str(), request.uid);
3170
3171 HILOG_INFO("GenerateExtensionAbilityRequest, moduleName: %{public}s.", request.abilityInfo.moduleName.c_str());
3172 request.want.SetModuleName(request.abilityInfo.moduleName);
3173
3174 return ERR_OK;
3175 }
3176
TerminateAbilityResult(const sptr<IRemoteObject> & token,int startId)3177 int AbilityManagerService::TerminateAbilityResult(const sptr<IRemoteObject> &token, int startId)
3178 {
3179 HILOG_INFO("Terminate ability result, startId: %{public}d", startId);
3180 if (!VerificationAllToken(token)) {
3181 return ERR_INVALID_VALUE;
3182 }
3183
3184 auto abilityRecord = Token::GetAbilityRecordByToken(token);
3185 CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE);
3186 if (!JudgeSelfCalled(abilityRecord)) {
3187 return CHECK_PERMISSION_FAILED;
3188 }
3189 int result = JudgeAbilityVisibleControl(abilityRecord->GetAbilityInfo());
3190 if (result != ERR_OK) {
3191 HILOG_ERROR("%{public}s JudgeAbilityVisibleControl error.", __func__);
3192 return result;
3193 }
3194
3195 auto userId = abilityRecord->GetApplicationInfo().uid / BASE_USER_RANGE;
3196 auto type = abilityRecord->GetAbilityInfo().type;
3197 if (type != AppExecFwk::AbilityType::SERVICE && type != AppExecFwk::AbilityType::EXTENSION) {
3198 HILOG_ERROR("target ability is not service.");
3199 return TARGET_ABILITY_NOT_SERVICE;
3200 }
3201
3202 auto connectManager = GetConnectManagerByUserId(userId);
3203 if (!connectManager) {
3204 HILOG_ERROR("connectManager is nullptr. userId=%{public}d", userId);
3205 return ERR_INVALID_VALUE;
3206 }
3207 return connectManager->TerminateAbilityResult(token, startId);
3208 }
3209
StopServiceAbility(const Want & want,int32_t userId)3210 int AbilityManagerService::StopServiceAbility(const Want &want, int32_t userId)
3211 {
3212 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
3213 HILOG_DEBUG("Stop service ability.");
3214 int32_t validUserId = GetValidUserId(userId);
3215 if (!JudgeMultiUserConcurrency(validUserId)) {
3216 HILOG_ERROR("Multi-user non-concurrent mode is not satisfied.");
3217 return ERR_INVALID_VALUE;
3218 }
3219
3220 AbilityRequest abilityRequest;
3221 auto result = GenerateAbilityRequest(want, DEFAULT_INVAL_VALUE, abilityRequest, nullptr, validUserId);
3222 if (result != ERR_OK) {
3223 HILOG_ERROR("Generate ability request local error.");
3224 return result;
3225 }
3226
3227 auto abilityInfo = abilityRequest.abilityInfo;
3228 validUserId = abilityInfo.applicationInfo.singleton ? U0_USER_ID : validUserId;
3229 HILOG_DEBUG("validUserId : %{public}d, singleton is : %{public}d",
3230 validUserId, static_cast<int>(abilityInfo.applicationInfo.singleton));
3231
3232 auto type = abilityInfo.type;
3233 if (type != AppExecFwk::AbilityType::SERVICE && type != AppExecFwk::AbilityType::EXTENSION) {
3234 HILOG_ERROR("Target ability is not service type.");
3235 return TARGET_ABILITY_NOT_SERVICE;
3236 }
3237
3238 auto connectManager = GetConnectManagerByUserId(validUserId);
3239 if (connectManager == nullptr) {
3240 return ERR_INVALID_VALUE;
3241 }
3242
3243 return connectManager->StopServiceAbility(abilityRequest);
3244 }
3245
OnAbilityDied(std::shared_ptr<AbilityRecord> abilityRecord)3246 void AbilityManagerService::OnAbilityDied(std::shared_ptr<AbilityRecord> abilityRecord)
3247 {
3248 CHECK_POINTER(abilityRecord);
3249
3250 auto manager = GetListManagerByUserId(abilityRecord->GetOwnerMissionUserId());
3251 if (manager && abilityRecord->GetAbilityInfo().type == AbilityType::PAGE) {
3252 manager->OnAbilityDied(abilityRecord, GetUserId());
3253 return;
3254 }
3255
3256 auto connectManager = GetConnectManagerByToken(abilityRecord->GetToken());
3257 if (connectManager) {
3258 connectManager->OnAbilityDied(abilityRecord, GetUserId());
3259 return;
3260 }
3261
3262 auto dataAbilityManager = GetDataAbilityManagerByToken(abilityRecord->GetToken());
3263 if (dataAbilityManager) {
3264 dataAbilityManager->OnAbilityDied(abilityRecord);
3265 }
3266 }
3267
OnCallConnectDied(std::shared_ptr<CallRecord> callRecord)3268 void AbilityManagerService::OnCallConnectDied(std::shared_ptr<CallRecord> callRecord)
3269 {
3270 CHECK_POINTER(callRecord);
3271 if (currentMissionListManager_) {
3272 currentMissionListManager_->OnCallConnectDied(callRecord);
3273 }
3274 }
3275
GetMaxRestartNum(int & max,bool isRootLauncher)3276 void AbilityManagerService::GetMaxRestartNum(int &max, bool isRootLauncher)
3277 {
3278 if (amsConfigResolver_) {
3279 max = amsConfigResolver_->GetMaxRestartNum(isRootLauncher);
3280 }
3281 }
3282
GetRestartIntervalTime(int & restartIntervalTime)3283 void AbilityManagerService::GetRestartIntervalTime(int &restartIntervalTime)
3284 {
3285 if (amsConfigResolver_) {
3286 restartIntervalTime = amsConfigResolver_->GetRestartIntervalTime();
3287 }
3288 }
3289
KillProcess(const std::string & bundleName)3290 int AbilityManagerService::KillProcess(const std::string &bundleName)
3291 {
3292 HILOG_DEBUG("Kill process, bundleName: %{public}s", bundleName.c_str());
3293 auto bms = GetBundleManager();
3294 CHECK_POINTER_AND_RETURN(bms, KILL_PROCESS_FAILED);
3295 int32_t userId = GetUserId();
3296 AppExecFwk::BundleInfo bundleInfo;
3297 if (!IN_PROCESS_CALL(
3298 bms->GetBundleInfo(bundleName, AppExecFwk::BundleFlag::GET_BUNDLE_DEFAULT, bundleInfo, userId))) {
3299 HILOG_ERROR("Failed to get bundle info when kill process.");
3300 return GET_BUNDLE_INFO_FAILED;
3301 }
3302
3303 if (bundleInfo.isKeepAlive) {
3304 HILOG_ERROR("Can not kill keep alive process.");
3305 return KILL_PROCESS_KEEP_ALIVE;
3306 }
3307
3308 int ret = DelayedSingleton<AppScheduler>::GetInstance()->KillApplication(bundleName);
3309 if (ret != ERR_OK) {
3310 return KILL_PROCESS_FAILED;
3311 }
3312 return ERR_OK;
3313 }
3314
ClearUpApplicationData(const std::string & bundleName)3315 int AbilityManagerService::ClearUpApplicationData(const std::string &bundleName)
3316 {
3317 HILOG_DEBUG("ClearUpApplicationData, bundleName: %{public}s", bundleName.c_str());
3318 int ret = DelayedSingleton<AppScheduler>::GetInstance()->ClearUpApplicationData(bundleName);
3319 if (ret != ERR_OK) {
3320 return CLEAR_APPLICATION_DATA_FAIL;
3321 }
3322 return ERR_OK;
3323 }
3324
UninstallApp(const std::string & bundleName,int32_t uid)3325 int AbilityManagerService::UninstallApp(const std::string &bundleName, int32_t uid)
3326 {
3327 HILOG_DEBUG("Uninstall app, bundleName: %{public}s, uid=%{public}d", bundleName.c_str(), uid);
3328 pid_t callingPid = IPCSkeleton::GetCallingPid();
3329 pid_t pid = getpid();
3330 if (callingPid != pid) {
3331 HILOG_ERROR("%{public}s: Not bundleMgr call.", __func__);
3332 return CHECK_PERMISSION_FAILED;
3333 }
3334
3335 int32_t targetUserId = uid / BASE_USER_RANGE;
3336 if (targetUserId == U0_USER_ID) {
3337 std::shared_lock<std::shared_mutex> lock(managersMutex_);
3338 for (auto item: missionListManagers_) {
3339 if (item.second) {
3340 item.second->UninstallApp(bundleName, uid);
3341 }
3342 }
3343 } else {
3344 auto listManager = GetListManagerByUserId(targetUserId);
3345 if (listManager) {
3346 listManager->UninstallApp(bundleName, uid);
3347 }
3348 }
3349
3350 if (pendingWantManager_) {
3351 pendingWantManager_->ClearPendingWantRecord(bundleName, uid);
3352 }
3353 int ret = DelayedSingleton<AppScheduler>::GetInstance()->KillApplicationByUid(bundleName, uid);
3354 if (ret != ERR_OK) {
3355 return UNINSTALL_APP_FAILED;
3356 }
3357 return ERR_OK;
3358 }
3359
GetBundleManager()3360 sptr<AppExecFwk::IBundleMgr> AbilityManagerService::GetBundleManager()
3361 {
3362 if (iBundleManager_ == nullptr) {
3363 auto bundleObj =
3364 OHOS::DelayedSingleton<SaMgrClient>::GetInstance()->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
3365 if (bundleObj == nullptr) {
3366 HILOG_ERROR("Failed to get bundle manager service.");
3367 return nullptr;
3368 }
3369 iBundleManager_ = iface_cast<AppExecFwk::IBundleMgr>(bundleObj);
3370 }
3371 return iBundleManager_;
3372 }
3373
PreLoadAppDataAbilities(const std::string & bundleName,const int32_t userId)3374 int AbilityManagerService::PreLoadAppDataAbilities(const std::string &bundleName, const int32_t userId)
3375 {
3376 if (bundleName.empty()) {
3377 HILOG_ERROR("Invalid bundle name when app data abilities preloading.");
3378 return ERR_INVALID_VALUE;
3379 }
3380
3381 auto dataAbilityManager = GetDataAbilityManagerByUserId(userId);
3382 if (dataAbilityManager == nullptr) {
3383 HILOG_ERROR("Invalid data ability manager when app data abilities preloading.");
3384 return ERR_INVALID_STATE;
3385 }
3386
3387 auto bms = GetBundleManager();
3388 CHECK_POINTER_AND_RETURN(bms, GET_ABILITY_SERVICE_FAILED);
3389
3390 AppExecFwk::BundleInfo bundleInfo;
3391 bool ret = IN_PROCESS_CALL(
3392 bms->GetBundleInfo(bundleName, AppExecFwk::BundleFlag::GET_BUNDLE_WITH_ABILITIES, bundleInfo, userId));
3393 if (!ret) {
3394 HILOG_ERROR("Failed to get bundle info when app data abilities preloading, userId is %{public}d", userId);
3395 return RESOLVE_APP_ERR;
3396 }
3397
3398 HILOG_INFO("App data abilities preloading for bundle '%{public}s'...", bundleName.data());
3399
3400 auto begin = system_clock::now();
3401 AbilityRequest dataAbilityRequest;
3402 dataAbilityRequest.appInfo = bundleInfo.applicationInfo;
3403 for (auto it = bundleInfo.abilityInfos.begin(); it != bundleInfo.abilityInfos.end(); ++it) {
3404 if (it->type != AppExecFwk::AbilityType::DATA) {
3405 continue;
3406 }
3407 if ((system_clock::now() - begin) >= DATA_ABILITY_START_TIMEOUT) {
3408 HILOG_ERROR("App data ability preloading for '%{public}s' timeout.", bundleName.c_str());
3409 return ERR_TIMED_OUT;
3410 }
3411 dataAbilityRequest.abilityInfo = *it;
3412 dataAbilityRequest.uid = bundleInfo.uid;
3413 HILOG_INFO("App data ability preloading: '%{public}s.%{public}s'...",
3414 it->bundleName.c_str(), it->name.c_str());
3415
3416 auto dataAbility = dataAbilityManager->Acquire(dataAbilityRequest, false, nullptr, false);
3417 if (dataAbility == nullptr) {
3418 HILOG_ERROR(
3419 "Failed to preload data ability '%{public}s.%{public}s'.", it->bundleName.c_str(), it->name.c_str());
3420 return ERR_NULL_OBJECT;
3421 }
3422 }
3423
3424 HILOG_INFO("App data abilities preloading done.");
3425
3426 return ERR_OK;
3427 }
3428
IsSystemUiApp(const AppExecFwk::AbilityInfo & info) const3429 bool AbilityManagerService::IsSystemUiApp(const AppExecFwk::AbilityInfo &info) const
3430 {
3431 if (info.bundleName != AbilityConfig::SYSTEM_UI_BUNDLE_NAME) {
3432 return false;
3433 }
3434 return (info.name == AbilityConfig::SYSTEM_UI_NAVIGATION_BAR ||
3435 info.name == AbilityConfig::SYSTEM_UI_STATUS_BAR ||
3436 info.name == AbilityConfig::SYSTEM_UI_ABILITY_NAME);
3437 }
3438
IsSystemUI(const std::string & bundleName) const3439 bool AbilityManagerService::IsSystemUI(const std::string &bundleName) const
3440 {
3441 return bundleName == AbilityConfig::SYSTEM_UI_BUNDLE_NAME;
3442 }
3443
HandleLoadTimeOut(int64_t eventId)3444 void AbilityManagerService::HandleLoadTimeOut(int64_t eventId)
3445 {
3446 HILOG_DEBUG("Handle load timeout.");
3447 std::shared_lock<std::shared_mutex> lock(managersMutex_);
3448 for (auto& item : missionListManagers_) {
3449 if (item.second) {
3450 item.second->OnTimeOut(AbilityManagerService::LOAD_TIMEOUT_MSG, eventId);
3451 }
3452 }
3453 }
3454
HandleActiveTimeOut(int64_t eventId)3455 void AbilityManagerService::HandleActiveTimeOut(int64_t eventId)
3456 {
3457 HILOG_DEBUG("Handle active timeout.");
3458 std::shared_lock<std::shared_mutex> lock(managersMutex_);
3459 for (auto& item : missionListManagers_) {
3460 if (item.second) {
3461 item.second->OnTimeOut(AbilityManagerService::ACTIVE_TIMEOUT_MSG, eventId);
3462 }
3463 }
3464 }
3465
HandleInactiveTimeOut(int64_t eventId)3466 void AbilityManagerService::HandleInactiveTimeOut(int64_t eventId)
3467 {
3468 HILOG_DEBUG("Handle inactive timeout.");
3469 std::shared_lock<std::shared_mutex> lock(managersMutex_);
3470 for (auto& item : missionListManagers_) {
3471 if (item.second) {
3472 item.second->OnTimeOut(AbilityManagerService::INACTIVE_TIMEOUT_MSG, eventId);
3473 }
3474 }
3475
3476 for (auto& item : connectManagers_) {
3477 if (item.second) {
3478 item.second->OnTimeOut(AbilityManagerService::INACTIVE_TIMEOUT_MSG, eventId);
3479 }
3480 }
3481 }
3482
HandleForegroundTimeOut(int64_t eventId)3483 void AbilityManagerService::HandleForegroundTimeOut(int64_t eventId)
3484 {
3485 HILOG_DEBUG("Handle foreground timeout.");
3486 std::shared_lock<std::shared_mutex> lock(managersMutex_);
3487 for (auto& item : missionListManagers_) {
3488 if (item.second) {
3489 item.second->OnTimeOut(AbilityManagerService::FOREGROUND_TIMEOUT_MSG, eventId);
3490 }
3491 }
3492 }
3493
HandleBackgroundTimeOut(int64_t eventId)3494 void AbilityManagerService::HandleBackgroundTimeOut(int64_t eventId)
3495 {
3496 HILOG_DEBUG("Handle background timeout.");
3497 std::shared_lock<std::shared_mutex> lock(managersMutex_);
3498 for (auto& item : missionListManagers_) {
3499 if (item.second) {
3500 item.second->OnTimeOut(AbilityManagerService::BACKGROUND_TIMEOUT_MSG, eventId);
3501 }
3502 }
3503 }
3504
VerificationToken(const sptr<IRemoteObject> & token)3505 bool AbilityManagerService::VerificationToken(const sptr<IRemoteObject> &token)
3506 {
3507 HILOG_INFO("Verification token.");
3508 CHECK_POINTER_RETURN_BOOL(dataAbilityManager_);
3509 CHECK_POINTER_RETURN_BOOL(connectManager_);
3510 CHECK_POINTER_RETURN_BOOL(currentMissionListManager_);
3511
3512 if (currentMissionListManager_->GetAbilityRecordByToken(token)) {
3513 return true;
3514 }
3515 if (currentMissionListManager_->GetAbilityFromTerminateList(token)) {
3516 return true;
3517 }
3518
3519 if (dataAbilityManager_->GetAbilityRecordByToken(token)) {
3520 HILOG_INFO("Verification token4.");
3521 return true;
3522 }
3523
3524 if (connectManager_->GetExtensionByTokenFromSeriveMap(token)) {
3525 HILOG_INFO("Verification token5.");
3526 return true;
3527 }
3528
3529 if (connectManager_->GetExtensionByTokenFromTerminatingMap(token)) {
3530 HILOG_INFO("Verification token5.");
3531 return true;
3532 }
3533
3534 HILOG_ERROR("Failed to verify token.");
3535 return false;
3536 }
3537
VerificationAllToken(const sptr<IRemoteObject> & token)3538 bool AbilityManagerService::VerificationAllToken(const sptr<IRemoteObject> &token)
3539 {
3540 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
3541 HILOG_INFO("VerificationAllToken.");
3542 std::shared_lock<std::shared_mutex> lock(managersMutex_);
3543 {
3544 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, "VerificationAllToken::SearchMissionListManagers");
3545 for (auto item: missionListManagers_) {
3546 if (item.second && item.second->GetAbilityRecordByToken(token)) {
3547 return true;
3548 }
3549
3550 if (item.second && item.second->GetAbilityFromTerminateList(token)) {
3551 return true;
3552 }
3553 }
3554 }
3555
3556 {
3557 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, "VerificationAllToken::SearchDataAbilityManagers_");
3558 for (auto item: dataAbilityManagers_) {
3559 if (item.second && item.second->GetAbilityRecordByToken(token)) {
3560 return true;
3561 }
3562 }
3563 }
3564
3565 {
3566 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, "VerificationAllToken::SearchConnectManagers_");
3567 for (auto item: connectManagers_) {
3568 if (item.second && item.second->GetExtensionByTokenFromSeriveMap(token)) {
3569 return true;
3570 }
3571 if (item.second && item.second->GetExtensionByTokenFromTerminatingMap(token)) {
3572 return true;
3573 }
3574 }
3575 }
3576 HILOG_ERROR("Failed to verify all token.");
3577 return false;
3578 }
3579
GetDataAbilityManager(const sptr<IAbilityScheduler> & scheduler)3580 std::shared_ptr<DataAbilityManager> AbilityManagerService::GetDataAbilityManager(
3581 const sptr<IAbilityScheduler> &scheduler)
3582 {
3583 if (scheduler == nullptr) {
3584 HILOG_ERROR("the param ability scheduler is nullptr");
3585 return nullptr;
3586 }
3587
3588 std::shared_lock<std::shared_mutex> lock(managersMutex_);
3589 for (auto& item: dataAbilityManagers_) {
3590 if (item.second && item.second->ContainsDataAbility(scheduler)) {
3591 return item.second;
3592 }
3593 }
3594
3595 return nullptr;
3596 }
3597
GetListManagerByUserId(int32_t userId)3598 std::shared_ptr<MissionListManager> AbilityManagerService::GetListManagerByUserId(int32_t userId)
3599 {
3600 std::shared_lock<std::shared_mutex> lock(managersMutex_);
3601 auto it = missionListManagers_.find(userId);
3602 if (it != missionListManagers_.end()) {
3603 return it->second;
3604 }
3605 HILOG_ERROR("%{public}s, Failed to get Manager. UserId = %{public}d", __func__, userId);
3606 return nullptr;
3607 }
3608
GetConnectManagerByUserId(int32_t userId)3609 std::shared_ptr<AbilityConnectManager> AbilityManagerService::GetConnectManagerByUserId(int32_t userId)
3610 {
3611 std::shared_lock<std::shared_mutex> lock(managersMutex_);
3612 auto it = connectManagers_.find(userId);
3613 if (it != connectManagers_.end()) {
3614 return it->second;
3615 }
3616 HILOG_ERROR("%{public}s, Failed to get Manager. UserId = %{public}d", __func__, userId);
3617 return nullptr;
3618 }
3619
GetDataAbilityManagerByUserId(int32_t userId)3620 std::shared_ptr<DataAbilityManager> AbilityManagerService::GetDataAbilityManagerByUserId(int32_t userId)
3621 {
3622 std::shared_lock<std::shared_mutex> lock(managersMutex_);
3623 auto it = dataAbilityManagers_.find(userId);
3624 if (it != dataAbilityManagers_.end()) {
3625 return it->second;
3626 }
3627 HILOG_ERROR("%{public}s, Failed to get Manager. UserId = %{public}d", __func__, userId);
3628 return nullptr;
3629 }
3630
GetConnectManagerByToken(const sptr<IRemoteObject> & token)3631 std::shared_ptr<AbilityConnectManager> AbilityManagerService::GetConnectManagerByToken(
3632 const sptr<IRemoteObject> &token)
3633 {
3634 std::shared_lock<std::shared_mutex> lock(managersMutex_);
3635 for (auto item: connectManagers_) {
3636 if (item.second && item.second->GetExtensionByTokenFromSeriveMap(token)) {
3637 return item.second;
3638 }
3639 if (item.second && item.second->GetExtensionByTokenFromTerminatingMap(token)) {
3640 return item.second;
3641 }
3642 }
3643
3644 return nullptr;
3645 }
3646
GetDataAbilityManagerByToken(const sptr<IRemoteObject> & token)3647 std::shared_ptr<DataAbilityManager> AbilityManagerService::GetDataAbilityManagerByToken(
3648 const sptr<IRemoteObject> &token)
3649 {
3650 std::shared_lock<std::shared_mutex> lock(managersMutex_);
3651 for (auto item: dataAbilityManagers_) {
3652 if (item.second && item.second->GetAbilityRecordByToken(token)) {
3653 return item.second;
3654 }
3655 }
3656
3657 return nullptr;
3658 }
3659
StartResidentApps()3660 void AbilityManagerService::StartResidentApps()
3661 {
3662 HILOG_DEBUG("%{public}s", __func__);
3663 ConnectBmsService();
3664 auto bms = GetBundleManager();
3665 CHECK_POINTER_IS_NULLPTR(bms);
3666 std::vector<AppExecFwk::BundleInfo> bundleInfos;
3667 if (!IN_PROCESS_CALL(
3668 bms->GetBundleInfos(OHOS::AppExecFwk::GET_BUNDLE_DEFAULT, bundleInfos, U0_USER_ID))) {
3669 HILOG_ERROR("Get resident bundleinfos failed");
3670 return;
3671 }
3672
3673 HILOG_INFO("StartResidentApps GetBundleInfos size: %{public}zu", bundleInfos.size());
3674
3675 DelayedSingleton<ResidentProcessManager>::GetInstance()->StartResidentProcessWithMainElement(bundleInfos);
3676 if (!bundleInfos.empty()) {
3677 #ifdef SUPPORT_GRAPHICS
3678 WaitParameter(BOOTEVENT_BOOT_ANIMATION_STARTED.c_str(), "true", amsConfigResolver_->GetBootAnimationTimeoutTime());
3679 #endif
3680 DelayedSingleton<ResidentProcessManager>::GetInstance()->StartResidentProcess(bundleInfos);
3681 }
3682 }
3683
ConnectBmsService()3684 void AbilityManagerService::ConnectBmsService()
3685 {
3686 HILOG_DEBUG("%{public}s", __func__);
3687 HILOG_INFO("Waiting AppMgr Service run completed.");
3688 while (!DelayedSingleton<AppScheduler>::GetInstance()->Init(shared_from_this())) {
3689 HILOG_ERROR("failed to init AppScheduler");
3690 usleep(REPOLL_TIME_MICRO_SECONDS);
3691 }
3692
3693 HILOG_INFO("Waiting BundleMgr Service run completed.");
3694 /* wait until connected to bundle manager service */
3695 while (iBundleManager_ == nullptr) {
3696 sptr<IRemoteObject> bundle_obj =
3697 OHOS::DelayedSingleton<SaMgrClient>::GetInstance()->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
3698 if (bundle_obj == nullptr) {
3699 HILOG_ERROR("failed to get bundle manager service");
3700 usleep(REPOLL_TIME_MICRO_SECONDS);
3701 continue;
3702 }
3703 iBundleManager_ = iface_cast<AppExecFwk::IBundleMgr>(bundle_obj);
3704 }
3705
3706 HILOG_INFO("Connect bms success!");
3707 }
3708
GetWantSenderInfo(const sptr<IWantSender> & target,std::shared_ptr<WantSenderInfo> & info)3709 int AbilityManagerService::GetWantSenderInfo(const sptr<IWantSender> &target, std::shared_ptr<WantSenderInfo> &info)
3710 {
3711 HILOG_INFO("Get pending request info.");
3712 CHECK_POINTER_AND_RETURN(pendingWantManager_, ERR_INVALID_VALUE);
3713 CHECK_POINTER_AND_RETURN(target, ERR_INVALID_VALUE);
3714 CHECK_POINTER_AND_RETURN(info, ERR_INVALID_VALUE);
3715 return pendingWantManager_->GetWantSenderInfo(target, info);
3716 }
3717
GetAppMemorySize()3718 int AbilityManagerService::GetAppMemorySize()
3719 {
3720 HILOG_INFO("service GetAppMemorySize start");
3721 const char *key = "const.product.arkheaplimit";
3722 const char *def = "512m";
3723 char *valueGet = nullptr;
3724 unsigned int len = 128;
3725 int ret = GetParameter(key, def, valueGet, len);
3726 int resultInt = 0;
3727 if ((ret != GET_PARAMETER_OTHER) && (ret != GET_PARAMETER_INCORRECT)) {
3728 if (valueGet == nullptr) {
3729 HILOG_WARN("%{public}s, valueGet is nullptr", __func__);
3730 return APP_MEMORY_SIZE;
3731 }
3732 int len = strlen(valueGet);
3733 for (int i = 0; i < len; i++) {
3734 if (valueGet[i] >= '0' && valueGet[i] <= '9') {
3735 resultInt *= SIZE_10;
3736 resultInt += valueGet[i] - '0';
3737 }
3738 }
3739 if (resultInt == 0) {
3740 return APP_MEMORY_SIZE;
3741 }
3742 return resultInt;
3743 }
3744 return APP_MEMORY_SIZE;
3745 }
3746
IsRamConstrainedDevice()3747 bool AbilityManagerService::IsRamConstrainedDevice()
3748 {
3749 HILOG_INFO("service IsRamConstrainedDevice start");
3750 const char *key = "const.product.islowram";
3751 const char *def = "0";
3752 char *valueGet = nullptr;
3753 unsigned int len = 128;
3754 int ret = GetParameter(key, def, valueGet, len);
3755 if ((ret != GET_PARAMETER_OTHER) && (ret != GET_PARAMETER_INCORRECT)) {
3756 int value = atoi(valueGet);
3757 if (value) {
3758 return true;
3759 }
3760 return false;
3761 }
3762 return false;
3763 }
3764
GetMissionSaveTime() const3765 int AbilityManagerService::GetMissionSaveTime() const
3766 {
3767 if (!amsConfigResolver_) {
3768 return 0;
3769 }
3770
3771 return amsConfigResolver_->GetMissionSaveTime();
3772 }
3773
GetMissionIdByAbilityToken(const sptr<IRemoteObject> & token)3774 int32_t AbilityManagerService::GetMissionIdByAbilityToken(const sptr<IRemoteObject> &token)
3775 {
3776 auto abilityRecord = Token::GetAbilityRecordByToken(token);
3777 if (!abilityRecord) {
3778 HILOG_ERROR("abilityRecord is Null.");
3779 return -1;
3780 }
3781
3782 if (!JudgeSelfCalled(abilityRecord) && (IPCSkeleton::GetCallingPid() != getpid())) {
3783 return -1;
3784 }
3785 auto userId = abilityRecord->GetOwnerMissionUserId();
3786 auto missionListManager = GetListManagerByUserId(userId);
3787 if (!missionListManager) {
3788 HILOG_ERROR("missionListManager is Null. owner mission userId=%{public}d", userId);
3789 return -1;
3790 }
3791 return missionListManager->GetMissionIdByAbilityToken(token);
3792 }
3793
GetAbilityTokenByMissionId(int32_t missionId)3794 sptr<IRemoteObject> AbilityManagerService::GetAbilityTokenByMissionId(int32_t missionId)
3795 {
3796 if (!currentMissionListManager_) {
3797 return nullptr;
3798 }
3799 return currentMissionListManager_->GetAbilityTokenByMissionId(missionId);
3800 }
3801
StartRemoteAbilityByCall(const Want & want,const sptr<IRemoteObject> & callerToken,const sptr<IRemoteObject> & connect)3802 int AbilityManagerService::StartRemoteAbilityByCall(const Want &want, const sptr<IRemoteObject> &callerToken,
3803 const sptr<IRemoteObject> &connect)
3804 {
3805 HILOG_INFO("%{public}s begin StartRemoteAbilityByCall", __func__);
3806 Want remoteWant = want;
3807 if (AddStartControlParam(remoteWant, callerToken) != ERR_OK) {
3808 HILOG_ERROR("%{public}s AddStartControlParam failed.", __func__);
3809 return ERR_INVALID_VALUE;
3810 }
3811 DistributedClient dmsClient;
3812 return dmsClient.StartRemoteAbilityByCall(remoteWant, connect);
3813 }
3814
ReleaseRemoteAbility(const sptr<IRemoteObject> & connect,const AppExecFwk::ElementName & element)3815 int AbilityManagerService::ReleaseRemoteAbility(const sptr<IRemoteObject> &connect,
3816 const AppExecFwk::ElementName &element)
3817 {
3818 DistributedClient dmsClient;
3819 return dmsClient.ReleaseRemoteAbility(connect, element);
3820 }
3821
StartAbilityByCall(const Want & want,const sptr<IAbilityConnection> & connect,const sptr<IRemoteObject> & callerToken)3822 int AbilityManagerService::StartAbilityByCall(
3823 const Want &want, const sptr<IAbilityConnection> &connect, const sptr<IRemoteObject> &callerToken)
3824 {
3825 HILOG_INFO("call ability.");
3826 CHECK_POINTER_AND_RETURN(connect, ERR_INVALID_VALUE);
3827 CHECK_POINTER_AND_RETURN(connect->AsObject(), ERR_INVALID_VALUE);
3828
3829 auto abilityRecord = Token::GetAbilityRecordByToken(callerToken);
3830 if (abilityRecord && !JudgeSelfCalled(abilityRecord)) {
3831 return CHECK_PERMISSION_FAILED;
3832 }
3833
3834 auto result = interceptorExecuter_ == nullptr ? ERR_INVALID_VALUE :
3835 interceptorExecuter_->DoProcess(want, 0, GetUserId(), false);
3836 if (result != ERR_OK) {
3837 HILOG_ERROR("interceptorExecuter_ is nullptr or DoProcess return error.");
3838 return result;
3839 }
3840
3841 if (CheckIfOperateRemote(want)) {
3842 HILOG_INFO("start remote ability by call");
3843 return StartRemoteAbilityByCall(want, callerToken, connect->AsObject());
3844 }
3845
3846 int32_t callerUserId = GetValidUserId(DEFAULT_INVAL_VALUE);
3847 if (!JudgeMultiUserConcurrency(callerUserId)) {
3848 HILOG_ERROR("Multi-user non-concurrent mode is not satisfied.");
3849 return ERR_INVALID_VALUE;
3850 }
3851
3852 AbilityRequest abilityRequest;
3853 abilityRequest.callType = AbilityCallType::CALL_REQUEST_TYPE;
3854 abilityRequest.callerUid = IPCSkeleton::GetCallingUid();
3855 abilityRequest.callerToken = callerToken;
3856 abilityRequest.startSetting = nullptr;
3857 abilityRequest.want = want;
3858 abilityRequest.connect = connect;
3859 result = GenerateAbilityRequest(want, -1, abilityRequest, callerToken, GetUserId());
3860 ComponentRequest componentRequest = initComponentRequest(callerToken, -1, result);
3861 if (!IsComponentInterceptionStart(want, componentRequest, abilityRequest)) {
3862 return componentRequest.requestResult;
3863 }
3864 if (result != ERR_OK) {
3865 HILOG_ERROR("Generate ability request error.");
3866 return result;
3867 }
3868
3869 if (!abilityRequest.abilityInfo.isStageBasedModel) {
3870 HILOG_ERROR("target ability is not stage base model.");
3871 return RESOLVE_CALL_ABILITY_VERSION_ERR;
3872 }
3873
3874 result = CheckStartByCallPermission(abilityRequest);
3875 if (result != ERR_OK) {
3876 HILOG_ERROR("CheckStartByCallPermission fail, result: %{public}d", result);
3877 return result;
3878 }
3879
3880 HILOG_DEBUG("abilityInfo.applicationInfo.singleton is %{public}s",
3881 abilityRequest.abilityInfo.applicationInfo.singleton ? "true" : "false");
3882
3883 if (!currentMissionListManager_) {
3884 HILOG_ERROR("currentMissionListManager_ is Null. curentUserId=%{public}d", GetUserId());
3885 return ERR_INVALID_VALUE;
3886 }
3887 UpdateCallerInfo(abilityRequest.want);
3888 ReportEventToSuspendManager(abilityRequest.abilityInfo);
3889 return currentMissionListManager_->ResolveLocked(abilityRequest);
3890 }
3891
ReleaseCall(const sptr<IAbilityConnection> & connect,const AppExecFwk::ElementName & element)3892 int AbilityManagerService::ReleaseCall(
3893 const sptr<IAbilityConnection> &connect, const AppExecFwk::ElementName &element)
3894 {
3895 HILOG_DEBUG("Release called ability.");
3896
3897 CHECK_POINTER_AND_RETURN(connect, ERR_INVALID_VALUE);
3898 CHECK_POINTER_AND_RETURN(connect->AsObject(), ERR_INVALID_VALUE);
3899 CHECK_POINTER_AND_RETURN(currentMissionListManager_, ERR_NO_INIT);
3900
3901 std::string elementName = element.GetURI();
3902 HILOG_DEBUG("try to release called ability, name: %{public}s.", elementName.c_str());
3903
3904 if (CheckIsRemote(element.GetDeviceID())) {
3905 HILOG_INFO("release remote ability");
3906 return ReleaseRemoteAbility(connect->AsObject(), element);
3907 }
3908
3909 return currentMissionListManager_->ReleaseCallLocked(connect, element);
3910 }
3911
JudgeAbilityVisibleControl(const AppExecFwk::AbilityInfo & abilityInfo,int callerUid)3912 int AbilityManagerService::JudgeAbilityVisibleControl(const AppExecFwk::AbilityInfo &abilityInfo, int callerUid)
3913 {
3914 HILOG_DEBUG("Judge ability visible begin.");
3915 if (!abilityInfo.visible) {
3916 HILOG_INFO("Ability visible is false.");
3917 if (callerUid == -1) {
3918 callerUid = IPCSkeleton::GetCallingUid();
3919 }
3920 if (!CheckCallerEligibility(abilityInfo, callerUid)) {
3921 HILOG_ERROR("called ability has no permission.");
3922 return ABILITY_VISIBLE_FALSE_DENY_REQUEST;
3923 }
3924 }
3925 HILOG_DEBUG("Judge ability visible success.");
3926 return ERR_OK;
3927 }
3928
CheckCallerEligibility(const AppExecFwk::AbilityInfo & abilityInfo,int callerUid)3929 bool AbilityManagerService::CheckCallerEligibility(const AppExecFwk::AbilityInfo &abilityInfo, int callerUid)
3930 {
3931 auto isSaCall = AAFwk::PermissionVerification::GetInstance()->IsSACall();
3932 if (!isSaCall) {
3933 auto bms = GetBundleManager();
3934 if (!bms) {
3935 HILOG_ERROR("fail to get bundle manager.");
3936 return false;
3937 }
3938
3939 if (AAFwk::PermissionVerification::GetInstance()->IsGatewayCall()) {
3940 return true;
3941 }
3942
3943 std::string bundleName;
3944 bool result = IN_PROCESS_CALL(bms->GetBundleNameForUid(callerUid, bundleName));
3945 if (!result) {
3946 HILOG_ERROR("GetBundleNameForUid from bms fail.");
3947 return false;
3948 }
3949 AppExecFwk::ApplicationInfo callerAppInfo;
3950 result = IN_PROCESS_CALL(bms->GetApplicationInfo(bundleName,
3951 AppExecFwk::ApplicationFlag::GET_BASIC_APPLICATION_INFO,
3952 GetUserId(), callerAppInfo));
3953 if (!result) {
3954 HILOG_ERROR("GetApplicationInfo from bms fail.");
3955 return false;
3956 }
3957
3958 auto apl = callerAppInfo.appPrivilegeLevel;
3959 if (apl != AbilityUtil::SYSTEM_BASIC && apl != AbilityUtil::SYSTEM_CORE) {
3960 HILOG_DEBUG("caller is normal app.");
3961 auto callerTokenId = IPCSkeleton::GetCallingTokenID();
3962 auto targetTokenId = abilityInfo.applicationInfo.accessTokenId;
3963 if (callerTokenId != targetTokenId) {
3964 HILOG_ERROR("the bundle name of caller is different from target one, caller: %{public}s "
3965 "target: %{public}s",
3966 bundleName.c_str(),
3967 abilityInfo.bundleName.c_str());
3968 return false;
3969 }
3970 }
3971 }
3972 HILOG_DEBUG("Success to check caller permission.");
3973 return true;
3974 }
3975
StartUser(int userId)3976 int AbilityManagerService::StartUser(int userId)
3977 {
3978 HILOG_DEBUG("%{public}s, userId:%{public}d", __func__, userId);
3979 if (IPCSkeleton::GetCallingUid() != ACCOUNT_MGR_SERVICE_UID) {
3980 HILOG_ERROR("%{public}s: Permission verification failed, not account process", __func__);
3981 return CHECK_PERMISSION_FAILED;
3982 }
3983
3984 if (userController_) {
3985 return userController_->StartUser(userId, true);
3986 }
3987 return 0;
3988 }
3989
StopUser(int userId,const sptr<IStopUserCallback> & callback)3990 int AbilityManagerService::StopUser(int userId, const sptr<IStopUserCallback> &callback)
3991 {
3992 HILOG_DEBUG("%{public}s", __func__);
3993 if (IPCSkeleton::GetCallingUid() != ACCOUNT_MGR_SERVICE_UID) {
3994 HILOG_ERROR("%{public}s: Permission verification failed, not account process", __func__);
3995 return CHECK_PERMISSION_FAILED;
3996 }
3997
3998 auto ret = -1;
3999 if (userController_) {
4000 ret = userController_->StopUser(userId);
4001 HILOG_DEBUG("ret = %{public}d", ret);
4002 }
4003 if (callback) {
4004 callback->OnStopUserDone(userId, ret);
4005 }
4006 return 0;
4007 }
4008
OnAcceptWantResponse(const AAFwk::Want & want,const std::string & flag)4009 void AbilityManagerService::OnAcceptWantResponse(
4010 const AAFwk::Want &want, const std::string &flag)
4011 {
4012 HILOG_DEBUG("On accept want response");
4013 if (!currentMissionListManager_) {
4014 return;
4015 }
4016 currentMissionListManager_->OnAcceptWantResponse(want, flag);
4017 }
4018
OnStartSpecifiedAbilityTimeoutResponse(const AAFwk::Want & want)4019 void AbilityManagerService::OnStartSpecifiedAbilityTimeoutResponse(const AAFwk::Want &want)
4020 {
4021 HILOG_DEBUG("%{public}s called.", __func__);
4022 if (!currentMissionListManager_) {
4023 return;
4024 }
4025 currentMissionListManager_->OnStartSpecifiedAbilityTimeoutResponse(want);
4026 }
4027
GetAbilityRunningInfos(std::vector<AbilityRunningInfo> & info)4028 int AbilityManagerService::GetAbilityRunningInfos(std::vector<AbilityRunningInfo> &info)
4029 {
4030 HILOG_DEBUG("Get running ability infos.");
4031 auto isPerm = AAFwk::PermissionVerification::GetInstance()->VerifyRunningInfoPerm();
4032 if (!currentMissionListManager_ || !connectManager_ || !dataAbilityManager_) {
4033 return ERR_INVALID_VALUE;
4034 }
4035
4036 currentMissionListManager_->GetAbilityRunningInfos(info, isPerm);
4037 UpdateFocusState(info);
4038
4039 return ERR_OK;
4040 }
4041
UpdateFocusState(std::vector<AbilityRunningInfo> & info)4042 void AbilityManagerService::UpdateFocusState(std::vector<AbilityRunningInfo> &info)
4043 {
4044 if (info.empty()) {
4045 return;
4046 }
4047
4048 #ifdef SUPPORT_GRAPHICS
4049 sptr<IRemoteObject> token;
4050 int ret = IN_PROCESS_CALL(GetTopAbility(token));
4051 if (ret != ERR_OK || token == nullptr) {
4052 return;
4053 }
4054
4055 auto abilityRecord = Token::GetAbilityRecordByToken(token);
4056 if (abilityRecord == nullptr) {
4057 HILOG_WARN("%{public}s abilityRecord is null.", __func__);
4058 return;
4059 }
4060
4061 for (auto &item : info) {
4062 if (item.uid == abilityRecord->GetUid() && item.pid == abilityRecord->GetPid() &&
4063 item.ability == abilityRecord->GetWant().GetElement()) {
4064 item.abilityState = static_cast<int>(AbilityState::ACTIVE);
4065 break;
4066 }
4067 }
4068 #endif
4069 }
4070
GetExtensionRunningInfos(int upperLimit,std::vector<ExtensionRunningInfo> & info)4071 int AbilityManagerService::GetExtensionRunningInfos(int upperLimit, std::vector<ExtensionRunningInfo> &info)
4072 {
4073 HILOG_DEBUG("Get extension infos, upperLimit : %{public}d", upperLimit);
4074 auto isPerm = AAFwk::PermissionVerification::GetInstance()->VerifyRunningInfoPerm();
4075 if (!connectManager_) {
4076 return ERR_INVALID_VALUE;
4077 }
4078
4079 connectManager_->GetExtensionRunningInfos(upperLimit, info, GetUserId(), isPerm);
4080 return ERR_OK;
4081 }
4082
GetProcessRunningInfos(std::vector<AppExecFwk::RunningProcessInfo> & info)4083 int AbilityManagerService::GetProcessRunningInfos(std::vector<AppExecFwk::RunningProcessInfo> &info)
4084 {
4085 return DelayedSingleton<AppScheduler>::GetInstance()->GetProcessRunningInfos(info);
4086 }
4087
GetProcessRunningInfosByUserId(std::vector<AppExecFwk::RunningProcessInfo> & info,int32_t userId)4088 int AbilityManagerService::GetProcessRunningInfosByUserId(
4089 std::vector<AppExecFwk::RunningProcessInfo> &info, int32_t userId)
4090 {
4091 return DelayedSingleton<AppScheduler>::GetInstance()->GetProcessRunningInfosByUserId(info, userId);
4092 }
4093
ClearUserData(int32_t userId)4094 void AbilityManagerService::ClearUserData(int32_t userId)
4095 {
4096 HILOG_DEBUG("%{public}s", __func__);
4097 std::unique_lock<std::shared_mutex> lock(managersMutex_);
4098 missionListManagers_.erase(userId);
4099 connectManagers_.erase(userId);
4100 dataAbilityManagers_.erase(userId);
4101 pendingWantManagers_.erase(userId);
4102 }
4103
RegisterSnapshotHandler(const sptr<ISnapshotHandler> & handler)4104 int AbilityManagerService::RegisterSnapshotHandler(const sptr<ISnapshotHandler>& handler)
4105 {
4106 auto isSaCall = AAFwk::PermissionVerification::GetInstance()->IsSACall();
4107 if (!isSaCall) {
4108 HILOG_ERROR("%{public}s: Permission verification failed", __func__);
4109 return 0;
4110 }
4111
4112 if (!currentMissionListManager_) {
4113 HILOG_ERROR("snapshot: currentMissionListManager_ is nullptr.");
4114 return INNER_ERR;
4115 }
4116 currentMissionListManager_->RegisterSnapshotHandler(handler);
4117 HILOG_INFO("snapshot: AbilityManagerService register snapshot handler success.");
4118 return ERR_OK;
4119 }
4120
GetMissionSnapshot(const std::string & deviceId,int32_t missionId,MissionSnapshot & missionSnapshot,bool isLowResolution)4121 int32_t AbilityManagerService::GetMissionSnapshot(const std::string& deviceId, int32_t missionId,
4122 MissionSnapshot& missionSnapshot, bool isLowResolution)
4123 {
4124 if (!PermissionVerification::GetInstance()->VerifyMissionPermission()) {
4125 HILOG_ERROR("%{public}s: Permission verification failed", __func__);
4126 return CHECK_PERMISSION_FAILED;
4127 }
4128
4129 if (CheckIsRemote(deviceId)) {
4130 HILOG_INFO("get remote mission snapshot.");
4131 return GetRemoteMissionSnapshotInfo(deviceId, missionId, missionSnapshot);
4132 }
4133 HILOG_INFO("get local mission snapshot.");
4134 if (!currentMissionListManager_) {
4135 HILOG_ERROR("snapshot: currentMissionListManager_ is nullptr.");
4136 return INNER_ERR;
4137 }
4138 auto token = GetAbilityTokenByMissionId(missionId);
4139 bool result = currentMissionListManager_->GetMissionSnapshot(missionId, token, missionSnapshot, isLowResolution);
4140 if (!result) {
4141 return INNER_ERR;
4142 }
4143 return ERR_OK;
4144 }
4145
UpdateMissionSnapShot(const sptr<IRemoteObject> & token)4146 void AbilityManagerService::UpdateMissionSnapShot(const sptr<IRemoteObject>& token)
4147 {
4148 CHECK_POINTER_LOG(currentMissionListManager_, "Current mission manager not init.");
4149 auto abilityRecord = Token::GetAbilityRecordByToken(token);
4150 if (abilityRecord && !JudgeSelfCalled(abilityRecord)) {
4151 return;
4152 }
4153 auto isSaCall = AAFwk::PermissionVerification::GetInstance()->IsSACall();
4154 if (!isSaCall) {
4155 auto bms = GetBundleManager();
4156 CHECK_POINTER_IS_NULLPTR(bms);
4157 AppExecFwk::ApplicationInfo appInfo;
4158 if (!IN_PROCESS_CALL(bms->GetApplicationInfo(BUNDLE_NAME_LAUNCHER,
4159 AppExecFwk::BundleFlag::GET_BUNDLE_DEFAULT, GetUserId(), appInfo))) {
4160 HILOG_ERROR("Not found GetApplicationInfo according to the bundle name.");
4161 return;
4162 }
4163 auto tokenId = IPCSkeleton::GetCallingTokenID();
4164 if (tokenId != appInfo.accessTokenId) {
4165 HILOG_ERROR("%{public}s: Permission verification failed", __func__);
4166 return;
4167 }
4168 }
4169 currentMissionListManager_->UpdateSnapShot(token);
4170 }
4171
EnableRecoverAbility(const sptr<IRemoteObject> & token)4172 void AbilityManagerService::EnableRecoverAbility(const sptr<IRemoteObject>& token)
4173 {
4174 if (token == nullptr) {
4175 return;
4176 }
4177 auto record = Token::GetAbilityRecordByToken(token);
4178 if (record == nullptr) {
4179 HILOG_ERROR("%{public}s AppRecovery::failed find abilityRecord by given token.", __func__);
4180 return;
4181 }
4182
4183 auto callingTokenId = IPCSkeleton::GetCallingTokenID();
4184 auto tokenID = record->GetApplicationInfo().accessTokenId;
4185 if (callingTokenId != tokenID) {
4186 HILOG_ERROR("AppRecovery ScheduleRecoverAbility not self, not enabled");
4187 return;
4188 }
4189
4190 auto it = appRecoveryHistory_.find(record->GetUid());
4191 if (it == appRecoveryHistory_.end()) {
4192 appRecoveryHistory_.emplace(record->GetUid(), 0);
4193 }
4194 }
4195
RecoverAbilityRestart(const Want & want)4196 void AbilityManagerService::RecoverAbilityRestart(const Want& want)
4197 {
4198 std::string identity = IPCSkeleton::ResetCallingIdentity();
4199 int32_t userId = GetValidUserId(DEFAULT_INVAL_VALUE);
4200 int32_t ret = StartAbility(want, userId, 0);
4201 if (ret != ERR_OK) {
4202 HILOG_ERROR("%{public}s AppRecovery::failed to restart ability. %{public}d", __func__, ret);
4203 }
4204 IPCSkeleton::SetCallingIdentity(identity);
4205 }
4206
ScheduleRecoverAbility(const sptr<IRemoteObject> & token,int32_t reason)4207 void AbilityManagerService::ScheduleRecoverAbility(const sptr<IRemoteObject>& token, int32_t reason)
4208 {
4209 if (token == nullptr) {
4210 return;
4211 }
4212 auto record = Token::GetAbilityRecordByToken(token);
4213 if (record == nullptr) {
4214 HILOG_ERROR("%{public}s AppRecovery::failed find abilityRecord by given token.", __func__);
4215 return;
4216 }
4217
4218 auto callingTokenId = IPCSkeleton::GetCallingTokenID();
4219 auto tokenID = record->GetApplicationInfo().accessTokenId;
4220 if (callingTokenId != tokenID) {
4221 HILOG_ERROR("AppRecovery ScheduleRecoverAbility not self, not enabled");
4222 return;
4223 }
4224
4225 AAFwk::Want want;
4226 {
4227 std::lock_guard<std::recursive_mutex> guard(globalLock_);
4228 auto type = record->GetAbilityInfo().type;
4229 if (type != AppExecFwk::AbilityType::PAGE) {
4230 HILOG_ERROR("%{public}s AppRecovery::only do recover for page ability.", __func__);
4231 return;
4232 }
4233
4234 constexpr int64_t MIN_RECOVERY_TIME = 60;
4235 int64_t now = time(nullptr);
4236 auto it = appRecoveryHistory_.find(record->GetUid());
4237 if ((it != appRecoveryHistory_.end()) &&
4238 (it->second + MIN_RECOVERY_TIME > now)) {
4239 HILOG_ERROR("%{public}s AppRecovery recover app more than once in one minute, just kill app(%{public}d).",
4240 __func__, record->GetPid());
4241 kill(record->GetPid(), SIGKILL);
4242 return;
4243 }
4244
4245 auto appInfo = record->GetApplicationInfo();
4246 auto abilityInfo = record->GetAbilityInfo();
4247 appRecoveryHistory_[record->GetUid()] = now;
4248 want = record->GetWant();
4249 want.SetParam(AAFwk::Want::PARAM_ABILITY_RECOVERY_RESTART, true);
4250
4251 HiSysEvent::Write(HiSysEvent::Domain::AAFWK, "APP_RECOVERY", HiSysEvent::EventType::BEHAVIOR,
4252 "APP_UID", record->GetUid(),
4253 "VERSION_CODE", std::to_string(appInfo.versionCode),
4254 "VERSION_NAME", appInfo.versionName,
4255 "BUNDLE_NAME", appInfo.bundleName,
4256 "ABILITY_NAME", abilityInfo.name);
4257 kill(record->GetPid(), SIGKILL);
4258 }
4259
4260 constexpr int delaytime = 2000;
4261 std::string taskName = "AppRecovery_kill:" + std::to_string(record->GetPid());
4262 auto task = std::bind(&AbilityManagerService::RecoverAbilityRestart, this, want);
4263 handler_->PostTask(task, taskName, delaytime);
4264 }
4265
GetRemoteMissionSnapshotInfo(const std::string & deviceId,int32_t missionId,MissionSnapshot & missionSnapshot)4266 int32_t AbilityManagerService::GetRemoteMissionSnapshotInfo(const std::string& deviceId, int32_t missionId,
4267 MissionSnapshot& missionSnapshot)
4268 {
4269 HILOG_INFO("GetRemoteMissionSnapshotInfo begin");
4270 std::unique_ptr<MissionSnapshot> missionSnapshotPtr = std::make_unique<MissionSnapshot>();
4271 DistributedClient dmsClient;
4272 int result = dmsClient.GetRemoteMissionSnapshotInfo(deviceId, missionId, missionSnapshotPtr);
4273 if (result != ERR_OK) {
4274 HILOG_ERROR("GetRemoteMissionSnapshotInfo failed, result = %{public}d", result);
4275 return result;
4276 }
4277 missionSnapshot = *missionSnapshotPtr;
4278 return ERR_OK;
4279 }
4280
StartFreezingScreen()4281 void AbilityManagerService::StartFreezingScreen()
4282 {
4283 HILOG_INFO("%{public}s", __func__);
4284 #ifdef SUPPORT_GRAPHICS
4285 std::vector<Rosen::DisplayId> displayIds = Rosen::DisplayManager::GetInstance().GetAllDisplayIds();
4286 IN_PROCESS_CALL_WITHOUT_RET(Rosen::DisplayManager::GetInstance().Freeze(displayIds));
4287 #endif
4288 }
4289
StopFreezingScreen()4290 void AbilityManagerService::StopFreezingScreen()
4291 {
4292 HILOG_INFO("%{public}s", __func__);
4293 #ifdef SUPPORT_GRAPHICS
4294 std::vector<Rosen::DisplayId> displayIds = Rosen::DisplayManager::GetInstance().GetAllDisplayIds();
4295 IN_PROCESS_CALL_WITHOUT_RET(Rosen::DisplayManager::GetInstance().Unfreeze(displayIds));
4296 #endif
4297 }
4298
UserStarted(int32_t userId)4299 void AbilityManagerService::UserStarted(int32_t userId)
4300 {
4301 HILOG_INFO("%{public}s", __func__);
4302 InitConnectManager(userId, false);
4303 InitMissionListManager(userId, false);
4304 InitDataAbilityManager(userId, false);
4305 InitPendWantManager(userId, false);
4306 }
4307
SwitchToUser(int32_t oldUserId,int32_t userId)4308 void AbilityManagerService::SwitchToUser(int32_t oldUserId, int32_t userId)
4309 {
4310 HILOG_INFO("%{public}s, oldUserId:%{public}d, newUserId:%{public}d", __func__, oldUserId, userId);
4311 SwitchManagers(userId);
4312 PauseOldUser(oldUserId);
4313 bool isBoot = false;
4314 if (oldUserId == U0_USER_ID) {
4315 isBoot = true;
4316 }
4317 ConnectBmsService();
4318 StartUserApps(userId, isBoot);
4319 PauseOldConnectManager(oldUserId);
4320 }
4321
SwitchManagers(int32_t userId,bool switchUser)4322 void AbilityManagerService::SwitchManagers(int32_t userId, bool switchUser)
4323 {
4324 HILOG_INFO("%{public}s, SwitchManagers:%{public}d-----begin", __func__, userId);
4325 InitConnectManager(userId, switchUser);
4326 if (userId != U0_USER_ID) {
4327 InitMissionListManager(userId, switchUser);
4328 }
4329 InitDataAbilityManager(userId, switchUser);
4330 InitPendWantManager(userId, switchUser);
4331 HILOG_INFO("%{public}s, SwitchManagers:%{public}d-----end", __func__, userId);
4332 }
4333
PauseOldUser(int32_t userId)4334 void AbilityManagerService::PauseOldUser(int32_t userId)
4335 {
4336 HILOG_INFO("%{public}s, PauseOldUser:%{public}d-----begin", __func__, userId);
4337 PauseOldMissionListManager(userId);
4338 HILOG_INFO("%{public}s, PauseOldUser:%{public}d-----end", __func__, userId);
4339 }
4340
PauseOldMissionListManager(int32_t userId)4341 void AbilityManagerService::PauseOldMissionListManager(int32_t userId)
4342 {
4343 HILOG_INFO("%{public}s, PauseOldMissionListManager:%{public}d-----begin", __func__, userId);
4344 std::shared_lock<std::shared_mutex> lock(managersMutex_);
4345 auto it = missionListManagers_.find(userId);
4346 if (it == missionListManagers_.end()) {
4347 HILOG_INFO("%{public}s, PauseOldMissionListManager:%{public}d-----end1", __func__, userId);
4348 return;
4349 }
4350 auto manager = it->second;
4351 if (!manager) {
4352 HILOG_INFO("%{public}s, PauseOldMissionListManager:%{public}d-----end2", __func__, userId);
4353 return;
4354 }
4355 manager->PauseManager();
4356 HILOG_INFO("%{public}s, PauseOldMissionListManager:%{public}d-----end", __func__, userId);
4357 }
4358
PauseOldConnectManager(int32_t userId)4359 void AbilityManagerService::PauseOldConnectManager(int32_t userId)
4360 {
4361 HILOG_INFO("%{public}s, PauseOldConnectManager:%{public}d-----begin", __func__, userId);
4362 if (userId == U0_USER_ID) {
4363 HILOG_INFO("%{public}s, u0 not stop, id:%{public}d-----nullptr", __func__, userId);
4364 return;
4365 }
4366
4367 std::shared_lock<std::shared_mutex> lock(managersMutex_);
4368 auto it = connectManagers_.find(userId);
4369 if (it == connectManagers_.end()) {
4370 HILOG_INFO("%{public}s, PauseOldConnectManager:%{public}d-----no user", __func__, userId);
4371 return;
4372 }
4373 auto manager = it->second;
4374 if (!manager) {
4375 HILOG_INFO("%{public}s, PauseOldConnectManager:%{public}d-----nullptr", __func__, userId);
4376 return;
4377 }
4378 manager->StopAllExtensions();
4379 HILOG_INFO("%{public}s, PauseOldConnectManager:%{public}d-----end", __func__, userId);
4380 }
4381
StartUserApps(int32_t userId,bool isBoot)4382 void AbilityManagerService::StartUserApps(int32_t userId, bool isBoot)
4383 {
4384 HILOG_INFO("StartUserApps, userId:%{public}d, currentUserId:%{public}d", userId, GetUserId());
4385 if (currentMissionListManager_ && currentMissionListManager_->IsStarted()) {
4386 HILOG_INFO("missionListManager ResumeManager");
4387 currentMissionListManager_->ResumeManager();
4388 }
4389 StartHighestPriorityAbility(userId, isBoot);
4390 }
4391
InitConnectManager(int32_t userId,bool switchUser)4392 void AbilityManagerService::InitConnectManager(int32_t userId, bool switchUser)
4393 {
4394 bool find = false;
4395 {
4396 std::shared_lock<std::shared_mutex> lock(managersMutex_);
4397 auto it = connectManagers_.find(userId);
4398 find = (it != connectManagers_.end());
4399 if (find) {
4400 if (switchUser) {
4401 connectManager_ = it->second;
4402 }
4403 }
4404 }
4405 if (!find) {
4406 auto manager = std::make_shared<AbilityConnectManager>(userId);
4407 manager->SetEventHandler(handler_);
4408 std::unique_lock<std::shared_mutex> lock(managersMutex_);
4409 connectManagers_.emplace(userId, manager);
4410 if (switchUser) {
4411 connectManager_ = manager;
4412 }
4413 }
4414 }
4415
InitDataAbilityManager(int32_t userId,bool switchUser)4416 void AbilityManagerService::InitDataAbilityManager(int32_t userId, bool switchUser)
4417 {
4418 bool find = false;
4419 {
4420 std::shared_lock<std::shared_mutex> lock(managersMutex_);
4421 auto it = dataAbilityManagers_.find(userId);
4422 find = (it != dataAbilityManagers_.end());
4423 if (find) {
4424 if (switchUser) {
4425 dataAbilityManager_ = it->second;
4426 }
4427 }
4428 }
4429 if (!find) {
4430 auto manager = std::make_shared<DataAbilityManager>();
4431 std::unique_lock<std::shared_mutex> lock(managersMutex_);
4432 dataAbilityManagers_.emplace(userId, manager);
4433 if (switchUser) {
4434 dataAbilityManager_ = manager;
4435 }
4436 }
4437 }
4438
InitPendWantManager(int32_t userId,bool switchUser)4439 void AbilityManagerService::InitPendWantManager(int32_t userId, bool switchUser)
4440 {
4441 bool find = false;
4442 {
4443 std::shared_lock<std::shared_mutex> lock(managersMutex_);
4444 auto it = pendingWantManagers_.find(userId);
4445 find = (it != pendingWantManagers_.end());
4446 if (find) {
4447 if (switchUser) {
4448 pendingWantManager_ = it->second;
4449 }
4450 }
4451 }
4452 if (!find) {
4453 auto manager = std::make_shared<PendingWantManager>();
4454 std::unique_lock<std::shared_mutex> lock(managersMutex_);
4455 pendingWantManagers_.emplace(userId, manager);
4456 if (switchUser) {
4457 pendingWantManager_ = manager;
4458 }
4459 }
4460 }
4461
GetValidUserId(const int32_t userId)4462 int32_t AbilityManagerService::GetValidUserId(const int32_t userId)
4463 {
4464 HILOG_DEBUG("%{public}s, userId = %{public}d.", __func__, userId);
4465 int32_t validUserId = userId;
4466
4467 if (DEFAULT_INVAL_VALUE == userId) {
4468 validUserId = IPCSkeleton::GetCallingUid() / BASE_USER_RANGE;
4469 HILOG_INFO("%{public}s, validUserId = %{public}d, CallingUid = %{public}d.", __func__, validUserId,
4470 IPCSkeleton::GetCallingUid());
4471 if (validUserId == U0_USER_ID) {
4472 validUserId = GetUserId();
4473 }
4474 }
4475 return validUserId;
4476 }
4477
SetAbilityController(const sptr<IAbilityController> & abilityController,bool imAStabilityTest)4478 int AbilityManagerService::SetAbilityController(const sptr<IAbilityController> &abilityController,
4479 bool imAStabilityTest)
4480 {
4481 HILOG_DEBUG("%{public}s, imAStabilityTest: %{public}d", __func__, imAStabilityTest);
4482 auto isPerm = AAFwk::PermissionVerification::GetInstance()->VerifyControllerPerm();
4483 if (!isPerm) {
4484 HILOG_ERROR("%{public}s: Permission verification failed", __func__);
4485 return CHECK_PERMISSION_FAILED;
4486 }
4487
4488 std::lock_guard<std::recursive_mutex> guard(globalLock_);
4489 abilityController_ = abilityController;
4490 controllerIsAStabilityTest_ = imAStabilityTest;
4491 HILOG_DEBUG("%{public}s, end", __func__);
4492 return ERR_OK;
4493 }
4494
SendANRProcessID(int pid)4495 int AbilityManagerService::SendANRProcessID(int pid)
4496 {
4497 HILOG_INFO("SendANRProcessID come, pid is %{public}d", pid);
4498 auto isSaCall = AAFwk::PermissionVerification::GetInstance()->IsSACall();
4499 auto isShellCall = AAFwk::PermissionVerification::GetInstance()->IsShellCall();
4500 if (!isSaCall && !isShellCall) {
4501 HILOG_ERROR("%{public}s: Permission verification failed", __func__);
4502 return CHECK_PERMISSION_FAILED;
4503 }
4504
4505 AppExecFwk::ApplicationInfo appInfo;
4506 bool debug;
4507 auto appScheduler = DelayedSingleton<AppScheduler>::GetInstance();
4508 if (appScheduler->GetApplicationInfoByProcessID(pid, appInfo, debug) == ERR_OK) {
4509 auto it = appRecoveryHistory_.find(appInfo.uid);
4510 if (it != appRecoveryHistory_.end()) {
4511 return ERR_OK;
4512 }
4513 }
4514
4515 if (debug) {
4516 HILOG_ERROR("SendANRProcessID error, debug mode.");
4517 return ERR_INVALID_VALUE;
4518 }
4519
4520 DelayedSingleton<AppScheduler>::GetInstance()->KillApplication(appInfo.bundleName);
4521 return ERR_OK;
4522 }
4523
IsRunningInStabilityTest()4524 bool AbilityManagerService::IsRunningInStabilityTest()
4525 {
4526 std::lock_guard<std::recursive_mutex> guard(globalLock_);
4527 bool ret = abilityController_ != nullptr && controllerIsAStabilityTest_;
4528 HILOG_DEBUG("%{public}s, IsRunningInStabilityTest: %{public}d", __func__, ret);
4529 return ret;
4530 }
4531
IsAbilityControllerStart(const Want & want,const std::string & bundleName)4532 bool AbilityManagerService::IsAbilityControllerStart(const Want &want, const std::string &bundleName)
4533 {
4534 HILOG_DEBUG("method call, controllerIsAStabilityTest_: %{public}d", controllerIsAStabilityTest_);
4535 if (abilityController_ == nullptr) {
4536 HILOG_DEBUG("abilityController_ is nullptr");
4537 return true;
4538 }
4539
4540 if (controllerIsAStabilityTest_) {
4541 bool isStart = abilityController_->AllowAbilityStart(want, bundleName);
4542 if (!isStart) {
4543 HILOG_INFO("Not finishing start ability because controller starting: %{public}s", bundleName.c_str());
4544 return false;
4545 }
4546 }
4547 return true;
4548 }
4549
IsAbilityControllerForeground(const std::string & bundleName)4550 bool AbilityManagerService::IsAbilityControllerForeground(const std::string &bundleName)
4551 {
4552 HILOG_DEBUG("method call, controllerIsAStabilityTest_: %{public}d", controllerIsAStabilityTest_);
4553 if (abilityController_ == nullptr) {
4554 HILOG_DEBUG("abilityController_ is nullptr");
4555 return true;
4556 }
4557
4558 if (controllerIsAStabilityTest_) {
4559 bool isResume = abilityController_->AllowAbilityBackground(bundleName);
4560 if (!isResume) {
4561 HILOG_INFO("Not finishing terminate ability because controller resuming: %{public}s", bundleName.c_str());
4562 return false;
4563 }
4564 }
4565 return true;
4566 }
4567
InitAbilityInfoFromExtension(AppExecFwk::ExtensionAbilityInfo & extensionInfo,AppExecFwk::AbilityInfo & abilityInfo)4568 int32_t AbilityManagerService::InitAbilityInfoFromExtension(AppExecFwk::ExtensionAbilityInfo &extensionInfo,
4569 AppExecFwk::AbilityInfo &abilityInfo)
4570 {
4571 abilityInfo.applicationName = extensionInfo.applicationInfo.name;
4572 abilityInfo.applicationInfo = extensionInfo.applicationInfo;
4573 abilityInfo.bundleName = extensionInfo.bundleName;
4574 abilityInfo.package = extensionInfo.moduleName;
4575 abilityInfo.moduleName = extensionInfo.moduleName;
4576 abilityInfo.name = extensionInfo.name;
4577 abilityInfo.srcEntrance = extensionInfo.srcEntrance;
4578 abilityInfo.srcPath = extensionInfo.srcEntrance;
4579 abilityInfo.iconPath = extensionInfo.icon;
4580 abilityInfo.iconId = extensionInfo.iconId;
4581 abilityInfo.label = extensionInfo.label;
4582 abilityInfo.labelId = extensionInfo.labelId;
4583 abilityInfo.description = extensionInfo.description;
4584 abilityInfo.descriptionId = extensionInfo.descriptionId;
4585 abilityInfo.priority = extensionInfo.priority;
4586 abilityInfo.permissions = extensionInfo.permissions;
4587 abilityInfo.readPermission = extensionInfo.readPermission;
4588 abilityInfo.writePermission = extensionInfo.writePermission;
4589 abilityInfo.uri = extensionInfo.uri;
4590 abilityInfo.extensionAbilityType = extensionInfo.type;
4591 abilityInfo.visible = extensionInfo.visible;
4592 abilityInfo.resourcePath = extensionInfo.resourcePath;
4593 abilityInfo.enabled = extensionInfo.enabled;
4594 abilityInfo.isModuleJson = true;
4595 abilityInfo.isStageBasedModel = true;
4596 abilityInfo.process = extensionInfo.process;
4597 abilityInfo.metadata = extensionInfo.metadata;
4598 abilityInfo.compileMode = extensionInfo.compileMode;
4599 abilityInfo.type = AppExecFwk::AbilityType::EXTENSION;
4600 if (!extensionInfo.hapPath.empty()) {
4601 abilityInfo.hapPath = extensionInfo.hapPath;
4602 }
4603 return 0;
4604 }
4605
StartUserTest(const Want & want,const sptr<IRemoteObject> & observer)4606 int AbilityManagerService::StartUserTest(const Want &want, const sptr<IRemoteObject> &observer)
4607 {
4608 HILOG_DEBUG("enter");
4609 if (observer == nullptr) {
4610 HILOG_ERROR("observer is nullptr");
4611 return ERR_INVALID_VALUE;
4612 }
4613
4614 std::string bundleName = want.GetStringParam("-b");
4615 if (bundleName.empty()) {
4616 HILOG_ERROR("Invalid bundle name");
4617 return ERR_INVALID_VALUE;
4618 }
4619
4620 auto bms = GetBundleManager();
4621 CHECK_POINTER_AND_RETURN(bms, START_USER_TEST_FAIL);
4622 AppExecFwk::BundleInfo bundleInfo;
4623 if (!IN_PROCESS_CALL(
4624 bms->GetBundleInfo(bundleName, AppExecFwk::BundleFlag::GET_BUNDLE_DEFAULT, bundleInfo, U0_USER_ID))) {
4625 HILOG_ERROR("Failed to get bundle info by U0_USER_ID %{public}d.", U0_USER_ID);
4626 int32_t userId = GetUserId();
4627 if (!IN_PROCESS_CALL(
4628 bms->GetBundleInfo(bundleName, AppExecFwk::BundleFlag::GET_BUNDLE_DEFAULT, bundleInfo, userId))) {
4629 HILOG_ERROR("Failed to get bundle info by userId %{public}d.", userId);
4630 return GET_BUNDLE_INFO_FAILED;
4631 }
4632 }
4633
4634 return DelayedSingleton<AppScheduler>::GetInstance()->StartUserTest(want, observer, bundleInfo, GetUserId());
4635 }
4636
FinishUserTest(const std::string & msg,const int64_t & resultCode,const std::string & bundleName)4637 int AbilityManagerService::FinishUserTest(
4638 const std::string &msg, const int64_t &resultCode, const std::string &bundleName)
4639 {
4640 HILOG_DEBUG("enter");
4641 if (bundleName.empty()) {
4642 HILOG_ERROR("Invalid bundle name.");
4643 return ERR_INVALID_VALUE;
4644 }
4645
4646 return DelayedSingleton<AppScheduler>::GetInstance()->FinishUserTest(msg, resultCode, bundleName);
4647 }
4648
GetTopAbility(sptr<IRemoteObject> & token)4649 int AbilityManagerService::GetTopAbility(sptr<IRemoteObject> &token)
4650 {
4651 auto isSaCall = AAFwk::PermissionVerification::GetInstance()->IsSACall();
4652 if (!isSaCall) {
4653 HILOG_ERROR("Permission verification failed");
4654 return CHECK_PERMISSION_FAILED;
4655 }
4656 #ifdef SUPPORT_GRAPHICS
4657 if (!wmsHandler_) {
4658 HILOG_ERROR("wmsHandler_ is nullptr.");
4659 return ERR_INVALID_VALUE;
4660 }
4661 wmsHandler_->GetFocusWindow(token);
4662
4663 if (!token) {
4664 HILOG_ERROR("token is nullptr");
4665 return ERR_INVALID_VALUE;
4666 }
4667 #endif
4668 return ERR_OK;
4669 }
4670
DelegatorDoAbilityForeground(const sptr<IRemoteObject> & token)4671 int AbilityManagerService::DelegatorDoAbilityForeground(const sptr<IRemoteObject> &token)
4672 {
4673 HILOG_DEBUG("enter");
4674 CHECK_POINTER_AND_RETURN(token, ERR_INVALID_VALUE);
4675
4676 auto missionId = GetMissionIdByAbilityToken(token);
4677 if (missionId < 0) {
4678 HILOG_ERROR("Invalid mission id.");
4679 return ERR_INVALID_VALUE;
4680 }
4681
4682 NotifyHandleAbilityStateChange(token, ABILITY_MOVE_TO_FOREGROUND_CODE);
4683 return DelegatorMoveMissionToFront(missionId);
4684 }
4685
DelegatorDoAbilityBackground(const sptr<IRemoteObject> & token)4686 int AbilityManagerService::DelegatorDoAbilityBackground(const sptr<IRemoteObject> &token)
4687 {
4688 HILOG_DEBUG("enter");
4689 NotifyHandleAbilityStateChange(token, ABILITY_MOVE_TO_BACKGROUND_CODE);
4690 return MinimizeAbility(token, true);
4691 }
4692
DoAbilityForeground(const sptr<IRemoteObject> & token,uint32_t flag)4693 int AbilityManagerService::DoAbilityForeground(const sptr<IRemoteObject> &token, uint32_t flag)
4694 {
4695 HILOG_DEBUG("DoAbilityForeground, sceneFlag:%{public}u", flag);
4696 CHECK_POINTER_AND_RETURN(token, ERR_INVALID_VALUE);
4697 if (!VerificationToken(token) && !VerificationAllToken(token)) {
4698 HILOG_ERROR("%{public}s token error.", __func__);
4699 return ERR_INVALID_VALUE;
4700 }
4701
4702 std::lock_guard<std::recursive_mutex> guard(globalLock_);
4703 auto abilityRecord = Token::GetAbilityRecordByToken(token);
4704 CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE);
4705 if (!JudgeSelfCalled(abilityRecord)) {
4706 return CHECK_PERMISSION_FAILED;
4707 }
4708 int result = JudgeAbilityVisibleControl(abilityRecord->GetAbilityInfo());
4709 if (result != ERR_OK) {
4710 HILOG_ERROR("%{public}s JudgeAbilityVisibleControl error.", __func__);
4711 return result;
4712 }
4713
4714 auto type = abilityRecord->GetAbilityInfo().type;
4715 if (type != AppExecFwk::AbilityType::PAGE) {
4716 HILOG_ERROR("Cannot minimize except page ability.");
4717 return ERR_WRONG_INTERFACE_CALL;
4718 }
4719
4720 if (!IsAbilityControllerForeground(abilityRecord->GetAbilityInfo().bundleName)) {
4721 HILOG_ERROR("IsAbilityControllerForeground false.");
4722 return ERR_WOULD_BLOCK;
4723 }
4724
4725 if (abilityRecord->GetPendingState() == AbilityState::FOREGROUND) {
4726 HILOG_DEBUG("pending state is FOREGROUND.");
4727 abilityRecord->SetPendingState(AbilityState::FOREGROUND);
4728 return ERR_OK;
4729 } else {
4730 HILOG_DEBUG("pending state is not FOREGROUND.");
4731 abilityRecord->SetPendingState(AbilityState::FOREGROUND);
4732 }
4733 abilityRecord->ProcessForegroundAbility(flag);
4734 return ERR_OK;
4735 }
4736
DoAbilityBackground(const sptr<IRemoteObject> & token,uint32_t flag)4737 int AbilityManagerService::DoAbilityBackground(const sptr<IRemoteObject> &token, uint32_t flag)
4738 {
4739 HILOG_DEBUG("DoAbilityBackground, sceneFlag:%{public}u", flag);
4740 CHECK_POINTER_AND_RETURN(token, ERR_INVALID_VALUE);
4741
4742 auto abilityRecord = Token::GetAbilityRecordByToken(token);
4743 CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE);
4744
4745 abilityRecord->lifeCycleStateInfo_.sceneFlag = flag;
4746 int ret = MinimizeAbility(token);
4747 abilityRecord->lifeCycleStateInfo_.sceneFlag = SCENE_FLAG_NORMAL;
4748 return ret;
4749 }
4750
DelegatorMoveMissionToFront(int32_t missionId)4751 int AbilityManagerService::DelegatorMoveMissionToFront(int32_t missionId)
4752 {
4753 HILOG_INFO("enter missionId : %{public}d", missionId);
4754 CHECK_POINTER_AND_RETURN(currentMissionListManager_, ERR_NO_INIT);
4755
4756 if (!IsAbilityControllerStartById(missionId)) {
4757 HILOG_ERROR("IsAbilityControllerStart false");
4758 return ERR_WOULD_BLOCK;
4759 }
4760
4761 return currentMissionListManager_->MoveMissionToFront(missionId);
4762 }
4763
UpdateCallerInfo(Want & want)4764 void AbilityManagerService::UpdateCallerInfo(Want& want)
4765 {
4766 int32_t tokenId = (int32_t)IPCSkeleton::GetCallingTokenID();
4767 int32_t callerUid = IPCSkeleton::GetCallingUid();
4768 int32_t callerPid = IPCSkeleton::GetCallingPid();
4769 want.SetParam(Want::PARAM_RESV_CALLER_TOKEN, tokenId);
4770 want.SetParam(Want::PARAM_RESV_CALLER_UID, callerUid);
4771 want.SetParam(Want::PARAM_RESV_CALLER_PID, callerPid);
4772 }
4773
JudgeMultiUserConcurrency(const int32_t userId)4774 bool AbilityManagerService::JudgeMultiUserConcurrency(const int32_t userId)
4775 {
4776 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
4777
4778 if (userId == U0_USER_ID) {
4779 HILOG_DEBUG("%{public}s, userId is 0.", __func__);
4780 return true;
4781 }
4782
4783 HILOG_DEBUG("userId : %{public}d, current userId : %{public}d", userId, GetUserId());
4784
4785 // Only non-concurrent mode is supported
4786 bool concurrencyMode = CONCURRENCY_MODE_FALSE;
4787 if (!concurrencyMode) {
4788 return (userId == GetUserId());
4789 }
4790
4791 return true;
4792 }
4793
4794 #ifdef ABILITY_COMMAND_FOR_TEST
ForceTimeoutForTest(const std::string & abilityName,const std::string & state)4795 int AbilityManagerService::ForceTimeoutForTest(const std::string &abilityName, const std::string &state)
4796 {
4797 if (abilityName.empty()) {
4798 HILOG_ERROR("abilityName is empty.");
4799 return INVALID_DATA;
4800 }
4801 if (abilityName == "clean") {
4802 timeoutMap_.clear();
4803 return ERR_OK;
4804 }
4805 if (state != AbilityRecord::ConvertAbilityState(AbilityState::INITIAL) &&
4806 state != AbilityRecord::ConvertAbilityState(AbilityState::INACTIVE) &&
4807 state != AbilityRecord::ConvertAbilityState(AbilityState::FOREGROUND) &&
4808 state != AbilityRecord::ConvertAbilityState(AbilityState::BACKGROUND) &&
4809 state != AbilityRecord::ConvertAbilityState(AbilityState::TERMINATING) &&
4810 state != std::string("COMMAND")) {
4811 HILOG_ERROR("lifecycle state is invalid.");
4812 return INVALID_DATA;
4813 }
4814 timeoutMap_.insert(std::make_pair(state, abilityName));
4815 return ERR_OK;
4816 }
4817 #endif
4818
CheckStaticCfgPermission(AppExecFwk::AbilityInfo & abilityInfo)4819 int AbilityManagerService::CheckStaticCfgPermission(AppExecFwk::AbilityInfo &abilityInfo)
4820 {
4821 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
4822 auto isSaCall = AAFwk::PermissionVerification::GetInstance()->IsSACall();
4823 if (isSaCall) {
4824 // do not need check static config permission when start ability by SA
4825 return AppExecFwk::Constants::PERMISSION_GRANTED;
4826 }
4827
4828 auto tokenId = IPCSkeleton::GetCallingTokenID();
4829 if (abilityInfo.applicationInfo.accessTokenId == tokenId) {
4830 return ERR_OK;
4831 }
4832
4833 if ((abilityInfo.type == AppExecFwk::AbilityType::EXTENSION &&
4834 abilityInfo.extensionAbilityType == AppExecFwk::ExtensionAbilityType::DATASHARE) ||
4835 (abilityInfo.type == AppExecFwk::AbilityType::DATA)) {
4836 // just need check the read permission and write permission of extension ability or data ability
4837 if (!abilityInfo.readPermission.empty()) {
4838 int checkReadPermission = AccessTokenKit::VerifyAccessToken(tokenId, abilityInfo.readPermission);
4839 if (checkReadPermission == ERR_OK) {
4840 return AppExecFwk::Constants::PERMISSION_GRANTED;
4841 }
4842 HILOG_WARN("verify access token fail, read permission: %{public}s", abilityInfo.readPermission.c_str());
4843 }
4844 if (!abilityInfo.writePermission.empty()) {
4845 int checkWritePermission = AccessTokenKit::VerifyAccessToken(tokenId, abilityInfo.writePermission);
4846 if (checkWritePermission == ERR_OK) {
4847 return AppExecFwk::Constants::PERMISSION_GRANTED;
4848 }
4849 HILOG_WARN("verify access token fail, write permission: %{public}s", abilityInfo.writePermission.c_str());
4850 }
4851
4852 if (!abilityInfo.readPermission.empty() || !abilityInfo.writePermission.empty()) {
4853 // 'readPermission' and 'writePermission' take precedence over 'permission'
4854 // when 'readPermission' or 'writePermission' is not empty, no need check 'permission'
4855 return AppExecFwk::Constants::PERMISSION_NOT_GRANTED;
4856 }
4857 }
4858
4859 // verify permission if 'permission' is not empty
4860 if (abilityInfo.permissions.empty() || AccessTokenKit::VerifyAccessToken(tokenId,
4861 PermissionConstants::PERMISSION_START_INVISIBLE_ABILITY) == ERR_OK) {
4862 return AppExecFwk::Constants::PERMISSION_GRANTED;
4863 }
4864
4865 for (auto permission : abilityInfo.permissions) {
4866 if (AccessTokenKit::VerifyAccessToken(tokenId, permission)
4867 != AppExecFwk::Constants::PERMISSION_GRANTED) {
4868 HILOG_ERROR("verify access token fail, permission: %{public}s", permission.c_str());
4869 return AppExecFwk::Constants::PERMISSION_NOT_GRANTED;
4870 }
4871 }
4872
4873 return AppExecFwk::Constants::PERMISSION_GRANTED;
4874 }
4875
IsNeedTimeoutForTest(const std::string & abilityName,const std::string & state) const4876 bool AbilityManagerService::IsNeedTimeoutForTest(const std::string &abilityName, const std::string &state) const
4877 {
4878 for (auto iter = timeoutMap_.begin(); iter != timeoutMap_.end(); iter++) {
4879 if (iter->first == state && iter->second == abilityName) {
4880 return true;
4881 }
4882 }
4883 return false;
4884 }
4885
GetValidDataAbilityUri(const std::string & abilityInfoUri,std::string & adjustUri)4886 bool AbilityManagerService::GetValidDataAbilityUri(const std::string &abilityInfoUri, std::string &adjustUri)
4887 {
4888 // note: do not use abilityInfo.uri directly, need check uri first.
4889 size_t firstSeparator = abilityInfoUri.find_first_of('/');
4890 size_t lastSeparator = abilityInfoUri.find_last_of('/');
4891 if (lastSeparator - firstSeparator != 1) {
4892 HILOG_ERROR("ability info uri error, uri: %{public}s", abilityInfoUri.c_str());
4893 return false;
4894 }
4895
4896 adjustUri = abilityInfoUri;
4897 adjustUri.insert(lastSeparator, "/");
4898 return true;
4899 }
4900
GetDataAbilityUri(const std::vector<AppExecFwk::AbilityInfo> & abilityInfos,const std::string & mainAbility,std::string & uri)4901 bool AbilityManagerService::GetDataAbilityUri(const std::vector<AppExecFwk::AbilityInfo> &abilityInfos,
4902 const std::string &mainAbility, std::string &uri)
4903 {
4904 if (abilityInfos.empty() || mainAbility.empty()) {
4905 HILOG_ERROR("abilityInfos or mainAbility is empty. mainAbility: %{public}s", mainAbility.c_str());
4906 return false;
4907 }
4908
4909 std::string dataAbilityUri;
4910 for (auto abilityInfo : abilityInfos) {
4911 if (abilityInfo.type == AppExecFwk::AbilityType::DATA &&
4912 abilityInfo.name == mainAbility) {
4913 dataAbilityUri = abilityInfo.uri;
4914 HILOG_INFO("get data ability uri: %{public}s", dataAbilityUri.c_str());
4915 break;
4916 }
4917 }
4918
4919 return GetValidDataAbilityUri(dataAbilityUri, uri);
4920 }
4921
GetAbilityRunningInfo(std::vector<AbilityRunningInfo> & info,std::shared_ptr<AbilityRecord> & abilityRecord)4922 void AbilityManagerService::GetAbilityRunningInfo(std::vector<AbilityRunningInfo> &info,
4923 std::shared_ptr<AbilityRecord> &abilityRecord)
4924 {
4925 AbilityRunningInfo runningInfo;
4926 AppExecFwk::RunningProcessInfo processInfo;
4927
4928 runningInfo.ability = abilityRecord->GetWant().GetElement();
4929 runningInfo.startTime = abilityRecord->GetStartTime();
4930 runningInfo.abilityState = static_cast<int>(abilityRecord->GetAbilityState());
4931
4932 DelayedSingleton<AppScheduler>::GetInstance()->
4933 GetRunningProcessInfoByToken(abilityRecord->GetToken(), processInfo);
4934 runningInfo.pid = processInfo.pid_;
4935 runningInfo.uid = processInfo.uid_;
4936 runningInfo.processName = processInfo.processName_;
4937 info.emplace_back(runningInfo);
4938 }
4939
VerifyAccountPermission(int32_t userId)4940 int AbilityManagerService::VerifyAccountPermission(int32_t userId)
4941 {
4942 if ((userId < 0) || (userController_ && (userController_->GetCurrentUserId() == userId))) {
4943 return ERR_OK;
4944 }
4945 return AAFwk::PermissionVerification::GetInstance()->VerifyAccountPermission();
4946 }
4947
4948 #ifdef ABILITY_COMMAND_FOR_TEST
BlockAmsService()4949 int AbilityManagerService::BlockAmsService()
4950 {
4951 HILOG_DEBUG("%{public}s", __func__);
4952 if (AAFwk::PermissionVerification::GetInstance()->IsShellCall()) {
4953 HILOG_ERROR("Not shell call");
4954 return ERR_PERMISSION_DENIED;
4955 }
4956 if (handler_) {
4957 HILOG_DEBUG("%{public}s begin post block ams service task", __func__);
4958 auto BlockAmsServiceTask = [aams = shared_from_this()]() {
4959 while (1) {
4960 HILOG_DEBUG("%{public}s begin waiting", __func__);
4961 std::this_thread::sleep_for(BLOCK_AMS_SERVICE_TIME*1s);
4962 }
4963 };
4964 handler_->PostTask(BlockAmsServiceTask, "blockamsservice");
4965 return ERR_OK;
4966 }
4967 return ERR_NO_INIT;
4968 }
4969
BlockAbility(int32_t abilityRecordId)4970 int AbilityManagerService::BlockAbility(int32_t abilityRecordId)
4971 {
4972 HILOG_DEBUG("%{public}s", __func__);
4973 if (AAFwk::PermissionVerification::GetInstance()->IsShellCall()) {
4974 HILOG_ERROR("Not shell call");
4975 return ERR_PERMISSION_DENIED;
4976 }
4977 CHECK_POINTER_AND_RETURN(currentMissionListManager_, ERR_NO_INIT);
4978 return currentMissionListManager_->BlockAbility(abilityRecordId);
4979 }
4980
BlockAppService()4981 int AbilityManagerService::BlockAppService()
4982 {
4983 HILOG_DEBUG("%{public}s", __func__);
4984 if (AAFwk::PermissionVerification::GetInstance()->IsShellCall()) {
4985 HILOG_ERROR("Not shell call");
4986 return ERR_PERMISSION_DENIED;
4987 }
4988 return DelayedSingleton<AppScheduler>::GetInstance()->BlockAppService();
4989 }
4990 #endif
4991
FreeInstallAbilityFromRemote(const Want & want,const sptr<IRemoteObject> & callback,int32_t userId,int requestCode)4992 int AbilityManagerService::FreeInstallAbilityFromRemote(const Want &want, const sptr<IRemoteObject> &callback,
4993 int32_t userId, int requestCode)
4994 {
4995 int32_t validUserId = GetValidUserId(userId);
4996 if (freeInstallManager_ == nullptr) {
4997 HILOG_ERROR("freeInstallManager_ is nullptr");
4998 return ERR_INVALID_VALUE;
4999 }
5000 return freeInstallManager_->FreeInstallAbilityFromRemote(want, callback, validUserId, requestCode);
5001 }
5002
GetTopAbility()5003 AppExecFwk::ElementName AbilityManagerService::GetTopAbility()
5004 {
5005 HILOG_DEBUG("%{public}s start.", __func__);
5006 AppExecFwk::ElementName elementName = {};
5007 #ifdef SUPPORT_GRAPHICS
5008 sptr<IRemoteObject> token;
5009 int ret = IN_PROCESS_CALL(GetTopAbility(token));
5010 if (ret) {
5011 return elementName;
5012 }
5013 if (!token) {
5014 HILOG_ERROR("token is nullptr");
5015 return elementName;
5016 }
5017 auto abilityRecord = Token::GetAbilityRecordByToken(token);
5018 if (abilityRecord == nullptr) {
5019 HILOG_ERROR("%{public}s abilityRecord is null.", __func__);
5020 return elementName;
5021 }
5022 elementName = abilityRecord->GetWant().GetElement();
5023 bool isDeviceEmpty = elementName.GetDeviceID().empty();
5024 std::string localDeviceId;
5025 bool hasLocalDeviceId = GetLocalDeviceId(localDeviceId);
5026 if (isDeviceEmpty && hasLocalDeviceId) {
5027 elementName.SetDeviceID(localDeviceId);
5028 }
5029 #endif
5030 return elementName;
5031 }
5032
Dump(int fd,const std::vector<std::u16string> & args)5033 int AbilityManagerService::Dump(int fd, const std::vector<std::u16string>& args)
5034 {
5035 HILOG_DEBUG("Dump begin fd: %{public}d", fd);
5036 std::string result;
5037 auto errCode = Dump(args, result);
5038 int ret = dprintf(fd, "%s\n", result.c_str());
5039 if (ret < 0) {
5040 HILOG_ERROR("dprintf error");
5041 return ERR_AAFWK_HIDUMP_ERROR;
5042 }
5043 HILOG_DEBUG("Dump end");
5044 return errCode;
5045 }
5046
Dump(const std::vector<std::u16string> & args,std::string & result)5047 int AbilityManagerService::Dump(const std::vector<std::u16string>& args, std::string& result)
5048 {
5049 ErrCode errCode = ERR_OK;
5050 auto size = args.size();
5051 if (size == 0) {
5052 ShowHelp(result);
5053 return errCode;
5054 }
5055
5056 std::vector<std::string> argsStr;
5057 for (auto arg : args) {
5058 argsStr.emplace_back(Str16ToStr8(arg));
5059 }
5060
5061 if (argsStr[0] == "-h") {
5062 ShowHelp(result);
5063 } else {
5064 errCode = ProcessMultiParam(argsStr, result);
5065 if (errCode == ERR_AAFWK_HIDUMP_INVALID_ARGS) {
5066 ShowIllegalInfomation(result);
5067 }
5068 }
5069 return errCode;
5070 }
5071
ProcessMultiParam(std::vector<std::string> & argsStr,std::string & result)5072 ErrCode AbilityManagerService::ProcessMultiParam(std::vector<std::string>& argsStr, std::string& result)
5073 {
5074 HILOG_DEBUG("%{public}s begin", __func__);
5075 bool isClient = false;
5076 bool isUser = false;
5077 int userID = DEFAULT_INVAL_VALUE;
5078 std::vector<std::string>::iterator it;
5079 for (it = argsStr.begin(); it != argsStr.end();) {
5080 if (*it == ARGS_CLIENT) {
5081 isClient = true;
5082 it = argsStr.erase(it);
5083 continue;
5084 }
5085 if (*it == ARGS_USER_ID) {
5086 it = argsStr.erase(it);
5087 if (it == argsStr.end()) {
5088 HILOG_ERROR("ARGS_USER_ID id invalid");
5089 return ERR_AAFWK_HIDUMP_INVALID_ARGS;
5090 }
5091 (void)StrToInt(*it, userID);
5092 if (userID < 0) {
5093 HILOG_ERROR("ARGS_USER_ID id invalid");
5094 return ERR_AAFWK_HIDUMP_INVALID_ARGS;
5095 }
5096 isUser = true;
5097 it = argsStr.erase(it);
5098 continue;
5099 }
5100 it++;
5101 }
5102 std::string cmd;
5103 for (unsigned int i = 0; i < argsStr.size(); i++) {
5104 cmd.append(argsStr[i]);
5105 if (i != argsStr.size() - 1) {
5106 cmd.append(" ");
5107 }
5108 }
5109 HILOG_INFO("%{public}s, isClient:%{public}d, userID is : %{public}d, cmd is : %{public}s",
5110 __func__, isClient, userID, cmd.c_str());
5111
5112 std::vector<std::string> dumpResults;
5113 DumpSysState(cmd, dumpResults, isClient, isUser, userID);
5114 for (auto it : dumpResults) {
5115 result += it + "\n";
5116 }
5117 return ERR_OK;
5118 }
5119
ShowHelp(std::string & result)5120 void AbilityManagerService::ShowHelp(std::string& result)
5121 {
5122 result.append("Usage:\n")
5123 .append("-h ")
5124 .append("help text for the tool\n")
5125 .append("-a [-c | -u {UserId}] ")
5126 .append("dump all ability infomation in the system or all ability infomation of client/UserId\n")
5127 .append("-l ")
5128 .append("dump all mission list information in the system\n")
5129 .append("-i {AbilityRecordId} ")
5130 .append("dump an ability infomation by ability record id\n")
5131 .append("-e ")
5132 .append("dump all extension infomation in the system(FA: ServiceAbilityRecords, Stage: ExtensionRecords)\n")
5133 .append("-p [PendingWantRecordId] ")
5134 .append("dump all pendingwant record infomation in the system\n")
5135 .append("-r ")
5136 .append("dump all process in the system\n")
5137 .append("-d ")
5138 .append("dump all data ability infomation in the system");
5139 }
5140
ShowIllegalInfomation(std::string & result)5141 void AbilityManagerService::ShowIllegalInfomation(std::string& result)
5142 {
5143 result.append(ILLEGAL_INFOMATION);
5144 }
5145
DumpAbilityInfoDone(std::vector<std::string> & infos,const sptr<IRemoteObject> & callerToken)5146 int AbilityManagerService::DumpAbilityInfoDone(std::vector<std::string> &infos, const sptr<IRemoteObject> &callerToken)
5147 {
5148 HILOG_DEBUG("DumpAbilityInfoDone begin");
5149 auto abilityRecord = Token::GetAbilityRecordByToken(callerToken);
5150 if (abilityRecord == nullptr) {
5151 HILOG_ERROR("abilityRecord nullptr");
5152 return ERR_INVALID_VALUE;
5153 }
5154 if (!JudgeSelfCalled(abilityRecord)) {
5155 return CHECK_PERMISSION_FAILED;
5156 }
5157 abilityRecord->DumpAbilityInfoDone(infos);
5158 return ERR_OK;
5159 }
5160
5161 #ifdef SUPPORT_GRAPHICS
SetMissionLabel(const sptr<IRemoteObject> & token,const std::string & label)5162 int AbilityManagerService::SetMissionLabel(const sptr<IRemoteObject> &token, const std::string &label)
5163 {
5164 HILOG_DEBUG("%{public}s", __func__);
5165 auto abilityRecord = Token::GetAbilityRecordByToken(token);
5166 if (!abilityRecord) {
5167 HILOG_ERROR("no such ability record");
5168 return -1;
5169 }
5170
5171 auto callingTokenId = IPCSkeleton::GetCallingTokenID();
5172 auto tokenID = abilityRecord->GetApplicationInfo().accessTokenId;
5173 if (callingTokenId != tokenID) {
5174 HILOG_ERROR("SetMissionLabel not self, not enabled");
5175 return -1;
5176 }
5177
5178 auto userId = abilityRecord->GetOwnerMissionUserId();
5179 auto missionListManager = GetListManagerByUserId(userId);
5180 if (!missionListManager) {
5181 HILOG_ERROR("failed to find mission list manager when set mission label.");
5182 return -1;
5183 }
5184
5185 return missionListManager->SetMissionLabel(token, label);
5186 }
5187
SetMissionIcon(const sptr<IRemoteObject> & token,const std::shared_ptr<OHOS::Media::PixelMap> & icon)5188 int AbilityManagerService::SetMissionIcon(const sptr<IRemoteObject> &token,
5189 const std::shared_ptr<OHOS::Media::PixelMap> &icon)
5190 {
5191 HILOG_DEBUG("%{public}s", __func__);
5192 auto abilityRecord = Token::GetAbilityRecordByToken(token);
5193 if (!abilityRecord) {
5194 HILOG_ERROR("no such ability record");
5195 return -1;
5196 }
5197
5198 auto callingTokenId = IPCSkeleton::GetCallingTokenID();
5199 auto tokenID = abilityRecord->GetApplicationInfo().accessTokenId;
5200 if (callingTokenId != tokenID) {
5201 HILOG_ERROR("not self, not enable to set mission icon");
5202 return -1;
5203 }
5204
5205 auto userId = abilityRecord->GetOwnerMissionUserId();
5206 auto missionListManager = GetListManagerByUserId(userId);
5207 if (!missionListManager) {
5208 HILOG_ERROR("failed to find mission list manager.");
5209 return -1;
5210 }
5211
5212 return missionListManager->SetMissionIcon(token, icon);
5213 }
5214
RegisterWindowManagerServiceHandler(const sptr<IWindowManagerServiceHandler> & handler)5215 int AbilityManagerService::RegisterWindowManagerServiceHandler(const sptr<IWindowManagerServiceHandler> &handler)
5216 {
5217 auto isSaCall = AAFwk::PermissionVerification::GetInstance()->IsSACall();
5218 auto isGatewayCall = AAFwk::PermissionVerification::GetInstance()->IsGatewayCall();
5219 if (!isSaCall && !isGatewayCall) {
5220 HILOG_ERROR("%{public}s: Permission verification failed", __func__);
5221 return CHECK_PERMISSION_FAILED;
5222 }
5223 wmsHandler_ = handler;
5224 HILOG_DEBUG("%{public}s: WMS handler registered successfully.", __func__);
5225 return ERR_OK;
5226 }
5227
GetWMSHandler() const5228 sptr<IWindowManagerServiceHandler> AbilityManagerService::GetWMSHandler() const
5229 {
5230 return wmsHandler_;
5231 }
5232
CompleteFirstFrameDrawing(const sptr<IRemoteObject> & abilityToken)5233 void AbilityManagerService::CompleteFirstFrameDrawing(const sptr<IRemoteObject> &abilityToken)
5234 {
5235 HILOG_DEBUG("%{public}s is called.", __func__);
5236 std::shared_lock<std::shared_mutex> lock(managersMutex_);
5237 for (auto& item : missionListManagers_) {
5238 if (item.second) {
5239 item.second->CompleteFirstFrameDrawing(abilityToken);
5240 }
5241 }
5242 }
5243
ShowPickerDialog(const Want & want,int32_t userId,const sptr<IRemoteObject> & callerToken)5244 int32_t AbilityManagerService::ShowPickerDialog(
5245 const Want& want, int32_t userId, const sptr<IRemoteObject> &callerToken)
5246 {
5247 AAFwk::Want newWant = want;
5248 constexpr char PICKER_DIALOG_ABILITY_BUNDLE_NAME[] = "com.ohos.sharepickerdialog";
5249 constexpr char PICKER_DIALOG_ABILITY_NAME[] = "PickerDialog";
5250 constexpr char TOKEN_KEY[] = "ohos.ability.params.token";
5251 newWant.SetElementName(PICKER_DIALOG_ABILITY_BUNDLE_NAME, PICKER_DIALOG_ABILITY_NAME);
5252 newWant.SetParam(TOKEN_KEY, callerToken);
5253 // note: clear actions
5254 newWant.SetAction("");
5255 return IN_PROCESS_CALL(StartAbility(newWant, DEFAULT_INVAL_VALUE, userId));
5256 }
5257 #endif
5258
CheckWindowMode(int32_t windowMode,const std::vector<AppExecFwk::SupportWindowMode> & windowModes) const5259 bool AbilityManagerService::CheckWindowMode(int32_t windowMode,
5260 const std::vector<AppExecFwk::SupportWindowMode>& windowModes) const
5261 {
5262 HILOG_INFO("Window mode is %{public}d.", windowMode);
5263 if (windowMode == AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_UNDEFINED) {
5264 return true;
5265 }
5266 auto it = windowModeMap.find(windowMode);
5267 if (it != windowModeMap.end()) {
5268 auto bmsWindowMode = it->second;
5269 for (auto mode : windowModes) {
5270 if (mode == bmsWindowMode) {
5271 return true;
5272 }
5273 }
5274 }
5275 return false;
5276 }
5277
CheckCallServicePermission(const AbilityRequest & abilityRequest)5278 int AbilityManagerService::CheckCallServicePermission(const AbilityRequest &abilityRequest)
5279 {
5280 if (!IsUseNewStartUpRule(abilityRequest)) {
5281 return CheckCallerPermissionOldRule(abilityRequest);
5282 }
5283
5284 if (abilityRequest.abilityInfo.isStageBasedModel) {
5285 auto extensionType = abilityRequest.abilityInfo.extensionAbilityType;
5286 HILOG_INFO("extensionType is %{public}d.", static_cast<int>(extensionType));
5287 if (extensionType == AppExecFwk::ExtensionAbilityType::SERVICE ||
5288 extensionType == AppExecFwk::ExtensionAbilityType::DATASHARE) {
5289 return CheckCallServiceExtensionPermission(abilityRequest);
5290 } else {
5291 return CheckCallOtherExtensionPermission(abilityRequest);
5292 }
5293 } else {
5294 return CheckCallServiceAbilityPermission(abilityRequest);
5295 }
5296 }
5297
CheckCallDataAbilityPermission(AbilityRequest & abilityRequest)5298 int AbilityManagerService::CheckCallDataAbilityPermission(AbilityRequest &abilityRequest)
5299 {
5300 HILOG_INFO("%{public}s begin", __func__);
5301 abilityRequest.appInfo = abilityRequest.abilityInfo.applicationInfo;
5302 abilityRequest.uid = abilityRequest.appInfo.uid;
5303 if (abilityRequest.appInfo.name.empty() || abilityRequest.appInfo.bundleName.empty()) {
5304 HILOG_ERROR("Invalid app info for data ability acquiring.");
5305 return ERR_INVALID_VALUE;
5306 }
5307 if (abilityRequest.abilityInfo.type != AppExecFwk::AbilityType::DATA) {
5308 HILOG_ERROR("BMS query result is not a data ability.");
5309 return ERR_WRONG_INTERFACE_CALL;
5310 }
5311
5312 if (!IsUseNewStartUpRule(abilityRequest)) {
5313 return CheckCallerPermissionOldRule(abilityRequest);
5314 }
5315
5316 AAFwk::PermissionVerification::VerificationInfo verificationInfo = CreateVerificationInfo(abilityRequest);
5317 if (IsCallFromBackground(abilityRequest, verificationInfo.isBackgroundCall) != ERR_OK) {
5318 return ERR_INVALID_VALUE;
5319 }
5320 int result = AAFwk::PermissionVerification::GetInstance()->CheckCallDataAbilityPermission(verificationInfo);
5321 if (result != ERR_OK) {
5322 HILOG_ERROR("Do not have permission to start DataAbility");
5323 return result;
5324 }
5325
5326 return ERR_OK;
5327 }
5328
CreateVerificationInfo(const AbilityRequest & abilityRequest)5329 AAFwk::PermissionVerification::VerificationInfo AbilityManagerService::CreateVerificationInfo(
5330 const AbilityRequest &abilityRequest)
5331 {
5332 AAFwk::PermissionVerification::VerificationInfo verificationInfo;
5333 verificationInfo.accessTokenId = abilityRequest.appInfo.accessTokenId;
5334 verificationInfo.visible = abilityRequest.abilityInfo.visible;
5335 HILOG_DEBUG("Call ServiceAbility or DataAbility, target bundleName: %{public}s.",
5336 abilityRequest.appInfo.bundleName.c_str());
5337 if (whiteListassociatedWakeUpFlag_ &&
5338 WHITE_LIST_ASS_WAKEUP_SET.find(abilityRequest.appInfo.bundleName) != WHITE_LIST_ASS_WAKEUP_SET.end()) {
5339 HILOG_DEBUG("Call ServiceAbility or DataAbility, target bundle in white-list, allow associatedWakeUp.");
5340 verificationInfo.associatedWakeUp = true;
5341 } else {
5342 verificationInfo.associatedWakeUp = abilityRequest.appInfo.associatedWakeUp;
5343 }
5344 if (AAFwk::PermissionVerification::GetInstance()->IsSACall() ||
5345 AAFwk::PermissionVerification::GetInstance()->IsShellCall()) {
5346 HILOG_INFO("Caller is not an application.");
5347 return verificationInfo;
5348 }
5349 std::shared_ptr<AbilityRecord> callerAbility = Token::GetAbilityRecordByToken(abilityRequest.callerToken);
5350 if (callerAbility) {
5351 verificationInfo.apiTargetVersion = callerAbility->GetApplicationInfo().apiTargetVersion;
5352 }
5353
5354 return verificationInfo;
5355 }
5356
CheckCallServiceExtensionPermission(const AbilityRequest & abilityRequest)5357 int AbilityManagerService::CheckCallServiceExtensionPermission(const AbilityRequest &abilityRequest)
5358 {
5359 HILOG_INFO("CheckCallServiceExtensionPermission begin");
5360 if (!IsUseNewStartUpRule(abilityRequest)) {
5361 return CheckCallerPermissionOldRule(abilityRequest);
5362 }
5363
5364 AAFwk::PermissionVerification::VerificationInfo verificationInfo;
5365 verificationInfo.accessTokenId = abilityRequest.appInfo.accessTokenId;
5366 verificationInfo.visible = abilityRequest.abilityInfo.visible;
5367 if (IsCallFromBackground(abilityRequest, verificationInfo.isBackgroundCall) != ERR_OK) {
5368 return ERR_INVALID_VALUE;
5369 }
5370
5371 int result = AAFwk::PermissionVerification::GetInstance()->CheckCallServiceExtensionPermission(verificationInfo);
5372 if (result != ERR_OK) {
5373 HILOG_ERROR("Do not have permission to start ServiceExtension or DataShareExtension");
5374 }
5375 return result;
5376 }
5377
CheckCallOtherExtensionPermission(const AbilityRequest & abilityRequest)5378 int AbilityManagerService::CheckCallOtherExtensionPermission(const AbilityRequest &abilityRequest)
5379 {
5380 HILOG_INFO("CheckCallOtherExtensionPermission begin");
5381 if (!IsUseNewStartUpRule(abilityRequest)) {
5382 return CheckCallerPermissionOldRule(abilityRequest);
5383 }
5384
5385 if (AAFwk::PermissionVerification::GetInstance()->IsSACall() ||
5386 AAFwk::PermissionVerification::GetInstance()->IsGatewayCall()) {
5387 return ERR_OK;
5388 }
5389
5390 auto extensionType = abilityRequest.abilityInfo.extensionAbilityType;
5391 HILOG_DEBUG("OtherExtension type: %{public}d.", static_cast<int32_t>(extensionType));
5392 if (extensionType == AppExecFwk::ExtensionAbilityType::WINDOW) {
5393 return ERR_OK;
5394 }
5395 const std::string fileAccessPermission = "ohos.permission.FILE_ACCESS_MANAGER";
5396 if (extensionType == AppExecFwk::ExtensionAbilityType::FILEACCESS_EXTENSION &&
5397 AAFwk::PermissionVerification::GetInstance()->VerifyCallingPermission(fileAccessPermission)) {
5398 HILOG_DEBUG("Temporary, FILEACCESS_EXTENSION use serviceExtension start-up rule.");
5399 return CheckCallServiceExtensionPermission(abilityRequest);
5400 }
5401
5402 HILOG_ERROR("CheckCallOtherExtensionPermission, Not SA, can not start other Extension");
5403 return CHECK_PERMISSION_FAILED;
5404 }
5405
5406
CheckCallServiceAbilityPermission(const AbilityRequest & abilityRequest)5407 int AbilityManagerService::CheckCallServiceAbilityPermission(const AbilityRequest &abilityRequest)
5408 {
5409 HILOG_INFO("%{public}s begin", __func__);
5410 if (!IsUseNewStartUpRule(abilityRequest)) {
5411 return CheckCallerPermissionOldRule(abilityRequest);
5412 }
5413
5414 AAFwk::PermissionVerification::VerificationInfo verificationInfo = CreateVerificationInfo(abilityRequest);
5415 if (IsCallFromBackground(abilityRequest, verificationInfo.isBackgroundCall) != ERR_OK) {
5416 return ERR_INVALID_VALUE;
5417 }
5418
5419 int result = AAFwk::PermissionVerification::GetInstance()->CheckCallServiceAbilityPermission(verificationInfo);
5420 if (result != ERR_OK) {
5421 HILOG_ERROR("Do not have permission to start ServiceAbility");
5422 }
5423 return result;
5424 }
5425
CheckCallAbilityPermission(const AbilityRequest & abilityRequest)5426 int AbilityManagerService::CheckCallAbilityPermission(const AbilityRequest &abilityRequest)
5427 {
5428 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
5429 HILOG_INFO("%{public}s begin", __func__);
5430 if (!IsUseNewStartUpRule(abilityRequest)) {
5431 return CheckCallerPermissionOldRule(abilityRequest);
5432 }
5433
5434 AAFwk::PermissionVerification::VerificationInfo verificationInfo;
5435 verificationInfo.accessTokenId = abilityRequest.appInfo.accessTokenId;
5436 verificationInfo.visible = abilityRequest.abilityInfo.visible;
5437 if (IsCallFromBackground(abilityRequest, verificationInfo.isBackgroundCall) != ERR_OK) {
5438 return ERR_INVALID_VALUE;
5439 }
5440
5441 int result = AAFwk::PermissionVerification::GetInstance()->CheckCallAbilityPermission(verificationInfo);
5442 if (result != ERR_OK) {
5443 HILOG_ERROR("Do not have permission to start PageAbility(FA) or Ability(Stage)");
5444 }
5445 return result;
5446 }
5447
CheckStartByCallPermission(const AbilityRequest & abilityRequest)5448 int AbilityManagerService::CheckStartByCallPermission(const AbilityRequest &abilityRequest)
5449 {
5450 HILOG_INFO("%{public}s begin", __func__);
5451 // check whether the target ability is singleton mode and page type.
5452 if (abilityRequest.abilityInfo.type == AppExecFwk::AbilityType::PAGE &&
5453 abilityRequest.abilityInfo.launchMode == AppExecFwk::LaunchMode::SINGLETON) {
5454 HILOG_DEBUG("Called ability is common ability and singleton.");
5455 } else {
5456 HILOG_ERROR("Called ability is not common ability or singleton.");
5457 return RESOLVE_CALL_ABILITY_TYPE_ERR;
5458 }
5459
5460 if (!IsUseNewStartUpRule(abilityRequest)) {
5461 return CheckCallerPermissionOldRule(abilityRequest, true);
5462 }
5463
5464 AAFwk::PermissionVerification::VerificationInfo verificationInfo;
5465 verificationInfo.accessTokenId = abilityRequest.appInfo.accessTokenId;
5466 verificationInfo.visible = abilityRequest.abilityInfo.visible;
5467 if (IsCallFromBackground(abilityRequest, verificationInfo.isBackgroundCall) != ERR_OK) {
5468 return ERR_INVALID_VALUE;
5469 }
5470
5471 if (AAFwk::PermissionVerification::GetInstance()->CheckStartByCallPermission(verificationInfo) != ERR_OK) {
5472 HILOG_ERROR("Do not have permission to StartAbilityByCall.");
5473 return RESOLVE_CALL_NO_PERMISSIONS;
5474 }
5475 HILOG_DEBUG("The caller has permission to resolve the call proxy of common ability.");
5476
5477 return ERR_OK;
5478 }
5479
IsCallFromBackground(const AbilityRequest & abilityRequest,bool & isBackgroundCall)5480 int AbilityManagerService::IsCallFromBackground(const AbilityRequest &abilityRequest, bool &isBackgroundCall)
5481 {
5482 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
5483 if (AAFwk::PermissionVerification::GetInstance()->IsSACall()) {
5484 return ERR_OK;
5485 }
5486
5487 if (AAFwk::PermissionVerification::GetInstance()->IsShellCall()) {
5488 isBackgroundCall = true;
5489 return ERR_OK;
5490 }
5491
5492 if (AbilityUtil::IsStartFreeInstall(abilityRequest.want)) {
5493 isBackgroundCall = false;
5494 return ERR_OK;
5495 }
5496
5497 AppExecFwk::RunningProcessInfo processInfo;
5498 std::shared_ptr<AbilityRecord> callerAbility = Token::GetAbilityRecordByToken(abilityRequest.callerToken);
5499 if (callerAbility) {
5500 DelayedSingleton<AppScheduler>::GetInstance()->
5501 GetRunningProcessInfoByToken(callerAbility->GetToken(), processInfo);
5502 } else {
5503 auto callerPid = IPCSkeleton::GetCallingPid();
5504 DelayedSingleton<AppScheduler>::GetInstance()->GetRunningProcessInfoByPid(callerPid, processInfo);
5505 if (processInfo.processName_.empty() && !AAFwk::PermissionVerification::GetInstance()->IsGatewayCall()) {
5506 HILOG_DEBUG("Can not find caller application by callerPid: %{private}d.", callerPid);
5507 if (AAFwk::PermissionVerification::GetInstance()->VerifyCallingPermission(
5508 PermissionConstants::PERMISSION_START_ABILITIES_FROM_BACKGROUND)) {
5509 HILOG_DEBUG("Caller has PERMISSION_START_ABILITIES_FROM_BACKGROUND, PASS.");
5510 isBackgroundCall = false;
5511 return ERR_OK;
5512 }
5513 HILOG_ERROR("Caller does not have PERMISSION_START_ABILITIES_FROM_BACKGROUND, REJECT.");
5514 return ERR_INVALID_VALUE;
5515 }
5516 }
5517
5518 if (IsDelegatorCall(processInfo, abilityRequest)) {
5519 HILOG_DEBUG("The call is from AbilityDelegator, allow background-call.");
5520 isBackgroundCall = false;
5521 return ERR_OK;
5522 }
5523
5524 if (backgroundJudgeFlag_) {
5525 isBackgroundCall = processInfo.state_ != AppExecFwk::AppProcessState::APP_STATE_FOREGROUND &&
5526 !processInfo.isFocused;
5527 } else {
5528 isBackgroundCall = !processInfo.isFocused;
5529 if (!processInfo.isFocused && processInfo.state_ == AppExecFwk::AppProcessState::APP_STATE_FOREGROUND) {
5530 // Allow background startup within 1 second after application startup if state is FOREGROUND
5531 int64_t aliveTime = AbilityUtil::SystemTimeMillis() - processInfo.startTimeMillis_;
5532 isBackgroundCall = aliveTime > APP_ALIVE_TIME_MS;
5533 HILOG_DEBUG("Process %{public}s is alive %{public}s ms.",
5534 processInfo.processName_.c_str(), std::to_string(aliveTime).c_str());
5535 }
5536 }
5537 HILOG_DEBUG("backgroundJudgeFlag: %{public}d, isBackgroundCall: %{public}d, callerAppState: %{public}d.",
5538 static_cast<int32_t>(backgroundJudgeFlag_),
5539 static_cast<int32_t>(isBackgroundCall),
5540 static_cast<int32_t>(processInfo.state_));
5541
5542 return ERR_OK;
5543 }
5544
IsDelegatorCall(const AppExecFwk::RunningProcessInfo & processInfo,const AbilityRequest & abilityRequest)5545 inline bool AbilityManagerService::IsDelegatorCall(
5546 const AppExecFwk::RunningProcessInfo &processInfo, const AbilityRequest &abilityRequest)
5547 {
5548 /* To make sure the AbilityDelegator is not counterfeited
5549 * 1. The caller-process must be test-process
5550 * 2. The callerToken must be nullptr
5551 */
5552 if (processInfo.isTestProcess &&
5553 !abilityRequest.callerToken && abilityRequest.want.GetBoolParam(IS_DELEGATOR_CALL, false)) {
5554 return true;
5555 }
5556 return false;
5557 }
5558
CheckCallerPermissionOldRule(const AbilityRequest & abilityRequest,const bool isStartByCall)5559 int AbilityManagerService::CheckCallerPermissionOldRule(const AbilityRequest &abilityRequest, const bool isStartByCall)
5560 {
5561 if (IPCSkeleton::GetCallingTokenID() == abilityRequest.abilityInfo.applicationInfo.accessTokenId) {
5562 return ERR_OK;
5563 }
5564 if (isStartByCall) {
5565 auto abilityInfo = abilityRequest.abilityInfo;
5566 auto callerUid = abilityRequest.callerUid;
5567
5568 if (!CheckCallerEligibility(abilityInfo, callerUid)) {
5569 HILOG_ERROR("called ability has no permission.");
5570 return RESOLVE_CALL_NO_PERMISSIONS;
5571 }
5572
5573 HILOG_DEBUG("the caller has permission to resolve the call proxy of common ability.");
5574 // check whether the target ability is singleton mode and page type.
5575 if (abilityInfo.type == AppExecFwk::AbilityType::PAGE &&
5576 abilityInfo.launchMode == AppExecFwk::LaunchMode::SINGLETON) {
5577 HILOG_DEBUG("called ability is common ability and singleton.");
5578 } else {
5579 HILOG_ERROR("called ability is not common ability or singleton.");
5580 return RESOLVE_CALL_ABILITY_TYPE_ERR;
5581 }
5582 return ERR_OK;
5583 } else {
5584 return JudgeAbilityVisibleControl(abilityRequest.abilityInfo);
5585 }
5586 }
5587
IsUseNewStartUpRule(const AbilityRequest & abilityRequest)5588 bool AbilityManagerService::IsUseNewStartUpRule(const AbilityRequest &abilityRequest)
5589 {
5590 if (!startUpNewRule_) {
5591 return false;
5592 }
5593
5594 if (AAFwk::PermissionVerification::GetInstance()->IsSACall() ||
5595 AAFwk::PermissionVerification::GetInstance()->IsShellCall()) {
5596 HILOG_INFO("Caller is not an application.");
5597 return true;
5598 }
5599
5600 // TEMP, white list
5601 std::shared_ptr<AbilityRecord> callerAbility = Token::GetAbilityRecordByToken(abilityRequest.callerToken);
5602 if (callerAbility) {
5603 const std::string bundleName = callerAbility->GetApplicationInfo().bundleName;
5604 HILOG_DEBUG("IsUseNewStartUpRule, caller bundleName is %{public}s.", bundleName.c_str());
5605 if (whiteListNormalFlag_ && WHITE_LIST_NORMAL_SET.find(bundleName) != WHITE_LIST_NORMAL_SET.end()) {
5606 return false;
5607 }
5608 if (newRuleExceptLauncherSystemUI_ &&
5609 (bundleName == BUNDLE_NAME_LAUNCHER || bundleName == BUNDLE_NAME_SYSTEMUI)) {
5610 return false;
5611 }
5612 }
5613 HILOG_INFO("Use new startup rule");
5614 return true;
5615 }
5616
CheckNewRuleSwitchState(const std::string & param)5617 bool AbilityManagerService::CheckNewRuleSwitchState(const std::string ¶m)
5618 {
5619 char value[NEW_RULE_VALUE_SIZE] = "false";
5620 int retSysParam = GetParameter(param.c_str(), "false", value, NEW_RULE_VALUE_SIZE);
5621 HILOG_INFO("CheckNewRuleSwitchState, %{public}s value is %{public}s.", param.c_str(), value);
5622 if (retSysParam > 0 && !std::strcmp(value, "true")) {
5623 return true;
5624 }
5625 return false;
5626 }
5627
GetStartUpNewRuleFlag() const5628 bool AbilityManagerService::GetStartUpNewRuleFlag() const
5629 {
5630 return startUpNewRule_;
5631 }
5632
CallRequestDone(const sptr<IRemoteObject> & token,const sptr<IRemoteObject> & callStub)5633 void AbilityManagerService::CallRequestDone(const sptr<IRemoteObject> &token, const sptr<IRemoteObject> &callStub)
5634 {
5635 auto abilityRecord = Token::GetAbilityRecordByToken(token);
5636 CHECK_POINTER(abilityRecord);
5637 if (!JudgeSelfCalled(abilityRecord)) {
5638 return;
5639 }
5640 abilityRecord->CallRequestDone(callStub);
5641 }
5642
AddStartControlParam(Want & want,const sptr<IRemoteObject> & callerToken)5643 int AbilityManagerService::AddStartControlParam(Want &want, const sptr<IRemoteObject> &callerToken)
5644 {
5645 if (AAFwk::PermissionVerification::GetInstance()->IsSACall() ||
5646 AAFwk::PermissionVerification::GetInstance()->IsShellCall()) {
5647 return ERR_OK;
5648 }
5649 auto abilityRecord = Token::GetAbilityRecordByToken(callerToken);
5650 CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE);
5651 int32_t apiVersion = abilityRecord->GetApplicationInfo().apiTargetVersion;
5652 want.SetParam(DMS_API_VERSION, apiVersion);
5653 bool isCallerBackground = true;
5654 AppExecFwk::RunningProcessInfo processInfo;
5655 DelayedSingleton<AppScheduler>::GetInstance()->
5656 GetRunningProcessInfoByToken(abilityRecord->GetToken(), processInfo);
5657 if (backgroundJudgeFlag_) {
5658 isCallerBackground = processInfo.state_ != AppExecFwk::AppProcessState::APP_STATE_FOREGROUND;
5659 } else {
5660 isCallerBackground = !processInfo.isFocused;
5661 }
5662 want.SetParam(DMS_IS_CALLER_BACKGROUND, isCallerBackground);
5663 return ERR_OK;
5664 }
5665
JudgeSelfCalled(const std::shared_ptr<AbilityRecord> & abilityRecord)5666 bool AbilityManagerService::JudgeSelfCalled(const std::shared_ptr<AbilityRecord> &abilityRecord)
5667 {
5668 auto isSaCall = AAFwk::PermissionVerification::GetInstance()->IsSACall();
5669 if (isSaCall) {
5670 return true;
5671 }
5672
5673 auto callingTokenId = IPCSkeleton::GetCallingTokenID();
5674 auto tokenID = abilityRecord->GetApplicationInfo().accessTokenId;
5675 if (callingTokenId != tokenID && !AAFwk::PermissionVerification::GetInstance()->IsGatewayCall()) {
5676 HILOG_ERROR("Is not self, not enabled");
5677 return false;
5678 }
5679
5680 return true;
5681 }
5682
SetComponentInterception(const sptr<AppExecFwk::IComponentInterception> & componentInterception)5683 int AbilityManagerService::SetComponentInterception(
5684 const sptr<AppExecFwk::IComponentInterception> &componentInterception)
5685 {
5686 HILOG_DEBUG("%{public}s", __func__);
5687 auto isPerm = AAFwk::PermissionVerification::GetInstance()->IsGatewayCall();
5688 if (!isPerm) {
5689 HILOG_ERROR("%{public}s: Permission verification failed", __func__);
5690 return CHECK_PERMISSION_FAILED;
5691 }
5692
5693 std::lock_guard<std::recursive_mutex> guard(globalLock_);
5694 componentInterception_ = componentInterception;
5695 HILOG_DEBUG("%{public}s, end", __func__);
5696 return ERR_OK;
5697 }
5698
IsComponentInterceptionStart(const Want & want,ComponentRequest & componentRequest,AbilityRequest & request)5699 bool AbilityManagerService::IsComponentInterceptionStart(const Want &want, ComponentRequest &componentRequest,
5700 AbilityRequest &request)
5701 {
5702 if (componentInterception_ != nullptr) {
5703 Want newWant = want;
5704 int32_t type = static_cast<int32_t>(request.abilityInfo.type);
5705 newWant.SetParam("abilityType", type);
5706 int32_t launchMode = static_cast<int32_t>(request.abilityInfo.launchMode);
5707 newWant.SetParam("launchMode", launchMode);
5708
5709 HILOG_DEBUG("%{public}s", __func__);
5710 sptr<Want> extraParam = new (std::nothrow) Want();
5711 bool isStart = componentInterception_->AllowComponentStart(newWant, componentRequest.callerToken,
5712 componentRequest.requestCode, componentRequest.componentStatus, extraParam);
5713 componentRequest.requestResult = extraParam->GetIntParam("requestResult", 0);
5714 UpdateAbilityRequestInfo(extraParam, request);
5715 if (!isStart) {
5716 HILOG_INFO("not finishing start component because interception, requestResult: %{public}d",
5717 componentRequest.requestResult);
5718 return false;
5719 }
5720 }
5721 return true;
5722 }
5723
NotifyHandleAbilityStateChange(const sptr<IRemoteObject> & abilityToken,int opCode)5724 void AbilityManagerService::NotifyHandleAbilityStateChange(const sptr<IRemoteObject> &abilityToken, int opCode)
5725 {
5726 if (componentInterception_ != nullptr) {
5727 componentInterception_->NotifyHandleAbilityStateChange(abilityToken, opCode);
5728 }
5729 }
5730
initComponentRequest(const sptr<IRemoteObject> & callerToken,const int requestCode,const int componentStatus)5731 ComponentRequest AbilityManagerService::initComponentRequest(const sptr<IRemoteObject> &callerToken,
5732 const int requestCode, const int componentStatus)
5733 {
5734 ComponentRequest componentRequest;
5735 componentRequest.callerToken = callerToken;
5736 componentRequest.requestCode = requestCode;
5737 componentRequest.componentStatus = componentStatus;
5738 return componentRequest;
5739 }
5740
UpdateAbilityRequestInfo(const sptr<Want> & want,AbilityRequest & request)5741 void AbilityManagerService::UpdateAbilityRequestInfo(const sptr<Want> &want, AbilityRequest &request)
5742 {
5743 if (want == nullptr) {
5744 return;
5745 }
5746 sptr<IRemoteObject> tempCallBack = want->GetRemoteObject(Want::PARAM_RESV_ABILITY_INFO_CALLBACK);
5747 if (tempCallBack == nullptr) {
5748 return;
5749 }
5750 int32_t procCode = want->GetIntParam(Want::PARAM_RESV_REQUEST_PROC_CODE, 0);
5751 if (procCode != 0) {
5752 request.want.SetParam(Want::PARAM_RESV_REQUEST_PROC_CODE, procCode);
5753 }
5754 int32_t tokenCode = want->GetIntParam(Want::PARAM_RESV_REQUEST_TOKEN_CODE, 0);
5755 if (tokenCode != 0) {
5756 request.want.SetParam(Want::PARAM_RESV_REQUEST_TOKEN_CODE, tokenCode);
5757 }
5758 request.abilityInfoCallback = tempCallBack;
5759 }
5760
SendResultToAbilityByToken(const Want & want,const sptr<IRemoteObject> & abilityToken,int32_t requestCode,int32_t resultCode,int32_t userId)5761 int32_t AbilityManagerService::SendResultToAbilityByToken(const Want &want, const sptr<IRemoteObject> &abilityToken,
5762 int32_t requestCode, int32_t resultCode, int32_t userId)
5763 {
5764 HILOG_DEBUG("%{public}s, requestCode: %{public}d, resultCode: %{public}d", __func__, requestCode, resultCode);
5765 auto isGatewayCall = AAFwk::PermissionVerification::GetInstance()->IsGatewayCall();
5766 if (!isGatewayCall) {
5767 HILOG_ERROR("%{public}s, Permission verification failed", __func__);
5768 return CHECK_PERMISSION_FAILED;
5769 }
5770 std::shared_ptr<AbilityRecord> abilityRecord = Token::GetAbilityRecordByToken(abilityToken);
5771 if (abilityRecord == nullptr) {
5772 HILOG_ERROR("%{public}s, abilityRecord is null", __func__);
5773 return ERR_INVALID_VALUE;
5774 }
5775 abilityRecord->SetResult(std::make_shared<AbilityResult>(requestCode, resultCode, want));
5776 abilityRecord->SendResult();
5777 return ERR_OK;
5778 }
5779
GetFocusAbility()5780 std::shared_ptr<AbilityRecord> AbilityManagerService::GetFocusAbility()
5781 {
5782 #ifdef SUPPORT_GRAPHICS
5783 sptr<IRemoteObject> token;
5784 if (!wmsHandler_) {
5785 HILOG_ERROR("wmsHandler_ is nullptr.");
5786 return nullptr;
5787 }
5788
5789 wmsHandler_->GetFocusWindow(token);
5790 if (!token) {
5791 HILOG_ERROR("token is nullptr");
5792 return nullptr;
5793 }
5794
5795 auto abilityRecord = Token::GetAbilityRecordByToken(token);
5796 if (!abilityRecord) {
5797 HILOG_ERROR("abilityRecord is nullptr.");
5798 }
5799 return abilityRecord;
5800 #endif
5801
5802 return nullptr;
5803 }
5804 } // namespace AAFwk
5805 } // namespace OHOS
5806