1 /*
2 * Copyright (c) 2021-2025 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 "app_mgr_service.h"
17
18 #include <chrono>
19 #include <cstdlib>
20 #include <nlohmann/json.hpp>
21 #include <sys/types.h>
22 #include <thread>
23
24 #include "ability_manager_errors.h"
25 #include "ability_manager_xcollie.h"
26 #include "app_death_recipient.h"
27 #include "app_mgr_constants.h"
28 #include "datetime_ex.h"
29 #include "fd_guard.h"
30 #include "freeze_util.h"
31 #include "global_constant.h"
32 #include "hilog_tag_wrapper.h"
33 #include "hitrace_meter.h"
34 #include "in_process_call_wrapper.h"
35 #include "ipc_skeleton.h"
36 #include "perf_profile.h"
37 #include "permission_constants.h"
38 #include "permission_verification.h"
39 #include "system_ability_definition.h"
40 #include "accesstoken_kit.h"
41 #include "app_mgr_service_const.h"
42 #include "app_mgr_service_dump_error_code.h"
43 #include "cache_process_manager.h"
44 #include "uri_permission_manager_client.h"
45
46 namespace OHOS {
47 namespace AppExecFwk {
48 using AAFwk::FdGuard;
49 constexpr const char* OPTION_KEY_HELP = "-h";
50 constexpr const char* OPTION_KEY_DUMP_IPC = "--ipc";
51 constexpr const char* OPTION_KEY_DUMP_FFRT = "--ffrt";
52 const int32_t HIDUMPER_SERVICE_UID = 1212;
53 constexpr const int INDEX_PID = 1;
54 constexpr const int INDEX_CMD = 2;
55 constexpr const size_t VALID_DUMP_IPC_ARG_SIZE = 3;
56 constexpr const size_t VALID_DUMP_FFRT_ARG_SIZE = 2;
57 constexpr const int MAX_DUMP_FFRT_PID_NUMBER = 3;
58 constexpr const int BASE_TEN = 10;
59 constexpr const char SIGN_TERMINAL = '\0';
60 constexpr int32_t DEFAULT_CONCURRENT_NUMBER = 1;
61 namespace {
62 using namespace std::chrono_literals;
63 constexpr const char* TASK_INIT_APPMGRSERVICEINNER = "InitAppMgrServiceInnerTask";
64 constexpr const char* TASK_ATTACH_APPLICATION = "AttachApplicationTask";
65 constexpr const char* TASK_APPLICATION_FOREGROUNDED = "ApplicationForegroundedTask";
66 constexpr const char* TASK_APPLICATION_BACKGROUNDED = "ApplicationBackgroundedTask";
67 constexpr const char* TASK_APPLICATION_TERMINATED = "ApplicationTerminatedTask";
68 constexpr const char* TASK_ABILITY_CLEANED = "AbilityCleanedTask";
69 constexpr const char* TASK_STARTUP_RESIDENT_PROCESS = "StartupResidentProcess";
70 constexpr const char* TASK_ADD_ABILITY_STAGE_DONE = "AddAbilityStageDone";
71 constexpr const char* TASK_START_USER_TEST_PROCESS = "StartUserTestProcess";
72 constexpr const char* TASK_FINISH_USER_TEST = "FinishUserTest";
73 constexpr const char* TASK_ATTACH_RENDER_PROCESS = "AttachRenderTask";
74 #ifdef SUPPORT_CHILD_PROCESS
75 constexpr const char* TASK_ATTACH_CHILD_PROCESS = "AttachChildProcessTask";
76 constexpr const char* TASK_EXIT_CHILD_PROCESS_SAFELY = "ExitChildProcessSafelyTask";
77 #endif // SUPPORT_CHILD_PROCESS
78 constexpr const char* FOUNDATION_PROCESS = "foundation";
79 constexpr const char* BS_PROCESS_NAME = "bgtaskmgr_service";
80 constexpr int32_t USER_UID = 2000;
81 constexpr const char* HIVIEW_PROCESS_NAME = "hiview";
82 constexpr const char* DEBUG_FROM = "ohos.param.debugFrom";
83 } // namespace
84
85 REGISTER_SYSTEM_ABILITY_BY_ID(AppMgrService, APP_MGR_SERVICE_ID, true);
86
AppMgrService()87 AppMgrService::AppMgrService()
88 {
89 appMgrServiceInner_ = std::make_shared<AppMgrServiceInner>();
90 TAG_LOGI(AAFwkTag::APPMGR, "instance created");
91 PerfProfile::GetInstance().SetAmsLoadStartTime(GetTickCount());
92 }
93
AppMgrService(const int32_t serviceId,bool runOnCreate)94 AppMgrService::AppMgrService(const int32_t serviceId, bool runOnCreate) : SystemAbility(serviceId, runOnCreate)
95 {
96 appMgrServiceInner_ = std::make_shared<AppMgrServiceInner>();
97 TAG_LOGI(AAFwkTag::APPMGR, "instance created");
98 PerfProfile::GetInstance().SetAmsLoadStartTime(GetTickCount());
99 }
100
~AppMgrService()101 AppMgrService::~AppMgrService()
102 {
103 TAG_LOGI(AAFwkTag::APPMGR, "instance destroyed");
104 }
105
OnStart()106 void AppMgrService::OnStart()
107 {
108 TAG_LOGI(AAFwkTag::APPMGR, "start service ready");
109 if (appMgrServiceState_.serviceRunningState == ServiceRunningState::STATE_RUNNING) {
110 TAG_LOGW(AAFwkTag::APPMGR, "start service fail");
111 return;
112 }
113
114 ErrCode errCode = Init();
115 if (FAILED(errCode)) {
116 TAG_LOGE(AAFwkTag::APPMGR, "fail, errCode: %{public}08x", errCode);
117 return;
118 }
119 appMgrServiceState_.serviceRunningState = ServiceRunningState::STATE_RUNNING;
120 if (!AddSystemAbilityListener(WINDOW_MANAGER_SERVICE_ID)) {
121 TAG_LOGE(AAFwkTag::APPMGR, "OnStart, add listener err");
122 }
123 if (!AddSystemAbilityListener(URI_PERMISSION_MGR_SERVICE_ID)) {
124 TAG_LOGE(AAFwkTag::APPMGR, "failed to add upms listener");
125 }
126 TAG_LOGI(AAFwkTag::APPMGR, "start service success");
127 PerfProfile::GetInstance().SetAmsLoadEndTime(GetTickCount());
128 PerfProfile::GetInstance().Dump();
129 }
130
OnStop()131 void AppMgrService::OnStop()
132 {
133 TAG_LOGI(AAFwkTag::APPMGR, "stop service ready");
134 appMgrServiceState_.serviceRunningState = ServiceRunningState::STATE_NOT_START;
135 eventHandler_.reset();
136 taskHandler_.reset();
137 if (appMgrServiceInner_) {
138 appMgrServiceInner_->OnStop();
139 }
140 TAG_LOGI(AAFwkTag::APPMGR, "stop service success");
141 }
142
SetInnerService(const std::shared_ptr<AppMgrServiceInner> & innerService)143 void AppMgrService::SetInnerService(const std::shared_ptr<AppMgrServiceInner> &innerService)
144 {
145 appMgrServiceInner_ = innerService;
146 }
147
QueryServiceState()148 AppMgrServiceState AppMgrService::QueryServiceState()
149 {
150 if (appMgrServiceInner_) {
151 appMgrServiceState_.connectionState = appMgrServiceInner_->QueryAppSpawnConnectionState();
152 }
153 return appMgrServiceState_;
154 }
155
Init()156 ErrCode AppMgrService::Init()
157 {
158 TAG_LOGI(AAFwkTag::APPMGR, "init ready");
159 if (!appMgrServiceInner_) {
160 TAG_LOGE(AAFwkTag::APPMGR, "init failed");
161 return ERR_INVALID_OPERATION;
162 }
163
164 taskHandler_ = AAFwk::TaskHandlerWrap::CreateConcurrentQueueHandler("app_mgr_task_queue",
165 DEFAULT_CONCURRENT_NUMBER);
166 taskHandler_->SetPrintTaskLog(true);
167 eventHandler_ = std::make_shared<AMSEventHandler>(taskHandler_, appMgrServiceInner_);
168 appMgrServiceInner_->SetTaskHandler(taskHandler_);
169 appMgrServiceInner_->SetEventHandler(eventHandler_);
170 DelayedSingleton<CacheProcessManager>::GetInstance()->SetAppMgr(appMgrServiceInner_);
171 std::function<void()> initAppMgrServiceInnerTask = [appMgrServiceInner = appMgrServiceInner_]() {
172 appMgrServiceInner->Init();
173 };
174 taskHandler_->SubmitTask(initAppMgrServiceInnerTask, TASK_INIT_APPMGRSERVICEINNER);
175
176 ErrCode openErr = appMgrServiceInner_->OpenAppSpawnConnection();
177 if (FAILED(openErr)) {
178 TAG_LOGW(AAFwkTag::APPMGR, "fail, errCode: %{public}08x", openErr);
179 }
180 if (!Publish(this)) {
181 TAG_LOGE(AAFwkTag::APPMGR, " publish fail");
182 return ERR_APPEXECFWK_SERVICE_NOT_CONNECTED;
183 }
184 amsMgrScheduler_ = new (std::nothrow) AmsMgrScheduler(appMgrServiceInner_, taskHandler_);
185 if (!amsMgrScheduler_) {
186 TAG_LOGE(AAFwkTag::APPMGR, "init failed");
187 return ERR_INVALID_OPERATION;
188 }
189 TAG_LOGI(AAFwkTag::APPMGR, "init success");
190 return ERR_OK;
191 }
192
AttachApplication(const sptr<IRemoteObject> & app)193 void AppMgrService::AttachApplication(const sptr<IRemoteObject> &app)
194 {
195 TAG_LOGD(AAFwkTag::APPMGR, "called");
196 if (!IsReady()) {
197 TAG_LOGE(AAFwkTag::APPMGR, "AttachApplication failed");
198 return;
199 }
200
201 AbilityRuntime::FreezeUtil::GetInstance().AddAppLifecycleEvent(IPCSkeleton::GetCallingPid(),
202 "AppMgrService::AttachApplication");
203 pid_t pid = IPCSkeleton::GetCallingPid();
204 auto appScheduler = iface_cast<IAppScheduler>(app);
205 if (appScheduler == nullptr) {
206 TAG_LOGE(AAFwkTag::APPMGR, "appScheduler null");
207 }
208 std::function<void()> attachApplicationFunc = [appMgrServiceInner = appMgrServiceInner_, pid, appScheduler]() {
209 appMgrServiceInner->AttachApplication(pid, appScheduler);
210 };
211 taskHandler_->SubmitTask(attachApplicationFunc, AAFwk::TaskAttribute{
212 .taskName_ = TASK_ATTACH_APPLICATION,
213 .taskQos_ = AAFwk::TaskQoS::USER_INTERACTIVE
214 });
215 }
216
PreloadApplication(const std::string & bundleName,int32_t userId,AppExecFwk::PreloadMode preloadMode,int32_t appIndex)217 int32_t AppMgrService::PreloadApplication(const std::string &bundleName, int32_t userId,
218 AppExecFwk::PreloadMode preloadMode, int32_t appIndex)
219 {
220 XCOLLIE_TIMER_LESS(__PRETTY_FUNCTION__);
221 TAG_LOGD(AAFwkTag::APPMGR, "PreloadApplication called");
222 if (!IsReady()) {
223 TAG_LOGE(AAFwkTag::APPMGR, "PreloadApplication failed");
224 return ERR_INVALID_OPERATION;
225 }
226 return appMgrServiceInner_->PreloadApplication(bundleName, userId, preloadMode, appIndex);
227 }
228
PreloadModuleFinished(const int32_t recordId)229 void AppMgrService::PreloadModuleFinished(const int32_t recordId)
230 {
231 TAG_LOGD(AAFwkTag::APPMGR, "PreloadModuleFinished called");
232 if (!IsReady()) {
233 TAG_LOGE(AAFwkTag::APPMGR, "PreloadModuleFinished failed");
234 return;
235 }
236 if (!JudgeAppSelfCalled(recordId)) {
237 return;
238 }
239 return appMgrServiceInner_->PreloadModuleFinished(IPCSkeleton::GetCallingPid());
240 }
241
ApplicationForegrounded(const int32_t recordId)242 void AppMgrService::ApplicationForegrounded(const int32_t recordId)
243 {
244 if (!IsReady()) {
245 return;
246 }
247 if (!JudgeAppSelfCalled(recordId)) {
248 return;
249 }
250 AbilityRuntime::FreezeUtil::GetInstance().AddAppLifecycleEvent(IPCSkeleton::GetCallingPid(),
251 "AppMgrService::AppForegrounded");
252 std::function<void()> applicationForegroundedFunc = [appMgrServiceInner = appMgrServiceInner_, recordId]() {
253 appMgrServiceInner->ApplicationForegrounded(recordId);
254 };
255 taskHandler_->SubmitTask(applicationForegroundedFunc, AAFwk::TaskAttribute{
256 .taskName_ = TASK_APPLICATION_FOREGROUNDED,
257 .taskQos_ = AAFwk::TaskQoS::USER_INTERACTIVE
258 });
259 }
260
ApplicationBackgrounded(const int32_t recordId)261 void AppMgrService::ApplicationBackgrounded(const int32_t recordId)
262 {
263 if (!IsReady()) {
264 return;
265 }
266 if (!JudgeAppSelfCalled(recordId)) {
267 return;
268 }
269 AbilityRuntime::FreezeUtil::GetInstance().AddAppLifecycleEvent(IPCSkeleton::GetCallingPid(),
270 "AppMgrService::AppBackgrounded");
271 taskHandler_->CancelTask("appbackground_" + std::to_string(recordId));
272 std::function<void()> applicationBackgroundedFunc = [appMgrServiceInner = appMgrServiceInner_, recordId]() {
273 appMgrServiceInner->ApplicationBackgrounded(recordId);
274 };
275 taskHandler_->SubmitTask(applicationBackgroundedFunc, AAFwk::TaskAttribute{
276 .taskName_ = TASK_APPLICATION_BACKGROUNDED,
277 .taskQos_ = AAFwk::TaskQoS::USER_INTERACTIVE
278 });
279 }
280
ApplicationTerminated(const int32_t recordId)281 void AppMgrService::ApplicationTerminated(const int32_t recordId)
282 {
283 if (!IsReady()) {
284 return;
285 }
286 if (!JudgeAppSelfCalled(recordId)) {
287 return;
288 }
289 std::function<void()> applicationTerminatedFunc = [appMgrServiceInner = appMgrServiceInner_, recordId]() {
290 appMgrServiceInner->ApplicationTerminated(recordId);
291 };
292 taskHandler_->SubmitTask(applicationTerminatedFunc, AAFwk::TaskAttribute{
293 .taskName_ = TASK_APPLICATION_TERMINATED,
294 .taskQos_ = AAFwk::TaskQoS::USER_INTERACTIVE
295 });
296 }
297
AbilityCleaned(const sptr<IRemoteObject> & token)298 void AppMgrService::AbilityCleaned(const sptr<IRemoteObject> &token)
299 {
300 if (!IsReady()) {
301 return;
302 }
303
304 auto callerUid = IPCSkeleton::GetCallingUid();
305 auto appRecord = appMgrServiceInner_->GetTerminatingAppRunningRecord(token);
306 if (!appRecord || appRecord->GetUid() != callerUid) {
307 TAG_LOGE(AAFwkTag::APPMGR, "verification failed");
308 return;
309 }
310
311 std::function<void()> abilityCleanedFunc = [appMgrServiceInner = appMgrServiceInner_, token]() {
312 appMgrServiceInner->AbilityTerminated(token);
313 };
314 taskHandler_->SubmitTask(abilityCleanedFunc, AAFwk::TaskAttribute{
315 .taskName_ = TASK_ABILITY_CLEANED,
316 .taskQos_ = AAFwk::TaskQoS::USER_INTERACTIVE
317 });
318 }
319
IsReady() const320 bool AppMgrService::IsReady() const
321 {
322 if (appMgrServiceInner_ && taskHandler_ && eventHandler_) {
323 return true;
324 }
325
326 TAG_LOGW(AAFwkTag::APPMGR, "not ready");
327 return false;
328 }
329
StartupResidentProcess(const std::vector<AppExecFwk::BundleInfo> & bundleInfos)330 void AppMgrService::StartupResidentProcess(const std::vector<AppExecFwk::BundleInfo> &bundleInfos)
331 {
332 if (!IsReady()) {
333 return;
334 }
335 pid_t callingPid = IPCSkeleton::GetCallingPid();
336 pid_t pid = getprocpid();
337 if (callingPid != pid) {
338 TAG_LOGE(AAFwkTag::APPMGR, "not process call");
339 return;
340 }
341 TAG_LOGI(AAFwkTag::APPMGR, "start process");
342 std::function <void()> startupResidentProcess = [appMgrServiceInner = appMgrServiceInner_, bundleInfos]() {
343 appMgrServiceInner->LoadResidentProcess(bundleInfos);
344 };
345 taskHandler_->SubmitTask(startupResidentProcess, AAFwk::TaskAttribute{
346 .taskName_ = TASK_STARTUP_RESIDENT_PROCESS,
347 .taskQos_ = AAFwk::TaskQoS::USER_INTERACTIVE
348 });
349 }
350
GetAmsMgr()351 sptr<IAmsMgr> AppMgrService::GetAmsMgr()
352 {
353 return amsMgrScheduler_;
354 }
355
ClearUpApplicationData(const std::string & bundleName,int32_t appCloneIndex,int32_t userId)356 int32_t AppMgrService::ClearUpApplicationData(const std::string &bundleName, int32_t appCloneIndex, int32_t userId)
357 {
358 if (!AAFwk::PermissionVerification::GetInstance()->JudgeCallerIsAllowedToUseSystemAPI()) {
359 TAG_LOGE(AAFwkTag::APPMGR, "caller is not SA");
360 return AAFwk::ERR_NOT_SYSTEM_APP;
361 }
362 if (!IsReady()) {
363 return ERR_INVALID_OPERATION;
364 }
365 std::shared_ptr<RemoteClientManager> remoteClientManager = std::make_shared<RemoteClientManager>();
366 if (remoteClientManager == nullptr) {
367 TAG_LOGE(AAFwkTag::APPMGR, "null remoteClientManager");
368 return ERR_INVALID_OPERATION;
369 }
370 auto bundleMgrHelper = remoteClientManager->GetBundleManagerHelper();
371 if (bundleMgrHelper == nullptr) {
372 TAG_LOGE(AAFwkTag::APPMGR, "null bundleMgrHelper");
373 return ERR_INVALID_OPERATION;
374 }
375 int32_t callingUid = IPCSkeleton::GetCallingUid();
376 if ((callingUid != 0 && callingUid != USER_UID) || userId < 0) {
377 auto isCallingPerm = AAFwk::PermissionVerification::GetInstance()->VerifyCallingPermission(
378 AAFwk::PermissionConstants::PERMISSION_CLEAN_APPLICATION_DATA);
379 if (!isCallingPerm) {
380 TAG_LOGE(AAFwkTag::APPMGR, "verification failed");
381 return AAFwk::CHECK_PERMISSION_FAILED;
382 }
383 }
384 if (appCloneIndex < 0 || appCloneIndex > AbilityRuntime::GlobalConstant::MAX_APP_CLONE_INDEX) {
385 TAG_LOGE(AAFwkTag::APPMGR, "appCloneIndex invalid");
386 return AAFwk::ERR_APP_CLONE_INDEX_INVALID;
387 }
388 pid_t pid = IPCSkeleton::GetCallingPid();
389 return appMgrServiceInner_->ClearUpApplicationData(bundleName, callingUid, pid, appCloneIndex, userId);
390 }
391
ClearUpApplicationDataBySelf(int32_t userId)392 int32_t AppMgrService::ClearUpApplicationDataBySelf(int32_t userId)
393 {
394 if (!IsReady()) {
395 return ERR_INVALID_OPERATION;
396 }
397 int32_t uid = IPCSkeleton::GetCallingUid();
398 pid_t pid = IPCSkeleton::GetCallingPid();
399 return appMgrServiceInner_->ClearUpApplicationDataBySelf(uid, pid, userId);
400 }
401
GetAllRunningProcesses(std::vector<RunningProcessInfo> & info)402 int32_t AppMgrService::GetAllRunningProcesses(std::vector<RunningProcessInfo> &info)
403 {
404 if (!IsReady()) {
405 return ERR_INVALID_OPERATION;
406 }
407 return appMgrServiceInner_->GetAllRunningProcesses(info);
408 }
409
GetRunningMultiAppInfoByBundleName(const std::string & bundleName,RunningMultiAppInfo & info)410 int32_t AppMgrService::GetRunningMultiAppInfoByBundleName(const std::string &bundleName,
411 RunningMultiAppInfo &info)
412 {
413 if (!IsReady()) {
414 return ERR_INVALID_OPERATION;
415 }
416
417 if (!AAFwk::PermissionVerification::GetInstance()->JudgeCallerIsAllowedToUseSystemAPI()) {
418 TAG_LOGE(AAFwkTag::ABILITYMGR, "caller is not SA");
419 return ERR_INVALID_OPERATION;
420 }
421
422 bool isCallingPermission = AAFwk::PermissionVerification::GetInstance()->VerifyRunningInfoPerm();
423 if (!isCallingPermission) {
424 TAG_LOGE(AAFwkTag::APPMGR, "verification failed");
425 return ERR_PERMISSION_DENIED;
426 }
427 return appMgrServiceInner_->GetRunningMultiAppInfoByBundleName(bundleName, info);
428 }
429
GetAllRunningInstanceKeysBySelf(std::vector<std::string> & instanceKeys)430 int32_t AppMgrService::GetAllRunningInstanceKeysBySelf(std::vector<std::string> &instanceKeys)
431 {
432 if (!IsReady()) {
433 return ERR_INVALID_OPERATION;
434 }
435 return appMgrServiceInner_->GetAllRunningInstanceKeysBySelf(instanceKeys);
436 }
437
GetAllRunningInstanceKeysByBundleName(const std::string & bundleName,std::vector<std::string> & instanceKeys,int32_t userId)438 int32_t AppMgrService::GetAllRunningInstanceKeysByBundleName(const std::string &bundleName,
439 std::vector<std::string> &instanceKeys, int32_t userId)
440 {
441 if (!IsReady()) {
442 return ERR_INVALID_OPERATION;
443 }
444 return appMgrServiceInner_->GetAllRunningInstanceKeysByBundleName(bundleName, instanceKeys, userId);
445 }
446
GetRunningProcessesByBundleType(BundleType bundleType,std::vector<RunningProcessInfo> & info)447 int32_t AppMgrService::GetRunningProcessesByBundleType(BundleType bundleType,
448 std::vector<RunningProcessInfo> &info)
449 {
450 if (!IsReady()) {
451 return ERR_INVALID_OPERATION;
452 }
453 return appMgrServiceInner_->GetRunningProcessesByBundleType(bundleType, info);
454 }
455
GetAllRenderProcesses(std::vector<RenderProcessInfo> & info)456 int32_t AppMgrService::GetAllRenderProcesses(std::vector<RenderProcessInfo> &info)
457 {
458 if (!IsReady()) {
459 return ERR_INVALID_OPERATION;
460 }
461 return appMgrServiceInner_->GetAllRenderProcesses(info);
462 }
463
GetAllChildrenProcesses(std::vector<ChildProcessInfo> & info)464 int AppMgrService::GetAllChildrenProcesses(std::vector<ChildProcessInfo> &info)
465 {
466 #ifdef SUPPORT_CHILD_PROCESS
467 if (!IsReady()) {
468 return ERR_INVALID_OPERATION;
469 }
470 return appMgrServiceInner_->GetAllChildrenProcesses(info);
471 #endif // SUPPORT_CHILD_PROCESS
472 return ERR_INVALID_OPERATION;
473 }
474
JudgeSandboxByPid(pid_t pid,bool & isSandbox)475 int32_t AppMgrService::JudgeSandboxByPid(pid_t pid, bool &isSandbox)
476 {
477 if (!IsReady()) {
478 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
479 return ERR_INVALID_OPERATION;
480 }
481 bool isCallingPermission =
482 AAFwk::PermissionVerification::GetInstance()->CheckSpecificSystemAbilityAccessPermission(FOUNDATION_PROCESS);
483 if (!isCallingPermission) {
484 TAG_LOGE(AAFwkTag::APPMGR, "verification failed");
485 return ERR_PERMISSION_DENIED;
486 }
487 auto appRunningRecord = appMgrServiceInner_->GetAppRunningRecordByPid(pid);
488 if (appRunningRecord && appRunningRecord->GetAppIndex() > AbilityRuntime::GlobalConstant::MAX_APP_CLONE_INDEX) {
489 isSandbox = true;
490 TAG_LOGD(AAFwkTag::APPMGR, "current app is a sandbox.");
491 return ERR_OK;
492 }
493 TAG_LOGD(AAFwkTag::APPMGR, "current app is not a sandbox.");
494 return ERR_OK;
495 }
496
IsTerminatingByPid(pid_t pid,bool & isTerminating)497 int32_t AppMgrService::IsTerminatingByPid(pid_t pid, bool &isTerminating)
498 {
499 if (!IsReady()) {
500 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
501 return ERR_INVALID_OPERATION;
502 }
503 bool isCallingPermission =
504 AAFwk::PermissionVerification::GetInstance()->CheckSpecificSystemAbilityAccessPermission(FOUNDATION_PROCESS);
505 if (!isCallingPermission) {
506 TAG_LOGE(AAFwkTag::APPMGR, "verification failed");
507 return ERR_PERMISSION_DENIED;
508 }
509 auto appRunningRecord = appMgrServiceInner_->GetAppRunningRecordByPid(pid);
510 if (appRunningRecord && appRunningRecord->IsTerminating()) {
511 isTerminating = true;
512 TAG_LOGD(AAFwkTag::APPMGR, "current pid %{public}d is terminating.", pid);
513 return ERR_OK;
514 }
515 TAG_LOGD(AAFwkTag::APPMGR, "current pid %{public}d is not terminating.", pid);
516 return ERR_OK;
517 }
518
GetProcessRunningInfosByUserId(std::vector<RunningProcessInfo> & info,int32_t userId)519 int32_t AppMgrService::GetProcessRunningInfosByUserId(std::vector<RunningProcessInfo> &info, int32_t userId)
520 {
521 if (!IsReady()) {
522 return ERR_INVALID_OPERATION;
523 }
524 return appMgrServiceInner_->GetProcessRunningInfosByUserId(info, userId);
525 }
526
GetProcessRunningInformation(RunningProcessInfo & info)527 int32_t AppMgrService::GetProcessRunningInformation(RunningProcessInfo &info)
528 {
529 if (!IsReady()) {
530 return ERR_INVALID_OPERATION;
531 }
532 return appMgrServiceInner_->GetProcessRunningInformation(info);
533 }
534
NotifyMemoryLevel(int32_t level)535 int32_t AppMgrService::NotifyMemoryLevel(int32_t level)
536 {
537 if (!IsReady()) {
538 return ERR_INVALID_OPERATION;
539 }
540 return appMgrServiceInner_->NotifyMemoryLevel(level);
541 }
542
NotifyProcMemoryLevel(const std::map<pid_t,MemoryLevel> & procLevelMap)543 int32_t AppMgrService::NotifyProcMemoryLevel(const std::map<pid_t, MemoryLevel> &procLevelMap)
544 {
545 if (!IsReady()) {
546 return ERR_INVALID_OPERATION;
547 }
548 return appMgrServiceInner_->NotifyProcMemoryLevel(procLevelMap);
549 }
550
DumpHeapMemory(const int32_t pid,OHOS::AppExecFwk::MallocInfo & mallocInfo)551 int32_t AppMgrService::DumpHeapMemory(const int32_t pid, OHOS::AppExecFwk::MallocInfo &mallocInfo)
552 {
553 if (!IsReady()) {
554 return ERR_INVALID_OPERATION;
555 }
556 return appMgrServiceInner_->DumpHeapMemory(pid, mallocInfo);
557 }
558
559 // Authenticate dump permissions
HasDumpPermission() const560 bool AppMgrService::HasDumpPermission() const
561 {
562 uint32_t callingTokenID = IPCSkeleton::GetCallingTokenID();
563 int res = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callingTokenID, "ohos.permission.DUMP");
564 if (res != Security::AccessToken::PermissionState::PERMISSION_GRANTED) {
565 TAG_LOGE(AAFwkTag::APPMGR, "no permission");
566 return false;
567 }
568 return true;
569 }
570
DumpJsHeapMemory(OHOS::AppExecFwk::JsHeapDumpInfo & info)571 int32_t AppMgrService::DumpJsHeapMemory(OHOS::AppExecFwk::JsHeapDumpInfo &info)
572 {
573 if (!IsReady() || !HasDumpPermission()) {
574 return ERR_INVALID_OPERATION;
575 }
576 return appMgrServiceInner_->DumpJsHeapMemory(info);
577 }
578
DumpCjHeapMemory(OHOS::AppExecFwk::CjHeapDumpInfo & info)579 int32_t AppMgrService::DumpCjHeapMemory(OHOS::AppExecFwk::CjHeapDumpInfo &info)
580 {
581 if (!IsReady() || !HasDumpPermission()) {
582 return ERR_INVALID_OPERATION;
583 }
584 static std::mutex mutex_;
585 std::lock_guard<std::mutex> lock(mutex_);
586 return appMgrServiceInner_->DumpCjHeapMemory(info);
587 }
588
AddAbilityStageDone(const int32_t recordId)589 void AppMgrService::AddAbilityStageDone(const int32_t recordId)
590 {
591 if (!IsReady()) {
592 return;
593 }
594 if (!JudgeAppSelfCalled(recordId)) {
595 return;
596 }
597 std::function <void()> addAbilityStageDone = [appMgrServiceInner = appMgrServiceInner_, recordId]() {
598 appMgrServiceInner->AddAbilityStageDone(recordId);
599 };
600 taskHandler_->SubmitTask(addAbilityStageDone, AAFwk::TaskAttribute{
601 .taskName_ = TASK_ADD_ABILITY_STAGE_DONE,
602 .taskQos_ = AAFwk::TaskQoS::USER_INTERACTIVE
603 });
604 }
605
RegisterApplicationStateObserver(const sptr<IApplicationStateObserver> & observer,const std::vector<std::string> & bundleNameList)606 int32_t AppMgrService::RegisterApplicationStateObserver(const sptr<IApplicationStateObserver> &observer,
607 const std::vector<std::string> &bundleNameList)
608 {
609 TAG_LOGD(AAFwkTag::APPMGR, "begin");
610 if (!IsReady()) {
611 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
612 return ERR_INVALID_OPERATION;
613 }
614 return appMgrServiceInner_->RegisterApplicationStateObserver(observer, bundleNameList);
615 }
616
UnregisterApplicationStateObserver(const sptr<IApplicationStateObserver> & observer)617 int32_t AppMgrService::UnregisterApplicationStateObserver(const sptr<IApplicationStateObserver> &observer)
618 {
619 TAG_LOGD(AAFwkTag::APPMGR, "begin");
620 if (!IsReady()) {
621 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
622 return ERR_INVALID_OPERATION;
623 }
624 return appMgrServiceInner_->UnregisterApplicationStateObserver(observer);
625 }
626
RegisterNativeChildExitNotify(const sptr<INativeChildNotify> notify)627 int32_t AppMgrService::RegisterNativeChildExitNotify(const sptr<INativeChildNotify> notify)
628 {
629 TAG_LOGD(AAFwkTag::APPMGR, "begin");
630 if (!IsReady()) {
631 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
632 return ERR_INVALID_OPERATION;
633 }
634 return appMgrServiceInner_->RegisterNativeChildExitNotify(notify);
635 }
636
UnregisterNativeChildExitNotify(const sptr<INativeChildNotify> notify)637 int32_t AppMgrService::UnregisterNativeChildExitNotify(const sptr<INativeChildNotify> notify)
638 {
639 TAG_LOGD(AAFwkTag::APPMGR, "begin");
640 if (!IsReady()) {
641 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
642 return ERR_INVALID_OPERATION;
643 }
644 return appMgrServiceInner_->UnregisterNativeChildExitNotify(notify);
645 }
646
RegisterAbilityForegroundStateObserver(const sptr<IAbilityForegroundStateObserver> & observer)647 int32_t AppMgrService::RegisterAbilityForegroundStateObserver(const sptr<IAbilityForegroundStateObserver> &observer)
648 {
649 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
650 TAG_LOGD(AAFwkTag::APPMGR, "called");
651 if (!IsReady()) {
652 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
653 return ERR_INVALID_OPERATION;
654 }
655 return appMgrServiceInner_->RegisterAbilityForegroundStateObserver(observer);
656 }
657
UnregisterAbilityForegroundStateObserver(const sptr<IAbilityForegroundStateObserver> & observer)658 int32_t AppMgrService::UnregisterAbilityForegroundStateObserver(const sptr<IAbilityForegroundStateObserver> &observer)
659 {
660 TAG_LOGD(AAFwkTag::APPMGR, "called");
661 if (!IsReady()) {
662 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
663 return ERR_INVALID_OPERATION;
664 }
665 return appMgrServiceInner_->UnregisterAbilityForegroundStateObserver(observer);
666 }
667
GetForegroundApplications(std::vector<AppStateData> & list)668 int32_t AppMgrService::GetForegroundApplications(std::vector<AppStateData> &list)
669 {
670 TAG_LOGD(AAFwkTag::APPMGR, "begin");
671 if (!IsReady()) {
672 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
673 return ERR_INVALID_OPERATION;
674 }
675 return appMgrServiceInner_->GetForegroundApplications(list);
676 }
677
StartUserTestProcess(const AAFwk::Want & want,const sptr<IRemoteObject> & observer,const AppExecFwk::BundleInfo & bundleInfo,int32_t userId)678 int AppMgrService::StartUserTestProcess(const AAFwk::Want &want, const sptr<IRemoteObject> &observer,
679 const AppExecFwk::BundleInfo &bundleInfo, int32_t userId)
680 {
681 if (!IsReady()) {
682 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
683 return ERR_INVALID_OPERATION;
684 }
685 if (!AAFwk::PermissionVerification::GetInstance()->IsShellCall()) {
686 TAG_LOGE(AAFwkTag::APPMGR, "StartUserTestProcess is not shell call");
687 return ERR_INVALID_OPERATION;
688 }
689 std::function<void()> startUserTestProcessFunc = [appMgrServiceInner = appMgrServiceInner_,
690 want, observer, bundleInfo, userId]() {
691 appMgrServiceInner->StartUserTestProcess(want, observer, bundleInfo, userId);
692 };
693 taskHandler_->SubmitTask(startUserTestProcessFunc, TASK_START_USER_TEST_PROCESS);
694 return ERR_OK;
695 }
696
FinishUserTest(const std::string & msg,const int64_t & resultCode,const std::string & bundleName)697 int AppMgrService::FinishUserTest(const std::string &msg, const int64_t &resultCode, const std::string &bundleName)
698 {
699 if (!IsReady()) {
700 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
701 return ERR_INVALID_OPERATION;
702 }
703 std::shared_ptr<RemoteClientManager> remoteClientManager = std::make_shared<RemoteClientManager>();
704 if (remoteClientManager == nullptr) {
705 TAG_LOGE(AAFwkTag::APPMGR, "null remoteClientManager");
706 return ERR_INVALID_OPERATION;
707 }
708 auto bundleMgrHelper = remoteClientManager->GetBundleManagerHelper();
709 if (bundleMgrHelper == nullptr) {
710 TAG_LOGE(AAFwkTag::APPMGR, "null bundleMgrHelper");
711 return ERR_INVALID_OPERATION;
712 }
713 int32_t callingUid = IPCSkeleton::GetCallingUid();
714 std::string callerBundleName;
715 auto result = IN_PROCESS_CALL(bundleMgrHelper->GetNameForUid(callingUid, callerBundleName));
716 if (result == ERR_OK) {
717 TAG_LOGI(AAFwkTag::APPMGR, "callingPid_ %{public}s", callerBundleName.c_str());
718 if (bundleName != callerBundleName) {
719 TAG_LOGE(AAFwkTag::APPMGR, "not process call");
720 return ERR_INVALID_OPERATION;
721 }
722 } else {
723 TAG_LOGE(AAFwkTag::APPMGR, "fail: %{public}d", result);
724 return ERR_INVALID_OPERATION;
725 }
726 pid_t callingPid = IPCSkeleton::GetCallingPid();
727 std::function<void()> finishUserTestProcessFunc = [appMgrServiceInner = appMgrServiceInner_, msg,
728 resultCode, bundleName, callingPid]() {
729 appMgrServiceInner->FinishUserTest(msg, resultCode, bundleName, callingPid);
730 };
731 taskHandler_->SubmitTask(finishUserTestProcessFunc, TASK_FINISH_USER_TEST);
732 return ERR_OK;
733 }
734
Dump(int fd,const std::vector<std::u16string> & args)735 int AppMgrService::Dump(int fd, const std::vector<std::u16string>& args)
736 {
737 TAG_LOGD(AAFwkTag::APPMGR, "called");
738 if (!IsReady()) {
739 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
740 return ERR_APPEXECFWK_HIDUMP_ERROR;
741 }
742
743 std::string result;
744 auto errCode = Dump(args, result);
745 int ret = dprintf(fd, "%s\n", result.c_str());
746 if (ret < 0) {
747 TAG_LOGE(AAFwkTag::APPMGR, "dprintf error");
748 return ERR_APPEXECFWK_HIDUMP_ERROR;
749 }
750 return errCode;
751 }
752
Dump(const std::vector<std::u16string> & args,std::string & result)753 int AppMgrService::Dump(const std::vector<std::u16string>& args, std::string& result)
754 {
755 TAG_LOGD(AAFwkTag::APPMGR, "called");
756 auto size = args.size();
757 if (size == 0) {
758 return ShowHelp(args, result);
759 }
760
761 std::string optionKey = Str16ToStr8(args[0]);
762 if (optionKey == OPTION_KEY_HELP) {
763 return ShowHelp(args, result);
764 }
765 if (optionKey == OPTION_KEY_DUMP_IPC) {
766 return DumpIpc(args, result);
767 }
768 if (optionKey == OPTION_KEY_DUMP_FFRT) {
769 return DumpFfrt(args, result);
770 }
771 result.append("error: unkown option.\n");
772 TAG_LOGE(AAFwkTag::APPMGR, "option key %{public}s does not exist", optionKey.c_str());
773 return DumpErrorCode::ERR_UNKNOWN_OPTION_ERROR;
774 }
775
ShowHelp(const std::vector<std::u16string> & args,std::string & result)776 int AppMgrService::ShowHelp(const std::vector<std::u16string>& args, std::string& result)
777 {
778 result.append("Usage:\n")
779 .append("-h ")
780 .append("help text for the tool\n")
781 .append("--ffrt pid1[,pid2,pid3] ")
782 .append("dump ffrt info\n");
783
784 return ERR_OK;
785 }
786
DumpIpcAllInner(const AppMgrService::DumpIpcKey key,std::string & result)787 int AppMgrService::DumpIpcAllInner(const AppMgrService::DumpIpcKey key, std::string& result)
788 {
789 TAG_LOGI(AAFwkTag::APPMGR, "call");
790 switch (key) {
791 case KEY_DUMP_IPC_START:
792 return DumpIpcAllStart(result);
793 case KEY_DUMP_IPC_STOP:
794 return DumpIpcAllStop(result);
795 case KEY_DUMP_IPC_STAT:
796 return DumpIpcAllStat(result);
797 default: {
798 result.append(MSG_DUMP_FAIL, strlen(MSG_DUMP_FAIL))
799 .append(MSG_DUMP_FAIL_REASON_INTERNAL, strlen(MSG_DUMP_FAIL_REASON_INTERNAL));
800 TAG_LOGE(AAFwkTag::APPMGR, "dump ipc all function does not exist");
801 return DumpErrorCode::ERR_INTERNAL_ERROR;
802 }
803 }
804 }
805
DumpIpcWithPidInner(const AppMgrService::DumpIpcKey key,const std::string & optionPid,std::string & result)806 int AppMgrService::DumpIpcWithPidInner(const AppMgrService::DumpIpcKey key,
807 const std::string& optionPid, std::string& result)
808 {
809 TAG_LOGI(AAFwkTag::APPMGR, "call");
810 int32_t pid = -1;
811 char* end = nullptr;
812 pid = static_cast<int32_t>(std::strtol(optionPid.c_str(), &end, BASE_TEN));
813 if (end && *end != SIGN_TERMINAL) {
814 result.append(MSG_DUMP_FAIL, strlen(MSG_DUMP_FAIL))
815 .append(MSG_DUMP_FAIL_REASON_INVALILD_PID, strlen(MSG_DUMP_FAIL_REASON_INVALILD_PID));
816 TAG_LOGE(AAFwkTag::APPMGR, "invalid pid: %{public}s", optionPid.c_str());
817 return DumpErrorCode::ERR_INVALID_PID_ERROR;
818 }
819 if (pid < 0) {
820 result.append(MSG_DUMP_FAIL, strlen(MSG_DUMP_FAIL))
821 .append(MSG_DUMP_FAIL_REASON_INVALILD_PID, strlen(MSG_DUMP_FAIL_REASON_INVALILD_PID));
822 TAG_LOGE(AAFwkTag::APPMGR, "invalid pid: %{public}s", optionPid.c_str());
823 return DumpErrorCode::ERR_INVALID_PID_ERROR;
824 }
825
826 switch (key) {
827 case KEY_DUMP_IPC_START:
828 return DumpIpcStart(pid, result);
829 case KEY_DUMP_IPC_STOP:
830 return DumpIpcStop(pid, result);
831 case KEY_DUMP_IPC_STAT:
832 return DumpIpcStat(pid, result);
833 default: {
834 TAG_LOGE(AAFwkTag::APPMGR, "option key %{public}d does not exist", key);
835 result.append(MSG_DUMP_FAIL, strlen(MSG_DUMP_FAIL))
836 .append(MSG_DUMP_FAIL_REASON_INTERNAL, strlen(MSG_DUMP_FAIL_REASON_INTERNAL));
837 TAG_LOGE(AAFwkTag::APPMGR, "dump ipc function does not exist");
838 return DumpErrorCode::ERR_INTERNAL_ERROR;
839 }
840 }
841 }
842
DumpFfrtInner(const std::string & pidsRaw,std::string & result)843 int AppMgrService::DumpFfrtInner(const std::string& pidsRaw, std::string& result)
844 {
845 TAG_LOGI(AAFwkTag::APPMGR, "call");
846 std::vector<std::string> pidsStr;
847 SplitStr(pidsRaw, ",", pidsStr);
848 if (pidsStr.empty()) {
849 TAG_LOGE(AAFwkTag::APPMGR, "pids are empty");
850 return DumpErrorCode::ERR_INVALID_PID_ERROR;
851 }
852 if (pidsStr.size() > MAX_DUMP_FFRT_PID_NUMBER) {
853 pidsStr.resize(MAX_DUMP_FFRT_PID_NUMBER);
854 }
855 std::vector<int32_t> pids;
856 for (const auto& pidStr : pidsStr) {
857 int pid = -1;
858 char* end = nullptr;
859 pid = static_cast<int32_t>(std::strtol(pidStr.c_str(), &end, BASE_TEN));
860 if (end && *end != SIGN_TERMINAL) {
861 TAG_LOGE(AAFwkTag::APPMGR, "invalid pid:%{public}s", pidStr.c_str());
862 continue;
863 }
864 if (pid < 0) {
865 TAG_LOGE(AAFwkTag::APPMGR, "invalid pid: %{public}s", pidStr.c_str());
866 continue;
867 }
868 TAG_LOGD(AAFwkTag::APPMGR, "valid pid:%{public}d", pid);
869 pids.push_back(pid);
870 }
871 TAG_LOGD(AAFwkTag::APPMGR, "number of valid pids:%{public}d", static_cast<int>(pids.size()));
872 if (pids.empty()) {
873 TAG_LOGE(AAFwkTag::APPMGR, "pids are empty");
874 return DumpErrorCode::ERR_INVALID_PID_ERROR;
875 }
876 return appMgrServiceInner_->DumpFfrt(pids, result);
877 }
878
GetDumpIpcKeyByOption(const std::string & option,DumpIpcKey & key)879 bool AppMgrService::GetDumpIpcKeyByOption(const std::string &option, DumpIpcKey &key)
880 {
881 if (option == "--start-stat") {
882 key = KEY_DUMP_IPC_START;
883 return true;
884 }
885 if (option == "--stop-stat") {
886 key = KEY_DUMP_IPC_STOP;
887 return true;
888 }
889 if (option == "--stat") {
890 key = KEY_DUMP_IPC_STAT;
891 return true;
892 }
893 return false;
894 }
895
DumpIpc(const std::vector<std::u16string> & args,std::string & result)896 int AppMgrService::DumpIpc(const std::vector<std::u16string>& args, std::string& result)
897 {
898 TAG_LOGD(AAFwkTag::APPMGR, "Called. AppMgrService::DumpIpc start");
899 if (args.size() != VALID_DUMP_IPC_ARG_SIZE) {
900 result.append(MSG_DUMP_FAIL, strlen(MSG_DUMP_FAIL))
901 .append(MSG_DUMP_FAIL_REASON_INVALILD_NUM_ARGS, strlen(MSG_DUMP_FAIL_REASON_INVALILD_NUM_ARGS));
902 TAG_LOGE(AAFwkTag::APPMGR, "invalid arguments");
903 return DumpErrorCode::ERR_INVALID_NUM_ARGS_ERROR;
904 }
905 auto isHidumperServiceCall = (IPCSkeleton::GetCallingUid() == HIDUMPER_SERVICE_UID);
906 if (!isHidumperServiceCall) {
907 result.append(MSG_DUMP_FAIL, strlen(MSG_DUMP_FAIL))
908 .append(MSG_DUMP_FAIL_REASON_PERMISSION_DENY, strlen(MSG_DUMP_FAIL_REASON_PERMISSION_DENY));
909 TAG_LOGE(AAFwkTag::APPMGR, "permission deny");
910 return DumpErrorCode::ERR_PERMISSION_DENY_ERROR;
911 }
912
913 std::string optionCmd = Str16ToStr8(args[INDEX_CMD]);
914 std::string optionPid = Str16ToStr8(args[INDEX_PID]);
915 TAG_LOGD(AAFwkTag::APPMGR, "option pid:%{public}s, option cmd:%{public}s",
916 optionPid.c_str(), optionCmd.c_str());
917
918 DumpIpcKey key;
919 if (!GetDumpIpcKeyByOption(optionCmd, key)) {
920 result.append(MSG_DUMP_FAIL, strlen(MSG_DUMP_FAIL))
921 .append(MSG_DUMP_FAIL_REASON_INVALILD_CMD, strlen(MSG_DUMP_FAIL_REASON_INVALILD_CMD));
922 TAG_LOGE(AAFwkTag::APPMGR, "option command %{public}s does not exist", optionCmd.c_str());
923 return DumpErrorCode::ERR_INVALID_CMD_ERROR;
924 }
925
926 if (optionPid == "-a" || optionPid == "all" || optionPid == "--all") {
927 return DumpIpcAllInner(key, result);
928 }
929 return DumpIpcWithPidInner(key, optionPid, result);
930 }
931
DumpFfrt(const std::vector<std::u16string> & args,std::string & result)932 int AppMgrService::DumpFfrt(const std::vector<std::u16string>& args, std::string& result)
933 {
934 TAG_LOGD(AAFwkTag::APPMGR, "Called. AppMgrService::DumpFfrt start");
935 if (args.size() != VALID_DUMP_FFRT_ARG_SIZE) {
936 result.append(MSG_DUMP_FAIL, strlen(MSG_DUMP_FAIL))
937 .append(MSG_DUMP_FAIL_REASON_INVALILD_NUM_ARGS, strlen(MSG_DUMP_FAIL_REASON_INVALILD_NUM_ARGS));
938 TAG_LOGE(AAFwkTag::APPMGR, "invalid arguments");
939 return DumpErrorCode::ERR_INVALID_NUM_ARGS_ERROR;
940 }
941 auto isHidumperServiceCall = (IPCSkeleton::GetCallingUid() == HIDUMPER_SERVICE_UID);
942 if (!isHidumperServiceCall) {
943 result.append(MSG_DUMP_FAIL, strlen(MSG_DUMP_FAIL))
944 .append(MSG_DUMP_FAIL_REASON_PERMISSION_DENY, strlen(MSG_DUMP_FAIL_REASON_PERMISSION_DENY));
945 TAG_LOGE(AAFwkTag::APPMGR, "permission deny");
946 return DumpErrorCode::ERR_PERMISSION_DENY_ERROR;
947 }
948
949 std::string pidsRaw = Str16ToStr8(args[INDEX_PID]);
950 TAG_LOGD(AAFwkTag::APPMGR, "pids:%{public}s", pidsRaw.c_str());
951
952 return DumpFfrtInner(pidsRaw, result);
953 }
954
DumpIpcAllStart(std::string & result)955 int AppMgrService::DumpIpcAllStart(std::string& result)
956 {
957 TAG_LOGD(AAFwkTag::APPMGR, "called");
958 return appMgrServiceInner_->DumpIpcAllStart(result);
959 }
960
DumpIpcAllStop(std::string & result)961 int AppMgrService::DumpIpcAllStop(std::string& result)
962 {
963 TAG_LOGD(AAFwkTag::APPMGR, "called");
964 return appMgrServiceInner_->DumpIpcAllStop(result);
965 }
966
DumpIpcAllStat(std::string & result)967 int AppMgrService::DumpIpcAllStat(std::string& result)
968 {
969 TAG_LOGD(AAFwkTag::APPMGR, "called");
970 return appMgrServiceInner_->DumpIpcAllStat(result);
971 }
972
DumpIpcStart(const int32_t pid,std::string & result)973 int AppMgrService::DumpIpcStart(const int32_t pid, std::string& result)
974 {
975 TAG_LOGD(AAFwkTag::APPMGR, "called");
976 return appMgrServiceInner_->DumpIpcStart(pid, result);
977 }
978
DumpIpcStop(const int32_t pid,std::string & result)979 int AppMgrService::DumpIpcStop(const int32_t pid, std::string& result)
980 {
981 TAG_LOGD(AAFwkTag::APPMGR, "called");
982 return appMgrServiceInner_->DumpIpcStop(pid, result);
983 }
984
DumpIpcStat(const int32_t pid,std::string & result)985 int AppMgrService::DumpIpcStat(const int32_t pid, std::string& result)
986 {
987 TAG_LOGD(AAFwkTag::APPMGR, "called");
988 return appMgrServiceInner_->DumpIpcStat(pid, result);
989 }
990
ScheduleAcceptWantDone(const int32_t recordId,const AAFwk::Want & want,const std::string & flag)991 void AppMgrService::ScheduleAcceptWantDone(const int32_t recordId, const AAFwk::Want &want, const std::string &flag)
992 {
993 if (!IsReady()) {
994 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
995 return;
996 }
997 if (!JudgeAppSelfCalled(recordId)) {
998 return;
999 }
1000 auto task = [appMgrServiceInner = appMgrServiceInner_, recordId, want, flag]() {
1001 appMgrServiceInner->ScheduleAcceptWantDone(recordId, want, flag);
1002 };
1003 taskHandler_->SubmitTask(task, "ScheduleAcceptWantDone");
1004 }
1005
ScheduleNewProcessRequestDone(const int32_t recordId,const AAFwk::Want & want,const std::string & flag)1006 void AppMgrService::ScheduleNewProcessRequestDone(const int32_t recordId, const AAFwk::Want &want,
1007 const std::string &flag)
1008 {
1009 if (!IsReady()) {
1010 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1011 return;
1012 }
1013 if (!JudgeAppSelfCalled(recordId)) {
1014 return;
1015 }
1016 auto task = [appMgrServiceInner = appMgrServiceInner_, recordId, want, flag]() {
1017 appMgrServiceInner->ScheduleNewProcessRequestDone(recordId, want, flag);
1018 };
1019 taskHandler_->SubmitTask(task, AAFwk::TaskAttribute{
1020 .taskName_ = "ScheduleNewProcessRequestDone",
1021 .taskQos_ = AAFwk::TaskQoS::USER_INTERACTIVE
1022 });
1023 }
1024
GetAbilityRecordsByProcessID(const int pid,std::vector<sptr<IRemoteObject>> & tokens)1025 int AppMgrService::GetAbilityRecordsByProcessID(const int pid, std::vector<sptr<IRemoteObject>> &tokens)
1026 {
1027 if (!IsReady()) {
1028 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1029 return ERR_INVALID_OPERATION;
1030 }
1031 auto isSaCall = AAFwk::PermissionVerification::GetInstance()->IsSACall();
1032 if (!isSaCall) {
1033 TAG_LOGE(AAFwkTag::APPMGR, "null Sacall");
1034 return ERR_INVALID_OPERATION;
1035 }
1036 return appMgrServiceInner_->GetAbilityRecordsByProcessID(pid, tokens);
1037 }
1038
PreStartNWebSpawnProcess()1039 int32_t AppMgrService::PreStartNWebSpawnProcess()
1040 {
1041 XCOLLIE_TIMER_LESS(__PRETTY_FUNCTION__);
1042 TAG_LOGI(AAFwkTag::APPMGR, "PreStartNWebSpawnProcess");
1043 if (!IsReady()) {
1044 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1045 return ERR_INVALID_OPERATION;
1046 }
1047
1048 return appMgrServiceInner_->PreStartNWebSpawnProcess(IPCSkeleton::GetCallingPid());
1049 }
1050
StartRenderProcess(const std::string & renderParam,int32_t ipcFd,int32_t sharedFd,int32_t crashFd,pid_t & renderPid,bool isGPU)1051 int32_t AppMgrService::StartRenderProcess(const std::string &renderParam, int32_t ipcFd,
1052 int32_t sharedFd, int32_t crashFd, pid_t &renderPid, bool isGPU)
1053 {
1054 XCOLLIE_TIMER_LESS(__PRETTY_FUNCTION__);
1055 FdGuard ipcFdGuard(ipcFd);
1056 FdGuard sharedFdGuard(sharedFd);
1057 FdGuard crashFdGuard(crashFd);
1058 if (!IsReady()) {
1059 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1060 return ERR_INVALID_OPERATION;
1061 }
1062
1063 return appMgrServiceInner_->StartRenderProcess(IPCSkeleton::GetCallingPid(), renderParam,
1064 std::move(ipcFdGuard), std::move(sharedFdGuard), std::move(crashFdGuard), renderPid, isGPU);
1065 }
1066
AttachRenderProcess(const sptr<IRemoteObject> & scheduler)1067 void AppMgrService::AttachRenderProcess(const sptr<IRemoteObject> &scheduler)
1068 {
1069 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1070 TAG_LOGI(AAFwkTag::APPMGR, "AttachRenderProcess");
1071 if (!IsReady()) {
1072 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1073 return;
1074 }
1075
1076 auto pid = IPCSkeleton::GetCallingPid();
1077 auto fun = [appMgrServiceInner = appMgrServiceInner_, pid, scheduler]() {
1078 appMgrServiceInner->AttachRenderProcess(pid, iface_cast<IRenderScheduler>(scheduler));
1079 };
1080 taskHandler_->SubmitTask(fun, AAFwk::TaskAttribute{
1081 .taskName_ = TASK_ATTACH_RENDER_PROCESS,
1082 .taskQos_ = AAFwk::TaskQoS::USER_INTERACTIVE
1083 });
1084 }
1085
SaveBrowserChannel(sptr<IRemoteObject> browser)1086 void AppMgrService::SaveBrowserChannel(sptr<IRemoteObject> browser)
1087 {
1088 if (!IsReady()) {
1089 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1090 return;
1091 }
1092
1093 appMgrServiceInner_->SaveBrowserChannel(IPCSkeleton::GetCallingPid(), browser);
1094 }
1095
GetRenderProcessTerminationStatus(pid_t renderPid,int & status)1096 int32_t AppMgrService::GetRenderProcessTerminationStatus(pid_t renderPid, int &status)
1097 {
1098 if (!IsReady()) {
1099 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1100 return ERR_INVALID_OPERATION;
1101 }
1102
1103 return appMgrServiceInner_->GetRenderProcessTerminationStatus(renderPid, status);
1104 }
1105
GetConfiguration(Configuration & config)1106 int32_t AppMgrService::GetConfiguration(Configuration& config)
1107 {
1108 if (!IsReady()) {
1109 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1110 return ERR_INVALID_OPERATION;
1111 }
1112 config = *(appMgrServiceInner_->GetConfiguration());
1113 return ERR_OK;
1114 }
1115
UpdateConfiguration(const Configuration & config,const int32_t userId)1116 int32_t AppMgrService::UpdateConfiguration(const Configuration& config, const int32_t userId)
1117 {
1118 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1119 if (!IsReady()) {
1120 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1121 return ERR_INVALID_OPERATION;
1122 }
1123 return appMgrServiceInner_->UpdateConfiguration(config, userId);
1124 }
1125
UpdateConfigurationForBackgroundApp(const std::vector<BackgroundAppInfo> & appInfos,const AppExecFwk::ConfigurationPolicy & policy,const int32_t userId)1126 int32_t AppMgrService::UpdateConfigurationForBackgroundApp(const std::vector<BackgroundAppInfo>& appInfos,
1127 const AppExecFwk::ConfigurationPolicy& policy, const int32_t userId)
1128 {
1129 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1130 if (!AAFwk::PermissionVerification::GetInstance()->IsSACall()) {
1131 TAG_LOGE(AAFwkTag::APPMGR, "caller not SA");
1132 return ERR_PERMISSION_DENIED;
1133 }
1134 if (!IsReady()) {
1135 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1136 return ERR_INVALID_OPERATION;
1137 }
1138 return appMgrServiceInner_->UpdateConfigurationForBackgroundApp(appInfos, policy, userId);
1139 }
1140
UpdateConfigurationByBundleName(const Configuration & config,const std::string & name,int32_t appIndex)1141 int32_t AppMgrService::UpdateConfigurationByBundleName(const Configuration& config, const std::string &name,
1142 int32_t appIndex)
1143 {
1144 if (!IsReady()) {
1145 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1146 return ERR_INVALID_OPERATION;
1147 }
1148 return appMgrServiceInner_->UpdateConfigurationByBundleName(config, name, appIndex);
1149 }
1150
RegisterConfigurationObserver(const sptr<IConfigurationObserver> & observer)1151 int32_t AppMgrService::RegisterConfigurationObserver(const sptr<IConfigurationObserver> &observer)
1152 {
1153 if (!IsReady()) {
1154 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1155 return ERR_INVALID_OPERATION;
1156 }
1157 return appMgrServiceInner_->RegisterConfigurationObserver(observer);
1158 }
1159
UnregisterConfigurationObserver(const sptr<IConfigurationObserver> & observer)1160 int32_t AppMgrService::UnregisterConfigurationObserver(const sptr<IConfigurationObserver> &observer)
1161 {
1162 if (!IsReady()) {
1163 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1164 return ERR_INVALID_OPERATION;
1165 }
1166 return appMgrServiceInner_->UnregisterConfigurationObserver(observer);
1167 }
1168
GetAppRunningStateByBundleName(const std::string & bundleName)1169 bool AppMgrService::GetAppRunningStateByBundleName(const std::string &bundleName)
1170 {
1171 if (!IsReady()) {
1172 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1173 return false;
1174 }
1175
1176 return appMgrServiceInner_->GetAppRunningStateByBundleName(bundleName);
1177 }
1178
NotifyLoadRepairPatch(const std::string & bundleName,const sptr<IQuickFixCallback> & callback)1179 int32_t AppMgrService::NotifyLoadRepairPatch(const std::string &bundleName, const sptr<IQuickFixCallback> &callback)
1180 {
1181 if (!IsReady()) {
1182 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1183 return ERR_INVALID_OPERATION;
1184 }
1185 return appMgrServiceInner_->NotifyLoadRepairPatch(bundleName, callback);
1186 }
1187
NotifyHotReloadPage(const std::string & bundleName,const sptr<IQuickFixCallback> & callback)1188 int32_t AppMgrService::NotifyHotReloadPage(const std::string &bundleName, const sptr<IQuickFixCallback> &callback)
1189 {
1190 if (!IsReady()) {
1191 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1192 return ERR_INVALID_OPERATION;
1193 }
1194 return appMgrServiceInner_->NotifyHotReloadPage(bundleName, callback);
1195 }
1196
1197 #ifdef BGTASKMGR_CONTINUOUS_TASK_ENABLE
SetContinuousTaskProcess(int32_t pid,bool isContinuousTask)1198 int32_t AppMgrService::SetContinuousTaskProcess(int32_t pid, bool isContinuousTask)
1199 {
1200 if (!AAFwk::PermissionVerification::GetInstance()->CheckSpecificSystemAbilityAccessPermission(BS_PROCESS_NAME) &&
1201 !AAFwk::PermissionVerification::GetInstance()->CheckSpecificSystemAbilityAccessPermission(FOUNDATION_PROCESS)) {
1202 TAG_LOGE(AAFwkTag::ABILITYMGR, "not rss or foundation");
1203 return ERR_INVALID_OPERATION;
1204 }
1205 if (!IsReady()) {
1206 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1207 return ERR_INVALID_OPERATION;
1208 }
1209
1210 return appMgrServiceInner_->SetContinuousTaskProcess(pid, isContinuousTask);
1211 }
1212 #endif
1213
NotifyUnLoadRepairPatch(const std::string & bundleName,const sptr<IQuickFixCallback> & callback)1214 int32_t AppMgrService::NotifyUnLoadRepairPatch(const std::string &bundleName, const sptr<IQuickFixCallback> &callback)
1215 {
1216 if (!IsReady()) {
1217 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1218 return ERR_INVALID_OPERATION;
1219 }
1220 return appMgrServiceInner_->NotifyUnLoadRepairPatch(bundleName, callback);
1221 }
1222
JudgeAppSelfCalled(int32_t recordId)1223 bool AppMgrService::JudgeAppSelfCalled(int32_t recordId)
1224 {
1225 if (appMgrServiceInner_ == nullptr) {
1226 return false;
1227 }
1228
1229 auto callingTokenId = IPCSkeleton::GetCallingTokenID();
1230 std::shared_ptr<AppRunningRecord> appRecord = appMgrServiceInner_->GetAppRunningRecordByAppRecordId(recordId);
1231 if (appRecord == nullptr || ((appRecord->GetApplicationInfo())->accessTokenId) != callingTokenId) {
1232 TAG_LOGE(AAFwkTag::APPMGR, "not enabled");
1233 return false;
1234 }
1235
1236 return true;
1237 }
1238
IsSharedBundleRunning(const std::string & bundleName,uint32_t versionCode)1239 bool AppMgrService::IsSharedBundleRunning(const std::string &bundleName, uint32_t versionCode)
1240 {
1241 if (!IsReady()) {
1242 return false;
1243 }
1244 return appMgrServiceInner_->IsSharedBundleRunning(bundleName, versionCode);
1245 }
1246
StartNativeProcessForDebugger(const AAFwk::Want & want)1247 int32_t AppMgrService::StartNativeProcessForDebugger(const AAFwk::Want &want)
1248 {
1249 if (!IsReady()) {
1250 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1251 return ERR_INVALID_OPERATION;
1252 }
1253 bool isShellCall = AAFwk::PermissionVerification::GetInstance()->IsShellCall();
1254 auto callingTokenId = IPCSkeleton::GetCallingTokenID();
1255 bool isLocalDebugCall = AAFwk::PermissionVerification::GetInstance()->VerifyStartLocalDebug(callingTokenId);
1256 if (!isShellCall && !isLocalDebugCall) {
1257 TAG_LOGE(AAFwkTag::APPMGR, "permission denied");
1258 return ERR_INVALID_OPERATION;
1259 }
1260 auto ret = appMgrServiceInner_->StartNativeProcessForDebugger(want);
1261 if (ret != ERR_OK) {
1262 TAG_LOGE(AAFwkTag::APPMGR, "start native process fail");
1263 }
1264 return ret;
1265 }
1266
GetBundleNameByPid(const int32_t pid,std::string & bundleName,int32_t & uid)1267 int32_t AppMgrService::GetBundleNameByPid(const int32_t pid, std::string &bundleName, int32_t &uid)
1268 {
1269 if (!IsReady()) {
1270 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1271 return ERR_INVALID_OPERATION;
1272 }
1273 return appMgrServiceInner_->GetBundleNameByPid(pid, bundleName, uid);
1274 }
1275
GetRunningProcessInfoByPid(const pid_t pid,OHOS::AppExecFwk::RunningProcessInfo & info)1276 int32_t AppMgrService::GetRunningProcessInfoByPid(const pid_t pid, OHOS::AppExecFwk::RunningProcessInfo &info)
1277 {
1278 if (!IsReady()) {
1279 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1280 return ERR_INVALID_OPERATION;
1281 }
1282 return appMgrServiceInner_->GetRunningProcessInfoByPid(pid, info);
1283 }
1284
GetRunningProcessInfoByChildProcessPid(const pid_t childPid,OHOS::AppExecFwk::RunningProcessInfo & info)1285 int32_t AppMgrService::GetRunningProcessInfoByChildProcessPid(const pid_t childPid,
1286 OHOS::AppExecFwk::RunningProcessInfo &info)
1287 {
1288 if (!IsReady()) {
1289 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1290 return ERR_INVALID_OPERATION;
1291 }
1292 return appMgrServiceInner_->GetRunningProcessInfoByChildProcessPid(childPid, info);
1293 }
1294
NotifyAppFault(const FaultData & faultData)1295 int32_t AppMgrService::NotifyAppFault(const FaultData &faultData)
1296 {
1297 if (!IsReady()) {
1298 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1299 return ERR_INVALID_OPERATION;
1300 }
1301
1302 auto ret = appMgrServiceInner_->NotifyAppFault(faultData);
1303 if (ret != ERR_OK) {
1304 TAG_LOGE(AAFwkTag::APPMGR, "faultData fail");
1305 }
1306 return ret;
1307 }
1308
NotifyAppFaultBySA(const AppFaultDataBySA & faultData)1309 int32_t AppMgrService::NotifyAppFaultBySA(const AppFaultDataBySA &faultData)
1310 {
1311 if (!IsReady()) {
1312 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1313 return ERR_INVALID_OPERATION;
1314 }
1315
1316 auto ret = appMgrServiceInner_->NotifyAppFaultBySA(faultData);
1317 if (ret != ERR_OK) {
1318 TAG_LOGE(AAFwkTag::APPMGR, "faultData fail");
1319 }
1320 return ret;
1321 }
1322
SetAppFreezeFilter(int32_t pid)1323 bool AppMgrService::SetAppFreezeFilter(int32_t pid)
1324 {
1325 if (!IsReady()) {
1326 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1327 return false;
1328 }
1329
1330 auto ret = appMgrServiceInner_->SetAppFreezeFilter(pid);
1331 if (!ret) {
1332 TAG_LOGE(AAFwkTag::APPMGR, "SetAppFreezeFilter fail");
1333 }
1334 return ret;
1335 }
1336
GetProcessMemoryByPid(const int32_t pid,int32_t & memorySize)1337 int32_t AppMgrService::GetProcessMemoryByPid(const int32_t pid, int32_t &memorySize)
1338 {
1339 if (!IsReady()) {
1340 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1341 return ERR_INVALID_OPERATION;
1342 }
1343
1344 return appMgrServiceInner_->GetProcessMemoryByPid(pid, memorySize);
1345 }
1346
GetRunningProcessInformation(const std::string & bundleName,int32_t userId,std::vector<RunningProcessInfo> & info)1347 int32_t AppMgrService::GetRunningProcessInformation(const std::string &bundleName, int32_t userId,
1348 std::vector<RunningProcessInfo> &info)
1349 {
1350 if (!IsReady()) {
1351 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1352 return ERR_INVALID_OPERATION;
1353 }
1354
1355 return appMgrServiceInner_->GetRunningProcessInformation(bundleName, userId, info);
1356 }
1357
OnAddSystemAbility(int32_t systemAbilityId,const std::string & deviceId)1358 void AppMgrService::OnAddSystemAbility(int32_t systemAbilityId, const std::string& deviceId)
1359 {
1360 TAG_LOGI(AAFwkTag::APPMGR, "systemAbilityId: %{public}d add", systemAbilityId);
1361 if (!IsReady()) {
1362 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1363 return;
1364 }
1365 if (systemAbilityId == URI_PERMISSION_MGR_SERVICE_ID) {
1366 AAFwk::UriPermissionManagerClient::GetInstance().SetUriPermServiceStarted();
1367 }
1368
1369 if (systemAbilityId != WINDOW_MANAGER_SERVICE_ID) {
1370 return;
1371 }
1372
1373 appMgrServiceInner_->InitFocusListener();
1374 #ifdef SUPPORT_SCREEN
1375 appMgrServiceInner_->InitWindowVisibilityChangedListener();
1376 appMgrServiceInner_->InitWindowPidVisibilityChangedListener();
1377 #endif
1378 }
1379
OnRemoveSystemAbility(int32_t systemAbilityId,const std::string & deviceId)1380 void AppMgrService::OnRemoveSystemAbility(int32_t systemAbilityId, const std::string& deviceId)
1381 {
1382 TAG_LOGI(AAFwkTag::APPMGR, "systemAbilityId: %{public}d remove", systemAbilityId);
1383 if (!IsReady()) {
1384 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1385 return;
1386 }
1387
1388 if (systemAbilityId != WINDOW_MANAGER_SERVICE_ID) {
1389 return;
1390 }
1391
1392 appMgrServiceInner_->FreeFocusListener();
1393 #ifdef SUPPORT_SCREEN
1394 appMgrServiceInner_->FreeWindowVisibilityChangedListener();
1395 appMgrServiceInner_->FreeWindowPidVisibilityChangedListener();
1396 #endif
1397 }
1398
ChangeAppGcState(pid_t pid,int32_t state,uint64_t tid)1399 int32_t AppMgrService::ChangeAppGcState(pid_t pid, int32_t state, uint64_t tid)
1400 {
1401 TAG_LOGD(AAFwkTag::APPMGR, "called");
1402 if (!appMgrServiceInner_) {
1403 return ERR_INVALID_VALUE;
1404 }
1405 return appMgrServiceInner_->ChangeAppGcState(pid, state, tid);
1406 }
1407
NotifyPageShow(const sptr<IRemoteObject> & token,const PageStateData & pageStateData)1408 int32_t AppMgrService::NotifyPageShow(const sptr<IRemoteObject> &token, const PageStateData &pageStateData)
1409 {
1410 TAG_LOGD(AAFwkTag::APPMGR,
1411 "bundleName: %{public}s, moduelName: %{public}s, abilityName: %{public}s, pageName: %{public}s",
1412 pageStateData.bundleName.c_str(), pageStateData.moduleName.c_str(), pageStateData.abilityName.c_str(),
1413 pageStateData.pageName.c_str());
1414 if (!IsReady()) {
1415 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1416 return ERR_INVALID_OPERATION;
1417 }
1418 return appMgrServiceInner_->NotifyPageShow(token, pageStateData);
1419 }
1420
NotifyPageHide(const sptr<IRemoteObject> & token,const PageStateData & pageStateData)1421 int32_t AppMgrService::NotifyPageHide(const sptr<IRemoteObject> &token, const PageStateData &pageStateData)
1422 {
1423 TAG_LOGD(AAFwkTag::APPMGR,
1424 "bundleName: %{public}s, moduelName: %{public}s, abilityName: %{public}s, pageName: %{public}s",
1425 pageStateData.bundleName.c_str(), pageStateData.moduleName.c_str(), pageStateData.abilityName.c_str(),
1426 pageStateData.pageName.c_str());
1427 if (!IsReady()) {
1428 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1429 return ERR_INVALID_OPERATION;
1430 }
1431 return appMgrServiceInner_->NotifyPageHide(token, pageStateData);
1432 }
1433
RegisterAppRunningStatusListener(const sptr<IRemoteObject> & listener)1434 int32_t AppMgrService::RegisterAppRunningStatusListener(const sptr<IRemoteObject> &listener)
1435 {
1436 TAG_LOGD(AAFwkTag::APPMGR, "called");
1437 if (!IsReady()) {
1438 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1439 return ERR_INVALID_OPERATION;
1440 }
1441 return appMgrServiceInner_->RegisterAppRunningStatusListener(listener);
1442 }
1443
UnregisterAppRunningStatusListener(const sptr<IRemoteObject> & listener)1444 int32_t AppMgrService::UnregisterAppRunningStatusListener(const sptr<IRemoteObject> &listener)
1445 {
1446 TAG_LOGD(AAFwkTag::APPMGR, "called");
1447 if (!IsReady()) {
1448 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1449 return ERR_INVALID_OPERATION;
1450 }
1451 return appMgrServiceInner_->UnregisterAppRunningStatusListener(listener);
1452 }
1453
RegisterAppForegroundStateObserver(const sptr<IAppForegroundStateObserver> & observer)1454 int32_t AppMgrService::RegisterAppForegroundStateObserver(const sptr<IAppForegroundStateObserver> &observer)
1455 {
1456 TAG_LOGD(AAFwkTag::APPMGR, "called");
1457 if (!IsReady()) {
1458 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1459 return ERR_INVALID_OPERATION;
1460 }
1461 return appMgrServiceInner_->RegisterAppForegroundStateObserver(observer);
1462 }
1463
UnregisterAppForegroundStateObserver(const sptr<IAppForegroundStateObserver> & observer)1464 int32_t AppMgrService::UnregisterAppForegroundStateObserver(const sptr<IAppForegroundStateObserver> &observer)
1465 {
1466 TAG_LOGD(AAFwkTag::APPMGR, "called");
1467 if (!IsReady()) {
1468 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1469 return ERR_INVALID_OPERATION;
1470 }
1471 return appMgrServiceInner_->UnregisterAppForegroundStateObserver(observer);
1472 }
1473
IsApplicationRunning(const std::string & bundleName,bool & isRunning)1474 int32_t AppMgrService::IsApplicationRunning(const std::string &bundleName, bool &isRunning)
1475 {
1476 if (!IsReady()) {
1477 return ERR_INVALID_OPERATION;
1478 }
1479 return appMgrServiceInner_->IsApplicationRunning(bundleName, isRunning);
1480 }
1481
IsAppRunning(const std::string & bundleName,int32_t appCloneIndex,bool & isRunning)1482 int32_t AppMgrService::IsAppRunning(const std::string &bundleName, int32_t appCloneIndex, bool &isRunning)
1483 {
1484 isRunning = false;
1485 if (!IsReady()) {
1486 return ERR_INVALID_OPERATION;
1487 }
1488 return appMgrServiceInner_->IsAppRunning(bundleName, appCloneIndex, isRunning);
1489 }
1490
IsAppRunningByBundleNameAndUserId(const std::string & bundleName,int32_t userId,bool & isRunning)1491 int32_t AppMgrService::IsAppRunningByBundleNameAndUserId(const std::string &bundleName, int32_t userId,
1492 bool &isRunning)
1493 {
1494 isRunning = false;
1495 if (!IsReady()) {
1496 return ERR_INVALID_OPERATION;
1497 }
1498 return appMgrServiceInner_->IsAppRunningByBundleNameAndUserId(bundleName, userId, isRunning);
1499 }
1500
1501 #ifdef SUPPORT_CHILD_PROCESS
StartChildProcess(pid_t & childPid,const ChildProcessRequest & request)1502 int32_t AppMgrService::StartChildProcess(pid_t &childPid, const ChildProcessRequest &request)
1503 {
1504 XCOLLIE_TIMER_LESS(__PRETTY_FUNCTION__);
1505 TAG_LOGD(AAFwkTag::APPMGR, "called");
1506 std::vector<FdGuard> fds;
1507 for (const auto &[name, fd] : request.args.fds) {
1508 fds.emplace_back(fd);
1509 }
1510 if (!IsReady()) {
1511 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1512 return ERR_INVALID_OPERATION;
1513 }
1514
1515 return appMgrServiceInner_->StartChildProcess(IPCSkeleton::GetCallingPid(), childPid, request);
1516 }
1517
GetChildProcessInfoForSelf(ChildProcessInfo & info)1518 int32_t AppMgrService::GetChildProcessInfoForSelf(ChildProcessInfo &info)
1519 {
1520 if (!IsReady()) {
1521 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1522 return ERR_INVALID_OPERATION;
1523 }
1524 return appMgrServiceInner_->GetChildProcessInfoForSelf(info);
1525 }
1526
AttachChildProcess(const sptr<IRemoteObject> & childScheduler)1527 void AppMgrService::AttachChildProcess(const sptr<IRemoteObject> &childScheduler)
1528 {
1529 TAG_LOGD(AAFwkTag::APPMGR, "AttachChildProcess.");
1530 if (!IsReady()) {
1531 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1532 return;
1533 }
1534 if (!taskHandler_) {
1535 TAG_LOGE(AAFwkTag::APPMGR, "null taskHandler_");
1536 return;
1537 }
1538 pid_t pid = IPCSkeleton::GetCallingPid();
1539 std::function<void()> task = [appMgrServiceInner = appMgrServiceInner_, pid, childScheduler]() {
1540 appMgrServiceInner->AttachChildProcess(pid, iface_cast<IChildScheduler>(childScheduler));
1541 };
1542 taskHandler_->SubmitTask(task, AAFwk::TaskAttribute{
1543 .taskName_ = TASK_ATTACH_CHILD_PROCESS,
1544 .taskQos_ = AAFwk::TaskQoS::USER_INTERACTIVE
1545 });
1546 }
1547
ExitChildProcessSafely()1548 void AppMgrService::ExitChildProcessSafely()
1549 {
1550 if (!IsReady()) {
1551 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1552 return;
1553 }
1554 if (!taskHandler_) {
1555 TAG_LOGE(AAFwkTag::APPMGR, "null taskHandler_");
1556 return;
1557 }
1558 pid_t pid = IPCSkeleton::GetCallingPid();
1559 std::function<void()> task = [appMgrServiceInner = appMgrServiceInner_, pid]() {
1560 appMgrServiceInner->ExitChildProcessSafelyByChildPid(pid);
1561 };
1562 taskHandler_->SubmitTask(task, AAFwk::TaskAttribute{
1563 .taskName_ = TASK_EXIT_CHILD_PROCESS_SAFELY,
1564 .taskQos_ = AAFwk::TaskQoS::USER_INTERACTIVE
1565 });
1566 }
1567 #endif // SUPPORT_CHILD_PROCESS
1568
IsFinalAppProcess()1569 bool AppMgrService::IsFinalAppProcess()
1570 {
1571 if (!IsReady()) {
1572 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1573 return false;
1574 }
1575 return appMgrServiceInner_->IsFinalAppProcessByBundleName("");
1576 }
1577
RegisterRenderStateObserver(const sptr<IRenderStateObserver> & observer)1578 int32_t AppMgrService::RegisterRenderStateObserver(const sptr<IRenderStateObserver> &observer)
1579 {
1580 if (!IsReady()) {
1581 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1582 return ERR_INVALID_OPERATION;
1583 }
1584
1585 if (AAFwk::PermissionVerification::GetInstance()->VerifyAppStateObserverPermission() == ERR_PERMISSION_DENIED) {
1586 TAG_LOGE(AAFwkTag::APPMGR, "verification failed");
1587 return ERR_PERMISSION_DENIED;
1588 }
1589 return appMgrServiceInner_->RegisterRenderStateObserver(observer);
1590 }
1591
UnregisterRenderStateObserver(const sptr<IRenderStateObserver> & observer)1592 int32_t AppMgrService::UnregisterRenderStateObserver(const sptr<IRenderStateObserver> &observer)
1593 {
1594 if (!IsReady()) {
1595 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1596 return ERR_INVALID_OPERATION;
1597 }
1598
1599 if (AAFwk::PermissionVerification::GetInstance()->VerifyAppStateObserverPermission() == ERR_PERMISSION_DENIED) {
1600 TAG_LOGE(AAFwkTag::APPMGR, "verification failed");
1601 return ERR_PERMISSION_DENIED;
1602 }
1603 return appMgrServiceInner_->UnregisterRenderStateObserver(observer);
1604 }
1605
UpdateRenderState(pid_t renderPid,int32_t state)1606 int32_t AppMgrService::UpdateRenderState(pid_t renderPid, int32_t state)
1607 {
1608 if (!IsReady()) {
1609 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1610 return ERR_INVALID_OPERATION;
1611 }
1612 return appMgrServiceInner_->UpdateRenderState(renderPid, state);
1613 }
1614
SignRestartAppFlag(int32_t uid,const std::string & instanceKey)1615 int32_t AppMgrService::SignRestartAppFlag(int32_t uid, const std::string &instanceKey)
1616 {
1617 if (!IsReady()) {
1618 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1619 return ERR_INVALID_OPERATION;
1620 }
1621 bool isCallingPermission =
1622 AAFwk::PermissionVerification::GetInstance()->CheckSpecificSystemAbilityAccessPermission(FOUNDATION_PROCESS);
1623 if (!isCallingPermission) {
1624 TAG_LOGE(AAFwkTag::APPMGR, "verification failed");
1625 return ERR_PERMISSION_DENIED;
1626 }
1627 return appMgrServiceInner_->SignRestartAppFlag(uid, instanceKey);
1628 }
1629
GetAppRunningUniqueIdByPid(pid_t pid,std::string & appRunningUniqueId)1630 int32_t AppMgrService::GetAppRunningUniqueIdByPid(pid_t pid, std::string &appRunningUniqueId)
1631 {
1632 if (!IsReady()) {
1633 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1634 return ERR_INVALID_OPERATION;
1635 }
1636 return appMgrServiceInner_->GetAppRunningUniqueIdByPid(pid, appRunningUniqueId);
1637 }
1638
GetAllUIExtensionRootHostPid(pid_t pid,std::vector<pid_t> & hostPids)1639 int32_t AppMgrService::GetAllUIExtensionRootHostPid(pid_t pid, std::vector<pid_t> &hostPids)
1640 {
1641 if (!IsReady()) {
1642 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1643 return ERR_INVALID_OPERATION;
1644 }
1645
1646 return appMgrServiceInner_->GetAllUIExtensionRootHostPid(pid, hostPids);
1647 }
1648
GetAllUIExtensionProviderPid(pid_t hostPid,std::vector<pid_t> & providerPids)1649 int32_t AppMgrService::GetAllUIExtensionProviderPid(pid_t hostPid, std::vector<pid_t> &providerPids)
1650 {
1651 if (!IsReady()) {
1652 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1653 return ERR_INVALID_OPERATION;
1654 }
1655
1656 return appMgrServiceInner_->GetAllUIExtensionProviderPid(hostPid, providerPids);
1657 }
1658
NotifyMemorySizeStateChanged(int32_t memorySizeState)1659 int32_t AppMgrService::NotifyMemorySizeStateChanged(int32_t memorySizeState)
1660 {
1661 if (!IsReady()) {
1662 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1663 return ERR_INVALID_OPERATION;
1664 }
1665
1666 return appMgrServiceInner_->NotifyMemorySizeStateChanged(memorySizeState);
1667 }
1668
SetSupportedProcessCacheSelf(bool isSupport)1669 int32_t AppMgrService::SetSupportedProcessCacheSelf(bool isSupport)
1670 {
1671 TAG_LOGI(AAFwkTag::APPMGR, "call");
1672 if (!IsReady()) {
1673 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1674 return ERR_INVALID_OPERATION;
1675 }
1676 return appMgrServiceInner_->SetSupportedProcessCacheSelf(isSupport);
1677 }
1678
SetSupportedProcessCache(int32_t pid,bool isSupport)1679 int32_t AppMgrService::SetSupportedProcessCache(int32_t pid, bool isSupport)
1680 {
1681 TAG_LOGI(AAFwkTag::APPMGR, "Called");
1682 if (!IsReady()) {
1683 TAG_LOGE(AAFwkTag::APPMGR, "Not ready.");
1684 return ERR_INVALID_OPERATION;
1685 }
1686 if (!AAFwk::PermissionVerification::GetInstance()->CheckSpecificSystemAbilityAccessPermission(FOUNDATION_PROCESS)) {
1687 TAG_LOGE(AAFwkTag::ABILITYMGR, "caller not foundation");
1688 return ERR_INVALID_OPERATION;
1689 }
1690 return appMgrServiceInner_->SetSupportedProcessCache(pid, isSupport);
1691 }
1692
IsProcessCacheSupported(int32_t pid,bool & isSupported)1693 int32_t AppMgrService::IsProcessCacheSupported(int32_t pid, bool &isSupported)
1694 {
1695 TAG_LOGD(AAFwkTag::APPMGR, "get supported process cache");
1696 if (appMgrServiceInner_ == nullptr) {
1697 TAG_LOGE(AAFwkTag::APPMGR, "appMgrServiceInner_ is nullptr");
1698 return AAFwk::ERR_NULL_APP_MGR_SERVICE_INNER;
1699 }
1700 if (!AAFwk::PermissionVerification::GetInstance()->CheckSpecificSystemAbilityAccessPermission(
1701 FOUNDATION_PROCESS)) {
1702 TAG_LOGE(AAFwkTag::ABILITYMGR, "caller not foundation");
1703 return AAFwk::ERR_NO_PERMISSION_CALLER;
1704 }
1705 return appMgrServiceInner_->IsProcessCacheSupported(pid, isSupported);
1706 }
1707
SetProcessCacheEnable(int32_t pid,bool enable)1708 int32_t AppMgrService::SetProcessCacheEnable(int32_t pid, bool enable)
1709 {
1710 TAG_LOGD(AAFwkTag::APPMGR, "set enable process cache");
1711 if (appMgrServiceInner_ == nullptr) {
1712 TAG_LOGE(AAFwkTag::APPMGR, "appMgrServiceInner_ is nullptr");
1713 return AAFwk::ERR_NULL_APP_MGR_SERVICE_INNER;
1714 }
1715 if (!AAFwk::PermissionVerification::GetInstance()->CheckSpecificSystemAbilityAccessPermission(
1716 FOUNDATION_PROCESS)) {
1717 TAG_LOGE(AAFwkTag::ABILITYMGR, "caller not foundation");
1718 return AAFwk::ERR_NO_PERMISSION_CALLER;
1719 }
1720 return appMgrServiceInner_->SetProcessCacheEnable(pid, enable);
1721 }
1722
SetAppAssertionPauseState(bool flag)1723 void AppMgrService::SetAppAssertionPauseState(bool flag)
1724 {
1725 TAG_LOGI(AAFwkTag::APPMGR, "call");
1726 if (!IsReady()) {
1727 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1728 return;
1729 }
1730 return appMgrServiceInner_->SetAppAssertionPauseState(flag);
1731 }
1732
1733 #ifdef SUPPORT_CHILD_PROCESS
CreateNativeChildProcess(const std::string & libName,int32_t childProcessCount,const sptr<IRemoteObject> & callback,const std::string & customProcessName)1734 int32_t AppMgrService::CreateNativeChildProcess(const std::string &libName, int32_t childProcessCount,
1735 const sptr<IRemoteObject> &callback, const std::string &customProcessName)
1736 {
1737 XCOLLIE_TIMER_LESS(__PRETTY_FUNCTION__);
1738 TAG_LOGI(AAFwkTag::APPMGR, "call");
1739 if (!IsReady()) {
1740 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1741 return ERR_INVALID_OPERATION;
1742 }
1743
1744 return appMgrServiceInner_->CreateNativeChildProcess(
1745 IPCSkeleton::GetCallingPid(), libName, childProcessCount, callback, customProcessName);
1746 }
1747 #endif // SUPPORT_CHILD_PROCESS
1748
CheckCallingIsUserTestMode(const pid_t pid,bool & isUserTest)1749 int32_t AppMgrService::CheckCallingIsUserTestMode(const pid_t pid, bool &isUserTest)
1750 {
1751 TAG_LOGD(AAFwkTag::APPMGR, "called");
1752 if (!appMgrServiceInner_) {
1753 return ERR_INVALID_VALUE;
1754 }
1755 return appMgrServiceInner_->CheckCallingIsUserTestModeInner(pid, isUserTest);
1756 }
1757
NotifyProcessDependedOnWeb()1758 int32_t AppMgrService::NotifyProcessDependedOnWeb()
1759 {
1760 TAG_LOGD(AAFwkTag::APPMGR, "called");
1761 if (!appMgrServiceInner_) {
1762 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1763 return ERR_INVALID_VALUE;
1764 }
1765 return appMgrServiceInner_->NotifyProcessDependedOnWeb();
1766 }
1767
KillProcessDependedOnWeb()1768 void AppMgrService::KillProcessDependedOnWeb()
1769 {
1770 TAG_LOGD(AAFwkTag::APPMGR, "called");
1771 if (!AAFwk::PermissionVerification::GetInstance()->VerifyKillProcessDependedOnWebPermission()) {
1772 TAG_LOGE(AAFwkTag::ABILITYMGR, "no permission");
1773 return;
1774 }
1775 if (!appMgrServiceInner_) {
1776 return;
1777 }
1778 appMgrServiceInner_->KillProcessDependedOnWeb();
1779 }
1780
RestartResidentProcessDependedOnWeb()1781 void AppMgrService::RestartResidentProcessDependedOnWeb()
1782 {
1783 TAG_LOGD(AAFwkTag::APPMGR, "called");
1784 if (!AAFwk::PermissionVerification::GetInstance()->CheckSpecificSystemAbilityAccessPermission(FOUNDATION_PROCESS)) {
1785 TAG_LOGE(AAFwkTag::ABILITYMGR, "not foundation");
1786 return;
1787 }
1788 if (!appMgrServiceInner_) {
1789 return;
1790 }
1791 appMgrServiceInner_->RestartResidentProcessDependedOnWeb();
1792 }
1793
GetSupportedProcessCachePids(const std::string & bundleName,std::vector<int32_t> & pidList)1794 int32_t AppMgrService::GetSupportedProcessCachePids(const std::string &bundleName,
1795 std::vector<int32_t> &pidList)
1796 {
1797 if (!IsReady()) {
1798 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1799 return ERR_INVALID_OPERATION;
1800 }
1801 if (!AAFwk::PermissionVerification::GetInstance()->JudgeCallerIsAllowedToUseSystemAPI()) {
1802 TAG_LOGE(AAFwkTag::APPMGR, "caller is not SA");
1803 return AAFwk::ERR_NOT_SYSTEM_APP;
1804 }
1805 auto isPerm = AAFwk::PermissionVerification::GetInstance()->VerifyRunningInfoPerm();
1806 if (!isPerm) {
1807 return AAFwk::CHECK_PERMISSION_FAILED;
1808 }
1809 if (!DelayedSingleton<CacheProcessManager>::GetInstance()->QueryEnableProcessCache()) {
1810 return AAFwk::ERR_CAPABILITY_NOT_SUPPORT;
1811 }
1812 return appMgrServiceInner_->GetSupportedProcessCachePids(bundleName, pidList);
1813 }
1814
RegisterKiaInterceptor(const sptr<IKiaInterceptor> & interceptor)1815 int32_t AppMgrService::RegisterKiaInterceptor(const sptr<IKiaInterceptor> &interceptor)
1816 {
1817 TAG_LOGD(AAFwkTag::APPMGR, "Called");
1818 if (!appMgrServiceInner_) {
1819 TAG_LOGE(AAFwkTag::APPMGR, "appMgrServiceInner_ is nullptr");
1820 return ERR_INVALID_VALUE;
1821 }
1822 return appMgrServiceInner_->RegisterKiaInterceptor(interceptor);
1823 }
1824
CheckIsKiaProcess(pid_t pid,bool & isKia)1825 int32_t AppMgrService::CheckIsKiaProcess(pid_t pid, bool &isKia)
1826 {
1827 TAG_LOGD(AAFwkTag::APPMGR, "Called");
1828 if (!appMgrServiceInner_) {
1829 TAG_LOGE(AAFwkTag::APPMGR, "appMgrServiceInner_ is nullptr");
1830 return ERR_INVALID_VALUE;
1831 }
1832 return appMgrServiceInner_->CheckIsKiaProcess(pid, isKia);
1833 }
1834
KillAppSelfWithInstanceKey(const std::string & instanceKey,bool clearPageStack,const std::string & reason)1835 int32_t AppMgrService::KillAppSelfWithInstanceKey(const std::string &instanceKey, bool clearPageStack,
1836 const std::string& reason)
1837 {
1838 if (!appMgrServiceInner_) {
1839 TAG_LOGE(AAFwkTag::APPMGR, "appMgrServiceInner_ is nullptr");
1840 return ERR_INVALID_VALUE;
1841 }
1842 return appMgrServiceInner_->KillAppSelfWithInstanceKey(instanceKey, clearPageStack, reason);
1843 }
1844
UpdateInstanceKeyBySpecifiedId(int32_t specifiedId,std::string & instanceKey)1845 void AppMgrService::UpdateInstanceKeyBySpecifiedId(int32_t specifiedId, std::string &instanceKey)
1846 {
1847 if (!AAFwk::PermissionVerification::GetInstance()->CheckSpecificSystemAbilityAccessPermission(FOUNDATION_PROCESS)) {
1848 TAG_LOGE(AAFwkTag::APPMGR, "not foundation");
1849 return;
1850 }
1851 if (!appMgrServiceInner_) {
1852 TAG_LOGE(AAFwkTag::APPMGR, "appMgrServiceInner_ is nullptr");
1853 return;
1854 }
1855 appMgrServiceInner_->UpdateInstanceKeyBySpecifiedId(specifiedId, instanceKey);
1856 }
1857
IsSpecifiedModuleLoaded(const AAFwk::Want & want,const AbilityInfo & abilityInfo,bool & result,bool & isDebug)1858 int32_t AppMgrService::IsSpecifiedModuleLoaded(const AAFwk::Want &want, const AbilityInfo &abilityInfo, bool &result,
1859 bool &isDebug)
1860 {
1861 if (!IsReady()) {
1862 return ERR_INVALID_OPERATION;
1863 }
1864 pid_t callingPid = IPCSkeleton::GetCallingPid();
1865 pid_t pid = getprocpid();
1866 if (callingPid != pid) {
1867 TAG_LOGE(AAFwkTag::APPMGR, "other process");
1868 return ERR_INVALID_OPERATION;
1869 }
1870 if (!appMgrServiceInner_) {
1871 TAG_LOGE(AAFwkTag::APPMGR, "appMgrServiceInner_ is nullptr");
1872 return ERR_INVALID_VALUE;
1873 }
1874 result = appMgrServiceInner_->IsSpecifiedModuleLoaded(want, abilityInfo, isDebug);
1875 return ERR_OK;
1876 }
1877
UpdateProcessMemoryState(const std::vector<ProcessMemoryState> & procMemState)1878 int32_t AppMgrService::UpdateProcessMemoryState(const std::vector<ProcessMemoryState> &procMemState)
1879 {
1880 TAG_LOGI(AAFwkTag::APPMGR, "procMemState.size = %{public}zu", procMemState.size());
1881 if (!IsReady()) {
1882 return ERR_INVALID_OPERATION;
1883 }
1884 if (!AAFwk::PermissionVerification::GetInstance()->IsSACall() &&
1885 !AAFwk::PermissionVerification::GetInstance()->IsShellCall()) {
1886 TAG_LOGE(AAFwkTag::APPMGR, "caller is not sa or shell");
1887 return ERR_PERMISSION_DENIED;
1888 }
1889 if (!AAFwk::PermissionVerification::GetInstance()->CheckSpecificSystemAbilityAccessPermission(
1890 HIVIEW_PROCESS_NAME)) {
1891 TAG_LOGW(AAFwkTag::APPMGR, "caller not sa dfx");
1892 }
1893 if (!appMgrServiceInner_) {
1894 TAG_LOGE(AAFwkTag::APPMGR, "appMgrServiceInner_ is nullptr");
1895 return ERR_INVALID_VALUE;
1896 }
1897 return appMgrServiceInner_->UpdateProcessMemoryState(procMemState);
1898 }
1899
LaunchAbility(sptr<IRemoteObject> token)1900 int32_t AppMgrService::LaunchAbility(sptr<IRemoteObject> token)
1901 {
1902 if (!IsReady()) {
1903 return AAFwk::ERR_APP_MGR_SERVICE_NOT_READY;
1904 }
1905 if (!AAFwk::PermissionVerification::GetInstance()->CheckSpecificSystemAbilityAccessPermission(FOUNDATION_PROCESS)) {
1906 TAG_LOGE(AAFwkTag::APPMGR, "not foundation");
1907 return AAFwk::ERR_NO_ALLOW_OUTSIDE_CALL;
1908 }
1909 return appMgrServiceInner_->LaunchAbility(token);
1910 }
1911
PromoteCurrentToCandidateMasterProcess(bool isInsertToHead)1912 int32_t AppMgrService::PromoteCurrentToCandidateMasterProcess(bool isInsertToHead)
1913 {
1914 TAG_LOGD(AAFwkTag::APPMGR, "call");
1915 if (!IsReady()) {
1916 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1917 return AAFwk::ERR_NULL_APP_MGR_SERVICE_INNER;
1918 }
1919 return appMgrServiceInner_->PromoteCurrentToCandidateMasterProcess(isInsertToHead);
1920 }
1921
DemoteCurrentFromCandidateMasterProcess()1922 int32_t AppMgrService::DemoteCurrentFromCandidateMasterProcess()
1923 {
1924 TAG_LOGD(AAFwkTag::APPMGR, "called");
1925 if (!IsReady()) {
1926 TAG_LOGE(AAFwkTag::APPMGR, "not ready");
1927 return AAFwk::ERR_NULL_APP_MGR_SERVICE_INNER;
1928 }
1929 return appMgrServiceInner_->DemoteCurrentFromCandidateMasterProcess();
1930 }
1931
QueryRunningSharedBundles(pid_t pid,std::map<std::string,uint32_t> & sharedBundles)1932 int32_t AppMgrService::QueryRunningSharedBundles(pid_t pid, std::map<std::string, uint32_t> &sharedBundles)
1933 {
1934 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1935 if (!IsReady()) {
1936 TAG_LOGE(AAFwkTag::APPMGR, "Service not ready");
1937 return AAFwk::ERR_APP_MGR_SERVICE_NOT_READY;
1938 }
1939 if (!appMgrServiceInner_->IsFoundationCall()) {
1940 TAG_LOGE(AAFwkTag::APPMGR, "Not foundation call.");
1941 return ERR_PERMISSION_DENIED;
1942 }
1943 return appMgrServiceInner_->QueryRunningSharedBundles(pid, sharedBundles);
1944 }
1945 } // namespace AppExecFwk
1946 } // namespace OHOS
1947