1/*
2 * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16#include "ams_mgr_scheduler.h"
17#include <sys/types.h>
18
19#include "datetime_ex.h"
20#include "ipc_skeleton.h"
21#include "system_ability_definition.h"
22
23#include "accesstoken_kit.h"
24#include "app_death_recipient.h"
25#include "app_exception_manager.h"
26#include "app_mgr_constants.h"
27#include "app_utils.h"
28#include "hilog_tag_wrapper.h"
29#include "perf_profile.h"
30#include "permission_constants.h"
31#include "permission_verification.h"
32
33namespace OHOS {
34namespace AppExecFwk {
35namespace {
36constexpr const char* TASK_TERMINATE_ABILITY = "TerminateAbilityTask";
37constexpr const char* TASK_UPDATE_ABILITY_STATE = "UpdateAbilityStateTask";
38constexpr const char* TASK_UPDATE_EXTENSION_STATE = "UpdateExtensionStateTask";
39constexpr const char* TASK_REGISTER_APP_STATE_CALLBACK = "RegisterAppStateCallbackTask";
40constexpr const char* TASK_STOP_ALL_PROCESS = "StopAllProcessTask";
41constexpr const char* TASK_ABILITY_BEHAVIOR_ANALYSIS = "AbilityBehaviorAnalysisTask";
42constexpr const char* TASK_KILL_PROCESS_BY_ABILITY_TOKEN = "KillProcessByAbilityTokenTask";
43constexpr const char* TASK_KILL_PROCESSES_BY_USERID = "KillProcessesByUserIdTask";
44constexpr const char* TASK_KILL_PROCESSES_BY_PIDS = "KillProcessesByPids";
45constexpr const char* TASK_ATTACH_PID_TO_PARENT = "AttachPidToParent";
46constexpr const char* TASK_KILL_APPLICATION = "KillApplicationTask";
47constexpr const char* TASK_CLEAR_PROCESS_BY_ABILITY_TOKEN = "ClearProcessByAbilityTokenTask";
48constexpr const char* FOUNDATION_NAME = "foundation";
49constexpr const char* SCENE_BOARD_BUNDLE_NAME = "com.ohos.sceneboard";
50constexpr const char* SCENEBOARD_ABILITY_NAME = "com.ohos.sceneboard.MainAbility";
51constexpr const char* TASK_SCENE_BOARD_ATTACH_TIMEOUT = "sceneBoardAttachTimeoutTask";
52constexpr const char* TASK_ATTACHED_TO_STATUS_BAR = "AttachedToStatusBar";
53constexpr const char* TASK_BLOCK_PROCESS_CACHE_BY_PIDS = "BlockProcessCacheByPids";
54constexpr int32_t SCENE_BOARD_ATTACH_TIMEOUT_TASK_TIME = 1000;
55constexpr const char* TASK_LOAD_ABILITY = "LoadAbilityTask";
56};  // namespace
57
58AmsMgrScheduler::AmsMgrScheduler(
59    const std::shared_ptr<AppMgrServiceInner> &mgrServiceInner_,
60    const std::shared_ptr<AAFwk::TaskHandlerWrap> &handler_)
61    : amsMgrServiceInner_(mgrServiceInner_), amsHandler_(handler_)
62{}
63
64AmsMgrScheduler::~AmsMgrScheduler()
65{
66    TAG_LOGI(AAFwkTag::APPMGR, "call");
67}
68
69void AmsMgrScheduler::LoadAbility(const std::shared_ptr<AbilityInfo> &abilityInfo,
70    const std::shared_ptr<ApplicationInfo> &appInfo,
71    const std::shared_ptr<AAFwk::Want> &want, std::shared_ptr<AbilityRuntime::LoadParam> loadParam)
72{
73    if (!abilityInfo || !appInfo) {
74        TAG_LOGE(AAFwkTag::APPMGR, "param error");
75        return;
76    }
77
78    if (!IsReady()) {
79        return;
80    }
81
82    if (amsMgrServiceInner_->VerifyRequestPermission() != ERR_OK) {
83        TAG_LOGE(AAFwkTag::APPMGR, "verification failed");
84        return;
85    }
86    PerfProfile::GetInstance().SetAbilityLoadStartTime(GetTickCount());
87    TAG_LOGI(AAFwkTag::APPMGR, "SubmitLoadTask: %{public}s-%{public}s", abilityInfo->bundleName.c_str(),
88        abilityInfo->name.c_str());
89    std::function<void()> loadAbilityFunc = [amsMgrServiceInner = amsMgrServiceInner_,
90        abilityInfo, appInfo, want, loadParam]() {
91        amsMgrServiceInner->LoadAbility(abilityInfo, appInfo, want, loadParam);
92    };
93
94    // cache other application load ability task before scene board attach
95    if (!amsMgrServiceInner_->GetSceneBoardAttachFlag() && abilityInfo->bundleName != SCENE_BOARD_BUNDLE_NAME) {
96        amsMgrServiceInner_->CacheLoadAbilityTask(std::move(loadAbilityFunc));
97        return;
98    }
99    if (abilityInfo->bundleName == SCENE_BOARD_BUNDLE_NAME && abilityInfo->name == SCENEBOARD_ABILITY_NAME) {
100        amsMgrServiceInner_->SetSceneBoardAttachFlag(false);
101        // set scene board attach timeout task
102        std::weak_ptr<AppMgrServiceInner> amsMgrServiceInner = amsMgrServiceInner_;
103        auto timeoutTask = [amsMgrServiceInner]() {
104            auto inner = amsMgrServiceInner.lock();
105            if (inner != nullptr) {
106                inner->SetSceneBoardAttachFlag(true);
107            }
108        };
109        amsHandler_->SubmitTask(timeoutTask, TASK_SCENE_BOARD_ATTACH_TIMEOUT, SCENE_BOARD_ATTACH_TIMEOUT_TASK_TIME);
110    }
111
112    if (abilityInfo->bundleName == AAFwk::AppUtils::GetInstance().GetMigrateClientBundleName()) {
113        amsHandler_->SubmitTask(loadAbilityFunc, AAFwk::TaskAttribute{
114            .taskName_ = TASK_LOAD_ABILITY,
115            .taskQos_ = AAFwk::TaskQoS::USER_INTERACTIVE,
116            .taskPriority_ = AAFwk::TaskQueuePriority::IMMEDIATE
117        });
118        return;
119    }
120
121    amsHandler_->SubmitTask(loadAbilityFunc);
122}
123
124void AmsMgrScheduler::UpdateAbilityState(const sptr<IRemoteObject> &token, const AbilityState state)
125{
126    if (!IsReady()) {
127        return;
128    }
129
130    if (amsMgrServiceInner_->VerifyRequestPermission() != ERR_OK) {
131        TAG_LOGE(AAFwkTag::APPMGR, "verification failed");
132        return;
133    }
134    std::function<void()> updateAbilityStateFunc = [amsMgrServiceInner = amsMgrServiceInner_, token, state] () {
135        amsMgrServiceInner->UpdateAbilityState(token, state);
136    };
137    amsHandler_->SubmitTask(updateAbilityStateFunc, AAFwk::TaskAttribute{
138        .taskName_ = TASK_UPDATE_ABILITY_STATE,
139        .taskQos_ = AAFwk::TaskQoS::USER_INTERACTIVE
140    });
141}
142
143void AmsMgrScheduler::UpdateExtensionState(const sptr<IRemoteObject> &token, const ExtensionState state)
144{
145    if (!IsReady()) {
146        return;
147    }
148
149    if (amsMgrServiceInner_->VerifyRequestPermission() != ERR_OK) {
150        TAG_LOGE(AAFwkTag::APPMGR, "verification failed");
151        return;
152    }
153    std::function<void()> updateExtensionStateFunc = [amsMgrServiceInner = amsMgrServiceInner_, token, state]() {
154        amsMgrServiceInner->UpdateExtensionState(token, state);
155    };
156    amsHandler_->SubmitTask(updateExtensionStateFunc, AAFwk::TaskAttribute{
157        .taskName_ = TASK_UPDATE_EXTENSION_STATE,
158        .taskQos_ = AAFwk::TaskQoS::USER_INTERACTIVE
159    });
160}
161
162void AmsMgrScheduler::TerminateAbility(const sptr<IRemoteObject> &token, bool clearMissionFlag)
163{
164    if (!IsReady()) {
165        return;
166    }
167
168    if (amsMgrServiceInner_->VerifyRequestPermission() != ERR_OK) {
169        TAG_LOGE(AAFwkTag::APPMGR, "verification failed");
170        return;
171    }
172    std::function<void()> terminateAbilityFunc = [amsMgrServiceInner = amsMgrServiceInner_, token, clearMissionFlag]() {
173        amsMgrServiceInner->TerminateAbility(token, clearMissionFlag);
174    };
175    amsHandler_->SubmitTask(terminateAbilityFunc, AAFwk::TaskAttribute{
176        .taskName_ = TASK_TERMINATE_ABILITY,
177        .taskQos_ = AAFwk::TaskQoS::USER_INTERACTIVE
178    });
179}
180
181void AmsMgrScheduler::RegisterAppStateCallback(const sptr<IAppStateCallback> &callback)
182{
183    if (!AAFwk::PermissionVerification::GetInstance()->IsSACall()) {
184        TAG_LOGE(AAFwkTag::APPMGR, "caller is not SA");
185        return;
186    }
187    if (!IsReady()) {
188        return;
189    }
190    std::function<void()> registerAppStateCallbackFunc = [amsMgrServiceInner = amsMgrServiceInner_, callback]() {
191        amsMgrServiceInner->RegisterAppStateCallback(callback);
192    };
193    amsHandler_->SubmitTask(registerAppStateCallbackFunc, TASK_REGISTER_APP_STATE_CALLBACK);
194}
195
196void AmsMgrScheduler::KillProcessByAbilityToken(const sptr<IRemoteObject> &token)
197{
198    if (!IsReady()) {
199        return;
200    }
201
202    if (amsMgrServiceInner_->VerifyKillProcessPermission(token) != ERR_OK) {
203        TAG_LOGE(AAFwkTag::APPMGR, "verification failed");
204        return;
205    }
206
207    std::function<void()> killProcessByAbilityTokenFunc = [amsMgrServiceInner = amsMgrServiceInner_, token]() {
208        amsMgrServiceInner->KillProcessByAbilityToken(token);
209    };
210    amsHandler_->SubmitTask(killProcessByAbilityTokenFunc, TASK_KILL_PROCESS_BY_ABILITY_TOKEN);
211}
212
213void AmsMgrScheduler::KillProcessesByUserId(int32_t userId)
214{
215    if (!IsReady()) {
216        return;
217    }
218
219    if (!AAFwk::PermissionVerification::GetInstance()->JudgeCallerIsAllowedToUseSystemAPI()) {
220        TAG_LOGE(AAFwkTag::APPMGR, "caller is not SA");
221        return;
222    }
223
224    bool isCallingFromFoundation =
225        AAFwk::PermissionVerification::GetInstance()->CheckSpecificSystemAbilityAccessPermission(FOUNDATION_NAME);
226    auto permission = AAFwk::PermissionConstants::PERMISSION_CLEAN_BACKGROUND_PROCESSES;
227    if (!isCallingFromFoundation &&
228        amsMgrServiceInner_->VerifyAccountPermission(permission, userId) == ERR_PERMISSION_DENIED) {
229        TAG_LOGE(AAFwkTag::APPMGR, "verification failed");
230        return;
231    }
232
233    std::function<void()> killProcessesByUserIdFunc = [amsMgrServiceInner = amsMgrServiceInner_, userId]() {
234        amsMgrServiceInner->KillProcessesByUserId(userId);
235    };
236    amsHandler_->SubmitTask(killProcessesByUserIdFunc, TASK_KILL_PROCESSES_BY_USERID);
237}
238
239void AmsMgrScheduler::KillProcessesByPids(std::vector<int32_t> &pids)
240{
241    if (!IsReady()) {
242        return;
243    }
244
245    pid_t callingPid = IPCSkeleton::GetCallingPid();
246    pid_t pid = getprocpid();
247    if (callingPid != pid) {
248        TAG_LOGE(AAFwkTag::APPMGR, "not allow other process to call");
249        return;
250    }
251
252    std::function<void()> killProcessesByPidsFunc = [amsMgrServiceInner = amsMgrServiceInner_, pids]() mutable {
253        amsMgrServiceInner->KillProcessesByPids(pids);
254    };
255    amsHandler_->SubmitTask(killProcessesByPidsFunc, TASK_KILL_PROCESSES_BY_PIDS);
256}
257
258void AmsMgrScheduler::AttachPidToParent(const sptr<IRemoteObject> &token, const sptr<IRemoteObject> &callerToken)
259{
260    if (!IsReady()) {
261        return;
262    }
263
264    pid_t callingPid = IPCSkeleton::GetCallingPid();
265    pid_t pid = getprocpid();
266    if (callingPid != pid) {
267        TAG_LOGE(AAFwkTag::APPMGR, "not allow other process to call");
268        return;
269    }
270
271    std::function<void()> attachPidToParentFunc = [amsMgrServiceInner = amsMgrServiceInner_, token, callerToken]() {
272        amsMgrServiceInner->AttachPidToParent(token, callerToken);
273    };
274    amsHandler_->SubmitTask(attachPidToParentFunc, TASK_ATTACH_PID_TO_PARENT);
275}
276
277int32_t AmsMgrScheduler::KillProcessWithAccount(
278    const std::string &bundleName, const int accountId, const bool clearPageStack)
279{
280    TAG_LOGI(AAFwkTag::APPMGR, "bundleName = %{public}s, accountId = %{public}d, clearPageStack = %{public}d",
281        bundleName.c_str(), accountId, clearPageStack);
282    if (!IsReady()) {
283        return ERR_INVALID_OPERATION;
284    }
285    return amsMgrServiceInner_->KillApplicationByUserId(bundleName, 0, accountId, clearPageStack,
286        "KillProcessWithAccount");
287}
288
289void AmsMgrScheduler::AbilityAttachTimeOut(const sptr<IRemoteObject> &token)
290{
291    TAG_LOGI(AAFwkTag::APPMGR, "call");
292    if (!IsReady()) {
293        return;
294    }
295
296    if (amsMgrServiceInner_->VerifyRequestPermission() != ERR_OK) {
297        TAG_LOGE(AAFwkTag::APPMGR, "verification failed");
298        return;
299    }
300    auto task = [amsMgrServiceInner = amsMgrServiceInner_, token]() {
301        amsMgrServiceInner->HandleAbilityAttachTimeOut(token);
302    };
303    amsHandler_->SubmitTask(task);
304}
305
306void AmsMgrScheduler::PrepareTerminate(const sptr<IRemoteObject> &token, bool clearMissionFlag)
307{
308    TAG_LOGD(AAFwkTag::APPMGR, "Notify AppMgrService to prepare to terminate the ability.");
309    if (!IsReady()) {
310        return;
311    }
312
313    if (amsMgrServiceInner_->VerifyRequestPermission() != ERR_OK) {
314        TAG_LOGE(AAFwkTag::APPMGR, "verification failed");
315        return;
316    }
317    auto task = [=]() { amsMgrServiceInner_->PrepareTerminate(token, clearMissionFlag); };
318    amsHandler_->SubmitTask(task, AAFwk::TaskQoS::USER_INTERACTIVE);
319}
320
321int32_t AmsMgrScheduler::UpdateApplicationInfoInstalled(const std::string &bundleName, const int uid)
322{
323    if (!IsReady()) {
324        return ERR_INVALID_OPERATION;
325    }
326
327    return amsMgrServiceInner_->UpdateApplicationInfoInstalled(bundleName, uid);
328}
329
330int32_t AmsMgrScheduler::KillApplication(const std::string &bundleName, const bool clearPageStack)
331{
332    TAG_LOGI(AAFwkTag::APPMGR, "bundleName = %{public}s, clearPageStack = %{public}d",
333        bundleName.c_str(), clearPageStack);
334    if (!IsReady()) {
335        return ERR_INVALID_OPERATION;
336    }
337
338    return amsMgrServiceInner_->KillApplication(bundleName, clearPageStack);
339}
340
341int32_t AmsMgrScheduler::ForceKillApplication(const std::string &bundleName,
342    const int userId, const int appIndex)
343{
344    TAG_LOGI(AAFwkTag::APPMGR, "bundleName=%{public}s,userId=%{public}d,apIndex=%{public}d",
345        bundleName.c_str(), userId, appIndex);
346    if (!IsReady()) {
347        return ERR_INVALID_OPERATION;
348    }
349
350    return amsMgrServiceInner_->ForceKillApplication(bundleName, userId, appIndex);
351}
352
353int32_t AmsMgrScheduler::KillProcessesByAccessTokenId(const uint32_t accessTokenId)
354{
355    TAG_LOGI(AAFwkTag::APPMGR, "accessTokenId=%{public}d", accessTokenId);
356    if (!IsReady()) {
357        return ERR_INVALID_OPERATION;
358    }
359
360    return amsMgrServiceInner_->KillProcessesByAccessTokenId(accessTokenId);
361}
362
363int32_t AmsMgrScheduler::KillApplicationByUid(const std::string &bundleName, const int uid,
364    const std::string& reason)
365{
366    TAG_LOGI(AAFwkTag::APPMGR, "bundleName = %{public}s, uid = %{public}d", bundleName.c_str(), uid);
367    if (!IsReady()) {
368        return ERR_INVALID_OPERATION;
369    }
370    return amsMgrServiceInner_->KillApplicationByUid(bundleName, uid, reason);
371}
372
373int32_t AmsMgrScheduler::KillApplicationSelf(const bool clearPageStack, const std::string& reason)
374{
375    if (!IsReady()) {
376        return ERR_INVALID_OPERATION;
377    }
378    return amsMgrServiceInner_->KillApplicationSelf(clearPageStack, reason);
379}
380
381bool AmsMgrScheduler::IsReady() const
382{
383    if (!amsMgrServiceInner_) {
384        TAG_LOGE(AAFwkTag::APPMGR, "null amsMgrServiceInner_");
385        return false;
386    }
387    if (!amsHandler_) {
388        TAG_LOGE(AAFwkTag::APPMGR, "null amsHandler_");
389        return false;
390    }
391    return true;
392}
393
394void AmsMgrScheduler::GetRunningProcessInfoByToken(
395    const sptr<IRemoteObject> &token, AppExecFwk::RunningProcessInfo &info)
396{
397    if (!IsReady()) {
398        return;
399    }
400
401    amsMgrServiceInner_->GetRunningProcessInfoByToken(token, info);
402}
403
404void AmsMgrScheduler::SetAbilityForegroundingFlagToAppRecord(const pid_t pid)
405{
406    if (!IsReady()) {
407        return;
408    }
409    amsMgrServiceInner_->SetAbilityForegroundingFlagToAppRecord(pid);
410}
411
412void AmsMgrScheduler::StartSpecifiedAbility(const AAFwk::Want &want, const AppExecFwk::AbilityInfo &abilityInfo,
413    int32_t requestId)
414{
415    if (!IsReady()) {
416        return;
417    }
418
419    if (amsMgrServiceInner_->VerifyRequestPermission() != ERR_OK) {
420        TAG_LOGE(AAFwkTag::APPMGR, "verification failed");
421        return;
422    }
423    auto task = [=]() { amsMgrServiceInner_->StartSpecifiedAbility(want, abilityInfo, requestId); };
424    amsHandler_->SubmitTask(task, AAFwk::TaskQoS::USER_INTERACTIVE);
425}
426
427void AmsMgrScheduler::StartSpecifiedProcess(const AAFwk::Want &want, const AppExecFwk::AbilityInfo &abilityInfo,
428    int32_t requestId)
429{
430    if (!IsReady()) {
431        TAG_LOGW(AAFwkTag::APPMGR, "not ready");
432        return;
433    }
434
435    if (amsMgrServiceInner_->VerifyRequestPermission() != ERR_OK) {
436        TAG_LOGE(AAFwkTag::APPMGR, "verification failed");
437        return;
438    }
439    auto task = [=]() { amsMgrServiceInner_->StartSpecifiedProcess(want, abilityInfo, requestId); };
440    amsHandler_->SubmitTask(task, AAFwk::TaskQoS::USER_INTERACTIVE);
441}
442
443void AmsMgrScheduler::RegisterStartSpecifiedAbilityResponse(const sptr<IStartSpecifiedAbilityResponse> &response)
444{
445    if (!AAFwk::PermissionVerification::GetInstance()->IsSACall()) {
446        TAG_LOGE(AAFwkTag::APPMGR, "caller is not SA");
447        return;
448    }
449    if (!IsReady()) {
450        return;
451    }
452    auto task = [=]() { amsMgrServiceInner_->RegisterStartSpecifiedAbilityResponse(response); };
453    amsHandler_->SubmitTask(task);
454}
455
456int AmsMgrScheduler::GetApplicationInfoByProcessID(const int pid, AppExecFwk::ApplicationInfo &application, bool &debug)
457{
458    if (!IsReady()) {
459        return ERR_INVALID_OPERATION;
460    }
461    return amsMgrServiceInner_->GetApplicationInfoByProcessID(pid, application, debug);
462}
463
464int32_t AmsMgrScheduler::NotifyAppMgrRecordExitReason(int32_t pid, int32_t reason, const std::string &exitMsg)
465{
466    if (!IsReady()) {
467        return ERR_INVALID_OPERATION;
468    }
469    return amsMgrServiceInner_->NotifyAppMgrRecordExitReason(pid, reason, exitMsg);
470}
471
472void AmsMgrScheduler::SetCurrentUserId(const int32_t userId)
473{
474    if (!IsReady()) {
475        return;
476    }
477    amsMgrServiceInner_->SetCurrentUserId(userId);
478}
479
480void AmsMgrScheduler::SetEnableStartProcessFlagByUserId(int32_t userId, bool enableStartProcess)
481{
482    if (!IsReady()) {
483        return;
484    }
485    if (amsMgrServiceInner_->VerifyRequestPermission() != ERR_OK) {
486        TAG_LOGE(AAFwkTag::APPMGR, "verification failed");
487        return;
488    }
489    amsMgrServiceInner_->SetEnableStartProcessFlagByUserId(userId, enableStartProcess);
490}
491
492int32_t AmsMgrScheduler::GetBundleNameByPid(const int pid, std::string &bundleName, int32_t &uid)
493{
494    if (!IsReady()) {
495        return ERR_INVALID_OPERATION;
496    }
497    return amsMgrServiceInner_->GetBundleNameByPid(pid, bundleName, uid);
498}
499
500int32_t AmsMgrScheduler::RegisterAppDebugListener(const sptr<IAppDebugListener> &listener)
501{
502    if (!IsReady()) {
503        TAG_LOGE(AAFwkTag::APPMGR, "not ready");
504        return ERR_INVALID_OPERATION;
505    }
506    return amsMgrServiceInner_->RegisterAppDebugListener(listener);
507}
508
509int32_t AmsMgrScheduler::UnregisterAppDebugListener(const sptr<IAppDebugListener> &listener)
510{
511    if (!IsReady()) {
512        TAG_LOGE(AAFwkTag::APPMGR, "not ready");
513        return ERR_INVALID_OPERATION;
514    }
515    return amsMgrServiceInner_->UnregisterAppDebugListener(listener);
516}
517
518int32_t AmsMgrScheduler::AttachAppDebug(const std::string &bundleName)
519{
520    if (!IsReady()) {
521        TAG_LOGE(AAFwkTag::APPMGR, "not ready");
522        return ERR_INVALID_OPERATION;
523    }
524    if (!AAFwk::PermissionVerification::GetInstance()->CheckSpecificSystemAbilityAccessPermission(FOUNDATION_NAME)) {
525        TAG_LOGE(AAFwkTag::APPMGR, "caller is not foundation");
526        return ERR_INVALID_OPERATION;
527    }
528    return amsMgrServiceInner_->AttachAppDebug(bundleName);
529}
530
531int32_t AmsMgrScheduler::DetachAppDebug(const std::string &bundleName)
532{
533    if (!IsReady()) {
534        TAG_LOGE(AAFwkTag::APPMGR, "not ready");
535        return ERR_INVALID_OPERATION;
536    }
537    if (!AAFwk::PermissionVerification::GetInstance()->CheckSpecificSystemAbilityAccessPermission(FOUNDATION_NAME)) {
538        TAG_LOGE(AAFwkTag::APPMGR, "caller is not foundation");
539        return ERR_INVALID_OPERATION;
540    }
541    return amsMgrServiceInner_->DetachAppDebug(bundleName);
542}
543
544int32_t AmsMgrScheduler::SetAppWaitingDebug(const std::string &bundleName, bool isPersist)
545{
546    if (!IsReady()) {
547        TAG_LOGE(AAFwkTag::APPMGR, "not ready");
548        return ERR_INVALID_OPERATION;
549    }
550    return amsMgrServiceInner_->SetAppWaitingDebug(bundleName, isPersist);
551}
552
553int32_t AmsMgrScheduler::CancelAppWaitingDebug()
554{
555    if (!IsReady()) {
556        TAG_LOGE(AAFwkTag::APPMGR, "not ready");
557        return ERR_INVALID_OPERATION;
558    }
559    return amsMgrServiceInner_->CancelAppWaitingDebug();
560}
561
562int32_t AmsMgrScheduler::GetWaitingDebugApp(std::vector<std::string> &debugInfoList)
563{
564    if (!IsReady()) {
565        TAG_LOGE(AAFwkTag::APPMGR, "not ready");
566        return ERR_INVALID_OPERATION;
567    }
568    return amsMgrServiceInner_->GetWaitingDebugApp(debugInfoList);
569}
570
571bool AmsMgrScheduler::IsWaitingDebugApp(const std::string &bundleName)
572{
573    if (!IsReady()) {
574        TAG_LOGE(AAFwkTag::APPMGR, "not ready");
575        return false;
576    }
577    return amsMgrServiceInner_->IsWaitingDebugApp(bundleName);
578}
579
580void AmsMgrScheduler::ClearNonPersistWaitingDebugFlag()
581{
582    if (!IsReady()) {
583        TAG_LOGE(AAFwkTag::APPMGR, "not ready");
584        return;
585    }
586    amsMgrServiceInner_->ClearNonPersistWaitingDebugFlag();
587}
588
589int32_t AmsMgrScheduler::RegisterAbilityDebugResponse(const sptr<IAbilityDebugResponse> &response)
590{
591    if (!IsReady()) {
592        TAG_LOGE(AAFwkTag::APPMGR, "not ready");
593        return ERR_INVALID_OPERATION;
594    }
595    return amsMgrServiceInner_->RegisterAbilityDebugResponse(response);
596}
597
598bool AmsMgrScheduler::IsAttachDebug(const std::string &bundleName)
599{
600    if (!IsReady()) {
601        TAG_LOGE(AAFwkTag::APPMGR, "not ready");
602        return false;
603    }
604    return amsMgrServiceInner_->IsAttachDebug(bundleName);
605}
606
607void AmsMgrScheduler::SetKeepAliveEnableState(const std::string &bundleName, bool enable, int32_t uid)
608{
609    if (!IsReady()) {
610        TAG_LOGE(AAFwkTag::APPMGR, "not ready");
611        return;
612    }
613    amsMgrServiceInner_->SetKeepAliveEnableState(bundleName, enable, uid);
614}
615
616void AmsMgrScheduler::ClearProcessByToken(sptr<IRemoteObject> token)
617{
618    if (!IsReady()) {
619        return;
620    }
621
622    auto callerTokenId = IPCSkeleton::GetCallingTokenID();
623    Security::AccessToken::NativeTokenInfo nativeInfo;
624    Security::AccessToken::AccessTokenKit::GetNativeTokenInfo(callerTokenId, nativeInfo);
625    if (nativeInfo.processName != "foundation") {
626        TAG_LOGE(AAFwkTag::APPMGR, "not foundation");
627        return;
628    }
629
630    std::function<void()> clearProcessByTokenFunc = [amsMgrServiceInner = amsMgrServiceInner_, token]() {
631        amsMgrServiceInner->ClearProcessByToken(token);
632    };
633    amsHandler_->SubmitTask(clearProcessByTokenFunc, TASK_CLEAR_PROCESS_BY_ABILITY_TOKEN);
634}
635
636bool AmsMgrScheduler::IsMemorySizeSufficent()
637{
638    if (!IsReady()) {
639        TAG_LOGE(AAFwkTag::APPMGR, "not ready");
640        return true;
641    }
642    if (amsMgrServiceInner_->VerifyRequestPermission() != ERR_OK) {
643        TAG_LOGE(AAFwkTag::APPMGR, "verification failed");
644        return true;
645    }
646    return amsMgrServiceInner_->IsMemorySizeSufficient();
647}
648
649void AmsMgrScheduler::AttachedToStatusBar(const sptr<IRemoteObject> &token)
650{
651    if (!IsReady()) {
652        TAG_LOGE(AAFwkTag::APPMGR, "not ready");
653        return;
654    }
655    auto callerTokenId = IPCSkeleton::GetCallingTokenID();
656    Security::AccessToken::NativeTokenInfo nativeInfo;
657    Security::AccessToken::AccessTokenKit::GetNativeTokenInfo(callerTokenId, nativeInfo);
658    if (nativeInfo.processName != "foundation") {
659        TAG_LOGE(AAFwkTag::APPMGR, "not foundation");
660        return;
661    }
662    std::function<void()> attachedToStatusBarFunc =
663        std::bind(&AppMgrServiceInner::AttachedToStatusBar, amsMgrServiceInner_, token);
664    amsHandler_->SubmitTask(attachedToStatusBarFunc, TASK_ATTACHED_TO_STATUS_BAR);
665}
666
667void AmsMgrScheduler::BlockProcessCacheByPids(const std::vector<int32_t> &pids)
668{
669    if (!IsReady()) {
670        return;
671    }
672
673    pid_t callingPid = IPCSkeleton::GetCallingPid();
674    pid_t pid = getprocpid();
675    if (callingPid != pid) {
676        TAG_LOGE(AAFwkTag::APPMGR, "not allow other process to call");
677        return;
678    }
679
680    std::function<void()> blockProcCacheFunc = [amsMgrServiceInner = amsMgrServiceInner_, pids]() mutable {
681        amsMgrServiceInner->BlockProcessCacheByPids(pids);
682    };
683    amsHandler_->SubmitTask(blockProcCacheFunc, TASK_BLOCK_PROCESS_CACHE_BY_PIDS);
684}
685
686bool AmsMgrScheduler::CleanAbilityByUserRequest(const sptr<IRemoteObject> &token)
687{
688    if (!IsReady()) {
689        TAG_LOGE(AAFwkTag::APPMGR, "not ready");
690        return false;
691    }
692
693    if (IPCSkeleton::GetCallingPid() != getprocpid()) {
694        TAG_LOGE(AAFwkTag::APPMGR, "not allow other process to call");
695        return false;
696    }
697    return amsMgrServiceInner_->CleanAbilityByUserRequest(token);
698}
699
700bool AmsMgrScheduler::IsKilledForUpgradeWeb(const std::string &bundleName)
701{
702    if (!IsReady()) {
703        TAG_LOGE(AAFwkTag::APPMGR, "not ready");
704        return false;
705    }
706    return amsMgrServiceInner_->IsKilledForUpgradeWeb(bundleName);
707}
708bool AmsMgrScheduler::IsProcessContainsOnlyUIAbility(const pid_t pid)
709{
710    if (!IsReady()) {
711        TAG_LOGE(AAFwkTag::APPMGR, "not ready");
712        return false;
713    }
714    pid_t callingPid = IPCSkeleton::GetCallingPid();
715    pid_t procPid = getprocpid();
716    if (callingPid != procPid) {
717        TAG_LOGE(AAFwkTag::APPMGR, "not allow other process to call");
718        return false;
719    }
720    return amsMgrServiceInner_->IsProcessContainsOnlyUIAbility(pid);
721}
722
723bool AmsMgrScheduler::IsProcessAttached(sptr<IRemoteObject> token)
724{
725    if (!IsReady()) {
726        TAG_LOGE(AAFwkTag::APPMGR, "not ready");
727        return false;
728    }
729    return amsMgrServiceInner_->IsProcessAttached(token);
730}
731
732bool AmsMgrScheduler::IsAppKilling(sptr<IRemoteObject> token)
733{
734    if (!IsReady()) {
735        TAG_LOGE(AAFwkTag::APPMGR, "AmsMgrService is not ready.");
736        return false;
737    }
738    return amsMgrServiceInner_->IsAppKilling(token);
739}
740
741void AmsMgrScheduler::SetAppExceptionCallback(sptr<IRemoteObject> callback)
742{
743    if (!IsReady()) {
744        TAG_LOGE(AAFwkTag::APPMGR, "AmsMgrService is not ready.");
745        return;
746    }
747    pid_t callingPid = IPCSkeleton::GetCallingPid();
748    pid_t procPid = getprocpid();
749    if (callingPid != procPid) {
750        TAG_LOGE(AAFwkTag::APPMGR, "not allow other process to call");
751        return;
752    }
753
754    if (callback == nullptr) {
755        TAG_LOGW(AAFwkTag::APPMGR, "callback null");
756    }
757    auto exceptionCallback = iface_cast<IAppExceptionCallback>(callback);
758    return AppExceptionManager::GetInstance().SetExceptionCallback(exceptionCallback);
759}
760} // namespace AppExecFwk
761}  // namespace OHOS
762