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 "display_manager.h"
22 #include "dm_common.h"
23 #include "hisysevent.h"
24 #include "hisysevent_manager.h"
25 #include "ipc_skeleton.h"
26 #include "iservice_registry.h"
27 #include "parameters.h"
28 #include "res_sched_log.h"
29 #include "res_sched_mgr.h"
30 #include "res_type.h"
31 #include "connection_observer_client.h"
32 #ifdef RESSCHED_TELEPHONY_STATE_REGISTRY_ENABLE
33 #include "telephony_observer_client.h"
34 #endif
35 #include "oobe_manager.h"
36 #include "system_ability_definition.h"
37 #ifdef DEVICE_MOVEMENT_PERCEPTION_ENABLE
38 #include "movement_client.h"
39 #include "movement_data_utils.h"
40 #endif
41 #include "input_manager.h"
42 #include "os_account_manager.h"
43 #ifdef RESSCHED_MULTIMEDIA_AV_SESSION_ENABLE
44 #include "avsession_manager.h"
45 #endif
46 
47 namespace OHOS {
48 namespace ResourceSchedule {
49 const static int8_t OPERATION_SUCCESS = 0;
50 const static int32_t TUPLE_PID = 0;
51 const static int32_t TUPLE_UID = 1;
52 const static int32_t TUPLE_NAME = 2;
53 const static bool DEVICE_MOVEMENT_OBSERVER_ENABLE =
54     system::GetBoolParameter("persist.sys.ressched_device_movement_observer_switch", true);
55 const std::string RES_SCHED_CG_EXT_SO = "libcgroup_sched_ext.z.so";
56 
Init()57 void ObserverManager::Init()
58 {
59     InitSysAbilityListener();
60 }
61 
Disable()62 void ObserverManager::Disable()
63 {
64     handleObserverMap_.clear();
65     removeObserverMap_.clear();
66     DisableHiSysEventObserver();
67     DisableTelephonyObserver();
68     sysAbilityListener_ = nullptr;
69 }
70 
InitObserverCbMap()71 void ObserverManager::InitObserverCbMap()
72 {
73     handleObserverMap_ = {
74         { DFX_SYS_EVENT_SERVICE_ABILITY_ID, [](std::shared_ptr<ObserverManager> mgr) {
75             mgr->InitHiSysEventObserver(); }},
76         { TELEPHONY_STATE_REGISTRY_SYS_ABILITY_ID, [](std::shared_ptr<ObserverManager> mgr) {
77             mgr->InitTelephonyObserver(); }},
78         { AUDIO_POLICY_SERVICE_ID, [](std::shared_ptr<ObserverManager> mgr) { mgr->InitAudioObserver(); }},
79         { MSDP_MOVEMENT_SERVICE_ID, [](std::shared_ptr<ObserverManager> mgr) { mgr->InitDeviceMovementObserver(); }},
80         { MULTIMODAL_INPUT_SERVICE_ID, [](std::shared_ptr<ObserverManager> mgr) { mgr->InitMMiEventObserver(); }},
81         { DISPLAY_MANAGER_SERVICE_ID, [](std::shared_ptr<ObserverManager> mgr) { mgr->InitDisplayModeObserver(); }},
82         { ABILITY_MGR_SERVICE_ID, [](std::shared_ptr<ObserverManager> mgr) { mgr->InitConnectionSubscriber(); }},
83         { DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID, [](std::shared_ptr<ObserverManager> mgr) {
84             mgr->InitDataShareObserver(); }},
85 #ifndef RESOURCE_REQUEST_REQUEST
86         { DOWNLOAD_SERVICE_ID, [](std::shared_ptr<ObserverManager> mgr) { mgr->InitDownloadUploadObserver(); }},
87 #endif
88 #ifdef RESSCHED_MULTIMEDIA_AV_SESSION_ENABLE
89         { AVSESSION_SERVICE_ID, [](std::shared_ptr<ObserverManager> mgr) { mgr->InitAVSessionStateChangeListener(); }},
90 #endif
91         { SUBSYS_ACCOUNT_SYS_ABILITY_ID_BEGIN, [](std::shared_ptr<ObserverManager> mgr) {
92             mgr->InitAccountObserver(); }},
93     };
94 
95     removeObserverMap_ = {
96         { DFX_SYS_EVENT_SERVICE_ABILITY_ID, [](std::shared_ptr<ObserverManager> mgr) {
97             mgr->DisableHiSysEventObserver(); }},
98         { TELEPHONY_STATE_REGISTRY_SYS_ABILITY_ID, [](std::shared_ptr<ObserverManager> mgr) {
99             mgr->DisableTelephonyObserver(); }},
100         { AUDIO_POLICY_SERVICE_ID, [](std::shared_ptr<ObserverManager> mgr) { mgr->DisableAudioObserver(); }},
101         { MSDP_MOVEMENT_SERVICE_ID, [](std::shared_ptr<ObserverManager> mgr) {
102             mgr->DisableDeviceMovementObserver(); }},
103         { MULTIMODAL_INPUT_SERVICE_ID, [](std::shared_ptr<ObserverManager> mgr) { mgr->DisableMMiEventObserver(); }},
104         { DISPLAY_MANAGER_SERVICE_ID, [](std::shared_ptr<ObserverManager> mgr) { mgr->DisableDisplayModeObserver(); }},
105         { ABILITY_MGR_SERVICE_ID, [](std::shared_ptr<ObserverManager> mgr) { mgr->DisableConnectionSubscriber(); }},
106         { DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID, [](std::shared_ptr<ObserverManager> mgr) {
107             mgr->DisableDataShareObserver(); }},
108 #ifndef RESOURCE_REQUEST_REQUEST
109         { DOWNLOAD_SERVICE_ID, [](std::shared_ptr<ObserverManager> mgr) { mgr->DisableDownloadUploadObserver(); }},
110 #endif
111 #ifdef RESSCHED_MULTIMEDIA_AV_SESSION_ENABLE
112         { AVSESSION_SERVICE_ID, [](std::shared_ptr<ObserverManager> mgr) {
113             mgr->DisableAVSessionStateChangeListener(); }},
114 #endif
115         { SUBSYS_ACCOUNT_SYS_ABILITY_ID_BEGIN, [](std::shared_ptr<ObserverManager> mgr) {
116             mgr->DisableAccountObserver(); }},
117     };
118 }
119 
InitSysAbilityListener()120 void ObserverManager::InitSysAbilityListener()
121 {
122     if (sysAbilityListener_ != nullptr) {
123         return;
124     }
125 
126     sysAbilityListener_ = new (std::nothrow) SystemAbilityStatusChangeListener();
127     if (sysAbilityListener_ == nullptr) {
128         RESSCHED_LOGE("Failed to create statusChangeListener due to no memory");
129         return;
130     }
131 
132     sptr<ISystemAbilityManager> systemAbilityManager
133         = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
134     if (systemAbilityManager == nullptr) {
135         sysAbilityListener_ = nullptr;
136         RESSCHED_LOGE("systemAbilityManager is null");
137         return;
138     }
139     InitObserverCbMap();
140     GetReportFunc();
141 
142     AddItemToSysAbilityListener(DFX_SYS_EVENT_SERVICE_ABILITY_ID, systemAbilityManager);
143     AddItemToSysAbilityListener(TELEPHONY_STATE_REGISTRY_SYS_ABILITY_ID, systemAbilityManager);
144     AddItemToSysAbilityListener(AUDIO_POLICY_SERVICE_ID, systemAbilityManager);
145     AddItemToSysAbilityListener(MSDP_MOVEMENT_SERVICE_ID, systemAbilityManager);
146     AddItemToSysAbilityListener(MULTIMODAL_INPUT_SERVICE_ID, systemAbilityManager);
147     AddItemToSysAbilityListener(DISPLAY_MANAGER_SERVICE_ID, systemAbilityManager);
148     AddItemToSysAbilityListener(ABILITY_MGR_SERVICE_ID, systemAbilityManager);
149     AddItemToSysAbilityListener(DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID, systemAbilityManager);
150 #ifndef RESOURCE_REQUEST_REQUEST
151     AddItemToSysAbilityListener(DOWNLOAD_SERVICE_ID, systemAbilityManager);
152 #endif
153 #ifdef RESSCHED_MULTIMEDIA_AV_SESSION_ENABLE
154     AddItemToSysAbilityListener(AVSESSION_SERVICE_ID, systemAbilityManager);
155 #endif
156     AddItemToSysAbilityListener(SUBSYS_ACCOUNT_SYS_ABILITY_ID_BEGIN, systemAbilityManager);
157 }
158 
AddItemToSysAbilityListener(int32_t systemAbilityId, sptr<ISystemAbilityManager>& systemAbilityManager)159 inline void ObserverManager::AddItemToSysAbilityListener(int32_t systemAbilityId,
160     sptr<ISystemAbilityManager>& systemAbilityManager)
161 {
162     if (systemAbilityManager->SubscribeSystemAbility(systemAbilityId, sysAbilityListener_) != ERR_OK) {
163         sysAbilityListener_ = nullptr;
164         RESSCHED_LOGE("%{public}s: subscribe system ability id: %{public}d failed", __func__, systemAbilityId);
165         HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::RSS, "INIT_FAULT", HiviewDFX::HiSysEvent::EventType::FAULT,
166                         "COMPONENT_NAME", "MAIN",
167                         "ERR_TYPE", "register failure",
168                         "ERR_MSG", "Register a staus change listener of the " + std::to_string(systemAbilityId) + " SA failed!");
169     } else {
170         RESSCHED_LOGI("%{public}s: subscribe system ability id: %{public}d succeed", __func__, systemAbilityId);
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 }
216 
InitHiSysEventObserver()217 void ObserverManager::InitHiSysEventObserver()
218 {
219     RESSCHED_LOGI("Init hisysevent observer");
220     if (!hiSysEventObserver_) {
221         hiSysEventObserver_ = std::make_shared<ResourceSchedule::HiSysEventObserver>();
222     }
223 
224     HiviewDFX::ListenerRule audioStreamState("AUDIO", "STREAM_CHANGE");
225     HiviewDFX::ListenerRule cameraConnectState("CAMERA", "CAMERA_CONNECT");
226     HiviewDFX::ListenerRule cameraDisconnectState("CAMERA", "CAMERA_DISCONNECT");
227     HiviewDFX::ListenerRule brSwitchState("BT_SERVICE", "BR_SWITCH_STATE");
228     HiviewDFX::ListenerRule bleSwitchState("BT_SERVICE", "BLE_SWITCH_STATE");
229     HiviewDFX::ListenerRule wifiConnectionState("COMMUNICATION", "WIFI_CONNECTION");
230     HiviewDFX::ListenerRule wifiScanState("COMMUNICATION", "WIFI_SCAN");
231     HiviewDFX::ListenerRule avCodecStartState("AV_CODEC", "CODEC_START_INFO");
232     HiviewDFX::ListenerRule avCodecStopState("AV_CODEC", "CODEC_STOP_INFO");
233     HiviewDFX::ListenerRule screenCaptureState("MULTIMEDIA", "PLAYER_STATE");
234     std::vector<HiviewDFX::ListenerRule> sysRules;
235     sysRules.push_back(audioStreamState);
236     sysRules.push_back(cameraConnectState);
237     sysRules.push_back(cameraDisconnectState);
238     sysRules.push_back(brSwitchState);
239     sysRules.push_back(bleSwitchState);
240     sysRules.push_back(wifiConnectionState);
241     sysRules.push_back(wifiScanState);
242     sysRules.push_back(avCodecStartState);
243     sysRules.push_back(avCodecStopState);
244     sysRules.push_back(screenCaptureState);
245     if (isNeedReport_) {
246         HiviewDFX::ListenerRule runninglockState("POWER", "RUNNINGLOCK");
247         sysRules.push_back(runninglockState);
248     }
249     auto res = HiviewDFX::HiSysEventManager::AddListener(hiSysEventObserver_, sysRules);
250     if (res == 0) {
251         RESSCHED_LOGD("ObserverManager init hisysevent observer successfully");
252     } else {
253         RESSCHED_LOGW("ObserverManager init hisysevent observer failed");
254         HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::RSS, "INIT_FAULT", HiviewDFX::HiSysEvent::EventType::FAULT,
255                         "COMPONENT_NAME", "MAIN",
256                         "ERR_TYPE", "register failure",
257                         "ERR_MSG", "Register a hisysevent observer failed!");
258     }
259 }
260 
DisableHiSysEventObserver()261 void ObserverManager::DisableHiSysEventObserver()
262 {
263     RESSCHED_LOGI("Disable hisysevent observer");
264     if (hiSysEventObserver_ == nullptr) {
265         return;
266     }
267 
268     auto res = HiviewDFX::HiSysEventManager::RemoveListener(hiSysEventObserver_);
269     if (res == 0) {
270         RESSCHED_LOGD("ObserverManager disable hisysevent observer successfully");
271     } else {
272         RESSCHED_LOGW("ObserverManager disable hisysevent observer failed");
273     }
274     hiSysEventObserver_ = nullptr;
275 }
276 
InitTelephonyObserver()277 void ObserverManager::InitTelephonyObserver()
278 {
279 #ifdef RESSCHED_TELEPHONY_STATE_REGISTRY_ENABLE
280     RESSCHED_LOGI("Init telephony observer");
281     if (!telephonyObserver_) {
282         telephonyObserver_ = std::make_unique<SchedTelephonyObserver>().release();
283     }
284     slotId_ = 0;
285     auto res = Telephony::TelephonyObserverClient::GetInstance().AddStateObserver(
286         telephonyObserver_, slotId_, Telephony::TelephonyObserverBroker::OBSERVER_MASK_CALL_STATE, false);
287     if (res == OPERATION_SUCCESS) {
288         RESSCHED_LOGD("ObserverManager init telephony observer successfully");
289     } else {
290         RESSCHED_LOGW("ObserverManager init telephony observer failed");
291         HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::RSS, "INIT_FAULT", HiviewDFX::HiSysEvent::EventType::FAULT,
292                         "COMPONENT_NAME", "MAIN",
293                         "ERR_TYPE", "register failure",
294                         "ERR_MSG", "Register a telephony observer failed!");
295     }
296 #endif
297 }
298 
DisableTelephonyObserver()299 void ObserverManager::DisableTelephonyObserver()
300 {
301 #ifdef RESSCHED_TELEPHONY_STATE_REGISTRY_ENABLE
302     RESSCHED_LOGI("Disable telephony observer");
303     if (!telephonyObserver_) {
304         RESSCHED_LOGD("ObserverManager has been disable telephony observer");
305         return ;
306     }
307     slotId_ = 0;
308     Telephony::TelephonyObserverClient::GetInstance().RemoveStateObserver(
309         slotId_, Telephony::TelephonyObserverBroker::OBSERVER_MASK_CALL_STATE);
310     telephonyObserver_ = nullptr;
311 #endif
312 }
313 
InitAudioObserver()314 void ObserverManager::InitAudioObserver()
315 {
316 #ifdef RESSCHED_AUDIO_FRAMEWORK_ENABLE
317     pid_ = getpid();
318     RESSCHED_LOGI("ObserverManager Init audio observer, pid: %{public}d", pid_);
319     if (!audioObserver_) {
320         audioObserver_ = std::make_shared<AudioObserver>();
321     }
322 
323     auto res = AudioStandard::AudioStreamManager::GetInstance()->RegisterAudioRendererEventListener(pid_,
324         audioObserver_);
325     if (res == OPERATION_SUCCESS) {
326         RESSCHED_LOGD("ObserverManager init audioRenderStateObserver successfully");
327     } else {
328         RESSCHED_LOGW("ObserverManager init audioRenderStateObserver failed");
329         HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::RSS, "INIT_FAULT", HiviewDFX::HiSysEvent::EventType::FAULT,
330                         "COMPONENT_NAME", "MAIN",
331                         "ERR_TYPE", "register failure",
332                         "ERR_MSG", "Register a audio observer failed!");
333     }
334 
335     res = AudioStandard::AudioSystemManager::GetInstance()->SetRingerModeCallback(pid_, audioObserver_);
336     if (res == OPERATION_SUCCESS) {
337         RESSCHED_LOGD("ObserverManager init audioRingModeObserver successfully");
338     } else {
339         RESSCHED_LOGW("ObserverManager init audioRingModeObserver failed");
340     }
341 
342     res = AudioStandard::AudioSystemManager::GetInstance()->RegisterVolumeKeyEventCallback(pid_, audioObserver_);
343     if (res == OPERATION_SUCCESS) {
344         RESSCHED_LOGD("ObserverManager init audioVolumeKeyObserver successfully");
345     } else {
346         RESSCHED_LOGW("ObserverManager init audioVolumeKeyObserver failed");
347     }
348 
349     AudioStandard::AudioRendererInfo rendererInfo = {};
350     rendererInfo.streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_MUSIC;
351     res = AudioStandard::AudioRoutingManager::GetInstance()
352         ->SetPreferredOutputDeviceChangeCallback(rendererInfo, audioObserver_);
353     if (res == OPERATION_SUCCESS) {
354         RESSCHED_LOGD("ObserverManager init audioOutputDeviceChangeObserver successfully");
355     } else {
356         RESSCHED_LOGW("ObserverManager init audioOutputDeviceChangeObserver failed");
357     }
358 #endif
359 }
360 
DisableAudioObserver()361 void ObserverManager::DisableAudioObserver()
362 {
363 #ifdef RESSCHED_AUDIO_FRAMEWORK_ENABLE
364     RESSCHED_LOGI("Disable telephony observer");
365     if (!audioObserver_) {
366         RESSCHED_LOGD("ObserverManager has been disable audioObserver");
367         return ;
368     }
369 
370     auto res = AudioStandard::AudioStreamManager::GetInstance()->UnregisterAudioRendererEventListener(pid_);
371     if (res == OPERATION_SUCCESS) {
372         RESSCHED_LOGD("ObserverManager disable audioVolumeKeyObserver successfully");
373     } else {
374         RESSCHED_LOGW("ObserverManager disable audioVolumeKeyObserver failed");
375     }
376 
377     res = AudioStandard::AudioSystemManager::GetInstance()->UnsetRingerModeCallback(pid_);
378     if (res == OPERATION_SUCCESS) {
379         RESSCHED_LOGD("ObserverManager disable audioVolumeKeyObserver successfully");
380     } else {
381         RESSCHED_LOGW("ObserverManager disable audioVolumeKeyObserver failed");
382     }
383 
384     res = AudioStandard::AudioSystemManager::GetInstance()->UnregisterVolumeKeyEventCallback(pid_);
385     if (res == OPERATION_SUCCESS) {
386         RESSCHED_LOGD("ObserverManager disable audioVolumeKeyObserver successfully");
387     } else {
388         RESSCHED_LOGW("ObserverManager disable audioVolumeKeyObserver failed");
389     }
390     audioObserver_ = nullptr;
391 #endif
392 }
393 
InitDeviceMovementObserver()394 void ObserverManager::InitDeviceMovementObserver()
395 {
396     if (!DEVICE_MOVEMENT_OBSERVER_ENABLE) {
397         RESSCHED_LOGI("Device movement observer is not enable");
398         return;
399     }
400 
401 #ifdef DEVICE_MOVEMENT_PERCEPTION_ENABLE
402     RESSCHED_LOGI("InitDeviceMovementObserver");
403     if (!deviceMovementObserver_) {
404         deviceMovementObserver_ = sptr<DeviceMovementObserver>(new DeviceMovementObserver());
405     }
406     if (Msdp::MovementClient::GetInstance().SubscribeCallback(
407         Msdp::MovementDataUtils::MovementType::TYPE_STILL, deviceMovementObserver_) != ERR_OK) {
408             HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::RSS, "INIT_FAULT", HiviewDFX::HiSysEvent::EventType::FAULT,
409                         "COMPONENT_NAME", "MAIN",
410                         "ERR_TYPE", "register failure",
411                         "ERR_MSG", "Register a device movement observer failed!");
412         }
413 #endif
414 }
415 
DisableDeviceMovementObserver()416 void ObserverManager::DisableDeviceMovementObserver()
417 {
418     if (!DEVICE_MOVEMENT_OBSERVER_ENABLE) {
419         RESSCHED_LOGI("Device movement observer is not enable");
420         return;
421     }
422 
423 #ifdef DEVICE_MOVEMENT_PERCEPTION_ENABLE
424     RESSCHED_LOGI("DisableDeviceMovementObserver");
425     if (!deviceMovementObserver_) {
426         RESSCHED_LOGD("ObserverManager has been disable deviceMovementObserver");
427         return;
428     }
429     Msdp::MovementClient::GetInstance().UnSubscribeCallback(
430         Msdp::MovementDataUtils::MovementType::TYPE_STILL, deviceMovementObserver_);
431     deviceMovementObserver_ = nullptr;
432 #endif
433 }
434 
InitMMiEventObserver()435 void ObserverManager::InitMMiEventObserver()
436 {
437     std::shared_ptr<OHOS::MMI::KeyOption> keyOption = std::make_shared<OHOS::MMI::KeyOption>();
438     keyOption = std::make_shared<OHOS::MMI::KeyOption>();
439     keyOption->SetFinalKey(OHOS::MMI::KeyEvent::KEYCODE_POWER);
440     keyOption->SetFinalKeyDown(true);
441     keyOption->SetFinalKeyDownDuration(0);
442     powerKeySubscribeId_ = MMI::InputManager::GetInstance()->SubscribeKeyEvent(keyOption,
443         [](std::shared_ptr<OHOS::MMI::KeyEvent> keyEvent) {
444         ResSchedMgr::GetInstance().ReportData(ResType::RES_TYPE_MMI_INPUT_POWER_KEY, keyEvent->GetKeyCode());
445     });
446     RESSCHED_LOGI("Subscribe power key event successfully.");
447 
448     if (!isNeedReport_) {
449         RESSCHED_LOGI("not need init mmi observer.");
450         return;
451     }
452     RESSCHED_LOGI("ObserverManager Init mmi observer.");
453     if (!mmiEventObserver_) {
454         mmiEventObserver_ = std::make_shared<MmiObserver>();
455     }
456 
457     auto res = MMI::InputManager::GetInstance()->AddInputEventObserver(mmiEventObserver_);
458     if (res == OPERATION_SUCCESS) {
459         RESSCHED_LOGD("ObserverManager init mmiEventObserver successfully");
460     } else {
461         RESSCHED_LOGE("ObserverManager init mmiEventObserver failed");
462         HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::RSS, "INIT_FAULT", HiviewDFX::HiSysEvent::EventType::FAULT,
463                         "COMPONENT_NAME", "MAIN",
464                         "ERR_TYPE", "register failure",
465                         "ERR_MSG", "Register a mmi observer failed!");
466         return;
467     }
468     // Get all events registered in multimodal input.
469     GetAllMmiStatusData();
470 }
471 
DisableMMiEventObserver()472 void ObserverManager::DisableMMiEventObserver()
473 {
474     RESSCHED_LOGI("Unsubscribes power key event");
475     MMI::InputManager::GetInstance()->UnsubscribeKeyEvent(powerKeySubscribeId_);
476     RESSCHED_LOGI("Disable mmi observer");
477     if (!mmiEventObserver_) {
478         RESSCHED_LOGD("ObserverManager has been disable mmiEventObserver");
479         return;
480     }
481 
482     auto res = MMI::InputManager::GetInstance()->RemoveInputEventObserver(mmiEventObserver_);
483     if (res == OPERATION_SUCCESS) {
484         RESSCHED_LOGD("ObserverManager disable mmiEventObserver successfully");
485     } else {
486         RESSCHED_LOGW("ObserverManager disable mmiEventObserver failed");
487     }
488     mmiEventObserver_ = nullptr;
489 }
490 
GetAllMmiStatusData()491 void ObserverManager::GetAllMmiStatusData()
492 {
493     RESSCHED_LOGI("get all mmi subscribed events.");
494     std::map<std::tuple<int32_t, int32_t, std::string>, int32_t> mmiStatusData;
495     MMI::InputManager::GetInstance()->GetAllMmiSubscribedEvents(mmiStatusData);
496     if (mmiStatusData.empty()) {
497         RESSCHED_LOGI("get mmi subscribed events is null.");
498         return;
499     }
500 
501     for (auto data = mmiStatusData.begin(); data != mmiStatusData.end(); ++data) {
502         int32_t pid = std::get<TUPLE_PID>(data->first);
503         int32_t uid = std::get<TUPLE_UID>(data->first);
504         std::string bundleName = std::get<TUPLE_NAME>(data->first);
505         int32_t status = data->second;
506         RESSCHED_LOGD(
507             "get mmi subscribed events, pid:%{public}d, uid:%{public}d, bundleName:%{public}s, status:%{public}d.",
508             pid, uid, bundleName.c_str(), status);
509         nlohmann::json payload;
510         payload["pid"] = pid;
511         payload["uid"] = uid;
512         payload["bundleName"] = bundleName;
513         payload["status"] = status;
514         ResSchedMgr::GetInstance().ReportData(ResType::RES_TYPE_MMI_STATUS_CHANGE, 0, payload);
515     }
516 }
517 
InitDisplayModeObserver()518 void ObserverManager::InitDisplayModeObserver()
519 {
520     RESSCHED_LOGI("ObserverManager Init display mode observer.");
521     bool isFoldable = OHOS::Rosen::DisplayManager::GetInstance().IsFoldable();
522     if (!isFoldable) {
523         RESSCHED_LOGI("ObserverManager Init display mode observer return for foldable.");
524         return;
525     }
526 
527     if (!foldDisplayModeObserver_) {
528         foldDisplayModeObserver_ = new (std::nothrow)FoldDisplayModeObserver();
529         if (foldDisplayModeObserver_ == nullptr) {
530             RESSCHED_LOGE("Failed to create fold ChangeListener due to no memory");
531             return;
532         }
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_ == nullptr) {
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_ == nullptr) {
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_ == nullptr) {
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 #ifndef RESOURCE_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