1 /*
2  * Copyright (c) 2023 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 <algorithm>
17 
18 #include "ability_death_recipient.h"
19 #include "datetime_ex.h"
20 #include "ipc_skeleton.h"
21 #include "memory_guard.h"
22 #include "sam_log.h"
23 #include "hisysevent_adapter.h"
24 #include "schedule/system_ability_state_scheduler.h"
25 #include "service_control.h"
26 #include "samgr_err_code.h"
27 #include "string_ex.h"
28 #include "system_ability_manager.h"
29 #include "samgr_xcollie.h"
30 #include "parameters.h"
31 #include "system_ability_manager_util.h"
32 #include "system_ability_definition.h"
33 
34 namespace OHOS {
35 namespace {
36 constexpr int64_t RESTART_TIME_INTERVAL_LIMIT = 20 * 1000;
37 constexpr int32_t RESTART_TIMES_LIMIT = 4;
38 constexpr int32_t MAX_SUBSCRIBE_COUNT = 256;
39 constexpr int32_t UNLOAD_TIMEOUT_TIME = 5 * 1000;
40 constexpr const char* LOCAL_DEVICE = "local";
41 constexpr int32_t MAX_DELAY_TIME = 5 * 60 * 1000;
42 constexpr int32_t MAX_DURATION = 10 * 60 * 1000; // ms
43 constexpr int32_t ONCE_DELAY_TIME = 10 * 1000; // ms
44 constexpr const char* CANCEL_UNLOAD = "cancelUnload";
45 constexpr const char* KEY_EVENT_ID = "eventId";
46 constexpr const char* KEY_NAME = "name";
47 constexpr const char* KEY_VALUE = "value";
48 constexpr const char* KEY_EXTRA_DATA_ID = "extraDataId";
49 constexpr const char* KEY_UNLOAD_TIMEOUT = "unloadTimeout";
50 const std::u16string SAMGR_PROCESS_NAME = u"samgr";
51 constexpr const char *SA_STATE_ENUM_STR[] = {
52     "NOT_LOADED", "LOADING", "LOADED", "UNLOADABLE", "UNLOADING" };
53 constexpr const char *PROCESS_STATE_ENUM_STR[] = {
54     "NOT_STARTED", "STARTED", "STOPPING" };
55 constexpr const char *PENDINGEVENT_ENUM_STR[] = {
56     "NO_EVENT", "LOAD_ABILITY_EVENT", "UNLOAD_ABILITY_EVENT" };
57 }
Init(const std::list<SaProfile> & saProfiles)58 void SystemAbilityStateScheduler::Init(const std::list<SaProfile>& saProfiles)
59 {
60     HILOGI("Scheduler:init start");
61     InitStateContext(saProfiles);
62     processListenerDeath_ = sptr<IRemoteObject::DeathRecipient>(new SystemProcessListenerDeathRecipient());
63     unloadEventHandler_ = std::make_shared<UnloadEventHandler>(weak_from_this());
64 
65     auto listener =  std::dynamic_pointer_cast<SystemAbilityStateListener>(shared_from_this());
66     stateMachine_ = std::make_shared<SystemAbilityStateMachine>(listener);
67     stateEventHandler_ = std::make_shared<SystemAbilityEventHandler>(stateMachine_);
68 
69     processHandler_ = std::make_shared<FFRTHandler>("ProcessHandler");
70     HILOGI("Scheduler:init end");
71 }
72 
CleanFfrt()73 void SystemAbilityStateScheduler::CleanFfrt()
74 {
75     if (processHandler_ != nullptr) {
76         processHandler_->CleanFfrt();
77     }
78     if (unloadEventHandler_ != nullptr) {
79         unloadEventHandler_->CleanFfrt();
80     }
81 }
82 
SetFfrt()83 void SystemAbilityStateScheduler::SetFfrt()
84 {
85     if (processHandler_ != nullptr) {
86         processHandler_->SetFfrt("ProcessHandler");
87     }
88     if (unloadEventHandler_ != nullptr) {
89         unloadEventHandler_->SetFfrt();
90     }
91 }
92 
InitStateContext(const std::list<SaProfile> & saProfiles)93 void SystemAbilityStateScheduler::InitStateContext(const std::list<SaProfile>& saProfiles)
94 {
95     for (auto& saProfile : saProfiles) {
96         if (saProfile.process.empty()) {
97             continue;
98         }
99         std::unique_lock<std::shared_mutex> processWriteLock(processMapLock_);
100         if (processContextMap_.count(saProfile.process) == 0) {
101             auto processContext = std::make_shared<SystemProcessContext>();
102             processContext->processName = saProfile.process;
103             processContext->abilityStateCountMap[SystemAbilityState::NOT_LOADED] = 0;
104             processContext->abilityStateCountMap[SystemAbilityState::LOADING] = 0;
105             processContext->abilityStateCountMap[SystemAbilityState::LOADED] = 0;
106             processContext->abilityStateCountMap[SystemAbilityState::UNLOADABLE] = 0;
107             processContext->abilityStateCountMap[SystemAbilityState::UNLOADING] = 0;
108             processContextMap_[saProfile.process] = processContext;
109         }
110         processContextMap_[saProfile.process]->saList.push_back(saProfile.saId);
111         processContextMap_[saProfile.process]->abilityStateCountMap[SystemAbilityState::NOT_LOADED]++;
112         auto abilityContext = std::make_shared<SystemAbilityContext>();
113         abilityContext->systemAbilityId = saProfile.saId;
114         abilityContext->isAutoRestart = saProfile.autoRestart;
115         int32_t delayUnloadTime = LimitDelayUnloadTime(saProfile.stopOnDemand.delayTime);
116         abilityContext->delayUnloadTime = delayUnloadTime;
117         abilityContext->ownProcessContext = processContextMap_[saProfile.process];
118         std::unique_lock<std::shared_mutex> abiltyWriteLock(abiltyMapLock_);
119         abilityContextMap_[saProfile.saId] = abilityContext;
120     }
121 }
122 
InitSamgrProcessContext()123 void SystemAbilityStateScheduler::InitSamgrProcessContext()
124 {
125     auto processContext = std::make_shared<SystemProcessContext>();
126     processContext->processName = SAMGR_PROCESS_NAME;
127     processContext->abilityStateCountMap[SystemAbilityState::NOT_LOADED] = 0;
128     processContext->abilityStateCountMap[SystemAbilityState::LOADING] = 0;
129     processContext->abilityStateCountMap[SystemAbilityState::LOADED] = 1;
130     processContext->abilityStateCountMap[SystemAbilityState::UNLOADABLE] = 0;
131     processContext->abilityStateCountMap[SystemAbilityState::UNLOADING] = 0;
132     processContext->pid = getpid();
133     processContext->uid = static_cast<int32_t>(getuid());
134     processContextMap_[SAMGR_PROCESS_NAME] = processContext;
135     processContextMap_[SAMGR_PROCESS_NAME]->saList.push_back(0);
136     processContext->state = SystemProcessState::STARTED;
137 
138     auto abilityContext = std::make_shared<SystemAbilityContext>();
139     abilityContext->systemAbilityId = 0;
140     abilityContext->isAutoRestart = false;
141     abilityContext->delayUnloadTime = MAX_DELAY_TIME;
142     abilityContext->ownProcessContext = processContextMap_[SAMGR_PROCESS_NAME];
143     std::unique_lock<std::shared_mutex> abiltyWriteLock(abiltyMapLock_);
144     abilityContextMap_[0] = abilityContext;
145 }
146 
LimitDelayUnloadTime(int32_t delayUnloadTime)147 int32_t SystemAbilityStateScheduler::LimitDelayUnloadTime(int32_t delayUnloadTime)
148 {
149     if (delayUnloadTime < 0) {
150         return 0;
151     }
152     if (delayUnloadTime > MAX_DELAY_TIME) {
153         return MAX_DELAY_TIME;
154     }
155     return delayUnloadTime;
156 }
157 
GetSystemAbilityContext(int32_t systemAbilityId,std::shared_ptr<SystemAbilityContext> & abilityContext)158 bool SystemAbilityStateScheduler::GetSystemAbilityContext(int32_t systemAbilityId,
159     std::shared_ptr<SystemAbilityContext>& abilityContext)
160 {
161     std::shared_lock<std::shared_mutex> readLock(abiltyMapLock_);
162     if (abilityContextMap_.count(systemAbilityId) == 0) {
163         HILOGD("Scheduler SA:%{public}d not in SA profiles", systemAbilityId);
164         return false;
165     }
166     abilityContext = abilityContextMap_[systemAbilityId];
167     if (abilityContext == nullptr) {
168         HILOGE("Scheduler SA:%{public}d context is null", systemAbilityId);
169         return false;
170     }
171     if (abilityContext->ownProcessContext == nullptr) {
172         HILOGE("Scheduler SA:%{public}d not in any proc", systemAbilityId);
173         return false;
174     }
175     return true;
176 }
177 
UpdateLimitDelayUnloadTime(int32_t systemAbilityId)178 void SystemAbilityStateScheduler::UpdateLimitDelayUnloadTime(int32_t systemAbilityId)
179 {
180     if (processHandler_ == nullptr) {
181         HILOGE("UpdateLimitDelayUnloadTime process handler not init");
182         return;
183     }
184     auto updateDelayUnloadTimeTask = [systemAbilityId, this]() {
185         UpdateLimitDelayUnloadTimeTask(systemAbilityId);
186     };
187     bool ret = processHandler_->PostTask(updateDelayUnloadTimeTask);
188     if (!ret) {
189         HILOGW("UpdateLimitDelayUnloadTime PostTask fail");
190     }
191 }
192 
UpdateLimitDelayUnloadTimeTask(int32_t systemAbilityId)193 void SystemAbilityStateScheduler::UpdateLimitDelayUnloadTimeTask(int32_t systemAbilityId)
194 {
195     std::shared_ptr<SystemAbilityContext> abilityContext;
196     if (!GetSystemAbilityContext(systemAbilityId, abilityContext)) {
197         return;
198     }
199     std::lock_guard<std::mutex> autoLock(abilityContext->ownProcessContext->processLock);
200     if (abilityContext->lastStartTime != 0) {
201         int64_t begin = abilityContext->lastStartTime;
202         int64_t end = GetTickCount();
203         if (end - begin <= MAX_DURATION) {
204             int64_t onceDelayTime = abilityContext->delayUnloadTime;
205             onceDelayTime += ONCE_DELAY_TIME;
206             abilityContext->delayUnloadTime = LimitDelayUnloadTime(onceDelayTime);
207             HILOGI("DelayUnloadTime is %{public}d, SA:%{public}d",
208                 abilityContext->delayUnloadTime, systemAbilityId);
209         }
210     }
211     abilityContext->lastStartTime = GetTickCount();
212 }
213 
GetSystemProcessContext(const std::u16string & processName,std::shared_ptr<SystemProcessContext> & processContext)214 bool SystemAbilityStateScheduler::GetSystemProcessContext(const std::u16string& processName,
215     std::shared_ptr<SystemProcessContext>& processContext)
216 {
217     std::shared_lock<std::shared_mutex> readLock(processMapLock_);
218     if (processContextMap_.count(processName) == 0) {
219         HILOGE("Scheduler proc:%{public}s invalid", Str16ToStr8(processName).c_str());
220         return false;
221     }
222     processContext = processContextMap_[processName];
223     if (processContext == nullptr) {
224         HILOGE("Scheduler proc:%{public}s context is null", Str16ToStr8(processName).c_str());
225         return false;
226     }
227     return true;
228 }
229 
IsSystemAbilityUnloading(int32_t systemAbilityId)230 bool SystemAbilityStateScheduler::IsSystemAbilityUnloading(int32_t systemAbilityId)
231 {
232     std::shared_ptr<SystemAbilityContext> abilityContext;
233     if (!GetSystemAbilityContext(systemAbilityId, abilityContext)) {
234         return false;
235     }
236     std::lock_guard<std::mutex> autoLock(abilityContext->ownProcessContext->processLock);
237     if (abilityContext->state ==SystemAbilityState::UNLOADING
238         || abilityContext->ownProcessContext->state == SystemProcessState::STOPPING) {
239         return true;
240     }
241     return false;
242 }
243 
HandleLoadAbilityEvent(int32_t systemAbilityId,bool & isExist)244 int32_t SystemAbilityStateScheduler::HandleLoadAbilityEvent(int32_t systemAbilityId, bool& isExist)
245 {
246     std::shared_ptr<SystemAbilityContext> abilityContext;
247     if (!GetSystemAbilityContext(systemAbilityId, abilityContext)) {
248         isExist = false;
249         return ERR_INVALID_VALUE;
250     }
251     std::lock_guard<std::mutex> autoLock(abilityContext->ownProcessContext->processLock);
252     if (abilityContext->ownProcessContext->state == SystemProcessState::NOT_STARTED) {
253         isExist = false;
254         return ERR_INVALID_VALUE;
255     }
256     if (abilityContext->ownProcessContext->state == SystemProcessState::STARTED
257         && abilityContext->state ==SystemAbilityState::NOT_LOADED) {
258         HILOGD("Scheduler SA:%{public}d handle load event by check start", systemAbilityId);
259         bool result = SystemAbilityManager::GetInstance()->DoLoadOnDemandAbility(systemAbilityId, isExist);
260         if (result) {
261             return stateMachine_->AbilityStateTransitionLocked(abilityContext, SystemAbilityState::LOADING);
262         }
263         return ERR_INVALID_VALUE;
264     }
265     isExist = true;
266     return ERR_OK;
267 }
268 
HandleLoadAbilityEvent(const LoadRequestInfo & loadRequestInfo)269 int32_t SystemAbilityStateScheduler::HandleLoadAbilityEvent(const LoadRequestInfo& loadRequestInfo)
270 {
271     std::shared_ptr<SystemAbilityContext> abilityContext;
272     if (!GetSystemAbilityContext(loadRequestInfo.systemAbilityId, abilityContext)) {
273         return GET_SA_CONTEXT_FAIL;
274     }
275     HILOGI("Scheduler SA:%{public}d load start %{public}d,%{public}d_"
276         "%{public}d_%{public}d", loadRequestInfo.systemAbilityId, loadRequestInfo.callingPid,
277         loadRequestInfo.loadEvent.eventId, abilityContext->ownProcessContext->state, abilityContext->state);
278     std::lock_guard<std::mutex> autoLock(abilityContext->ownProcessContext->processLock);
279     int32_t result = HandleLoadAbilityEventLocked(abilityContext, loadRequestInfo);
280     if (result != ERR_OK) {
281         HILOGE("Scheduler SA:%{public}d handle load fail,ret:%{public}d",
282             loadRequestInfo.systemAbilityId, result);
283     }
284     return result;
285 }
286 
HandleLoadAbilityEventLocked(const std::shared_ptr<SystemAbilityContext> & abilityContext,const LoadRequestInfo & loadRequestInfo)287 int32_t SystemAbilityStateScheduler::HandleLoadAbilityEventLocked(
288     const std::shared_ptr<SystemAbilityContext>& abilityContext, const LoadRequestInfo& loadRequestInfo)
289 {
290     if (abilityContext->state ==SystemAbilityState::UNLOADING
291         || abilityContext->ownProcessContext->state == SystemProcessState::STOPPING) {
292         return PendLoadEventLocked(abilityContext, loadRequestInfo);
293     }
294     nlohmann::json activeReason;
295     activeReason[KEY_EVENT_ID] = loadRequestInfo.loadEvent.eventId;
296     activeReason[KEY_NAME] = loadRequestInfo.loadEvent.name;
297     activeReason[KEY_VALUE] = loadRequestInfo.loadEvent.value;
298     activeReason[KEY_EXTRA_DATA_ID] = loadRequestInfo.loadEvent.extraDataId;
299     int32_t result = INVALID_SA_STATE;
300     switch (abilityContext->state) {
301         case SystemAbilityState::LOADING:
302             result = RemovePendingUnloadEventLocked(abilityContext);
303             break;
304         case SystemAbilityState::LOADED:
305             result = RemoveDelayUnloadEventLocked(abilityContext->systemAbilityId);
306             break;
307         case SystemAbilityState::UNLOADABLE:
308             result = ActiveSystemAbilityLocked(abilityContext, activeReason);
309             break;
310         case SystemAbilityState::NOT_LOADED:
311             result = ERR_OK;
312             break;
313         default:
314             result = INVALID_SA_STATE;
315             HILOGI("Scheduler SA:%{public}d in state %{public}d, can't load SA",
316                 loadRequestInfo.systemAbilityId, abilityContext->state);
317             break;
318     }
319     if (result == ERR_OK) {
320         return DoLoadSystemAbilityLocked(abilityContext, loadRequestInfo);
321     }
322     return result;
323 }
324 
HandleUnloadAbilityEvent(const std::shared_ptr<UnloadRequestInfo> unloadRequestInfo)325 int32_t SystemAbilityStateScheduler::HandleUnloadAbilityEvent(
326     const std::shared_ptr<UnloadRequestInfo> unloadRequestInfo)
327 {
328     if (unloadRequestInfo == nullptr) {
329         HILOGE("Scheduler:HandleUnloadSaEvent unloadRequestInfo is null");
330         return UNLOAD_REQUEST_NULL;
331     }
332     std::shared_ptr<SystemAbilityContext> abilityContext;
333     if (!GetSystemAbilityContext(unloadRequestInfo->systemAbilityId, abilityContext)) {
334         return GET_SA_CONTEXT_FAIL;
335     }
336     HILOGI("Scheduler SA:%{public}d unload start %{public}d,%{public}d_"
337         "%{public}d_%{public}d", unloadRequestInfo->systemAbilityId, unloadRequestInfo->callingPid,
338         unloadRequestInfo->unloadEvent.eventId, abilityContext->ownProcessContext->state, abilityContext->state);
339     std::lock_guard<std::mutex> autoLock(abilityContext->ownProcessContext->processLock);
340     int32_t result = HandleUnloadAbilityEventLocked(abilityContext, unloadRequestInfo);
341     if (result != ERR_OK) {
342         HILOGE("Scheduler SA:%{public}d handle unload fail,ret:%{public}d",
343             unloadRequestInfo->systemAbilityId, result);
344     }
345     return result;
346 }
347 
HandleUnloadAbilityEventLocked(const std::shared_ptr<SystemAbilityContext> & abilityContext,const std::shared_ptr<UnloadRequestInfo> unloadRequestInfo)348 int32_t SystemAbilityStateScheduler::HandleUnloadAbilityEventLocked(
349     const std::shared_ptr<SystemAbilityContext>& abilityContext,
350     const std::shared_ptr<UnloadRequestInfo> unloadRequestInfo)
351 {
352     if (unloadRequestInfo == nullptr) {
353         HILOGE("Scheduler SA:%{public}d unloadRequestInfo is null", abilityContext->systemAbilityId);
354         return UNLOAD_REQUEST_NULL;
355     }
356     abilityContext->unloadRequest = unloadRequestInfo;
357     int32_t result = INVALID_SA_STATE;
358     switch (abilityContext->state) {
359         case SystemAbilityState::LOADING:
360             result = PendUnloadEventLocked(abilityContext, unloadRequestInfo);
361             break;
362         case SystemAbilityState::LOADED:
363             if (unloadRequestInfo->unloadEvent.eventId == INTERFACE_CALL) {
364                 result = ProcessDelayUnloadEventLocked(abilityContext->systemAbilityId);
365             } else {
366                 result = SendDelayUnloadEventLocked(abilityContext->systemAbilityId, abilityContext->delayUnloadTime);
367             }
368             break;
369         default:
370             result = ERR_OK;
371             HILOGI("Scheduler SA:%{public}d in state %{public}d,not need unload SA,callPid:%{public}d",
372                 abilityContext->systemAbilityId, abilityContext->state, unloadRequestInfo->callingPid);
373             break;
374     }
375     return result;
376 }
377 
HandleCancelUnloadAbilityEvent(int32_t systemAbilityId)378 int32_t SystemAbilityStateScheduler::HandleCancelUnloadAbilityEvent(int32_t systemAbilityId)
379 {
380     HILOGI("Scheduler SA:%{public}d cancel unload start", systemAbilityId);
381     std::shared_ptr<SystemAbilityContext> abilityContext;
382     if (!GetSystemAbilityContext(systemAbilityId, abilityContext)) {
383         return ERR_INVALID_VALUE;
384     }
385     nlohmann::json activeReason;
386     activeReason[KEY_EVENT_ID] = INTERFACE_CALL;
387     activeReason[KEY_NAME] = CANCEL_UNLOAD;
388     activeReason[KEY_VALUE] = "";
389     activeReason[KEY_EXTRA_DATA_ID] = -1;
390     int32_t result = ERR_INVALID_VALUE;
391     std::lock_guard<std::mutex> autoLock(abilityContext->ownProcessContext->processLock);
392     switch (abilityContext->state) {
393         case SystemAbilityState::UNLOADABLE:
394             result = ActiveSystemAbilityLocked(abilityContext, activeReason);
395             break;
396         default:
397             result = ERR_OK;
398             HILOGI("Scheduler SA:%{public}d in state %{public}d,not need cancel unload",
399                 systemAbilityId, abilityContext->state);
400             break;
401     }
402     return result;
403 }
404 
ActiveSystemAbilityLocked(const std::shared_ptr<SystemAbilityContext> & abilityContext,const nlohmann::json & activeReason)405 int32_t SystemAbilityStateScheduler::ActiveSystemAbilityLocked(
406     const std::shared_ptr<SystemAbilityContext>& abilityContext,
407     const nlohmann::json& activeReason)
408 {
409     bool result = SystemAbilityManager::GetInstance()->ActiveSystemAbility(abilityContext->systemAbilityId,
410         abilityContext->ownProcessContext->processName, activeReason);
411     if (!result) {
412         HILOGE("Scheduler SA:%{public}d active fail", abilityContext->systemAbilityId);
413         return ACTIVE_SA_FAIL;
414     }
415     return stateMachine_->AbilityStateTransitionLocked(abilityContext, SystemAbilityState::LOADED);
416 }
417 
SendAbilityStateEvent(int32_t systemAbilityId,AbilityStateEvent event)418 int32_t SystemAbilityStateScheduler::SendAbilityStateEvent(int32_t systemAbilityId, AbilityStateEvent event)
419 {
420     HILOGD("Scheduler SA:%{public}d recv state event", systemAbilityId);
421     std::shared_ptr<SystemAbilityContext> abilityContext;
422     if (!GetSystemAbilityContext(systemAbilityId, abilityContext)) {
423         return ERR_INVALID_VALUE;
424     }
425     std::lock_guard<std::mutex> autoLock(abilityContext->ownProcessContext->processLock);
426     return stateEventHandler_->HandleAbilityEventLocked(abilityContext, event);
427 }
428 
SendProcessStateEvent(const ProcessInfo & processInfo,ProcessStateEvent event)429 int32_t SystemAbilityStateScheduler::SendProcessStateEvent(const ProcessInfo& processInfo, ProcessStateEvent event)
430 {
431     HILOGD("Scheduler proc:%{public}s receive state event",
432         Str16ToStr8(processInfo.processName).c_str());
433     std::shared_ptr<SystemProcessContext> processContext;
434     if (!GetSystemProcessContext(processInfo.processName, processContext)) {
435         return ERR_INVALID_VALUE;
436     }
437     std::lock_guard<std::mutex> autoLock(processContext->processLock);
438     return stateEventHandler_->HandleProcessEventLocked(processContext, processInfo, event);
439 }
440 
SendDelayUnloadEventLocked(uint32_t systemAbilityId,int32_t delayTime)441 int32_t SystemAbilityStateScheduler::SendDelayUnloadEventLocked(uint32_t systemAbilityId, int32_t delayTime)
442 {
443     if (unloadEventHandler_ == nullptr) {
444         HILOGE("Scheduler:unload handler not init");
445         return UNLOAD_EVENT_HANDLER_NULL;
446     }
447     if (unloadEventHandler_->HasInnerEvent(systemAbilityId)) {
448         return ERR_OK;
449     }
450     HILOGI("Scheduler SA:%{public}d send delay unload event", systemAbilityId);
451     bool ret = unloadEventHandler_->SendEvent(systemAbilityId, 0, delayTime);
452     if (!ret) {
453         HILOGE("Scheduler:send event fail");
454         return SEND_EVENT_FAIL;
455     }
456     return ERR_OK;
457 }
458 
RemoveDelayUnloadEventLocked(uint32_t systemAbilityId)459 int32_t SystemAbilityStateScheduler::RemoveDelayUnloadEventLocked(uint32_t systemAbilityId)
460 {
461     if (unloadEventHandler_ == nullptr) {
462         HILOGE("Scheduler:unload handler not init");
463         return UNLOAD_EVENT_HANDLER_NULL;
464     }
465     if (!unloadEventHandler_->HasInnerEvent(systemAbilityId)) {
466         return ERR_OK;
467     }
468     HILOGI("Scheduler SA:%{public}d rm delay unload event", systemAbilityId);
469     unloadEventHandler_->RemoveEvent(systemAbilityId);
470     return ERR_OK;
471 }
472 
PendLoadEventLocked(const std::shared_ptr<SystemAbilityContext> & abilityContext,const LoadRequestInfo & loadRequestInfo)473 int32_t SystemAbilityStateScheduler::PendLoadEventLocked(const std::shared_ptr<SystemAbilityContext>& abilityContext,
474     const LoadRequestInfo& loadRequestInfo)
475 {
476     HILOGI("Scheduler SA:%{public}d save load event", abilityContext->systemAbilityId);
477     if (loadRequestInfo.callback == nullptr) {
478         HILOGW("Scheduler:callback invalid!");
479         return CALLBACK_NULL;
480     }
481     bool isExist = std::any_of(abilityContext->pendingLoadEventList.begin(),
482         abilityContext->pendingLoadEventList.end(), [&loadRequestInfo](const auto& loadEventItem) {
483             return loadRequestInfo.callback->AsObject() == loadEventItem.callback->AsObject();
484         });
485     if (isExist) {
486         HILOGI("Scheduler SA:%{public}d existed callback", abilityContext->systemAbilityId);
487         return ERR_OK;
488     }
489     auto& count = abilityContext->pendingLoadEventCountMap[loadRequestInfo.callingPid];
490     if (count >= MAX_SUBSCRIBE_COUNT) {
491         HILOGE("Scheduler SA:%{public}d pid:%{public}d overflow max callback count!",
492             abilityContext->systemAbilityId, loadRequestInfo.callingPid);
493         return PEND_LOAD_EVENT_SIZE_LIMIT;
494     }
495     ++count;
496     abilityContext->pendingLoadEventList.emplace_back(loadRequestInfo);
497     abilityContext->pendingEvent = PendingEvent::LOAD_ABILITY_EVENT;
498     return ERR_OK;
499 }
500 
PendUnloadEventLocked(const std::shared_ptr<SystemAbilityContext> & abilityContext,const std::shared_ptr<UnloadRequestInfo> unloadRequestInfo)501 int32_t SystemAbilityStateScheduler::PendUnloadEventLocked(
502     const std::shared_ptr<SystemAbilityContext>& abilityContext,
503     const std::shared_ptr<UnloadRequestInfo> unloadRequestInfo)
504 {
505     HILOGI("Scheduler SA:%{public}d save unload event", abilityContext->systemAbilityId);
506     abilityContext->pendingEvent = PendingEvent::UNLOAD_ABILITY_EVENT;
507     abilityContext->pendingUnloadEvent = unloadRequestInfo;
508     return ERR_OK;
509 }
510 
RemovePendingUnloadEventLocked(const std::shared_ptr<SystemAbilityContext> & abilityContext)511 int32_t SystemAbilityStateScheduler::RemovePendingUnloadEventLocked(
512     const std::shared_ptr<SystemAbilityContext>& abilityContext)
513 {
514     if (abilityContext->pendingEvent == PendingEvent::UNLOAD_ABILITY_EVENT) {
515         HILOGI("Scheduler SA:%{public}d rm pending unload event", abilityContext->systemAbilityId);
516         abilityContext->pendingEvent = PendingEvent::NO_EVENT;
517     }
518     return ERR_OK;
519 }
520 
HandlePendingLoadEventLocked(const std::shared_ptr<SystemAbilityContext> & abilityContext)521 int32_t SystemAbilityStateScheduler::HandlePendingLoadEventLocked(
522     const std::shared_ptr<SystemAbilityContext>& abilityContext)
523 {
524     if (abilityContext->pendingEvent != PendingEvent::LOAD_ABILITY_EVENT) {
525         HILOGD("Scheduler SA:%{public}d no pending load event", abilityContext->systemAbilityId);
526         return ERR_OK;
527     }
528     HILOGI("Scheduler SA:%{public}d handle pending load event start", abilityContext->systemAbilityId);
529     abilityContext->pendingEvent = PendingEvent::NO_EVENT;
530     for (auto& loadRequestInfo : abilityContext->pendingLoadEventList) {
531         int32_t result = HandleLoadAbilityEventLocked(abilityContext, loadRequestInfo);
532         if (result != ERR_OK) {
533             HILOGE("Scheduler SA:%{public}d handle pending load event fail,callPid:%{public}d",
534                 abilityContext->systemAbilityId, loadRequestInfo.callingPid);
535         }
536     }
537     abilityContext->pendingLoadEventList.clear();
538     abilityContext->pendingLoadEventCountMap.clear();
539     return ERR_OK;
540 }
541 
HandlePendingUnloadEventLocked(const std::shared_ptr<SystemAbilityContext> & abilityContext)542 int32_t SystemAbilityStateScheduler::HandlePendingUnloadEventLocked(
543     const std::shared_ptr<SystemAbilityContext>& abilityContext)
544 {
545     if (abilityContext->pendingEvent != PendingEvent::UNLOAD_ABILITY_EVENT) {
546         HILOGD("Scheduler SA:%{public}d no pending unload event", abilityContext->systemAbilityId);
547         return ERR_OK;
548     }
549     HILOGI("Scheduler SA:%{public}d handle pending unload event start", abilityContext->systemAbilityId);
550     abilityContext->pendingEvent = PendingEvent::NO_EVENT;
551     return HandleUnloadAbilityEventLocked(abilityContext, abilityContext->pendingUnloadEvent);
552 }
553 
DoLoadSystemAbilityLocked(const std::shared_ptr<SystemAbilityContext> & abilityContext,const LoadRequestInfo & loadRequestInfo)554 int32_t SystemAbilityStateScheduler::DoLoadSystemAbilityLocked(
555     const std::shared_ptr<SystemAbilityContext>& abilityContext, const LoadRequestInfo& loadRequestInfo)
556 {
557     int32_t result = ERR_OK;
558     if (loadRequestInfo.deviceId == LOCAL_DEVICE) {
559         HILOGD("Scheduler SA:%{public}d load ability from local start", abilityContext->systemAbilityId);
560         result = SystemAbilityManager::GetInstance()->DoLoadSystemAbility(abilityContext->systemAbilityId,
561             abilityContext->ownProcessContext->processName, loadRequestInfo.callback, loadRequestInfo.callingPid,
562             loadRequestInfo.loadEvent);
563     } else {
564         HILOGD("Scheduler SA:%{public}d load ability from remote start", abilityContext->systemAbilityId);
565         result = SystemAbilityManager::GetInstance()->DoLoadSystemAbilityFromRpc(loadRequestInfo.deviceId,
566             abilityContext->systemAbilityId, abilityContext->ownProcessContext->processName, loadRequestInfo.callback,
567             loadRequestInfo.loadEvent);
568     }
569     if (result == ERR_OK && abilityContext->state == SystemAbilityState::NOT_LOADED) {
570         return stateMachine_->AbilityStateTransitionLocked(abilityContext, SystemAbilityState::LOADING);
571     }
572     return result;
573 }
574 
TryUnloadAllSystemAbility(const std::shared_ptr<SystemProcessContext> & processContext)575 int32_t SystemAbilityStateScheduler::TryUnloadAllSystemAbility(
576     const std::shared_ptr<SystemProcessContext>& processContext)
577 {
578     if (processContext == nullptr) {
579         HILOGE("Scheduler:proc context is null");
580         return ERR_INVALID_VALUE;
581     }
582     std::lock_guard<std::mutex> autoLock(processContext->processLock);
583     if (CanUnloadAllSystemAbilityLocked(processContext, true)) {
584         return UnloadAllSystemAbilityLocked(processContext);
585     }
586     return ERR_OK;
587 }
588 
CanUnloadAllSystemAbility(const std::shared_ptr<SystemProcessContext> & processContext)589 bool SystemAbilityStateScheduler::CanUnloadAllSystemAbility(
590     const std::shared_ptr<SystemProcessContext>& processContext)
591 {
592     std::lock_guard<std::mutex> autoLock(processContext->stateCountLock);
593     return CanUnloadAllSystemAbilityLocked(processContext, true);
594 }
595 
CanUnloadAllSystemAbilityLocked(const std::shared_ptr<SystemProcessContext> & processContext,bool isNeedCheckRecycleStrategy)596 bool SystemAbilityStateScheduler::CanUnloadAllSystemAbilityLocked(
597     const std::shared_ptr<SystemProcessContext>& processContext, bool isNeedCheckRecycleStrategy)
598 {
599     uint32_t notLoadAbilityCount = processContext->abilityStateCountMap[SystemAbilityState::NOT_LOADED];
600     uint32_t unloadableAbilityCount = processContext->abilityStateCountMap[SystemAbilityState::UNLOADABLE];
601     if (unloadableAbilityCount == 0) {
602         return false;
603     }
604     if (notLoadAbilityCount + unloadableAbilityCount == processContext->saList.size()) {
605         if (isNeedCheckRecycleStrategy) {
606             return CheckSaIsImmediatelyRecycle(processContext);
607         } else {
608             return true;
609         }
610     }
611     HILOGI("Scheduler proc:%{public}s SA num:%{public}zu,notloaded:%{public}d,unloadable:%{public}d",
612         Str16ToStr8(processContext->processName).c_str(), processContext->saList.size(), notLoadAbilityCount,
613         unloadableAbilityCount);
614     return false;
615 }
616 
CheckSaIsImmediatelyRecycle(const std::shared_ptr<SystemProcessContext> & processContext)617 bool SystemAbilityStateScheduler::CheckSaIsImmediatelyRecycle(
618     const std::shared_ptr<SystemProcessContext>& processContext)
619 {
620     for (auto& saId: processContext->saList) {
621         if (SystemAbilityManager::GetInstance()->CheckSaIsImmediatelyRecycle(saId)) {
622             return true;
623         }
624     }
625     HILOGI("CheckSaIsImmediatelyRecycle is false");
626     return false;
627 }
628 
PostTryUnloadAllAbilityTask(const std::shared_ptr<SystemProcessContext> & processContext)629 int32_t SystemAbilityStateScheduler::PostTryUnloadAllAbilityTask(
630     const std::shared_ptr<SystemProcessContext>& processContext)
631 {
632     bool result = processHandler_->PostTask([this, processContext] () {
633         int32_t ret = TryUnloadAllSystemAbility(processContext);
634         if (ret != ERR_OK) {
635             HILOGE("Scheduler proc:%{public}s unload all SA fail",
636                 Str16ToStr8(processContext->processName).c_str());
637         }
638     });
639     if (!result) {
640         HILOGW("Scheduler proc:%{public}s post task fail",
641             Str16ToStr8(processContext->processName).c_str());
642         return ERR_INVALID_VALUE;
643     }
644     return ERR_OK;
645 }
646 
PostUnloadTimeoutTask(const std::shared_ptr<SystemProcessContext> & processContext)647 int32_t SystemAbilityStateScheduler::PostUnloadTimeoutTask(const std::shared_ptr<SystemProcessContext>& processContext)
648 {
649     auto timeoutTask = [this, processContext] () {
650         std::string name = KEY_UNLOAD_TIMEOUT + Str16ToStr8(processContext->processName);
651         if (processHandler_ != nullptr) {
652             HILOGD("TimeoutTask deltask proc:%{public}s", name.c_str());
653             processHandler_->DelTask(name);
654         } else {
655             HILOGE("TimeoutTask processHandler_ is null");
656         }
657         std::lock_guard<std::mutex> autoLock(processContext->processLock);
658         if (processContext->state == SystemProcessState::STOPPING) {
659             HILOGW("Scheduler proc:%{public}s unload SA timeout",
660                 Str16ToStr8(processContext->processName).c_str());
661             int32_t result = KillSystemProcessLocked(processContext);
662             HILOGI("Scheduler proc:%{public}s kill proc timeout ret:%{public}d",
663                 Str16ToStr8(processContext->processName).c_str(), result);
664         }
665     };
666     bool ret = processHandler_->PostTask(timeoutTask, KEY_UNLOAD_TIMEOUT + Str16ToStr8(processContext->processName),
667         UNLOAD_TIMEOUT_TIME);
668     if (!ret) {
669         HILOGW("Scheduler proc:%{public}s post timeout task fail",
670             Str16ToStr8(processContext->processName).c_str());
671         return ERR_INVALID_VALUE;
672     }
673     return ERR_OK;
674 }
675 
RemoveUnloadTimeoutTask(const std::shared_ptr<SystemProcessContext> & processContext)676 void SystemAbilityStateScheduler::RemoveUnloadTimeoutTask(const std::shared_ptr<SystemProcessContext>& processContext)
677 {
678     processHandler_->RemoveTask(KEY_UNLOAD_TIMEOUT + Str16ToStr8(processContext->processName));
679 }
680 
PostTryKillProcessTask(const std::shared_ptr<SystemProcessContext> & processContext)681 int32_t SystemAbilityStateScheduler::PostTryKillProcessTask(
682     const std::shared_ptr<SystemProcessContext>& processContext)
683 {
684     bool result = processHandler_->PostTask([this, processContext] () {
685         int32_t ret = TryKillSystemProcess(processContext);
686         if (ret != ERR_OK) {
687             HILOGE("Scheduler proc:%{public}s kill proc fail",
688                 Str16ToStr8(processContext->processName).c_str());
689         }
690     });
691     if (!result) {
692         HILOGW("Scheduler proc:%{public}s post task fail",
693             Str16ToStr8(processContext->processName).c_str());
694         return ERR_INVALID_VALUE;
695     }
696     return ERR_OK;
697 }
698 
UnloadAllSystemAbilityLocked(const std::shared_ptr<SystemProcessContext> & processContext)699 int32_t SystemAbilityStateScheduler::UnloadAllSystemAbilityLocked(
700     const std::shared_ptr<SystemProcessContext>& processContext)
701 {
702     HILOGI("Scheduler proc:%{public}s unload all SA", Str16ToStr8(processContext->processName).c_str());
703     for (auto& saId : processContext->saList) {
704         std::shared_ptr<SystemAbilityContext> abilityContext;
705         if (!GetSystemAbilityContext(saId, abilityContext)) {
706             continue;
707         }
708         int32_t result = ERR_OK;
709         if (abilityContext->state == SystemAbilityState::UNLOADABLE) {
710             result = DoUnloadSystemAbilityLocked(abilityContext);
711         }
712         if (result != ERR_OK) {
713             HILOGE("Scheduler SA:%{public}d unload fail", saId);
714         }
715     }
716     PostUnloadTimeoutTask(processContext);
717     return stateMachine_->ProcessStateTransitionLocked(processContext, SystemProcessState::STOPPING);
718 }
719 
DoUnloadSystemAbilityLocked(const std::shared_ptr<SystemAbilityContext> & abilityContext)720 int32_t SystemAbilityStateScheduler::DoUnloadSystemAbilityLocked(
721     const std::shared_ptr<SystemAbilityContext>& abilityContext)
722 {
723     if (abilityContext->unloadRequest == nullptr) {
724         HILOGE("Scheduler SA:%{public}d DoUnloadSaLocked unloadRequest is null",
725             abilityContext->systemAbilityId);
726         return ERR_INVALID_VALUE;
727     }
728     int32_t result = ERR_OK;
729     HILOGI("Scheduler SA:%{public}d unload start", abilityContext->systemAbilityId);
730     result = SystemAbilityManager::GetInstance()->DoUnloadSystemAbility(abilityContext->systemAbilityId,
731         abilityContext->ownProcessContext->processName, abilityContext->unloadRequest->unloadEvent);
732     if (result == ERR_OK) {
733         return stateMachine_->AbilityStateTransitionLocked(abilityContext, SystemAbilityState::UNLOADING);
734     }
735     return result;
736 }
737 
UnloadAllIdleSystemAbility()738 int32_t SystemAbilityStateScheduler::UnloadAllIdleSystemAbility()
739 {
740     HILOGI("Scheduler:UnloadAllIdleSa");
741     int32_t result = ERR_OK;
742     std::shared_lock<std::shared_mutex> readLock(processMapLock_);
743     for (auto it : processContextMap_) {
744         auto& processContext = it.second;
745         if (processContext == nullptr) {
746             continue;
747         }
748 
749         int32_t ret = ERR_OK;
750         std::lock_guard<std::mutex> autoLock(processContext->processLock);
751         if (CanUnloadAllSystemAbilityLocked(processContext)) {
752             ret = UnloadAllSystemAbilityLocked(processContext);
753         }
754         if (ret != ERR_OK) {
755             result = ret;
756             HILOGI("Scheduler proc:%{public}s unload all SA fail",
757                 Str16ToStr8(processContext->processName).c_str());
758         }
759     }
760     return result;
761 }
762 
TryKillSystemProcess(const std::shared_ptr<SystemProcessContext> & processContext)763 int32_t SystemAbilityStateScheduler::TryKillSystemProcess(
764     const std::shared_ptr<SystemProcessContext>& processContext)
765 {
766     if (processContext == nullptr) {
767         HILOGE("Scheduler:proc context is null");
768         return ERR_INVALID_VALUE;
769     }
770     std::lock_guard<std::mutex> autoLock(processContext->processLock);
771     if (CanKillSystemProcessLocked(processContext)) {
772         return KillSystemProcessLocked(processContext);
773     }
774     return ERR_OK;
775 }
776 
CanKillSystemProcess(const std::shared_ptr<SystemProcessContext> & processContext)777 bool SystemAbilityStateScheduler::CanKillSystemProcess(
778     const std::shared_ptr<SystemProcessContext>& processContext)
779 {
780     std::lock_guard<std::mutex> autoLock(processContext->stateCountLock);
781     return CanKillSystemProcessLocked(processContext);
782 }
783 
CanKillSystemProcessLocked(const std::shared_ptr<SystemProcessContext> & processContext)784 bool SystemAbilityStateScheduler::CanKillSystemProcessLocked(
785     const std::shared_ptr<SystemProcessContext>& processContext)
786 {
787     uint32_t notLoadAbilityCount = processContext->abilityStateCountMap[SystemAbilityState::NOT_LOADED];
788     HILOGI("Scheduler proc:%{public}s,SA num:%{public}zu,notloaded num:%{public}d",
789         Str16ToStr8(processContext->processName).c_str(), processContext->saList.size(), notLoadAbilityCount);
790     if (notLoadAbilityCount == processContext->saList.size()) {
791         return true;
792     }
793     return false;
794 }
795 
KillSystemProcessLocked(const std::shared_ptr<SystemProcessContext> & processContext)796 int32_t SystemAbilityStateScheduler::KillSystemProcessLocked(
797     const std::shared_ptr<SystemProcessContext>& processContext)
798 {
799     int64_t begin = GetTickCount();
800     int32_t result = ERR_OK;
801     {
802         SamgrXCollie samgrXCollie("samgr--killProccess_" + Str16ToStr8(processContext->processName));
803         result = ServiceControlWithExtra(Str16ToStr8(processContext->processName).c_str(),
804             ServiceAction::STOP, nullptr, 0);
805     }
806 
807     int64_t duration = GetTickCount() - begin;
808     if (result != 0) {
809         ReportProcessStopFail(Str16ToStr8(processContext->processName), processContext->pid, processContext->uid,
810             "err:" + ToString(result));
811     }
812     ReportProcessStopDuration(Str16ToStr8(processContext->processName), processContext->pid,
813         processContext->uid, duration);
814     KHILOGI("Scheduler proc:%{public}s kill pid:%{public}d,%{public}d_%{public}d_"
815         "%{public}" PRId64 "ms", Str16ToStr8(processContext->processName).c_str(), processContext->pid,
816         processContext->uid, result, duration);
817     return result;
818 }
819 
CanRestartProcessLocked(const std::shared_ptr<SystemProcessContext> & processContext)820 bool SystemAbilityStateScheduler::CanRestartProcessLocked(const std::shared_ptr<SystemProcessContext>& processContext)
821 {
822     if (!processContext->enableRestart) {
823         return false;
824     }
825     int64_t curtime = GetTickCount();
826     if (processContext->restartCountsCtrl.size() < RESTART_TIMES_LIMIT) {
827         processContext->restartCountsCtrl.push_back(curtime);
828         return true;
829     } else if (processContext->restartCountsCtrl.size() == RESTART_TIMES_LIMIT) {
830         if (curtime - processContext->restartCountsCtrl.front() < RESTART_TIME_INTERVAL_LIMIT) {
831             processContext->enableRestart = false;
832             return false;
833         }
834         processContext->restartCountsCtrl.push_back(curtime);
835         processContext->restartCountsCtrl.pop_front();
836         return true;
837     } else {
838         HILOGE("Scheduler proc:%{public}s unkown err",
839             Str16ToStr8(processContext->processName).c_str());
840     }
841     return false;
842 }
843 
GetAbnormallyDiedAbilityLocked(std::shared_ptr<SystemProcessContext> & processContext,std::list<std::shared_ptr<SystemAbilityContext>> & abnormallyDiedAbilityList)844 int32_t SystemAbilityStateScheduler::GetAbnormallyDiedAbilityLocked(
845     std::shared_ptr<SystemProcessContext>& processContext,
846     std::list<std::shared_ptr<SystemAbilityContext>>& abnormallyDiedAbilityList)
847 {
848     for (auto& saId : processContext->saList) {
849         std::shared_ptr<SystemAbilityContext> abilityContext;
850         if (!GetSystemAbilityContext(saId, abilityContext)) {
851             continue;
852         }
853         if (abilityContext->state == SystemAbilityState::LOADED
854             || abilityContext->state == SystemAbilityState::LOADING) {
855             SamgrUtil::SendUpdateSaState(abilityContext->systemAbilityId, "crash");
856             HILOGI("Scheduler SA:%{public}d abnormally died", abilityContext->systemAbilityId);
857             if (abilityContext->systemAbilityId == SUBSYS_ACCOUNT_SYS_ABILITY_ID_BEGIN) {
858                 SystemAbilityManager::GetInstance()->RemoveWhiteCommonEvent();
859             }
860             if (!abilityContext->isAutoRestart) {
861                 continue;
862             }
863             if (system::GetBoolParameter("resourceschedule.memmgr.min.memmory.watermark", false)) {
864                 HILOGW("restart fail,watermark=true");
865                 continue;
866             }
867             HILOGI("Scheduler SA:%{public}d is auto restart", abilityContext->systemAbilityId);
868             abnormallyDiedAbilityList.emplace_back(abilityContext);
869         }
870     }
871     return ERR_OK;
872 }
873 
874 
HandleAbnormallyDiedAbilityLocked(std::shared_ptr<SystemProcessContext> & processContext,std::list<std::shared_ptr<SystemAbilityContext>> & abnormallyDiedAbilityList)875 int32_t SystemAbilityStateScheduler::HandleAbnormallyDiedAbilityLocked(
876     std::shared_ptr<SystemProcessContext>& processContext,
877     std::list<std::shared_ptr<SystemAbilityContext>>& abnormallyDiedAbilityList)
878 {
879     if (abnormallyDiedAbilityList.empty()) {
880         return ERR_OK;
881     }
882     if (!CanRestartProcessLocked(processContext)) {
883         HILOGW("Scheduler proc:%{public}s can't restart:More than 4 restarts in 20s",
884             Str16ToStr8(processContext->processName).c_str());
885         return ERR_OK;
886     }
887     OnDemandEvent onDemandEvent = {INTERFACE_CALL, "restart"};
888     sptr<ISystemAbilityLoadCallback> callback(new SystemAbilityLoadCallbackStub());
889     for (auto& abilityContext : abnormallyDiedAbilityList) {
890         // Actively remove SA to prevent restart failure if the death recipient of SA is not processed in time.
891         SystemAbilityManager::GetInstance()->RemoveDiedSystemAbility(abilityContext->systemAbilityId);
892         LoadRequestInfo loadRequestInfo = {LOCAL_DEVICE, callback,
893             abilityContext->systemAbilityId, -1, onDemandEvent};
894         HandleLoadAbilityEventLocked(abilityContext, loadRequestInfo);
895     }
896     return ERR_OK;
897 }
898 
NotifyProcessStarted(const std::shared_ptr<SystemProcessContext> & processContext)899 void SystemAbilityStateScheduler::NotifyProcessStarted(const std::shared_ptr<SystemProcessContext>& processContext)
900 {
901     std::shared_lock<std::shared_mutex> readLock(listenerSetLock_);
902     for (auto& listener : processListeners_) {
903         if (listener->AsObject() != nullptr) {
904             SystemProcessInfo systemProcessInfo = {Str16ToStr8(processContext->processName), processContext->pid,
905                 processContext->uid};
906             listener->OnSystemProcessStarted(systemProcessInfo);
907         }
908     }
909 }
910 
NotifyProcessStopped(const std::shared_ptr<SystemProcessContext> & processContext)911 void SystemAbilityStateScheduler::NotifyProcessStopped(const std::shared_ptr<SystemProcessContext>& processContext)
912 {
913     std::shared_lock<std::shared_mutex> readLock(listenerSetLock_);
914     for (auto& listener : processListeners_) {
915         if (listener->AsObject() != nullptr) {
916             SystemProcessInfo systemProcessInfo = {Str16ToStr8(processContext->processName), processContext->pid,
917                 processContext->uid};
918             listener->OnSystemProcessStopped(systemProcessInfo);
919         }
920     }
921 }
922 
OnProcessStartedLocked(const std::u16string & processName)923 void SystemAbilityStateScheduler::OnProcessStartedLocked(const std::u16string& processName)
924 {
925     HILOGI("Scheduler proc:%{public}s started", Str16ToStr8(processName).c_str());
926     std::shared_ptr<SystemProcessContext> processContext;
927     if (!GetSystemProcessContext(processName, processContext)) {
928         return;
929     }
930     NotifyProcessStarted(processContext);
931 }
932 
OnProcessNotStartedLocked(const std::u16string & processName)933 void SystemAbilityStateScheduler::OnProcessNotStartedLocked(const std::u16string& processName)
934 {
935     HILOGI("Scheduler proc:%{public}s stopped", Str16ToStr8(processName).c_str());
936     std::shared_ptr<SystemProcessContext> processContext;
937     if (!GetSystemProcessContext(processName, processContext)) {
938         return;
939     }
940     NotifyProcessStopped(processContext);
941     RemoveUnloadTimeoutTask(processContext);
942 
943     std::list<std::shared_ptr<SystemAbilityContext>> abnormallyDiedAbilityList;
944     GetAbnormallyDiedAbilityLocked(processContext, abnormallyDiedAbilityList);
945     for (auto& saId : processContext->saList) {
946         std::shared_ptr<SystemAbilityContext> abilityContext;
947         if (!GetSystemAbilityContext(saId, abilityContext)) {
948             continue;
949         }
950         int32_t result = stateMachine_->AbilityStateTransitionLocked(abilityContext, SystemAbilityState::NOT_LOADED);
951         if (result != ERR_OK) {
952             continue;
953         }
954         HandlePendingLoadEventLocked(abilityContext);
955     }
956     HandleAbnormallyDiedAbilityLocked(processContext, abnormallyDiedAbilityList);
957 }
958 
HandleAbilityDiedEvent(int32_t systemAbilityId)959 int32_t SystemAbilityStateScheduler::HandleAbilityDiedEvent(int32_t systemAbilityId)
960 {
961     HILOGD("Scheduler SA:%{public}d handle ability died event", systemAbilityId);
962     return ERR_OK;
963 }
964 
OnAbilityNotLoadedLocked(int32_t systemAbilityId)965 void SystemAbilityStateScheduler::OnAbilityNotLoadedLocked(int32_t systemAbilityId)
966 {
967     HILOGI("Scheduler SA:%{public}d not loaded", systemAbilityId);
968     std::shared_ptr<SystemAbilityContext> abilityContext;
969     if (!GetSystemAbilityContext(systemAbilityId, abilityContext)) {
970         return;
971     }
972     RemoveDelayUnloadEventLocked(abilityContext->systemAbilityId);
973     RemovePendingUnloadEventLocked(abilityContext);
974     if (abilityContext->ownProcessContext->state == SystemProcessState::STOPPING) {
975         PostTryKillProcessTask(abilityContext->ownProcessContext);
976     } else if (abilityContext->ownProcessContext->state == SystemProcessState::STARTED) {
977         PostTryUnloadAllAbilityTask(abilityContext->ownProcessContext);
978     }
979 }
980 
OnAbilityLoadedLocked(int32_t systemAbilityId)981 void SystemAbilityStateScheduler::OnAbilityLoadedLocked(int32_t systemAbilityId)
982 {
983     HILOGI("Scheduler SA:%{public}d loaded", systemAbilityId);
984     std::shared_ptr<SystemAbilityContext> abilityContext;
985     if (!GetSystemAbilityContext(systemAbilityId, abilityContext)) {
986         return;
987     }
988     HandlePendingUnloadEventLocked(abilityContext);
989 }
990 
OnAbilityUnloadableLocked(int32_t systemAbilityId)991 void SystemAbilityStateScheduler::OnAbilityUnloadableLocked(int32_t systemAbilityId)
992 {
993     HILOGI("Scheduler SA:%{public}d unloadable", systemAbilityId);
994     std::shared_ptr<SystemAbilityContext> abilityContext;
995     if (!GetSystemAbilityContext(systemAbilityId, abilityContext)) {
996         return;
997     }
998     PostTryUnloadAllAbilityTask(abilityContext->ownProcessContext);
999 }
1000 
GetSystemProcessInfo(int32_t systemAbilityId,SystemProcessInfo & systemProcessInfo)1001 int32_t SystemAbilityStateScheduler::GetSystemProcessInfo(int32_t systemAbilityId,
1002     SystemProcessInfo& systemProcessInfo)
1003 {
1004     HILOGI("Scheduler:get proc info by [SA:%{public}d]", systemAbilityId);
1005     std::shared_ptr<SystemAbilityContext> abilityContext;
1006     if (!GetSystemAbilityContext(systemAbilityId, abilityContext)) {
1007         HILOGI("Scheduler:get SA context by said fail");
1008         return ERR_INVALID_VALUE;
1009     }
1010     std::shared_ptr<SystemProcessContext> processContext = abilityContext->ownProcessContext;
1011     std::lock_guard<std::mutex> autoLock(processContext->processLock);
1012     systemProcessInfo = {Str16ToStr8(processContext->processName), processContext->pid,
1013                 processContext->uid};
1014     return ERR_OK;
1015 }
1016 
GetRunningSystemProcess(std::list<SystemProcessInfo> & systemProcessInfos)1017 int32_t SystemAbilityStateScheduler::GetRunningSystemProcess(std::list<SystemProcessInfo>& systemProcessInfos)
1018 {
1019     HILOGI("Scheduler:get running process");
1020     std::shared_lock<std::shared_mutex> readLock(processMapLock_);
1021     for (auto it : processContextMap_) {
1022         auto& processContext = it.second;
1023         if (processContext == nullptr) {
1024             continue;
1025         }
1026         std::lock_guard<std::mutex> autoLock(processContext->processLock);
1027         if (processContext->state == SystemProcessState::STARTED) {
1028             SystemProcessInfo systemProcessInfo = {Str16ToStr8(processContext->processName), processContext->pid,
1029                 processContext->uid};
1030             systemProcessInfos.emplace_back(systemProcessInfo);
1031         }
1032     }
1033     return ERR_OK;
1034 }
1035 
GetProcessNameByProcessId(int32_t pid,std::u16string & processName)1036 int32_t SystemAbilityStateScheduler::GetProcessNameByProcessId(int32_t pid, std::u16string& processName)
1037 {
1038     HILOGD("[SA Scheduler] get processName by processId");
1039     std::shared_lock<std::shared_mutex> readLock(processMapLock_);
1040     for (auto it : processContextMap_) {
1041         auto& processContext = it.second;
1042         if (processContext == nullptr) {
1043             continue;
1044         }
1045         std::lock_guard<std::mutex> autoLock(processContext->processLock);
1046         if (processContext->pid == pid) {
1047             processName = processContext->processName;
1048             return ERR_OK;
1049         }
1050     }
1051     return ERR_INVALID_VALUE;
1052 }
1053 
GetAllSystemAbilityInfo(std::string & result)1054 void SystemAbilityStateScheduler::GetAllSystemAbilityInfo(std::string& result)
1055 {
1056     std::shared_lock<std::shared_mutex> readLock(abiltyMapLock_);
1057     for (auto it : abilityContextMap_) {
1058         if (it.second == nullptr) {
1059             continue;
1060         }
1061         result += "said:                           ";
1062         result += std::to_string(it.second->systemAbilityId);
1063         result += "\n";
1064         result += "sa_state:                       ";
1065         result += SA_STATE_ENUM_STR[static_cast<int32_t>(it.second->state)];
1066         result += "\n";
1067         result += "sa_pending_event:               ";
1068         result += PENDINGEVENT_ENUM_STR[static_cast<int32_t>(it.second->pendingEvent)];
1069         if (it.second->ownProcessContext != nullptr) {
1070             std::lock_guard<std::mutex> autoLock(it.second->ownProcessContext->stateCountLock);
1071             result += '\n';
1072             result += "process_name:                   ";
1073             result += Str16ToStr8(it.second->ownProcessContext->processName);
1074             result += '\n';
1075             result += "pid:                            ";
1076             result += std::to_string(it.second->ownProcessContext->pid);
1077             result += '\n';
1078             result += "uid:                            ";
1079             result += std::to_string(it.second->ownProcessContext->uid);
1080         }
1081         result += "\n---------------------------------------------------\n";
1082     }
1083 }
1084 
GetSystemAbilityInfo(int32_t said,std::string & result)1085 void SystemAbilityStateScheduler::GetSystemAbilityInfo(int32_t said, std::string& result)
1086 {
1087     std::shared_ptr<SystemAbilityContext> abilityContext;
1088     if (!GetSystemAbilityContext(said, abilityContext)) {
1089         result.append("said is not exist");
1090         return;
1091     }
1092     std::lock_guard<std::mutex> autoLock(abilityContext->ownProcessContext->processLock);
1093     result += "said:                           ";
1094     result += std::to_string(said);
1095     result += "\n";
1096     result += "sa_state:                       ";
1097     result += SA_STATE_ENUM_STR[static_cast<int32_t>(abilityContext->state)];
1098     result += "\n";
1099     result += "sa_pending_event:               ";
1100     result += PENDINGEVENT_ENUM_STR[static_cast<int32_t>(abilityContext->pendingEvent)];
1101     result += "\n";
1102     result += "process_name:                   ";
1103     result += Str16ToStr8(abilityContext->ownProcessContext->processName);
1104     result += "\n";
1105     result += "process_state:                  ";
1106     result += PROCESS_STATE_ENUM_STR[static_cast<int32_t>(abilityContext->ownProcessContext->state)];
1107     result += "\n";
1108     result += "pid:                            ";
1109     result += std::to_string(abilityContext->ownProcessContext->pid);
1110     result += "\n";
1111 }
1112 
GetProcessInfo(const std::string & processName,std::string & result)1113 void SystemAbilityStateScheduler::GetProcessInfo(const std::string& processName, std::string& result)
1114 {
1115     std::shared_ptr<SystemProcessContext> processContext;
1116     if (!GetSystemProcessContext(Str8ToStr16(processName), processContext)) {
1117         result.append("process is not exist");
1118         return;
1119     }
1120     std::lock_guard<std::mutex> autoLock(processContext->processLock);
1121     result += "process_name:                   ";
1122     result += Str16ToStr8(processContext->processName);
1123     result += "\n";
1124     result += "process_state:                  ";
1125     result += PROCESS_STATE_ENUM_STR[static_cast<int32_t>(processContext->state)];
1126     result += "\n";
1127     result += "pid:                            ";
1128     result += std::to_string(processContext->pid);
1129     result += "\n---------------------------------------------------\n";
1130     for (auto it : processContext->saList) {
1131         std::shared_ptr<SystemAbilityContext> abilityContext;
1132         if (!GetSystemAbilityContext(it, abilityContext)) {
1133             result.append("process said is not exist");
1134             return;
1135         }
1136         result += "said:                           ";
1137         result += std::to_string(abilityContext->systemAbilityId);
1138         result += '\n';
1139         result += "sa_state:                       ";
1140         result += SA_STATE_ENUM_STR[static_cast<int32_t>(abilityContext->state)];
1141         result += '\n';
1142         result += "sa_pending_event:               ";
1143         result += PENDINGEVENT_ENUM_STR[static_cast<int32_t>(abilityContext->pendingEvent)];
1144         result += "\n---------------------------------------------------\n";
1145     }
1146 }
1147 
GetAllSystemAbilityInfoByState(const std::string & state,std::string & result)1148 void SystemAbilityStateScheduler::GetAllSystemAbilityInfoByState(const std::string& state, std::string& result)
1149 {
1150     std::shared_lock<std::shared_mutex> readLock(abiltyMapLock_);
1151     for (auto it : abilityContextMap_) {
1152         if (it.second == nullptr || SA_STATE_ENUM_STR[static_cast<int32_t>(it.second->state)] != state) {
1153             continue;
1154         }
1155         result += "said:                           ";
1156         result += std::to_string(it.second->systemAbilityId);
1157         result += '\n';
1158         result += "sa_state:                       ";
1159         result += SA_STATE_ENUM_STR[static_cast<int32_t>(it.second->state)];
1160         result += '\n';
1161         result += "sa_pending_event:               ";
1162         result += PENDINGEVENT_ENUM_STR[static_cast<int32_t>(it.second->pendingEvent)];
1163         if (it.second->ownProcessContext != nullptr) {
1164             std::lock_guard<std::mutex> autoLock(it.second->ownProcessContext->stateCountLock);
1165             result += '\n';
1166             result += "process_name:                   ";
1167             result += Str16ToStr8(it.second->ownProcessContext->processName);
1168             result += '\n';
1169             result += "pid:                            ";
1170             result += std::to_string(it.second->ownProcessContext->pid);
1171             result += '\n';
1172             result += "uid:                            ";
1173             result += std::to_string(it.second->ownProcessContext->uid);
1174         }
1175         result += "\n---------------------------------------------------\n";
1176     }
1177 }
1178 
SubscribeSystemProcess(const sptr<ISystemProcessStatusChange> & listener)1179 int32_t SystemAbilityStateScheduler::SubscribeSystemProcess(const sptr<ISystemProcessStatusChange>& listener)
1180 {
1181     std::unique_lock<std::shared_mutex> writeLock(listenerSetLock_);
1182     auto iter = std::find_if(processListeners_.begin(), processListeners_.end(),
1183         [listener](sptr<ISystemProcessStatusChange>& item) {
1184         return item->AsObject() == listener->AsObject();
1185     });
1186     if (iter == processListeners_.end()) {
1187         if (processListenerDeath_ != nullptr) {
1188             bool ret = listener->AsObject()->AddDeathRecipient(processListenerDeath_);
1189             HILOGI("SubscribeSystemProcess AddDeathRecipient %{public}s", ret ? "succeed" : "failed");
1190         }
1191         processListeners_.emplace_back(listener);
1192     } else {
1193         HILOGI("SubscribeSystemProcess listener already exists");
1194     }
1195     return ERR_OK;
1196 }
1197 
UnSubscribeSystemProcess(const sptr<ISystemProcessStatusChange> & listener)1198 int32_t SystemAbilityStateScheduler::UnSubscribeSystemProcess(const sptr<ISystemProcessStatusChange>& listener)
1199 {
1200     std::unique_lock<std::shared_mutex> writeLock(listenerSetLock_);
1201     auto iter = std::find_if(processListeners_.begin(), processListeners_.end(),
1202         [listener](sptr<ISystemProcessStatusChange>& item) {
1203         return item->AsObject() == listener->AsObject();
1204     });
1205     if (iter != processListeners_.end()) {
1206         if (processListenerDeath_ != nullptr) {
1207             listener->AsObject()->RemoveDeathRecipient(processListenerDeath_);
1208         }
1209         processListeners_.erase(iter);
1210         HILOGI("UnSubscribeSystemProcess listener remove success");
1211     } else {
1212         HILOGI("UnSubscribeSystemProcess listener not exists");
1213     }
1214     return ERR_OK;
1215 }
1216 
IsSystemProcessNeverStartedLocked(const std::u16string & processName)1217 bool SystemAbilityStateScheduler::IsSystemProcessNeverStartedLocked(const std::u16string& processName)
1218 {
1219     std::shared_ptr<SystemProcessContext> processContext;
1220     if (!GetSystemProcessContext(processName, processContext)) {
1221         return true;
1222     }
1223     return processContext->pid < 0;
1224 }
1225 
ProcessDelayUnloadEvent(int32_t systemAbilityId)1226 int32_t SystemAbilityStateScheduler::ProcessDelayUnloadEvent(int32_t systemAbilityId)
1227 {
1228     std::shared_ptr<SystemAbilityContext> abilityContext;
1229     if (!GetSystemAbilityContext(systemAbilityId, abilityContext)) {
1230         return GET_SA_CONTEXT_FAIL;
1231     }
1232     std::lock_guard<std::mutex> autoLock(abilityContext->ownProcessContext->processLock);
1233     return ProcessDelayUnloadEventLocked(systemAbilityId);
1234 }
1235 
ProcessDelayUnloadEventLocked(int32_t systemAbilityId)1236 int32_t SystemAbilityStateScheduler::ProcessDelayUnloadEventLocked(int32_t systemAbilityId)
1237 {
1238     std::shared_ptr<SystemAbilityContext> abilityContext;
1239     if (!GetSystemAbilityContext(systemAbilityId, abilityContext)) {
1240         return GET_SA_CONTEXT_FAIL;
1241     }
1242     if (abilityContext->unloadRequest == nullptr) {
1243         HILOGE("Scheduler SA:%{public}d unloadRequest is null", abilityContext->systemAbilityId);
1244         return UNLOAD_REQUEST_NULL;
1245     }
1246     if (abilityContext->state != SystemAbilityState::LOADED) {
1247         HILOGW("Scheduler SA:%{public}d can't proc delay unload event", systemAbilityId);
1248         return ERR_OK;
1249     }
1250     HILOGI("Scheduler SA:%{public}d proc delay unload event", systemAbilityId);
1251     int32_t delayTime = 0;
1252     nlohmann::json idleReason;
1253     idleReason[KEY_EVENT_ID] = abilityContext->unloadRequest->unloadEvent.eventId;
1254     idleReason[KEY_NAME] = abilityContext->unloadRequest->unloadEvent.name;
1255     idleReason[KEY_VALUE] = abilityContext->unloadRequest->unloadEvent.value;
1256     idleReason[KEY_EXTRA_DATA_ID] = abilityContext->unloadRequest->unloadEvent.extraDataId;
1257     bool result = SystemAbilityManager::GetInstance()->IdleSystemAbility(abilityContext->systemAbilityId,
1258         abilityContext->ownProcessContext->processName, idleReason, delayTime);
1259     if (!result) {
1260         HILOGE("Scheduler SA:%{public}d idle fail", systemAbilityId);
1261         return IDLE_SA_FAIL;
1262     }
1263     if (delayTime < 0) {
1264         HILOGI("Scheduler SA:%{public}d reject unload", systemAbilityId);
1265         return ERR_OK;
1266     } else if (delayTime == 0) {
1267         HILOGI("Scheduler SA:%{public}d agree unload", systemAbilityId);
1268         return stateMachine_->AbilityStateTransitionLocked(abilityContext, SystemAbilityState::UNLOADABLE);
1269     } else {
1270         HILOGI("Scheduler SA:%{public}d choose delay unload", systemAbilityId);
1271         return SendDelayUnloadEventLocked(abilityContext->systemAbilityId, fmin(delayTime, MAX_DELAY_TIME));
1272     }
1273 }
1274 
CheckEnableOnce(const OnDemandEvent & event,const std::list<SaControlInfo> & saControlList)1275 void SystemAbilityStateScheduler::CheckEnableOnce(const OnDemandEvent& event,
1276     const std::list<SaControlInfo>& saControlList)
1277 {
1278     sptr<ISystemAbilityLoadCallback> callback(new SystemAbilityLoadCallbackStub());
1279     for (auto& saControl : saControlList) {
1280         int32_t result = ERR_INVALID_VALUE;
1281         if (saControl.ondemandId == START_ON_DEMAND) {
1282             result = CheckStartEnableOnce(event, saControl, callback);
1283         } else if (saControl.ondemandId == STOP_ON_DEMAND) {
1284             result = CheckStopEnableOnce(event, saControl);
1285         } else {
1286             HILOGE("ondemandId error");
1287         }
1288         if (result != ERR_OK) {
1289             HILOGE("process ondemand event failed, ondemandId:%{public}d, SA:%{public}d",
1290                 saControl.ondemandId, saControl.saId);
1291         }
1292     }
1293 }
1294 
CheckStartEnableOnce(const OnDemandEvent & event,const SaControlInfo & saControl,sptr<ISystemAbilityLoadCallback> callback)1295 int32_t SystemAbilityStateScheduler::CheckStartEnableOnce(const OnDemandEvent& event,
1296     const SaControlInfo& saControl, sptr<ISystemAbilityLoadCallback> callback)
1297 {
1298     int32_t result = ERR_INVALID_VALUE;
1299     if (saControl.enableOnce) {
1300         lock_guard<mutex> autoLock(startEnableOnceLock_);
1301         auto iter = startEnableOnceMap_.find(saControl.saId);
1302         if (iter != startEnableOnceMap_.end() && SamgrUtil::IsSameEvent(event, startEnableOnceMap_[saControl.saId])) {
1303             HILOGI("ondemand canceled for enable-once, ondemandId:%{public}d, SA:%{public}d",
1304                 saControl.ondemandId, saControl.saId);
1305             return result;
1306         }
1307         startEnableOnceMap_[saControl.saId].emplace_back(event);
1308         HILOGI("startEnableOnceMap_ add SA:%{public}d, eventId:%{public}d",
1309             saControl.saId, event.eventId);
1310     }
1311     auto callingPid = IPCSkeleton::GetCallingPid();
1312     LoadRequestInfo loadRequestInfo = {LOCAL_DEVICE, callback, saControl.saId, callingPid, event};
1313     result = HandleLoadAbilityEvent(loadRequestInfo);
1314     if (saControl.enableOnce && result != ERR_OK) {
1315         lock_guard<mutex> autoLock(startEnableOnceLock_);
1316         auto& events = startEnableOnceMap_[saControl.saId];
1317         events.remove(event);
1318         if (events.empty()) {
1319             startEnableOnceMap_.erase(saControl.saId);
1320         }
1321         HILOGI("startEnableOnceMap_remove SA:%{public}d, eventId:%{public}d",
1322             saControl.saId, event.eventId);
1323     }
1324     if (result != ERR_OK) {
1325         ReportSamgrSaLoadFail(saControl.saId, IPCSkeleton::GetCallingPid(), IPCSkeleton::GetCallingUid(),
1326             "ondemand load err:" + ToString(result));
1327     }
1328     return result;
1329 }
1330 
CheckStopEnableOnce(const OnDemandEvent & event,const SaControlInfo & saControl)1331 int32_t SystemAbilityStateScheduler::CheckStopEnableOnce(const OnDemandEvent& event,
1332     const SaControlInfo& saControl)
1333 {
1334     int32_t result = ERR_INVALID_VALUE;
1335     if (saControl.enableOnce) {
1336         lock_guard<mutex> autoLock(stopEnableOnceLock_);
1337         auto iter = stopEnableOnceMap_.find(saControl.saId);
1338         if (iter != stopEnableOnceMap_.end() && SamgrUtil::IsSameEvent(event, stopEnableOnceMap_[saControl.saId])) {
1339             HILOGI("ondemand canceled for enable-once, ondemandId:%{public}d, SA:%{public}d",
1340                 saControl.ondemandId, saControl.saId);
1341             return result;
1342         }
1343         stopEnableOnceMap_[saControl.saId].emplace_back(event);
1344         HILOGI("stopEnableOnceMap_ add SA:%{public}d, eventId:%{public}d",
1345             saControl.saId, event.eventId);
1346     }
1347     auto callingPid = IPCSkeleton::GetCallingPid();
1348     std::shared_ptr<UnloadRequestInfo> unloadRequestInfo =
1349         std::make_shared<UnloadRequestInfo>(event, saControl.saId, callingPid);
1350     result = HandleUnloadAbilityEvent(unloadRequestInfo);
1351     if (saControl.enableOnce && result != ERR_OK) {
1352         lock_guard<mutex> autoLock(stopEnableOnceLock_);
1353         auto& events = stopEnableOnceMap_[saControl.saId];
1354         events.remove(event);
1355         if (events.empty()) {
1356             stopEnableOnceMap_.erase(saControl.saId);
1357         }
1358         HILOGI("stopEnableOnceMap_ remove SA:%{public}d, eventId:%{public}d",
1359             saControl.saId, event.eventId);
1360     }
1361     if (result != ERR_OK) {
1362         ReportSaUnLoadFail(saControl.saId, IPCSkeleton::GetCallingPid(), IPCSkeleton::GetCallingUid(),
1363             "Ondemand unload err:" + ToString(result));
1364     }
1365     return result;
1366 }
1367 
ProcessEvent(uint32_t eventId)1368 void SystemAbilityStateScheduler::UnloadEventHandler::ProcessEvent(uint32_t eventId)
1369 {
1370     int32_t systemAbilityId = static_cast<int32_t>(eventId);
1371     if (handler_ != nullptr) {
1372         HILOGD("ProcessEvent deltask SA:%{public}d", systemAbilityId);
1373         handler_->DelTask(std::to_string(eventId));
1374     } else {
1375         HILOGE("ProcessEvent handler_ is null");
1376     }
1377     auto stateScheduler = stateScheduler_.lock();
1378     int32_t result = ERR_OK;
1379     if (stateScheduler != nullptr) {
1380         result = stateScheduler->ProcessDelayUnloadEvent(systemAbilityId);
1381     }
1382     if (result != ERR_OK) {
1383         HILOGE("Scheduler SA:%{public}d proc delay unload event fail", systemAbilityId);
1384     }
1385 }
1386 
SendEvent(uint32_t eventId,int64_t extraDataId,uint64_t delayTime)1387 bool SystemAbilityStateScheduler::UnloadEventHandler::SendEvent(uint32_t eventId,
1388     int64_t extraDataId, uint64_t delayTime)
1389 {
1390     if (handler_ == nullptr) {
1391         HILOGE("SystemAbilityStateScheduler SendEvent handler is null!");
1392         return false;
1393     }
1394     auto task = [this, eventId] {this->ProcessEvent(eventId);};
1395     return handler_->PostTask(task, std::to_string(eventId), delayTime);
1396 }
1397 
RemoveEvent(uint32_t eventId)1398 void SystemAbilityStateScheduler::UnloadEventHandler::RemoveEvent(uint32_t eventId)
1399 {
1400     if (handler_ == nullptr) {
1401         HILOGE("SystemAbilityStateScheduler SendEvent handler is null!");
1402         return;
1403     }
1404     handler_->RemoveTask(std::to_string(eventId));
1405 }
1406 
HasInnerEvent(uint32_t eventId)1407 bool SystemAbilityStateScheduler::UnloadEventHandler::HasInnerEvent(uint32_t eventId)
1408 {
1409     if (handler_ == nullptr) {
1410         HILOGE("SystemAbilityStateScheduler SendEvent handler is null!");
1411         return false;
1412     }
1413     return handler_->HasInnerEvent(std::to_string(eventId));
1414 }
1415 
CleanFfrt()1416 void SystemAbilityStateScheduler::UnloadEventHandler::CleanFfrt()
1417 {
1418     if (handler_ != nullptr) {
1419         handler_->CleanFfrt();
1420     }
1421 }
1422 
SetFfrt()1423 void SystemAbilityStateScheduler::UnloadEventHandler::SetFfrt()
1424 {
1425     if (handler_ != nullptr) {
1426         handler_->SetFfrt("UnloadEventHandler");
1427     }
1428 }
1429 
1430 }  // namespace OHOS