1 /*
2  * Copyright (c) 2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "mem_mgr_event_center.h"
17 #include <string>
18 #include "memmgr_log.h"
19 #include "memmgr_ptr_util.h"
20 #include "common_event_observer.h"
21 #include "reclaim_priority_manager.h"
22 #include "window_visibility_observer.h"
23 #ifdef CONFIG_BGTASK_MGR
24 #include "background_task_mgr_helper.h"
25 #endif
26 #include "connection_observer_client.h"
27 #include "common_event_support.h"
28 #include "common_event_manager.h"
29 
30 namespace OHOS {
31 namespace Memory {
32 namespace {
33 const std::string TAG = "MemMgrEventCenter";
34 const std::string MEMMGR_CENTER_HANDLER = "MemMgrEventCenterHandler";
35 const int ACCOUNT_MAX_RETRY_TIMES = 10;
36 const int ACCOUNT_RETRY_DELAY = 3000;
37 const int EXTCONN_RETRY_TIME = 1000;
38 }
39 
40 IMPLEMENT_SINGLE_INSTANCE(MemMgrEventCenter);
41 
MemMgrEventCenter()42 MemMgrEventCenter::MemMgrEventCenter()
43 {}
44 
Init()45 bool MemMgrEventCenter::Init()
46 {
47     HILOGI("called");
48     if (CreateRegisterHandler()) {
49         HandlerRegisterEvent(RegisterEvent::REG_ALLOBS_EVENT);
50         return true;
51     }
52     return false;
53 }
54 
CreateRegisterHandler()55 bool MemMgrEventCenter::CreateRegisterHandler()
56 {
57     if (!regObsHandler_) {
58         MAKE_POINTER(regObsHandler_, shared, AppExecFwk::EventHandler, "failed to create register handler",
59         return false, AppExecFwk::EventRunner::Create(MEMMGR_CENTER_HANDLER));
60     }
61     return true;
62 }
63 
RemoveEventObserver(int32_t systemAbilityId)64 void MemMgrEventCenter::RemoveEventObserver(int32_t systemAbilityId)
65 {
66     HILOGI("called");
67     if (systemAbilityId == ABILITY_MGR_SERVICE_ID || systemAbilityId == APP_MGR_SERVICE_ID) {
68         ReclaimPriorityManager::GetInstance().Reset();
69     }
70 }
71 
OnProcessDied(int pid)72 void MemMgrEventCenter::OnProcessDied(int pid)
73 {
74     HILOGD("called");
75     WindowVisibilityObserver::GetInstance().OnProcessDied(pid);
76 }
77 
OnExtensionServiceDied()78 void MemMgrEventCenter::OnExtensionServiceDied()
79 {
80     HILOGD("called");
81     extConnObserver_ = nullptr;
82 }
83 
RegisterEventObserver()84 bool MemMgrEventCenter::RegisterEventObserver()
85 {
86     HILOGI("called");
87     if (!memoryPressureObserver_) {
88         RegisterMemoryPressureObserver();
89     }
90 
91 #ifdef USE_PURGEABLE_MEMORY
92     if (!kswapdObserver_) {
93         RegisterKswapdObserver();
94     }
95 #endif
96 
97     if (!appStateObserver_) {
98         RegisterAppStateObserver();
99     }
100 
101     if (!extConnObserver_) {
102         RegisterExtConnObserver();
103     }
104 
105     if (!accountObserver_) {
106         RegisterAccountObserver();
107     }
108 
109     if (!commonEventObserver_) {
110         RegisterCommonEventObserver();
111     }
112 
113 #ifdef CONFIG_BGTASK_MGR
114     if (!bgTaskObserver_) {
115         RegisterBgTaskObserver();
116     }
117 #endif
118     return true;
119 }
120 
HandlerRegisterEvent(int64_t registerEventId)121 void MemMgrEventCenter::HandlerRegisterEvent(int64_t registerEventId)
122 {
123     if (registerEventId == RegisterEvent::REG_ALLOBS_EVENT) {
124         regObsHandler_->PostImmediateTask([this] { this->RegisterEventObserver(); });
125     } else if (registerEventId == RegisterEvent::REG_MEMPRESSOBS_EVENT) {
126         regObsHandler_->PostImmediateTask([this] { this->RegisterMemoryPressureObserver(); });
127     } else if (registerEventId == RegisterEvent::REG_APPOBS_EVENT) {
128         regObsHandler_->PostImmediateTask([this] { this->RegisterAppStateObserver(); });
129     } else if (registerEventId == RegisterEvent::REG_EXTOBS_EVENT) {
130         regObsHandler_->PostImmediateTask([this] { this->RegisterExtConnObserver(); });
131     } else if (registerEventId == RegisterEvent::REG_ACCOUNTOBS_EVENT) {
132         regObsHandler_->PostImmediateTask([this] { this->RegisterAccountObserver(); });
133     } else if (registerEventId == RegisterEvent::REG_COMMONOBS_EVENT) {
134         regObsHandler_->PostImmediateTask([this] { this->RegisterCommonEventObserver(); });
135     } else if (registerEventId == RegisterEvent::REG_BGTASKOBS_EVENT) {
136         #ifdef CONFIG_BGTASK_MGR
137             {
138                 regObsHandler_->PostImmediateTask([this] { this->RegisterBgTaskObserver(); });
139             }
140         #endif
141     }
142     return;
143 }
144 
RegisterAppStateObserver()145 void MemMgrEventCenter::RegisterAppStateObserver()
146 {
147     HILOGI("called");
148     MAKE_POINTER(appMgrClient_, unique, AppExecFwk::AppMgrClient, "make appMgrClient failed",
149          return, /* no param */);
150     appStateObserver_ = new (std::nothrow) AppStateObserver();
151     while (appMgrClient_->ConnectAppMgrService() != AppExecFwk::AppMgrResultCode::RESULT_OK) {
152         HILOGE("ConnectAppMgrService fail, try again! retryTimes=%{public}d", ++regAppStatusObsRetry_);
153     }
154     auto systemAbilityManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
155     sptr<AppExecFwk::IAppMgr> appObject =
156         iface_cast<AppExecFwk::IAppMgr>(systemAbilityManager->GetSystemAbility(APP_MGR_SERVICE_ID));
157     if (appObject) {
158         int ret = appObject->RegisterApplicationStateObserver(appStateObserver_);
159         if (ret == ERR_OK) {
160             HILOGI("register success");
161             return;
162         }
163         HILOGE("register fail, ret = %{public}d", ret);
164         return;
165     }
166     HILOGE("get SystemAbilityManager fail");
167 }
168 
RegisterExtConnObserver()169 void MemMgrEventCenter::RegisterExtConnObserver()
170 {
171     HILOGI("called");
172     MAKE_POINTER(extConnObserver_, shared, ExtensionConnectionObserver, "make ExtensionConnectionObserver failed",
173         /* no return */, /* no param */);
174     if (extConnObserver_ != nullptr) {
175         int32_t ret = AbilityRuntime::ConnectionObserverClient::GetInstance().RegisterObserver(extConnObserver_);
176         if (ret == ERR_OK) {
177             HILOGI("register success");
178             return;
179         }
180         HILOGE("register fail, ret = %{public}d", ret);
181     }
182     regObsHandler_->PostTask([this] { this->RegisterExtConnObserver(); },
183         EXTCONN_RETRY_TIME, AppExecFwk::EventQueue::Priority::LOW);
184 }
185 
RegisterBgTaskObserver()186 void MemMgrEventCenter::RegisterBgTaskObserver()
187 {
188     HILOGI("called");
189 #ifdef CONFIG_BGTASK_MGR
190     if (!bgTaskObserver_) {
191         MAKE_POINTER(bgTaskObserver_, shared, BgTaskObserver, "make BgTaskObserver failed",
192             return, /* no param */);
193     }
194     ErrCode ret = BackgroundTaskMgr::BackgroundTaskMgrHelper::SubscribeBackgroundTask(*bgTaskObserver_);
195     if (ret == ERR_OK) {
196         HILOGI("register success");
197         return;
198     }
199     HILOGE("register fail, ret = %{public}d", ret);
200 #else
201     HILOGI("BackgroundTaskMgr is not enable.");
202 #endif
203 }
204 
RegisterCommonEventObserver()205 void MemMgrEventCenter::RegisterCommonEventObserver()
206 {
207     HILOGI("called");
208     EventFwk::MatchingSkills matchingSkills;
209     matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_BOOT_COMPLETED);
210     matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_POWER_CONNECTED);
211     matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_POWER_DISCONNECTED);
212     matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_ON);
213     matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_OFF);
214     EventFwk::CommonEventSubscribeInfo commonEventSubscribeInfo(matchingSkills);
215     MAKE_POINTER(commonEventObserver_, shared, CommonEventObserver, "make unique failed",
216         return, commonEventSubscribeInfo);
217     if (EventFwk::CommonEventManager::SubscribeCommonEvent(commonEventObserver_)) {
218         HILOGI("register success");
219         return;
220     }
221     HILOGI("register fail");
222 }
223 
RegisterAccountObserver()224 void MemMgrEventCenter::RegisterAccountObserver()
225 {
226     HILOGI("called");
227     regAccountObsRetry_++;
228     AccountSA::OsAccountSubscribeInfo osAccountSubscribeInfo;
229     osAccountSubscribeInfo.SetOsAccountSubscribeType(AccountSA::OS_ACCOUNT_SUBSCRIBE_TYPE::ACTIVED);
230     osAccountSubscribeInfo.SetName("MemMgrAccountActivedSubscriber");
231     MAKE_POINTER(accountObserver_, shared, AccountObserver, "make unique failed", return, osAccountSubscribeInfo);
232     ErrCode errCode = AccountSA::OsAccountManager::SubscribeOsAccount(accountObserver_);
233     if (errCode == ERR_OK) {
234         HILOGI("register success");
235         return;
236     }
237 
238     if (regAccountObsRetry_ < ACCOUNT_MAX_RETRY_TIMES) {
239         HILOGE("register fail, retCode = %{public}d, try again after 3s!, retryTimes=%{public}d/10",
240             errCode, regAccountObsRetry_);
241         regObsHandler_->PostTask([this] { this->RegisterAccountObserver(); }, ACCOUNT_RETRY_DELAY,
242             AppExecFwk::EventQueue::Priority::LOW); // 3000 means 3s
243     }
244 }
245 
RegisterMemoryPressureObserver()246 void MemMgrEventCenter::RegisterMemoryPressureObserver()
247 {
248     HILOGI("called");
249     MAKE_POINTER(memoryPressureObserver_, shared, MemoryPressureObserver, "make MemoryPressureObserver failed", return,
250                  /* no param */);
251     regObsHandler_->PostTask([this] { this->memoryPressureObserver_->Init(); },
252         10000, AppExecFwk::EventQueue::Priority::HIGH); // 10000 means 10s
253 }
254 
RegisterKswapdObserver()255 void MemMgrEventCenter::RegisterKswapdObserver()
256 {
257     HILOGI("called");
258     MAKE_POINTER(kswapdObserver_, shared, KswapdObserver, "make KswapdObserver failed", return, /* no param */);
259     regObsHandler_->PostTask([this] { this->kswapdObserver_->Init(); },
260         10000, AppExecFwk::EventQueue::Priority::HIGH); // 10000 means 10s
261 }
262 
~MemMgrEventCenter()263 MemMgrEventCenter::~MemMgrEventCenter()
264 {
265     HILOGI("called");
266     UnregisterEventObserver();
267 }
268 
UnregisterEventObserver()269 void MemMgrEventCenter::UnregisterEventObserver()
270 {
271 #ifdef CONFIG_BGTASK_MGR
272     if (bgTaskObserver_) {
273         BackgroundTaskMgr::BackgroundTaskMgrHelper::UnsubscribeBackgroundTask(*bgTaskObserver_);
274     }
275 #endif
276     if (accountObserver_) {
277         AccountSA::OsAccountManager::UnsubscribeOsAccount(accountObserver_);
278     }
279     if (commonEventObserver_) {
280         EventFwk::CommonEventManager::UnSubscribeCommonEvent(commonEventObserver_);
281     }
282     if (appStateObserver_) {
283         appStateObserver_ = nullptr;
284     }
285     appMgrClient_ = nullptr;
286     regObsHandler_ = nullptr;
287     extConnObserver_ = nullptr;
288     accountObserver_ = nullptr;
289 }
290 
Dump(int fd)291 void MemMgrEventCenter::Dump(int fd)
292 {
293     dprintf(fd, "state list of all observer\n");
294     dprintf(fd, "                 name               state \n");
295     dprintf(fd, "%30s %8s\n", "MemoryPressureObserver", memoryPressureObserver_ == nullptr ? "N" : "Y");
296     dprintf(fd, "-----------------------------------------------------------------\n");
297     dprintf(fd, "%30s %8s\n", "KswapdObserver", kswapdObserver_ == nullptr ? "N" : "Y");
298     dprintf(fd, "-----------------------------------------------------------------\n");
299     dprintf(fd, "%30s %8s\n", "AppStateObserver", appStateObserver_ == nullptr ? "N" : "Y");
300     dprintf(fd, "-----------------------------------------------------------------\n");
301     dprintf(fd, "%30s %8s\n", "ExtConnObserver", extConnObserver_ == nullptr ? "N" : "Y");
302     dprintf(fd, "-----------------------------------------------------------------\n");
303 #ifdef CONFIG_BGTASK_MGR
304     dprintf(fd, "%30s %8s\n", "BgTaskObserver", bgTaskObserver_ == nullptr ? "N" : "Y");
305     dprintf(fd, "-----------------------------------------------------------------\n");
306 #endif
307     dprintf(fd, "%30s %8s\n", "AccountObserver", accountObserver_ == nullptr ? "N" : "Y");
308     dprintf(fd, "-----------------------------------------------------------------\n");
309     dprintf(fd, "%30s %8s\n", "CommonEventObserver", commonEventObserver_ == nullptr ? "N" : "Y");
310     dprintf(fd, "-----------------------------------------------------------------\n");
311 }
312 
RetryRegisterEventObserver(int32_t systemAbilityId)313 void MemMgrEventCenter::RetryRegisterEventObserver(int32_t systemAbilityId)
314 {
315 #ifdef CONFIG_BGTASK_MGR
316     if (systemAbilityId == BACKGROUND_TASK_MANAGER_SERVICE_ID) {
317         HandlerRegisterEvent(RegisterEvent::REG_BGTASKOBS_EVENT);
318     }
319 #endif
320     if (systemAbilityId == ABILITY_MGR_SERVICE_ID || systemAbilityId == APP_MGR_SERVICE_ID) {
321         HandlerRegisterEvent(RegisterEvent::REG_APPOBS_EVENT);
322     }
323 
324     if (systemAbilityId == SUBSYS_ACCOUNT_SYS_ABILITY_ID_BEGIN) {
325         HandlerRegisterEvent(RegisterEvent::REG_ACCOUNTOBS_EVENT);
326     }
327 
328     if (systemAbilityId == COMMON_EVENT_SERVICE_ID || systemAbilityId == COMMON_EVENT_SERVICE_ABILITY_ID) {
329         HandlerRegisterEvent(RegisterEvent::REG_COMMONOBS_EVENT);
330     }
331     HandlerRegisterEvent(RegisterEvent::REG_ALLOBS_EVENT);
332 }
333 
334 } // namespace Memory
335 } // namespace OHOS
336