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