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 <string>
17
18 #include "observer_manager.h"
19
20 #include "hisysevent.h"
21 #include "hisysevent_manager.h"
22 #include "ipc_skeleton.h"
23 #include "iservice_registry.h"
24 #include "parameters.h"
25 #include "res_sched_log.h"
26 #ifdef RESSCHED_TELEPHONY_STATE_REGISTRY_ENABLE
27 #include "telephony_observer_client.h"
28 #endif
29 #include "system_ability_definition.h"
30 #ifdef DEVICE_MOVEMENT_PERCEPTION_ENABLE
31 #include "movement_client.h"
32 #include "movement_data_utils.h"
33 #endif
34
35 namespace OHOS {
36 namespace ResourceSchedule {
37 const static int8_t OPERATION_SUCCESS = 0;
38 const static bool DEVICE_MOVEMENT_OBSERVER_ENABLE =
39 system::GetBoolParameter("persist.sys.ressched_device_movement_observer_switch", false);
IMPLEMENT_SINGLE_INSTANCE(ObserverManager)40 IMPLEMENT_SINGLE_INSTANCE(ObserverManager)
41
42 void ObserverManager::Init()
43 {
44 InitSysAbilityListener();
45 }
46
Disable()47 void ObserverManager::Disable()
48 {
49 handleObserverMap_.clear();
50 removeObserverMap_.clear();
51 DisableCameraObserver();
52 DisableTelephonyObserver();
53 sysAbilityListener_ = nullptr;
54 }
55
InitSysAbilityListener()56 void ObserverManager::InitSysAbilityListener()
57 {
58 if (sysAbilityListener_ != nullptr) {
59 return;
60 }
61
62 sysAbilityListener_ = new (std::nothrow) SystemAbilityStatusChangeListener();
63 if (sysAbilityListener_ == nullptr) {
64 RESSCHED_LOGE("Failed to create statusChangeListener due to no memory");
65 return;
66 }
67
68 sptr<ISystemAbilityManager> systemAbilityManager
69 = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
70 if (systemAbilityManager == nullptr) {
71 sysAbilityListener_ = nullptr;
72 RESSCHED_LOGE("systemAbilityManager is null");
73 return;
74 }
75
76 handleObserverMap_ = {
77 { DFX_SYS_EVENT_SERVICE_ABILITY_ID, std::bind(&ObserverManager::InitCameraObserver, std::placeholders::_1) },
78 { TELEPHONY_STATE_REGISTRY_SYS_ABILITY_ID,
79 std::bind(&ObserverManager::InitTelephonyObserver, std::placeholders::_1) },
80 { AUDIO_POLICY_SERVICE_ID, std::bind(&ObserverManager::InitAudioObserver, std::placeholders::_1) },
81 { MSDP_MOVEMENT_SERVICE_ID, std::bind(&ObserverManager::InitDeviceMovementObserver, std::placeholders::_1) }
82 };
83 removeObserverMap_ = {
84 { DFX_SYS_EVENT_SERVICE_ABILITY_ID, std::bind(&ObserverManager::DisableCameraObserver, std::placeholders::_1) },
85 { TELEPHONY_STATE_REGISTRY_SYS_ABILITY_ID,
86 std::bind(&ObserverManager::DisableTelephonyObserver, std::placeholders::_1) },
87 { AUDIO_POLICY_SERVICE_ID, std::bind(&ObserverManager::DisableAudioObserver, std::placeholders::_1) },
88 { MSDP_MOVEMENT_SERVICE_ID, std::bind(&ObserverManager::DisableDeviceMovementObserver, std::placeholders::_1) }
89 };
90 AddItemToSysAbilityListener(DFX_SYS_EVENT_SERVICE_ABILITY_ID, systemAbilityManager);
91 AddItemToSysAbilityListener(TELEPHONY_STATE_REGISTRY_SYS_ABILITY_ID, systemAbilityManager);
92 AddItemToSysAbilityListener(AUDIO_POLICY_SERVICE_ID, systemAbilityManager);
93 AddItemToSysAbilityListener(MSDP_MOVEMENT_SERVICE_ID, systemAbilityManager);
94 }
95
AddItemToSysAbilityListener(int32_t systemAbilityId,sptr<ISystemAbilityManager> & systemAbilityManager)96 inline void ObserverManager::AddItemToSysAbilityListener(int32_t systemAbilityId,
97 sptr<ISystemAbilityManager>& systemAbilityManager)
98 {
99 if (systemAbilityManager->SubscribeSystemAbility(systemAbilityId, sysAbilityListener_) != ERR_OK) {
100 sysAbilityListener_ = nullptr;
101 RESSCHED_LOGE("%{public}s: subscribe system ability id: %{public}d failed", __func__, systemAbilityId);
102 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::RSS, "INIT_FAULT", HiviewDFX::HiSysEvent::EventType::FAULT,
103 "COMPONENT_NAME", "MAIN",
104 "ERR_TYPE", "register failure",
105 "ERR_MSG", "Register a staus change listener of the " + std::to_string(systemAbilityId) + " SA failed!");
106 }
107 }
108
OnAddSystemAbility(int32_t systemAbilityId,const std::string & deviceId)109 void ObserverManager::SystemAbilityStatusChangeListener::OnAddSystemAbility(
110 int32_t systemAbilityId, const std::string& deviceId)
111 {
112 RESSCHED_LOGI("Add system ability, system ability id: %{public}d", systemAbilityId);
113 auto funcIter = ObserverManager::GetInstance().handleObserverMap_.find(systemAbilityId);
114 if (funcIter != ObserverManager::GetInstance().handleObserverMap_.end()) {
115 auto function = funcIter->second;
116 if (function) {
117 function(&ObserverManager::GetInstance());
118 }
119 }
120 }
121
OnRemoveSystemAbility(int32_t systemAbilityId,const std::string & deviceId)122 void ObserverManager::SystemAbilityStatusChangeListener::OnRemoveSystemAbility(
123 int32_t systemAbilityId, const std::string& deviceId)
124 {
125 RESSCHED_LOGD("Remove system ability, system ability id: %{public}d", systemAbilityId);
126 auto funcIter = ObserverManager::GetInstance().removeObserverMap_.find(systemAbilityId);
127 if (funcIter != ObserverManager::GetInstance().removeObserverMap_.end()) {
128 auto function = funcIter->second;
129 if (function) {
130 function(&ObserverManager::GetInstance());
131 }
132 }
133 }
134
InitCameraObserver()135 void ObserverManager::InitCameraObserver()
136 {
137 RESSCHED_LOGI("Init camera observer");
138 if (!cameraObserver_) {
139 cameraObserver_ = std::make_shared<ResourceSchedule::CameraObserver>();
140 }
141
142 HiviewDFX::ListenerRule cameraStateRule("CAMERA", "CAMERA_STATE");
143 HiviewDFX::ListenerRule cameraStatisticRule("CAMERA", "CAMERA_STATISTIC");
144 std::vector<HiviewDFX::ListenerRule> sysRules;
145 sysRules.push_back(cameraStateRule);
146 sysRules.push_back(cameraStatisticRule);
147 auto res = HiviewDFX::HiSysEventManager::AddListener(cameraObserver_, sysRules);
148 if (res == 0) {
149 RESSCHED_LOGD("ObserverManager init camera observer successfully");
150 } else {
151 RESSCHED_LOGW("ObserverManager init camera observer failed");
152 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::RSS, "INIT_FAULT", HiviewDFX::HiSysEvent::EventType::FAULT,
153 "COMPONENT_NAME", "MAIN",
154 "ERR_TYPE", "register failure",
155 "ERR_MSG", "Register a camera observer failed!");
156 }
157 }
158
DisableCameraObserver()159 void ObserverManager::DisableCameraObserver()
160 {
161 RESSCHED_LOGI("Disable camera observer");
162 if (cameraObserver_ == nullptr) {
163 return;
164 }
165
166 auto res = HiviewDFX::HiSysEventManager::RemoveListener(cameraObserver_);
167 if (res == 0) {
168 RESSCHED_LOGD("ObserverManager disable camera observer successfully");
169 } else {
170 RESSCHED_LOGW("ObserverManager disable camera observer failed");
171 }
172 cameraObserver_ = nullptr;
173 }
174
InitTelephonyObserver()175 void ObserverManager::InitTelephonyObserver()
176 {
177 #ifdef RESSCHED_TELEPHONY_STATE_REGISTRY_ENABLE
178 RESSCHED_LOGI("Init telephony observer");
179 if (!telephonyObserver_) {
180 telephonyObserver_ = std::make_unique<SchedTelephonyObserver>().release();
181 }
182 slotId_ = 0;
183 auto res = Telephony::TelephonyObserverClient::GetInstance().AddStateObserver(
184 telephonyObserver_, slotId_, Telephony::TelephonyObserverBroker::OBSERVER_MASK_CALL_STATE, false);
185 if (res == OPERATION_SUCCESS) {
186 RESSCHED_LOGD("ObserverManager init telephony observer successfully");
187 } else {
188 RESSCHED_LOGW("ObserverManager init telephony observer failed");
189 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::RSS, "INIT_FAULT", HiviewDFX::HiSysEvent::EventType::FAULT,
190 "COMPONENT_NAME", "MAIN",
191 "ERR_TYPE", "register failure",
192 "ERR_MSG", "Register a telephony observer failed!");
193 }
194 #endif
195 }
196
DisableTelephonyObserver()197 void ObserverManager::DisableTelephonyObserver()
198 {
199 #ifdef RESSCHED_TELEPHONY_STATE_REGISTRY_ENABLE
200 RESSCHED_LOGI("Disable telephony observer");
201 if (!telephonyObserver_) {
202 RESSCHED_LOGD("ObserverManager has been disable telephony observer");
203 return ;
204 }
205 slotId_ = 0;
206 Telephony::TelephonyObserverClient::GetInstance().RemoveStateObserver(
207 slotId_, Telephony::TelephonyObserverBroker::OBSERVER_MASK_CALL_STATE);
208 telephonyObserver_ = nullptr;
209 #endif
210 }
211
InitAudioObserver()212 void ObserverManager::InitAudioObserver()
213 {
214 pid_ = getpid();
215 RESSCHED_LOGI("ObserverManager Init audio observer, pid: %{public}d", pid_);
216 if (!audioObserver_) {
217 audioObserver_ = std::make_shared<AudioObserver>();
218 }
219
220 auto res = AudioStandard::AudioStreamManager::GetInstance()->RegisterAudioRendererEventListener(pid_,
221 audioObserver_);
222 if (res == OPERATION_SUCCESS) {
223 RESSCHED_LOGD("ObserverManager init audioRenderStateObserver successfully");
224 } else {
225 RESSCHED_LOGW("ObserverManager init audioRenderStateObserver 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 audio observer failed!");
230 }
231
232 res = AudioStandard::AudioSystemManager::GetInstance()->SetRingerModeCallback(pid_, audioObserver_);
233 if (res == OPERATION_SUCCESS) {
234 RESSCHED_LOGD("ObserverManager init audioRingModeObserver successfully");
235 } else {
236 RESSCHED_LOGW("ObserverManager init audioRingModeObserver failed");
237 }
238
239 res = AudioStandard::AudioSystemManager::GetInstance()->RegisterVolumeKeyEventCallback(pid_, audioObserver_);
240 if (res == OPERATION_SUCCESS) {
241 RESSCHED_LOGD("ObserverManager init audioVolumeKeyObserver successfully");
242 } else {
243 RESSCHED_LOGW("ObserverManager init audioVolumeKeyObserver failed");
244 }
245 }
246
DisableAudioObserver()247 void ObserverManager::DisableAudioObserver()
248 {
249 RESSCHED_LOGI("Disable telephony observer");
250 if (!audioObserver_) {
251 RESSCHED_LOGD("ObserverManager has been disable audioObserver");
252 return ;
253 }
254
255 auto res = AudioStandard::AudioStreamManager::GetInstance()->UnregisterAudioRendererEventListener(pid_);
256 if (res == OPERATION_SUCCESS) {
257 RESSCHED_LOGD("ObserverManager disable audioVolumeKeyObserver successfully");
258 } else {
259 RESSCHED_LOGW("ObserverManager disable audioVolumeKeyObserver failed");
260 }
261
262 res = AudioStandard::AudioSystemManager::GetInstance()->UnsetRingerModeCallback(pid_);
263 if (res == OPERATION_SUCCESS) {
264 RESSCHED_LOGD("ObserverManager disable audioVolumeKeyObserver successfully");
265 } else {
266 RESSCHED_LOGW("ObserverManager disable audioVolumeKeyObserver failed");
267 }
268
269 res = AudioStandard::AudioSystemManager::GetInstance()->UnregisterVolumeKeyEventCallback(pid_);
270 if (res == OPERATION_SUCCESS) {
271 RESSCHED_LOGD("ObserverManager disable audioVolumeKeyObserver successfully");
272 } else {
273 RESSCHED_LOGW("ObserverManager disable audioVolumeKeyObserver failed");
274 }
275 audioObserver_ = nullptr;
276 }
277
InitDeviceMovementObserver()278 void ObserverManager::InitDeviceMovementObserver()
279 {
280 if (!DEVICE_MOVEMENT_OBSERVER_ENABLE) {
281 RESSCHED_LOGI("Device movement observer is not enable");
282 return;
283 }
284
285 #ifdef DEVICE_MOVEMENT_PERCEPTION_ENABLE
286 RESSCHED_LOGI("InitDeviceMovementObserver");
287 if (!deviceMovementObserver_) {
288 deviceMovementObserver_ = sptr<DeviceMovementObserver>(new DeviceMovementObserver());
289 }
290 if (Msdp::MovementClient::GetInstance().SubscribeCallback(
291 Msdp::MovementDataUtils::MovementType::TYPE_STILL, deviceMovementObserver_) != ERR_OK) {
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 device movement observer failed!");
296 }
297 #endif
298 }
299
DisableDeviceMovementObserver()300 void ObserverManager::DisableDeviceMovementObserver()
301 {
302 if (!DEVICE_MOVEMENT_OBSERVER_ENABLE) {
303 RESSCHED_LOGI("Device movement observer is not enable");
304 return;
305 }
306
307 #ifdef DEVICE_MOVEMENT_PERCEPTION_ENABLE
308 RESSCHED_LOGI("DisableDeviceMovementObserver");
309 if (!deviceMovementObserver_) {
310 RESSCHED_LOGD("ObserverManager has been disable deviceMovementObserver");
311 return;
312 }
313 Msdp::MovementClient::GetInstance().UnSubscribeCallback(
314 Msdp::MovementDataUtils::MovementType::TYPE_STILL, deviceMovementObserver_);
315 deviceMovementObserver_ = nullptr;
316 #endif
317 }
318
ObserverManagerInit()319 extern "C" void ObserverManagerInit()
320 {
321 ObserverManager::GetInstance().Init();
322 }
323
ObserverManagerDisable()324 extern "C" void ObserverManagerDisable()
325 {
326 ObserverManager::GetInstance().Disable();
327 }
328 } // namespace ResourceSchedule
329 } // namespace OHOS
330