1 /*
2  * Copyright (c) 2022-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 "observer_manager.h"
17 
18 #include <dlfcn.h>
19 #include <string>
20 
21 #include "cgroup_event_handler.h"
22 #include "display_manager.h"
23 #include "dm_common.h"
24 #include "hisysevent.h"
25 #include "hisysevent_manager.h"
26 #include "ipc_skeleton.h"
27 #include "iservice_registry.h"
28 #include "parameters.h"
29 #include "res_sched_log.h"
30 #include "connection_observer_client.h"
31 #ifdef RESSCHED_TELEPHONY_STATE_REGISTRY_ENABLE
32 #include "telephony_observer_client.h"
33 #endif
34 #include "oobe_manager.h"
35 #include "system_ability_definition.h"
36 #ifdef DEVICE_MOVEMENT_PERCEPTION_ENABLE
37 #include "movement_client.h"
38 #include "movement_data_utils.h"
39 #endif
40 #include "input_manager.h"
41 #include "os_account_manager.h"
42 #include "sched_controller.h"
43 #include "supervisor.h"
44 #ifdef RESSCHED_MULTIMEDIA_AV_SESSION_ENABLE
45 #include "avsession_manager.h"
46 #endif
47 
48 namespace OHOS {
49 namespace ResourceSchedule {
50 const static int8_t OPERATION_SUCCESS = 0;
51 const static int32_t TUPLE_PID = 0;
52 const static int32_t TUPLE_UID = 1;
53 const static int32_t TUPLE_NAME = 2;
54 const static bool DEVICE_MOVEMENT_OBSERVER_ENABLE =
55     system::GetBoolParameter("persist.sys.ressched_device_movement_observer_switch", true);
56 const std::string RES_SCHED_CG_EXT_SO = "libcgroup_sched_ext.z.so";
57 
Init()58 void ObserverManager::Init()
59 {
60     InitSysAbilityListener();
61 }
62 
Disable()63 void ObserverManager::Disable()
64 {
65     handleObserverMap_.clear();
66     removeObserverMap_.clear();
67     DisableHiSysEventObserver();
68     DisableTelephonyObserver();
69     sysAbilityListener_ = nullptr;
70 }
71 
InitObserverCbMap()72 void ObserverManager::InitObserverCbMap()
73 {
74     handleObserverMap_ = {
75         { DFX_SYS_EVENT_SERVICE_ABILITY_ID, [](std::shared_ptr<ObserverManager> mgr) {
76             mgr->InitHiSysEventObserver(); }},
77         { TELEPHONY_STATE_REGISTRY_SYS_ABILITY_ID, [](std::shared_ptr<ObserverManager> mgr) {
78             mgr->InitTelephonyObserver(); }},
79         { AUDIO_POLICY_SERVICE_ID, [](std::shared_ptr<ObserverManager> mgr) { mgr->InitAudioObserver(); }},
80         { MSDP_MOVEMENT_SERVICE_ID, [](std::shared_ptr<ObserverManager> mgr) { mgr->InitDeviceMovementObserver(); }},
81         { MULTIMODAL_INPUT_SERVICE_ID, [](std::shared_ptr<ObserverManager> mgr) { mgr->InitMMiEventObserver(); }},
82         { DISPLAY_MANAGER_SERVICE_ID, [](std::shared_ptr<ObserverManager> mgr) { mgr->InitDisplayModeObserver(); }},
83         { ABILITY_MGR_SERVICE_ID, [](std::shared_ptr<ObserverManager> mgr) { mgr->InitConnectionSubscriber(); }},
84         { DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID, [](std::shared_ptr<ObserverManager> mgr) {
85             mgr->InitDataShareObserver(); }},
86 #ifndef RESOURCE_REQUEST_REQUEST
87         { DOWNLOAD_SERVICE_ID, [](std::shared_ptr<ObserverManager> mgr) { mgr->InitDownloadUploadObserver(); }},
88 #endif
89 #ifdef RESSCHED_MULTIMEDIA_AV_SESSION_ENABLE
90         { AVSESSION_SERVICE_ID, [](std::shared_ptr<ObserverManager> mgr) { mgr->InitAVSessionStateChangeListener(); }},
91 #endif
92         { SUBSYS_ACCOUNT_SYS_ABILITY_ID_BEGIN, [](std::shared_ptr<ObserverManager> mgr) {
93             mgr->InitAccountObserver(); }},
94     };
95 
96     removeObserverMap_ = {
97         { DFX_SYS_EVENT_SERVICE_ABILITY_ID, [](std::shared_ptr<ObserverManager> mgr) {
98             mgr->DisableHiSysEventObserver(); }},
99         { TELEPHONY_STATE_REGISTRY_SYS_ABILITY_ID, [](std::shared_ptr<ObserverManager> mgr) {
100             mgr->DisableTelephonyObserver(); }},
101         { AUDIO_POLICY_SERVICE_ID, [](std::shared_ptr<ObserverManager> mgr) { mgr->DisableAudioObserver(); }},
102         { MSDP_MOVEMENT_SERVICE_ID, [](std::shared_ptr<ObserverManager> mgr) {
103             mgr->DisableDeviceMovementObserver(); }},
104         { MULTIMODAL_INPUT_SERVICE_ID, [](std::shared_ptr<ObserverManager> mgr) { mgr->DisableMMiEventObserver(); }},
105         { DISPLAY_MANAGER_SERVICE_ID, [](std::shared_ptr<ObserverManager> mgr) { mgr->DisableDisplayModeObserver(); }},
106         { ABILITY_MGR_SERVICE_ID, [](std::shared_ptr<ObserverManager> mgr) { mgr->DisableConnectionSubscriber(); }},
107         { DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID, [](std::shared_ptr<ObserverManager> mgr) {
108             mgr->DisableDataShareObserver(); }},
109 #ifndef RESOURCE_REQUEST_REQUEST
110         { DOWNLOAD_SERVICE_ID, [](std::shared_ptr<ObserverManager> mgr) { mgr->DisableDownloadUploadObserver(); }},
111 #endif
112 #ifdef RESSCHED_MULTIMEDIA_AV_SESSION_ENABLE
113         { AVSESSION_SERVICE_ID, [](std::shared_ptr<ObserverManager> mgr) {
114             mgr->DisableAVSessionStateChangeListener(); }},
115 #endif
116         { SUBSYS_ACCOUNT_SYS_ABILITY_ID_BEGIN, [](std::shared_ptr<ObserverManager> mgr) {
117             mgr->DisableAccountObserver(); }},
118     };
119 }
120 
InitSysAbilityListener()121 void ObserverManager::InitSysAbilityListener()
122 {
123     if (sysAbilityListener_ != nullptr) {
124         return;
125     }
126 
127     sysAbilityListener_ = new (std::nothrow) SystemAbilityStatusChangeListener();
128     if (sysAbilityListener_ == nullptr) {
129         RESSCHED_LOGE("Failed to create statusChangeListener due to no memory");
130         return;
131     }
132 
133     sptr<ISystemAbilityManager> systemAbilityManager
134         = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
135     if (systemAbilityManager == nullptr) {
136         sysAbilityListener_ = nullptr;
137         RESSCHED_LOGE("systemAbilityManager is null");
138         return;
139     }
140     InitObserverCbMap();
141     GetReportFunc();
142 
143     AddItemToSysAbilityListener(DFX_SYS_EVENT_SERVICE_ABILITY_ID, systemAbilityManager);
144     AddItemToSysAbilityListener(TELEPHONY_STATE_REGISTRY_SYS_ABILITY_ID, systemAbilityManager);
145     AddItemToSysAbilityListener(AUDIO_POLICY_SERVICE_ID, systemAbilityManager);
146     AddItemToSysAbilityListener(MSDP_MOVEMENT_SERVICE_ID, systemAbilityManager);
147     AddItemToSysAbilityListener(MULTIMODAL_INPUT_SERVICE_ID, systemAbilityManager);
148     AddItemToSysAbilityListener(DISPLAY_MANAGER_SERVICE_ID, systemAbilityManager);
149     AddItemToSysAbilityListener(ABILITY_MGR_SERVICE_ID, systemAbilityManager);
150     AddItemToSysAbilityListener(DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID, systemAbilityManager);
151 #ifdef RESSCHED_REQUEST_REQUEST
152     AddItemToSysAbilityListener(DOWNLOAD_SERVICE_ID, systemAbilityManager);
153 #endif
154 #ifdef RESSCHED_MULTIMEDIA_AV_SESSION_ENABLE
155     AddItemToSysAbilityListener(AVSESSION_SERVICE_ID, systemAbilityManager);
156 #endif
157     AddItemToSysAbilityListener(SUBSYS_ACCOUNT_SYS_ABILITY_ID_BEGIN, systemAbilityManager);
158 }
159 
AddItemToSysAbilityListener(int32_t systemAbilityId,sptr<ISystemAbilityManager> & systemAbilityManager)160 inline void ObserverManager::AddItemToSysAbilityListener(int32_t systemAbilityId,
161     sptr<ISystemAbilityManager>& systemAbilityManager)
162 {
163     if (systemAbilityManager->SubscribeSystemAbility(systemAbilityId, sysAbilityListener_) != ERR_OK) {
164         sysAbilityListener_ = nullptr;
165         RESSCHED_LOGE("%{public}s: subscribe system ability id: %{public}d failed", __func__, systemAbilityId);
166         HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::RSS, "INIT_FAULT", HiviewDFX::HiSysEvent::EventType::FAULT,
167                         "COMPONENT_NAME", "MAIN",
168                         "ERR_TYPE", "register failure",
169                         "ERR_MSG", "Register a staus change listener of the " +
170                         std::to_string(systemAbilityId) + " SA failed!");
171     }
172 }
173 
OnAddSystemAbility(int32_t systemAbilityId,const std::string & deviceId)174 void ObserverManager::SystemAbilityStatusChangeListener::OnAddSystemAbility(
175     int32_t systemAbilityId, const std::string& deviceId)
176 {
177     RESSCHED_LOGI("Add system ability, system ability id: %{public}d", systemAbilityId);
178     auto funcIter = ObserverManager::GetInstance()->handleObserverMap_.find(systemAbilityId);
179     if (funcIter != ObserverManager::GetInstance()->handleObserverMap_.end()) {
180         auto function = funcIter->second;
181             if (function) {
182                 function(ObserverManager::GetInstance());
183             }
184     }
185 }
186 
OnRemoveSystemAbility(int32_t systemAbilityId,const std::string & deviceId)187 void ObserverManager::SystemAbilityStatusChangeListener::OnRemoveSystemAbility(
188     int32_t systemAbilityId, const std::string& deviceId)
189 {
190     RESSCHED_LOGD("Remove system ability, system ability id: %{public}d", systemAbilityId);
191     auto funcIter = ObserverManager::GetInstance()->removeObserverMap_.find(systemAbilityId);
192     if (funcIter != ObserverManager::GetInstance()->removeObserverMap_.end()) {
193         auto function = funcIter->second;
194             if (function) {
195                 function(ObserverManager::GetInstance());
196             }
197     }
198 }
199 
GetReportFunc()200 void ObserverManager::GetReportFunc()
201 {
202     auto handle = dlopen(RES_SCHED_CG_EXT_SO.c_str(), RTLD_NOW);
203     if (!handle) {
204         RESSCHED_LOGE("GetReportFunc dlopen failed");
205         return;
206     }
207     ReportFunc reportFunc = reinterpret_cast<ReportFunc>(dlsym(handle, "IsNeedReportEvents"));
208     if (!reportFunc) {
209         RESSCHED_LOGE("GetReportFunc dlsym 'IsNeedReportEvents' failed");
210         dlclose(handle);
211         return;
212     }
213 
214     isNeedReport_ = reportFunc();
215     dlclose(handle);
216 }
217 
InitHiSysEventObserver()218 void ObserverManager::InitHiSysEventObserver()
219 {
220     RESSCHED_LOGI("Init hisysevent observer");
221     if (!hiSysEventObserver_) {
222         hiSysEventObserver_ = std::make_shared<ResourceSchedule::HiSysEventObserver>();
223     }
224 
225     HiviewDFX::ListenerRule audioStreamState("AUDIO", "STREAM_CHANGE");
226     HiviewDFX::ListenerRule cameraConnectState("CAMERA", "CAMERA_CONNECT");
227     HiviewDFX::ListenerRule cameraDisconnectState("CAMERA", "CAMERA_DISCONNECT");
228     HiviewDFX::ListenerRule brSwitchState("BT_SERVICE", "BR_SWITCH_STATE");
229     HiviewDFX::ListenerRule bleSwitchState("BT_SERVICE", "BLE_SWITCH_STATE");
230     HiviewDFX::ListenerRule wifiConnectionState("COMMUNICATION", "WIFI_CONNECTION");
231     HiviewDFX::ListenerRule wifiScanState("COMMUNICATION", "WIFI_SCAN");
232     HiviewDFX::ListenerRule avCodecStartState("AV_CODEC", "CODEC_START_INFO");
233     HiviewDFX::ListenerRule avCodecStopState("AV_CODEC", "CODEC_STOP_INFO");
234     HiviewDFX::ListenerRule screenCaptureState("MULTIMEDIA", "PLAYER_STATE");
235     std::vector<HiviewDFX::ListenerRule> sysRules;
236     sysRules.push_back(audioStreamState);
237     sysRules.push_back(cameraConnectState);
238     sysRules.push_back(cameraDisconnectState);
239     sysRules.push_back(brSwitchState);
240     sysRules.push_back(bleSwitchState);
241     sysRules.push_back(wifiConnectionState);
242     sysRules.push_back(wifiScanState);
243     sysRules.push_back(avCodecStartState);
244     sysRules.push_back(avCodecStopState);
245     sysRules.push_back(screenCaptureState);
246     if (isNeedReport_) {
247         HiviewDFX::ListenerRule runninglockState("POWER", "RUNNINGLOCK");
248         sysRules.push_back(runninglockState);
249     }
250     auto res = HiviewDFX::HiSysEventManager::AddListener(hiSysEventObserver_, sysRules);
251     if (res == 0) {
252         RESSCHED_LOGD("ObserverManager init hisysevent observer successfully");
253     } else {
254         RESSCHED_LOGW("ObserverManager init hisysevent observer failed");
255         HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::RSS, "INIT_FAULT", HiviewDFX::HiSysEvent::EventType::FAULT,
256                         "COMPONENT_NAME", "MAIN",
257                         "ERR_TYPE", "register failure",
258                         "ERR_MSG", "Register a hisysevent observer failed!");
259     }
260 }
261 
DisableHiSysEventObserver()262 void ObserverManager::DisableHiSysEventObserver()
263 {
264     RESSCHED_LOGI("Disable hisysevent observer");
265     if (hiSysEventObserver_ == nullptr) {
266         return;
267     }
268 
269     auto res = HiviewDFX::HiSysEventManager::RemoveListener(hiSysEventObserver_);
270     if (res == 0) {
271         RESSCHED_LOGD("ObserverManager disable hisysevent observer successfully");
272     } else {
273         RESSCHED_LOGW("ObserverManager disable hisysevent observer failed");
274     }
275     hiSysEventObserver_ = nullptr;
276 }
277 
InitTelephonyObserver()278 void ObserverManager::InitTelephonyObserver()
279 {
280 #ifdef RESSCHED_TELEPHONY_STATE_REGISTRY_ENABLE
281     RESSCHED_LOGI("Init telephony observer");
282     if (!telephonyObserver_) {
283         telephonyObserver_ = std::make_unique<SchedTelephonyObserver>().release();
284     }
285     slotId_ = 0;
286     auto res = Telephony::TelephonyObserverClient::GetInstance().AddStateObserver(
287         telephonyObserver_, slotId_, Telephony::TelephonyObserverBroker::OBSERVER_MASK_CALL_STATE, false);
288     if (res == OPERATION_SUCCESS) {
289         RESSCHED_LOGD("ObserverManager init telephony observer successfully");
290     } else {
291         RESSCHED_LOGW("ObserverManager init telephony observer failed");
292         HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::RSS, "INIT_FAULT", HiviewDFX::HiSysEvent::EventType::FAULT,
293                         "COMPONENT_NAME", "MAIN",
294                         "ERR_TYPE", "register failure",
295                         "ERR_MSG", "Register a telephony observer failed!");
296     }
297 #endif
298 }
299 
DisableTelephonyObserver()300 void ObserverManager::DisableTelephonyObserver()
301 {
302 #ifdef RESSCHED_TELEPHONY_STATE_REGISTRY_ENABLE
303     RESSCHED_LOGI("Disable telephony observer");
304     if (!telephonyObserver_) {
305         RESSCHED_LOGD("ObserverManager has been disable telephony observer");
306         return ;
307     }
308     slotId_ = 0;
309     Telephony::TelephonyObserverClient::GetInstance().RemoveStateObserver(
310         slotId_, Telephony::TelephonyObserverBroker::OBSERVER_MASK_CALL_STATE);
311     telephonyObserver_ = nullptr;
312 #endif
313 }
314 
InitAudioObserver()315 void ObserverManager::InitAudioObserver()
316 {
317 #ifdef RESSCHED_AUDIO_FRAMEWORK_ENABLE
318     pid_ = getpid();
319     RESSCHED_LOGI("ObserverManager Init audio observer, pid: %{public}d", pid_);
320     if (!audioObserver_) {
321         audioObserver_ = std::make_shared<AudioObserver>();
322     }
323 
324     auto res = AudioStandard::AudioStreamManager::GetInstance()->RegisterAudioRendererEventListener(pid_,
325         audioObserver_);
326     if (res == OPERATION_SUCCESS) {
327         RESSCHED_LOGD("ObserverManager init audioRenderStateObserver successfully");
328     } else {
329         RESSCHED_LOGW("ObserverManager init audioRenderStateObserver failed");
330         HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::RSS, "INIT_FAULT", HiviewDFX::HiSysEvent::EventType::FAULT,
331                         "COMPONENT_NAME", "MAIN",
332                         "ERR_TYPE", "register failure",
333                         "ERR_MSG", "Register a audio observer failed!");
334     }
335 
336     res = AudioStandard::AudioSystemManager::GetInstance()->SetRingerModeCallback(pid_, audioObserver_);
337     if (res == OPERATION_SUCCESS) {
338         RESSCHED_LOGD("ObserverManager init audioRingModeObserver successfully");
339     } else {
340         RESSCHED_LOGW("ObserverManager init audioRingModeObserver failed");
341     }
342 
343     res = AudioStandard::AudioSystemManager::GetInstance()->RegisterVolumeKeyEventCallback(pid_, audioObserver_);
344     if (res == OPERATION_SUCCESS) {
345         RESSCHED_LOGD("ObserverManager init audioVolumeKeyObserver successfully");
346     } else {
347         RESSCHED_LOGW("ObserverManager init audioVolumeKeyObserver failed");
348     }
349 
350     AudioStandard::AudioRendererInfo rendererInfo = {};
351     rendererInfo.streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_MUSIC;
352     res = AudioStandard::AudioRoutingManager::GetInstance()
353         ->SetPreferredOutputDeviceChangeCallback(rendererInfo, audioObserver_);
354     if (res == OPERATION_SUCCESS) {
355         RESSCHED_LOGD("ObserverManager init audioOutputDeviceChangeObserver successfully");
356     } else {
357         RESSCHED_LOGW("ObserverManager init audioOutputDeviceChangeObserver failed");
358     }
359 #endif
360 }
361 
DisableAudioObserver()362 void ObserverManager::DisableAudioObserver()
363 {
364 #ifdef RESSCHED_AUDIO_FRAMEWORK_ENABLE
365     RESSCHED_LOGI("Disable telephony observer");
366     if (!audioObserver_) {
367         RESSCHED_LOGD("ObserverManager has been disable audioObserver");
368         return ;
369     }
370 
371     auto res = AudioStandard::AudioStreamManager::GetInstance()->UnregisterAudioRendererEventListener(pid_);
372     if (res == OPERATION_SUCCESS) {
373         RESSCHED_LOGD("ObserverManager disable audioVolumeKeyObserver successfully");
374     } else {
375         RESSCHED_LOGW("ObserverManager disable audioVolumeKeyObserver failed");
376     }
377 
378     res = AudioStandard::AudioSystemManager::GetInstance()->UnsetRingerModeCallback(pid_);
379     if (res == OPERATION_SUCCESS) {
380         RESSCHED_LOGD("ObserverManager disable audioVolumeKeyObserver successfully");
381     } else {
382         RESSCHED_LOGW("ObserverManager disable audioVolumeKeyObserver failed");
383     }
384 
385     res = AudioStandard::AudioSystemManager::GetInstance()->UnregisterVolumeKeyEventCallback(pid_);
386     if (res == OPERATION_SUCCESS) {
387         RESSCHED_LOGD("ObserverManager disable audioVolumeKeyObserver successfully");
388     } else {
389         RESSCHED_LOGW("ObserverManager disable audioVolumeKeyObserver failed");
390     }
391     audioObserver_ = nullptr;
392 #endif
393 }
394 
InitDeviceMovementObserver()395 void ObserverManager::InitDeviceMovementObserver()
396 {
397     if (!DEVICE_MOVEMENT_OBSERVER_ENABLE) {
398         RESSCHED_LOGI("Device movement observer is not enable");
399         return;
400     }
401 
402 #ifdef DEVICE_MOVEMENT_PERCEPTION_ENABLE
403     RESSCHED_LOGI("InitDeviceMovementObserver");
404     if (!deviceMovementObserver_) {
405         deviceMovementObserver_ = sptr<DeviceMovementObserver>(new DeviceMovementObserver());
406     }
407     if (Msdp::MovementClient::GetInstance().SubscribeCallback(
408         Msdp::MovementDataUtils::MovementType::TYPE_STILL, deviceMovementObserver_) != ERR_OK) {
409         HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::RSS, "INIT_FAULT", HiviewDFX::HiSysEvent::EventType::FAULT,
410                         "COMPONENT_NAME", "MAIN",
411                         "ERR_TYPE", "register failure",
412                         "ERR_MSG", "Register a device movement observer failed!");
413     }
414 #endif
415 }
416 
DisableDeviceMovementObserver()417 void ObserverManager::DisableDeviceMovementObserver()
418 {
419     if (!DEVICE_MOVEMENT_OBSERVER_ENABLE) {
420         RESSCHED_LOGI("Device movement observer is not enable");
421         return;
422     }
423 
424 #ifdef DEVICE_MOVEMENT_PERCEPTION_ENABLE
425     RESSCHED_LOGI("DisableDeviceMovementObserver");
426     if (!deviceMovementObserver_) {
427         RESSCHED_LOGD("ObserverManager has been disable deviceMovementObserver");
428         return;
429     }
430     Msdp::MovementClient::GetInstance().UnSubscribeCallback(
431         Msdp::MovementDataUtils::MovementType::TYPE_STILL, deviceMovementObserver_);
432     deviceMovementObserver_ = nullptr;
433 #endif
434 }
435 
InitMMiEventObserver()436 void ObserverManager::InitMMiEventObserver()
437 {
438     if (!isNeedReport_) {
439         RESSCHED_LOGI("not need init mmi observer.");
440         return;
441     }
442     RESSCHED_LOGI("ObserverManager Init mmi observer.");
443     if (!mmiEventObserver_) {
444         mmiEventObserver_ = std::make_shared<MmiObserver>();
445     }
446 
447     auto res = MMI::InputManager::GetInstance()->AddInputEventObserver(mmiEventObserver_);
448     if (res == OPERATION_SUCCESS) {
449         RESSCHED_LOGD("ObserverManager init mmiEventObserver successfully");
450     } else {
451         RESSCHED_LOGE("ObserverManager init mmiEventObserver failed");
452         HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::RSS, "INIT_FAULT", HiviewDFX::HiSysEvent::EventType::FAULT,
453                         "COMPONENT_NAME", "MAIN",
454                         "ERR_TYPE", "register failure",
455                         "ERR_MSG", "Register a mmi observer failed!");
456         return;
457     }
458     // Get all events registered in multimodal input.
459     auto handler = SchedController::GetInstance().GetCgroupEventHandler();
460     if (handler) {
461         handler->PostTask([weak = weak_from_this()] {
462             auto self = weak.lock();
463             if (self == nullptr) {
464                 return;
465             }
466             self->GetAllMmiStatusData();
467         });
468     }
469 }
470 
DisableMMiEventObserver()471 void ObserverManager::DisableMMiEventObserver()
472 {
473     RESSCHED_LOGI("Disable mmi observer");
474     if (!mmiEventObserver_) {
475         RESSCHED_LOGD("ObserverManager has been disable mmiEventObserver");
476         return;
477     }
478 
479     auto res = MMI::InputManager::GetInstance()->RemoveInputEventObserver(mmiEventObserver_);
480     if (res == OPERATION_SUCCESS) {
481         RESSCHED_LOGD("ObserverManager disable mmiEventObserver successfully");
482     } else {
483         RESSCHED_LOGW("ObserverManager disable mmiEventObserver failed");
484     }
485     mmiEventObserver_ = nullptr;
486 }
487 
GetAllMmiStatusData()488 void ObserverManager::GetAllMmiStatusData()
489 {
490     RESSCHED_LOGI("get all mmi subscribed events.");
491     std::map<std::tuple<int32_t, int32_t, std::string>, int32_t> mmiStatusData;
492     MMI::InputManager::GetInstance()->GetAllMmiSubscribedEvents(mmiStatusData);
493     if (mmiStatusData.empty()) {
494         RESSCHED_LOGI("get mmi subscribed events is null.");
495         return;
496     }
497     auto supervisor = SchedController::GetInstance().GetSupervisor();
498     if (supervisor == nullptr) {
499         RESSCHED_LOGE("get supervisor is null.");
500         return;
501     }
502 
503     for (auto data = mmiStatusData.begin(); data != mmiStatusData.end(); ++data) {
504         int32_t pid = std::get<TUPLE_PID>(data->first);
505         int32_t uid = std::get<TUPLE_UID>(data->first);
506         std::string bundleName = std::get<TUPLE_NAME>(data->first);
507         int32_t status = data->second;
508         RESSCHED_LOGD(
509             "get mmi subscribed events, pid:%{public}d, uid:%{public}d, bundleName:%{public}s, status:%{public}d.",
510             pid, uid, bundleName.c_str(), status);
511         auto app = supervisor->GetAppRecord(uid);
512         auto procRecord = app ? app->GetProcessRecord(pid) : nullptr;
513         if (procRecord) {
514             procRecord->mmiStatus_ = status;
515         }
516     }
517 }
518 
InitDisplayModeObserver()519 void ObserverManager::InitDisplayModeObserver()
520 {
521     RESSCHED_LOGI("ObserverManager Init display mode observer.");
522     bool isFoldable = OHOS::Rosen::DisplayManager::GetInstance().IsFoldable();
523     if (!isFoldable) {
524         RESSCHED_LOGI("ObserverManager Init display mode observer return for foldable.");
525         return;
526     }
527 
528     if (!foldDisplayModeObserver_) {
529         foldDisplayModeObserver_ = new (std::nothrow)FoldDisplayModeObserver();
530         if (foldDisplayModeObserver_ == nullptr) {
531             RESSCHED_LOGE("Failed to create fold ChangeListener due to no memory");
532             return;
533         }
534     }
535     auto ret = OHOS::Rosen::DisplayManager::GetInstance().RegisterDisplayModeListener(foldDisplayModeObserver_);
536     if (ret == OHOS::Rosen::DMError::DM_OK) {
537         RESSCHED_LOGI("ObserverManager init displayModeObserver successfully");
538         auto displayMode = OHOS::Rosen::DisplayManager::GetInstance().GetFoldDisplayMode();
539         foldDisplayModeObserver_->OnDisplayModeChanged(displayMode);
540     } else {
541         RESSCHED_LOGW("ObserverManager init displayModeObserver failed");
542         foldDisplayModeObserver_ = nullptr;
543         return;
544     }
545 }
546 
DisableDisplayModeObserver()547 void ObserverManager::DisableDisplayModeObserver()
548 {
549     RESSCHED_LOGI("ObserverManager Disable display mode observer.");
550     if (!foldDisplayModeObserver_) {
551         RESSCHED_LOGE("ObserverManager has been disable displayModeObserver");
552         return;
553     }
554 
555     auto ret = OHOS::Rosen::DisplayManager::GetInstance().UnregisterDisplayModeListener(foldDisplayModeObserver_);
556     if (ret == OHOS::Rosen::DMError::DM_OK) {
557         RESSCHED_LOGI("ObserverManager disable displayModeObserver successfully");
558     } else {
559         RESSCHED_LOGW("ObserverManager disable displayModeObserver failed");
560         return;
561     }
562     foldDisplayModeObserver_ = nullptr;
563 }
564 
InitConnectionSubscriber()565 void ObserverManager::InitConnectionSubscriber()
566 {
567     if (!connectionSubscriber_) {
568         connectionSubscriber_ = std::make_shared<ConnectionSubscriber>();
569     }
570 
571     auto res = AbilityRuntime::ConnectionObserverClient::GetInstance().RegisterObserver(connectionSubscriber_);
572     if (res == OPERATION_SUCCESS) {
573         RESSCHED_LOGD("ObserverManager init connectionSubscriber successfully");
574     } else {
575         RESSCHED_LOGW("ObserverManager init connectionSubscriber failed");
576         HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::RSS, "INIT_FAULT", HiviewDFX::HiSysEvent::EventType::FAULT,
577                         "COMPONENT_NAME", "MAIN",
578                         "ERR_TYPE", "register failure",
579                         "ERR_MSG", "Register a connect subscriber failed!");
580     }
581 }
582 
DisableConnectionSubscriber()583 void ObserverManager::DisableConnectionSubscriber()
584 {
585     RESSCHED_LOGI("Disable connect subscriber state listener");
586     if (!connectionSubscriber_) {
587         RESSCHED_LOGD("ObserverManager has been disable connect subscriber state listener");
588         return;
589     }
590 
591     auto res = AbilityRuntime::ConnectionObserverClient::GetInstance().UnregisterObserver(connectionSubscriber_);
592     if (res == OPERATION_SUCCESS) {
593         RESSCHED_LOGD("ObserverManager disable connect subscriber state listener successfully");
594     } else {
595         RESSCHED_LOGW("ObserverManager disable connect subscriber state listener failed");
596     }
597 
598     connectionSubscriber_ = nullptr;
599 }
600 
InitDataShareObserver()601 void ObserverManager::InitDataShareObserver()
602 {
603     RESSCHED_LOGI("ObserverManager Init dataShare observer.");
604     OOBEManager::GetInstance().StartListen();
605 }
606 
DisableDataShareObserver()607 void ObserverManager::DisableDataShareObserver()
608 {
609     RESSCHED_LOGI("Disable dataShare observer.");
610     OOBEManager::GetInstance().UnregisterObserver();
611 }
612 #ifdef RESSCHED_MULTIMEDIA_AV_SESSION_ENABLE
InitAVSessionStateChangeListener()613 void ObserverManager::InitAVSessionStateChangeListener()
614 {
615     if (!avSessionStateListener_) {
616         avSessionStateListener_ = std::make_shared<AvSessionStateListener>();
617     }
618 
619     auto res = AVSession::AVSessionManager::GetInstance().RegisterSessionListenerForAllUsers(avSessionStateListener_);
620     if (res == OPERATION_SUCCESS) {
621         RESSCHED_LOGI("ObserverManager init session state listener successfully");
622     } else {
623         RESSCHED_LOGW("ObserverManager init session state listener failed");
624         HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::RSS, "INIT_FAULT", HiviewDFX::HiSysEvent::EventType::FAULT,
625                         "COMPONENT_NAME", "MAIN",
626                         "ERR_TYPE", "register failure",
627                         "ERR_MSG", "Register a session state listener failed!");
628     }
629 }
630 
DisableAVSessionStateChangeListener()631 void ObserverManager::DisableAVSessionStateChangeListener()
632 {
633     RESSCHED_LOGI("Disable session state listener");
634     avSessionStateListener_ = nullptr;
635 }
636 #endif
637 #ifdef RESSCHED_REQUEST_REQUEST
InitDownloadUploadObserver()638 void ObserverManager::InitDownloadUploadObserver()
639 {
640     if (downLoadUploadObserver_ == nullptr) {
641         downLoadUploadObserver_ = std::make_shared<DownLoadUploadObserver>();
642     }
643 
644     auto res = OHOS::Request::SubscribeRunningTaskCount(downLoadUploadObserver_);
645     if (res == OPERATION_SUCCESS) {
646         RESSCHED_LOGI("ObserverManager init download Upload observer successfully");
647     } else {
648         RESSCHED_LOGW("ObserverManager init download Upload observer failed");
649         HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::RSS, "INIT_FAULT", HiviewDFX::HiSysEvent::EventType::FAULT,
650                         "COMPONENT_NAME", "MAIN",
651                         "ERR_TYPE", "register failure",
652                         "ERR_MSG", "Register a download Upload observer failed!");
653     }
654 }
655 
DisableDownloadUploadObserver()656 void ObserverManager::DisableDownloadUploadObserver()
657 {
658     OHOS::Request::UnsubscribeRunningTaskCount(downLoadUploadObserver_);
659     RESSCHED_LOGI("Disable download Upload observer");
660     downLoadUploadObserver_ = nullptr;
661 }
662 #endif
663 
InitAccountObserver()664 void ObserverManager::InitAccountObserver()
665 {
666     RESSCHED_LOGI("InitAccountObserver");
667     if (!accountObserver_) {
668         AccountSA::OsAccountSubscribeInfo osAccountSubscribeInfo;
669         osAccountSubscribeInfo.SetOsAccountSubscribeType(AccountSA::OS_ACCOUNT_SUBSCRIBE_TYPE::ACTIVATING);
670         osAccountSubscribeInfo.SetName("ResschdeAccountActivatingSubscriber");
671         accountObserver_ = std::make_shared<AccountObserver>(osAccountSubscribeInfo);
672     }
673     if (!accountObserver_) {
674         RESSCHED_LOGE("account observer make failed");
675     }
676     ErrCode errCode = AccountSA::OsAccountManager::SubscribeOsAccount(accountObserver_);
677     if (errCode == ERR_OK) {
678         RESSCHED_LOGI("account observer register success");
679     } else {
680         RESSCHED_LOGW("account observer register failed");
681         HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::RSS, "INIT_FAULT", HiviewDFX::HiSysEvent::EventType::FAULT,
682                         "COMPONENT_NAME", "MAIN",
683                         "ERR_TYPE", "register failure",
684                         "ERR_MSG", "Register a account observer failed!");
685     }
686 }
687 
DisableAccountObserver()688 void ObserverManager::DisableAccountObserver()
689 {
690     RESSCHED_LOGI("account sa removed");
691 }
692 
ObserverManagerInit()693 extern "C" void ObserverManagerInit()
694 {
695     auto instance = ObserverManager::GetInstance();
696     if (instance) {
697         instance->Init();
698     } else {
699         RESSCHED_LOGE("ObserverManager GetInstance failed");
700     }
701 }
702 
ObserverManagerDisable()703 extern "C" void ObserverManagerDisable()
704 {
705     ObserverManager::GetInstance()->Disable();
706 }
707 } // namespace ResourceSchedule
708 } // namespace OHOS