1 /*
2 * Copyright (c) 2023-2025 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 #ifndef LOG_TAG
16 #define LOG_TAG "AudioPolicyServerHandler"
17 #endif
18
19 #include "audio_policy_server_handler.h"
20 #include "audio_policy_service.h"
21 #include "audio_core_service.h"
22 #include "istandard_audio_routing_manager_listener.h"
23 #include "iaudio_policy_client.h"
24 #include "audio_policy_client_holder.h"
25 #include "audio_policy_manager_listener.h"
26
27 namespace OHOS {
28 namespace AudioStandard {
29 constexpr int32_t RSS_UID = 1096;
30
GeneratePidsStrForPrinting(const std::unordered_map<int32_t,std::shared_ptr<AudioPolicyClientHolder>> & unorderedMap)31 static std::string GeneratePidsStrForPrinting(
32 const std::unordered_map<int32_t, std::shared_ptr<AudioPolicyClientHolder>> &unorderedMap)
33 {
34 std::string retString = "[";
35 for (const auto &[pid, iAudioPolicyClient] : unorderedMap) {
36 retString += (std::to_string(pid) + ',');
37 }
38 retString += ']';
39 return retString;
40 }
41
AudioPolicyServerHandler()42 AudioPolicyServerHandler::AudioPolicyServerHandler() : AppExecFwk::EventHandler(
43 AppExecFwk::EventRunner::Create("OS_APAsyncRunner", AppExecFwk::ThreadMode::FFRT))
44 {
45 AUDIO_DEBUG_LOG("ctor");
46 }
47
~AudioPolicyServerHandler()48 AudioPolicyServerHandler::~AudioPolicyServerHandler()
49 {
50 AUDIO_WARNING_LOG("dtor should not happen");
51 };
52
Init(std::shared_ptr<IAudioInterruptEventDispatcher> dispatcher)53 void AudioPolicyServerHandler::Init(std::shared_ptr<IAudioInterruptEventDispatcher> dispatcher)
54 {
55 interruptEventDispatcher_ = dispatcher;
56 }
57
AddAudioPolicyClientProxyMap(int32_t clientPid,const std::shared_ptr<AudioPolicyClientHolder> & cb)58 void AudioPolicyServerHandler::AddAudioPolicyClientProxyMap(int32_t clientPid,
59 const std::shared_ptr<AudioPolicyClientHolder> &cb)
60 {
61 std::lock_guard<std::mutex> lock(handleMapMutex_);
62 auto [it, res] = audioPolicyClientProxyAPSCbsMap_.try_emplace(clientPid, cb);
63 if (!res) {
64 if (cb == it->second) {
65 AUDIO_WARNING_LOG("Duplicate registration");
66 } else {
67 AUDIO_ERR_LOG("client registers multiple callbacks, the callback may be lost.");
68 }
69 }
70 pidsStrForPrinting_ = GeneratePidsStrForPrinting(audioPolicyClientProxyAPSCbsMap_);
71 AUDIO_INFO_LOG("group data num [%{public}zu] pid [%{public}d] map %{public}s",
72 audioPolicyClientProxyAPSCbsMap_.size(), clientPid, pidsStrForPrinting_.c_str());
73 }
74
RemoveAudioPolicyClientProxyMap(pid_t clientPid)75 void AudioPolicyServerHandler::RemoveAudioPolicyClientProxyMap(pid_t clientPid)
76 {
77 std::lock_guard<std::mutex> lock(handleMapMutex_);
78 audioPolicyClientProxyAPSCbsMap_.erase(clientPid);
79 clientCallbacksMap_.erase(clientPid);
80 pidsStrForPrinting_ = GeneratePidsStrForPrinting(audioPolicyClientProxyAPSCbsMap_);
81 AUDIO_INFO_LOG("RemoveAudioPolicyClientProxyMap, group data num [%{public}zu] map %{public}s",
82 audioPolicyClientProxyAPSCbsMap_.size(), pidsStrForPrinting_.c_str());
83 }
84
AddExternInterruptCbsMap(int32_t clientId,const std::shared_ptr<AudioInterruptCallback> & callback)85 void AudioPolicyServerHandler::AddExternInterruptCbsMap(int32_t clientId,
86 const std::shared_ptr<AudioInterruptCallback> &callback)
87 {
88 std::lock_guard<std::mutex> lock(handleMapMutex_);
89 amInterruptCbsMap_[clientId] = callback;
90 AUDIO_INFO_LOG("AddExternInterruptCbsMap, group data num [%{public}zu]",
91 amInterruptCbsMap_.size());
92 }
93
RemoveExternInterruptCbsMap(int32_t clientId)94 int32_t AudioPolicyServerHandler::RemoveExternInterruptCbsMap(int32_t clientId)
95 {
96 std::lock_guard<std::mutex> lock(handleMapMutex_);
97 if (amInterruptCbsMap_.erase(clientId) == 0) {
98 AUDIO_ERR_LOG("RemoveExternInterruptCbsMap client %{public}d not present", clientId);
99 return ERR_INVALID_OPERATION;
100 }
101 return SUCCESS;
102 }
103
AddAvailableDeviceChangeMap(int32_t clientId,const AudioDeviceUsage usage,const std::shared_ptr<AudioPolicyManagerListenerCallback> & callback)104 void AudioPolicyServerHandler::AddAvailableDeviceChangeMap(int32_t clientId, const AudioDeviceUsage usage,
105 const std::shared_ptr<AudioPolicyManagerListenerCallback> &callback)
106 {
107 std::lock_guard<std::mutex> lock(handleMapMutex_);
108 availableDeviceChangeCbsMap_[{clientId, usage}] = callback;
109 AUDIO_INFO_LOG("AddAvailableDeviceChangeMap, group data num [%{public}zu]", availableDeviceChangeCbsMap_.size());
110 }
111
RemoveAvailableDeviceChangeMap(const int32_t clientId,AudioDeviceUsage usage)112 void AudioPolicyServerHandler::RemoveAvailableDeviceChangeMap(const int32_t clientId, AudioDeviceUsage usage)
113 {
114 std::lock_guard<std::mutex> lock(handleMapMutex_);
115 if (availableDeviceChangeCbsMap_.erase({clientId, usage}) == 0) {
116 AUDIO_INFO_LOG("client not present in %{public}s", __func__);
117 }
118 // for routing manager napi remove all device change callback
119 if (usage == AudioDeviceUsage::D_ALL_DEVICES) {
120 for (auto it = availableDeviceChangeCbsMap_.begin(); it != availableDeviceChangeCbsMap_.end();) {
121 if ((*it).first.first == clientId) {
122 it = availableDeviceChangeCbsMap_.erase(it);
123 } else {
124 it++;
125 }
126 }
127 }
128 AUDIO_INFO_LOG("RemoveAvailableDeviceChangeMap, group data num [%{public}zu]",
129 availableDeviceChangeCbsMap_.size());
130 }
131
AddDistributedRoutingRoleChangeCbsMap(int32_t clientId,const sptr<IStandardAudioRoutingManagerListener> & callback)132 void AudioPolicyServerHandler::AddDistributedRoutingRoleChangeCbsMap(int32_t clientId,
133 const sptr<IStandardAudioRoutingManagerListener> &callback)
134 {
135 std::lock_guard<std::mutex> lock(handleMapMutex_);
136 if (callback != nullptr) {
137 distributedRoutingRoleChangeCbsMap_[clientId] = callback;
138 }
139 AUDIO_DEBUG_LOG("SetDistributedRoutingRoleCallback: distributedRoutingRoleChangeCbsMap_ size: %{public}zu",
140 distributedRoutingRoleChangeCbsMap_.size());
141 }
142
RemoveDistributedRoutingRoleChangeCbsMap(int32_t clientId)143 int32_t AudioPolicyServerHandler::RemoveDistributedRoutingRoleChangeCbsMap(int32_t clientId)
144 {
145 std::lock_guard<std::mutex> lock(handleMapMutex_);
146 if (distributedRoutingRoleChangeCbsMap_.erase(clientId) == 0) {
147 AUDIO_ERR_LOG("RemoveDistributedRoutingRoleChangeCbsMap clientPid %{public}d not present", clientId);
148 return ERR_INVALID_OPERATION;
149 }
150
151 AUDIO_DEBUG_LOG("UnsetDistributedRoutingRoleCallback: distributedRoutingRoleChangeCbsMap_ size: %{public}zu",
152 distributedRoutingRoleChangeCbsMap_.size());
153 return SUCCESS;
154 }
155
SendDeviceChangedCallback(const std::vector<std::shared_ptr<AudioDeviceDescriptor>> & desc,bool isConnected)156 bool AudioPolicyServerHandler::SendDeviceChangedCallback(
157 const std::vector<std::shared_ptr<AudioDeviceDescriptor>> &desc, bool isConnected)
158 {
159 Trace trace("AudioPolicyServerHandler::SendDeviceChangedCallback");
160 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
161 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
162 eventContextObj->deviceChangeAction.type = isConnected ? DeviceChangeType::CONNECT : DeviceChangeType::DISCONNECT;
163 eventContextObj->deviceChangeAction.deviceDescriptors = desc;
164
165 lock_guard<mutex> runnerlock(runnerMutex_);
166 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::AUDIO_DEVICE_CHANGE, eventContextObj));
167 CHECK_AND_RETURN_RET_LOG(ret, ret, "SendDeviceChangedCallback event failed");
168 return ret;
169 }
170
SendMicrophoneBlockedCallback(const std::vector<std::shared_ptr<AudioDeviceDescriptor>> & desc,DeviceBlockStatus status)171 bool AudioPolicyServerHandler::SendMicrophoneBlockedCallback(
172 const std::vector<std::shared_ptr<AudioDeviceDescriptor>> &desc, DeviceBlockStatus status)
173 {
174 Trace trace("AudioPolicyServerHandler::SendMicrophoneBlockedCallback");
175 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
176 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
177 eventContextObj->microphoneBlockedInfo.blockStatus = status;
178 eventContextObj->microphoneBlockedInfo.devices = desc;
179
180 lock_guard<mutex> runnerlock(runnerMutex_);
181 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::MICROPHONE_BLOCKED, eventContextObj));
182 CHECK_AND_RETURN_RET_LOG(ret, ret, "SendMicrophoneBlockedCallback event failed");
183 return ret;
184 }
185
SendAvailableDeviceChange(const std::vector<std::shared_ptr<AudioDeviceDescriptor>> & desc,bool isConnected)186 bool AudioPolicyServerHandler::SendAvailableDeviceChange(
187 const std::vector<std::shared_ptr<AudioDeviceDescriptor>> &desc, bool isConnected)
188 {
189 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
190 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
191 eventContextObj->deviceChangeAction.type = isConnected ? DeviceChangeType::CONNECT : DeviceChangeType::DISCONNECT;
192 eventContextObj->deviceChangeAction.deviceDescriptors = desc;
193
194 lock_guard<mutex> runnerlock(runnerMutex_);
195 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::AVAILABLE_AUDIO_DEVICE_CHANGE,
196 eventContextObj));
197 CHECK_AND_RETURN_RET_LOG(ret, ret, "SendAvailableDeviceChange event failed");
198 return ret;
199 }
200
SendVolumeKeyEventCallback(const VolumeEvent & volumeEvent)201 bool AudioPolicyServerHandler::SendVolumeKeyEventCallback(const VolumeEvent &volumeEvent)
202 {
203 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
204 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
205 if (volumeEvent.volumeType == AudioStreamType::STREAM_VOICE_CALL_ASSISTANT) {
206 return false;
207 }
208 eventContextObj->volumeEvent = volumeEvent;
209 lock_guard<mutex> runnerlock(runnerMutex_);
210 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::VOLUME_KEY_EVENT, eventContextObj));
211 CHECK_AND_RETURN_RET_LOG(ret, ret, "SendVolumeKeyEventCallback event failed");
212 return ret;
213 }
214
SendAudioSessionDeactiveCallback(const std::pair<int32_t,AudioSessionDeactiveEvent> & sessionDeactivePair)215 bool AudioPolicyServerHandler::SendAudioSessionDeactiveCallback(
216 const std::pair<int32_t, AudioSessionDeactiveEvent> &sessionDeactivePair)
217 {
218 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
219 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
220 eventContextObj->sessionDeactivePair = sessionDeactivePair;
221 lock_guard<mutex> runnerlock(runnerMutex_);
222 AUDIO_INFO_LOG("Send AudioSessionDeactiveCallback pid %{public}d", sessionDeactivePair.first);
223 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::AUDIO_SESSION_DEACTIVE_EVENT,
224 eventContextObj));
225 CHECK_AND_RETURN_RET_LOG(ret, ret, "SendAudioSessionDeactiveCallback event failed");
226 return ret;
227 }
228
SendAudioFocusInfoChangeCallback(int32_t callbackCategory,const AudioInterrupt & audioInterrupt,const std::list<std::pair<AudioInterrupt,AudioFocuState>> & focusInfoList)229 bool AudioPolicyServerHandler::SendAudioFocusInfoChangeCallback(int32_t callbackCategory,
230 const AudioInterrupt &audioInterrupt, const std::list<std::pair<AudioInterrupt, AudioFocuState>> &focusInfoList)
231 {
232 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
233 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
234 eventContextObj->audioInterrupt = audioInterrupt;
235 eventContextObj->focusInfoList = focusInfoList;
236 bool ret = false;
237
238 lock_guard<mutex> runnerlock(runnerMutex_);
239 if (callbackCategory == FocusCallbackCategory::REQUEST_CALLBACK_CATEGORY) {
240 ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::REQUEST_CATEGORY_EVENT, eventContextObj));
241 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send REQUEST_CATEGORY_EVENT event failed");
242 } else if (callbackCategory == FocusCallbackCategory::ABANDON_CALLBACK_CATEGORY) {
243 ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::ABANDON_CATEGORY_EVENT, eventContextObj));
244 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send ABANDON_CATEGORY_EVENT event failed");
245 }
246 ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::FOCUS_INFOCHANGE, eventContextObj));
247 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send FOCUS_INFOCHANGE event failed");
248
249 return ret;
250 }
251
SendRingerModeUpdatedCallback(const AudioRingerMode & ringMode)252 bool AudioPolicyServerHandler::SendRingerModeUpdatedCallback(const AudioRingerMode &ringMode)
253 {
254 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
255 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
256 eventContextObj->ringMode = ringMode;
257 lock_guard<mutex> runnerlock(runnerMutex_);
258 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::RINGER_MODEUPDATE_EVENT, eventContextObj));
259 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send RINGER_MODEUPDATE_EVENT event failed");
260 return ret;
261 }
262
SendActiveVolumeTypeChangeCallback(const AudioVolumeType & volumeType)263 bool AudioPolicyServerHandler::SendActiveVolumeTypeChangeCallback(const AudioVolumeType &volumeType)
264 {
265 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
266 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
267 eventContextObj->volumeType = volumeType;
268 lock_guard<mutex> runnerlock(runnerMutex_);
269 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::ACTIVE_VOLUME_TYPE_CHANGE_EVENT,
270 eventContextObj));
271 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send ACTIVE_VOLUME_TYPE_CHANGE_EVENT event failed");
272 return ret;
273 }
274
SendAppVolumeChangeCallback(int32_t appUid,const VolumeEvent & volumeEvent)275 bool AudioPolicyServerHandler::SendAppVolumeChangeCallback(int32_t appUid, const VolumeEvent &volumeEvent)
276 {
277 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
278 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
279 eventContextObj->appUid = appUid;
280 eventContextObj->volumeEvent = volumeEvent;
281 lock_guard<mutex> runnerlock(runnerMutex_);
282 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::APP_VOLUME_CHANGE_EVENT,
283 eventContextObj));
284 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send RINGER_MODEUPDATE_EVENT event failed");
285 return ret;
286 }
287
SendMicStateUpdatedCallback(const MicStateChangeEvent & micStateChangeEvent)288 bool AudioPolicyServerHandler::SendMicStateUpdatedCallback(const MicStateChangeEvent &micStateChangeEvent)
289 {
290 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
291 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
292 eventContextObj->micStateChangeEvent = micStateChangeEvent;
293 lock_guard<mutex> runnerlock(runnerMutex_);
294 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::MIC_STATE_CHANGE_EVENT, eventContextObj));
295 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send MIC_STATE_CHANGE_EVENT event failed");
296 return ret;
297 }
298
SendMicStateWithClientIdCallback(const MicStateChangeEvent & micStateChangeEvent,int32_t clientId)299 bool AudioPolicyServerHandler::SendMicStateWithClientIdCallback(const MicStateChangeEvent &micStateChangeEvent,
300 int32_t clientId)
301 {
302 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
303 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
304 eventContextObj->micStateChangeEvent = micStateChangeEvent;
305 eventContextObj->clientId = clientId;
306 lock_guard<mutex> runnerlock(runnerMutex_);
307 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::MIC_STATE_CHANGE_EVENT_WITH_CLIENTID,
308 eventContextObj));
309 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send MIC_STATE_CHANGE_EVENT_WITH_CLIENTID event failed");
310 return ret;
311 }
312
SendInterruptEventInternalCallback(const InterruptEventInternal & interruptEvent)313 bool AudioPolicyServerHandler::SendInterruptEventInternalCallback(const InterruptEventInternal &interruptEvent)
314 {
315 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
316 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
317 eventContextObj->interruptEvent = interruptEvent;
318 lock_guard<mutex> runnerlock(runnerMutex_);
319 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::INTERRUPT_EVENT, eventContextObj));
320 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send INTERRUPT_EVENT event failed");
321 return ret;
322 }
323
SendInterruptEventWithStreamIdCallback(const InterruptEventInternal & interruptEvent,const uint32_t & streamId)324 bool AudioPolicyServerHandler::SendInterruptEventWithStreamIdCallback(const InterruptEventInternal &interruptEvent,
325 const uint32_t &streamId)
326 {
327 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
328 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
329 eventContextObj->interruptEvent = interruptEvent;
330 eventContextObj->sessionId = streamId;
331 lock_guard<mutex> runnerlock(runnerMutex_);
332 AUDIO_INFO_LOG("Send interrupt event with streamId callback, streamId = %{public}u", streamId);
333 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::INTERRUPT_EVENT_WITH_STREAMID,
334 eventContextObj));
335 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send INTERRUPT_EVENT_WITH_STREAMID event failed");
336 return ret;
337 }
338
SendInterruptEventCallbackForAudioSession(const InterruptEventInternal & interruptEvent,const AudioInterrupt & audioInterrupt)339 bool AudioPolicyServerHandler::SendInterruptEventCallbackForAudioSession(const InterruptEventInternal &interruptEvent,
340 const AudioInterrupt &audioInterrupt)
341 {
342 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
343 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
344 eventContextObj->interruptEvent = interruptEvent;
345 eventContextObj->audioInterrupt = audioInterrupt;
346 lock_guard<mutex> runnerlock(runnerMutex_);
347 AUDIO_INFO_LOG("Send InterruptEventCallbackForAudioSession pid %{public}d", audioInterrupt.pid);
348 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::INTERRUPT_EVENT_FOR_AUDIO_SESSION,
349 eventContextObj));
350 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send INTERRUPT_EVENT_FOR_AUDIO_SESSION event failed");
351 return ret;
352 }
353
SendInterruptEventWithClientIdCallback(const InterruptEventInternal & interruptEvent,const int32_t & clientId)354 bool AudioPolicyServerHandler::SendInterruptEventWithClientIdCallback(const InterruptEventInternal &interruptEvent,
355 const int32_t &clientId)
356 {
357 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
358 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
359 eventContextObj->interruptEvent = interruptEvent;
360 eventContextObj->clientId = clientId;
361 lock_guard<mutex> runnerlock(runnerMutex_);
362 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::INTERRUPT_EVENT_WITH_CLIENTID,
363 eventContextObj));
364 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send INTERRUPT_EVENT_WITH_CLIENTID event failed");
365 return ret;
366 }
367
SendPreferredOutputDeviceUpdated()368 bool AudioPolicyServerHandler::SendPreferredOutputDeviceUpdated()
369 {
370 lock_guard<mutex> runnerlock(runnerMutex_);
371 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::PREFERRED_OUTPUT_DEVICE_UPDATED));
372 CHECK_AND_RETURN_RET_LOG(ret, ret, "SendPreferredOutputDeviceUpdated event failed");
373 return ret;
374 }
375
SendPreferredInputDeviceUpdated()376 bool AudioPolicyServerHandler::SendPreferredInputDeviceUpdated()
377 {
378 lock_guard<mutex> runnerlock(runnerMutex_);
379 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::PREFERRED_INPUT_DEVICE_UPDATED));
380 CHECK_AND_RETURN_RET_LOG(ret, ret, "SendPreferredInputDeviceUpdated event failed");
381 return ret;
382 }
383
SendDistributedRoutingRoleChange(const std::shared_ptr<AudioDeviceDescriptor> descriptor,const CastType & type)384 bool AudioPolicyServerHandler::SendDistributedRoutingRoleChange(
385 const std::shared_ptr<AudioDeviceDescriptor> descriptor, const CastType &type)
386 {
387 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
388 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
389 eventContextObj->descriptor = descriptor;
390 eventContextObj->type = type;
391 lock_guard<mutex> runnerlock(runnerMutex_);
392 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::DISTRIBUTED_ROUTING_ROLE_CHANGE,
393 eventContextObj));
394 CHECK_AND_RETURN_RET_LOG(ret, ret, "SendDistributedRoutingRoleChange event failed");
395 return ret;
396 }
397
SendAudioSessionDeviceChange(const AudioStreamDeviceChangeReason changeReason,int callerPid)398 bool AudioPolicyServerHandler::SendAudioSessionDeviceChange(
399 const AudioStreamDeviceChangeReason changeReason, int callerPid)
400 {
401 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
402 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
403 eventContextObj->reason_ = changeReason;
404 eventContextObj->callerPid_ = callerPid;
405
406 lock_guard<mutex> runnerlock(runnerMutex_);
407 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::SESSION_DEVICE_CHANGE,
408 eventContextObj));
409 CHECK_AND_RETURN_RET_LOG(ret, ret, "SendAudionSessionOutputDeviceChange event failed");
410 return ret;
411 }
412
SendRendererInfoEvent(const std::vector<std::shared_ptr<AudioRendererChangeInfo>> & audioRendererChangeInfos)413 bool AudioPolicyServerHandler::SendRendererInfoEvent(
414 const std::vector<std::shared_ptr<AudioRendererChangeInfo>> &audioRendererChangeInfos)
415 {
416 std::vector<std::shared_ptr<AudioRendererChangeInfo>> rendererChangeInfos;
417 for (const auto &changeInfo : audioRendererChangeInfos) {
418 rendererChangeInfos.push_back(std::make_shared<AudioRendererChangeInfo>(*changeInfo));
419 }
420
421 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
422 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
423 eventContextObj->audioRendererChangeInfos = move(rendererChangeInfos);
424
425 lock_guard<mutex> runnerlock(runnerMutex_);
426 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::RENDERER_INFO_EVENT,
427 eventContextObj));
428 CHECK_AND_RETURN_RET_LOG(ret, ret, "SendRendererInfoEvent event failed");
429 return ret;
430 }
431
SendCapturerInfoEvent(const std::vector<std::shared_ptr<AudioCapturerChangeInfo>> & audioCapturerChangeInfos)432 bool AudioPolicyServerHandler::SendCapturerInfoEvent(
433 const std::vector<std::shared_ptr<AudioCapturerChangeInfo>> &audioCapturerChangeInfos)
434 {
435 std::vector<std::shared_ptr<AudioCapturerChangeInfo>> capturerChangeInfos;
436 for (const auto &changeInfo : audioCapturerChangeInfos) {
437 capturerChangeInfos.push_back(std::make_shared<AudioCapturerChangeInfo>(*changeInfo));
438 }
439
440 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
441 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
442 eventContextObj->audioCapturerChangeInfos = move(capturerChangeInfos);
443
444 lock_guard<mutex> runnerlock(runnerMutex_);
445 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::CAPTURER_INFO_EVENT,
446 eventContextObj));
447 CHECK_AND_RETURN_RET_LOG(ret, ret, "SendRendererInfoEvent event failed");
448 return ret;
449 }
450
SendRendererDeviceChangeEvent(const int32_t clientPid,const uint32_t sessionId,const AudioDeviceDescriptor & outputDeviceInfo,const AudioStreamDeviceChangeReasonExt reason)451 bool AudioPolicyServerHandler::SendRendererDeviceChangeEvent(const int32_t clientPid, const uint32_t sessionId,
452 const AudioDeviceDescriptor &outputDeviceInfo, const AudioStreamDeviceChangeReasonExt reason)
453 {
454 std::shared_ptr<RendererDeviceChangeEvent> eventContextObj = std::make_shared<RendererDeviceChangeEvent>(
455 clientPid, sessionId, outputDeviceInfo, reason);
456 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
457
458 lock_guard<mutex> runnerlock(runnerMutex_);
459 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::RENDERER_DEVICE_CHANGE_EVENT,
460 eventContextObj));
461 CHECK_AND_RETURN_RET_LOG(ret, ret, "SendRendererDeviceChangeEvent event failed");
462 return ret;
463 }
464
SendCapturerCreateEvent(AudioCapturerInfo capturerInfo,AudioStreamInfo streamInfo,uint64_t sessionId,bool isSync,int32_t & error)465 bool AudioPolicyServerHandler::SendCapturerCreateEvent(AudioCapturerInfo capturerInfo,
466 AudioStreamInfo streamInfo, uint64_t sessionId, bool isSync, int32_t &error)
467 {
468 auto eventContextObj = std::make_shared<CapturerCreateEvent>(capturerInfo, streamInfo, sessionId, SUCCESS);
469 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
470
471 bool ret;
472 if (isSync) {
473 ret = SendSyncEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::ON_CAPTURER_CREATE,
474 eventContextObj));
475 error = eventContextObj->error_;
476 } else {
477 ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::ON_CAPTURER_CREATE,
478 eventContextObj));
479 error = SUCCESS;
480 }
481 CHECK_AND_RETURN_RET_LOG(ret, ret, "failed");
482 return ret;
483 }
484
SendCapturerRemovedEvent(uint64_t sessionId,bool isSync)485 bool AudioPolicyServerHandler::SendCapturerRemovedEvent(uint64_t sessionId, bool isSync)
486 {
487 auto eventContextObj = std::make_shared<uint64_t>(sessionId);
488 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
489
490 bool ret;
491 if (isSync) {
492 ret = SendSyncEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::ON_CAPTURER_REMOVED,
493 eventContextObj));
494 } else {
495 ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::ON_CAPTURER_REMOVED,
496 eventContextObj));
497 }
498 CHECK_AND_RETURN_RET_LOG(ret, ret, "failed");
499 return ret;
500 }
501
SendWakeupCloseEvent(bool isSync)502 bool AudioPolicyServerHandler::SendWakeupCloseEvent(bool isSync)
503 {
504 bool ret;
505 if (isSync) {
506 ret = SendSyncEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::ON_WAKEUP_CLOSE));
507 } else {
508 ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::ON_WAKEUP_CLOSE));
509 }
510 CHECK_AND_RETURN_RET_LOG(ret, ret, "failed");
511 return ret;
512 }
513
SendRecreateRendererStreamEvent(int32_t clientId,uint32_t sessionID,uint32_t routeFlag,const AudioStreamDeviceChangeReasonExt reason)514 bool AudioPolicyServerHandler::SendRecreateRendererStreamEvent(
515 int32_t clientId, uint32_t sessionID, uint32_t routeFlag, const AudioStreamDeviceChangeReasonExt reason)
516 {
517 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
518 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
519 eventContextObj->clientId = clientId;
520 eventContextObj->sessionId = sessionID;
521 eventContextObj->reason_ = reason;
522 eventContextObj->routeFlag = routeFlag;
523 return SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::RECREATE_RENDERER_STREAM_EVENT,
524 eventContextObj));
525 }
526
SendRecreateCapturerStreamEvent(int32_t clientId,uint32_t sessionID,uint32_t routeFlag,const AudioStreamDeviceChangeReasonExt reason)527 bool AudioPolicyServerHandler::SendRecreateCapturerStreamEvent(
528 int32_t clientId, uint32_t sessionID, uint32_t routeFlag, const AudioStreamDeviceChangeReasonExt reason)
529 {
530 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
531 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
532 eventContextObj->clientId = clientId;
533 eventContextObj->sessionId = sessionID;
534 eventContextObj->reason_ = reason;
535 eventContextObj->routeFlag = routeFlag;
536 return SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::RECREATE_CAPTURER_STREAM_EVENT,
537 eventContextObj));
538 }
539
SendNnStateChangeCallback(const int32_t & state)540 bool AudioPolicyServerHandler::SendNnStateChangeCallback(const int32_t &state)
541 {
542 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
543 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
544 eventContextObj->nnState = state;
545 lock_guard<mutex> runnerlock(runnerMutex_);
546 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::NN_STATE_CHANGE, eventContextObj));
547 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send NN_STATE_CHANGE event failed");
548 return ret;
549 }
550
SendHeadTrackingDeviceChangeEvent(const std::unordered_map<std::string,bool> & changeInfo)551 bool AudioPolicyServerHandler::SendHeadTrackingDeviceChangeEvent(
552 const std::unordered_map<std::string, bool> &changeInfo)
553 {
554 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
555 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
556 eventContextObj->headTrackingDeviceChangeInfo = changeInfo;
557 lock_guard<mutex> runnerlock(runnerMutex_);
558 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::HEAD_TRACKING_DEVICE_CHANGE,
559 eventContextObj));
560 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send HEAD_TRACKING_DEVICE_CHANGE event failed");
561 return ret;
562 }
563
SendSpatializatonEnabledChangeEvent(const bool & enabled)564 bool AudioPolicyServerHandler::SendSpatializatonEnabledChangeEvent(const bool &enabled)
565 {
566 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
567 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
568 eventContextObj->spatializationEnabled = enabled;
569 lock_guard<mutex> runnerlock(runnerMutex_);
570 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::SPATIALIZATION_ENABLED_CHANGE,
571 eventContextObj));
572 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send SPATIALIZATION_ENABLED_CHANGE event failed");
573 return ret;
574 }
575
SendSpatializatonEnabledChangeForAnyDeviceEvent(const std::shared_ptr<AudioDeviceDescriptor> & selectedAudioDevice,const bool & enabled)576 bool AudioPolicyServerHandler::SendSpatializatonEnabledChangeForAnyDeviceEvent(
577 const std::shared_ptr<AudioDeviceDescriptor> &selectedAudioDevice, const bool &enabled)
578 {
579 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
580 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
581 eventContextObj->spatializationEnabled = enabled;
582 eventContextObj->descriptor = selectedAudioDevice;
583 lock_guard<mutex> runnerlock(runnerMutex_);
584 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::SPATIALIZATION_ENABLED_CHANGE_FOR_ANY_DEVICE,
585 eventContextObj));
586 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send SPATIALIZATION_ENABLED_CHANGE event failed");
587 return ret;
588 }
589
SendSpatializatonEnabledChangeForCurrentDeviceEvent(const bool & enabled)590 bool AudioPolicyServerHandler::SendSpatializatonEnabledChangeForCurrentDeviceEvent(const bool &enabled)
591 {
592 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
593 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
594 eventContextObj->spatializationEnabled = enabled;
595 lock_guard<mutex> runnerlock(runnerMutex_);
596 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(
597 EventAudioServerCmd::SPATIALIZATION_ENABLED_CHANGE_FOR_CURRENT_DEVICE, eventContextObj));
598 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send SPATIALIZATION_ENABLED_CHANGE_FOR_CURRENT_DEVICE event failed");
599 return ret;
600 }
601
SendHeadTrackingEnabledChangeEvent(const bool & enabled)602 bool AudioPolicyServerHandler::SendHeadTrackingEnabledChangeEvent(const bool &enabled)
603 {
604 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
605 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
606 eventContextObj->headTrackingEnabled = enabled;
607 lock_guard<mutex> runnerlock(runnerMutex_);
608 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::HEAD_TRACKING_ENABLED_CHANGE,
609 eventContextObj));
610 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send HEAD_TRACKING_ENABLED_CHANGE event failed");
611 return ret;
612 }
613
SendAudioSceneChangeEvent(const AudioScene & audioScene)614 bool AudioPolicyServerHandler::SendAudioSceneChangeEvent(const AudioScene &audioScene)
615 {
616 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
617 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
618 eventContextObj->audioScene = audioScene;
619 lock_guard<mutex> runnerlock(runnerMutex_);
620 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::AUDIO_SCENE_CHANGE,
621 eventContextObj));
622 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send HEAD_TRACKING_ENABLED_CHANGE event failed");
623 return ret;
624 }
625
SendHeadTrackingEnabledChangeForAnyDeviceEvent(const std::shared_ptr<AudioDeviceDescriptor> & selectedAudioDevice,const bool & enabled)626 bool AudioPolicyServerHandler::SendHeadTrackingEnabledChangeForAnyDeviceEvent(
627 const std::shared_ptr<AudioDeviceDescriptor> &selectedAudioDevice, const bool &enabled)
628 {
629 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
630 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
631 eventContextObj->headTrackingEnabled = enabled;
632 eventContextObj->descriptor = selectedAudioDevice;
633 lock_guard<mutex> runnerlock(runnerMutex_);
634 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::HEAD_TRACKING_ENABLED_CHANGE_FOR_ANY_DEVICE,
635 eventContextObj));
636 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send HEAD_TRACKING_ENABLED_CHANGE event failed");
637 return ret;
638 }
639
SendPipeStreamCleanEvent(AudioPipeType pipeType)640 bool AudioPolicyServerHandler::SendPipeStreamCleanEvent(AudioPipeType pipeType)
641 {
642 auto eventContextObj = std::make_shared<int32_t>(pipeType);
643 lock_guard<mutex> runnerlock(runnerMutex_);
644 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::PIPE_STREAM_CLEAN_EVENT,
645 eventContextObj));
646 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send PIPE_STREAM_CLEAN_EVENT event failed");
647 return ret;
648 }
649
SendFormatUnsupportedErrorEvent(const AudioErrors & errorCode)650 bool AudioPolicyServerHandler::SendFormatUnsupportedErrorEvent(const AudioErrors &errorCode)
651 {
652 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
653 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
654 eventContextObj->errorCode = errorCode;
655 lock_guard<mutex> runnerlock(runnerMutex_);
656 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::FORMAT_UNSUPPORTED_ERROR, eventContextObj));
657 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send FORMAT_UNSUPPORTED_ERROR event failed");
658 return ret;
659 }
660
HandleDeviceChangedCallback(const AppExecFwk::InnerEvent::Pointer & event)661 void AudioPolicyServerHandler::HandleDeviceChangedCallback(const AppExecFwk::InnerEvent::Pointer &event)
662 {
663 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
664 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
665 std::lock_guard<std::mutex> lock(handleMapMutex_);
666 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
667 if (it->second && eventContextObj->deviceChangeAction.deviceDescriptors.size() > 0) {
668 DeviceChangeAction deviceChangeAction = eventContextObj->deviceChangeAction;
669 if (!(it->second->hasBTPermission_)) {
670 AudioPolicyService::GetAudioPolicyService().
671 UpdateDescWhenNoBTPermission(deviceChangeAction.deviceDescriptors);
672 }
673 if (clientCallbacksMap_.count(it->first) > 0 &&
674 clientCallbacksMap_[it->first].count(CALLBACK_SET_DEVICE_CHANGE) > 0 &&
675 clientCallbacksMap_[it->first][CALLBACK_SET_DEVICE_CHANGE]) {
676 AUDIO_INFO_LOG("Send DeviceChange deviceType[%{public}d] change to clientPid[%{public}d]",
677 deviceChangeAction.deviceDescriptors[0]->deviceType_, it->first);
678 it->second->OnDeviceChange(deviceChangeAction);
679 }
680 }
681 }
682 }
683
HandleMicrophoneBlockedCallback(const AppExecFwk::InnerEvent::Pointer & event)684 void AudioPolicyServerHandler::HandleMicrophoneBlockedCallback(const AppExecFwk::InnerEvent::Pointer &event)
685 {
686 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
687 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
688 std::lock_guard<std::mutex> lock(handleMapMutex_);
689
690 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
691 if (it->second && eventContextObj->microphoneBlockedInfo.devices.size() > 0) {
692 MicrophoneBlockedInfo microphoneBlockedInfo = eventContextObj->microphoneBlockedInfo;
693 if (clientCallbacksMap_.count(it->first) > 0 &&
694 clientCallbacksMap_[it->first].count(CALLBACK_SET_MICROPHONE_BLOCKED) > 0 &&
695 clientCallbacksMap_[it->first][CALLBACK_SET_MICROPHONE_BLOCKED]) {
696 it->second->OnMicrophoneBlocked(microphoneBlockedInfo);
697 }
698 }
699 }
700 }
701
HandleAvailableDeviceChange(const AppExecFwk::InnerEvent::Pointer & event)702 void AudioPolicyServerHandler::HandleAvailableDeviceChange(const AppExecFwk::InnerEvent::Pointer &event)
703 {
704 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
705 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
706 std::lock_guard<std::mutex> lock(handleMapMutex_);
707 for (auto it = availableDeviceChangeCbsMap_.begin(); it != availableDeviceChangeCbsMap_.end(); ++it) {
708 AudioDeviceUsage usage = it->first.second;
709 DeviceChangeAction deviceChangeAction = eventContextObj->deviceChangeAction;
710 deviceChangeAction.deviceDescriptors = AudioPolicyService::GetAudioPolicyService().
711 DeviceFilterByUsageInner(it->first.second, deviceChangeAction.deviceDescriptors);
712 if (it->second && deviceChangeAction.deviceDescriptors.size() > 0) {
713 if (!(it->second->hasBTPermission_)) {
714 AudioPolicyService::GetAudioPolicyService().
715 UpdateDescWhenNoBTPermission(deviceChangeAction.deviceDescriptors);
716 }
717 it->second->OnAvailableDeviceChange(usage, deviceChangeAction);
718 }
719 }
720 }
721
HandleVolumeChangeCallback(int32_t clientId,std::shared_ptr<AudioPolicyClientHolder> audioPolicyClient,const VolumeEvent & volumeEvent)722 void AudioPolicyServerHandler::HandleVolumeChangeCallback(int32_t clientId,
723 std::shared_ptr<AudioPolicyClientHolder> audioPolicyClient, const VolumeEvent &volumeEvent)
724 {
725 bool callbackRegistered = clientCallbacksMap_.count(clientId) > 0 &&
726 clientCallbacksMap_[clientId].count(CALLBACK_STREAM_VOLUME_CHANGE) > 0;
727 bool callbackEnabled = clientCallbacksMap_[clientId][CALLBACK_STREAM_VOLUME_CHANGE];
728 if (!callbackRegistered || !callbackEnabled) {
729 return;
730 }
731 AudioVolumeType volumeType = VolumeUtils::GetVolumeTypeFromStreamType(volumeEvent.volumeType);
732 std::set<StreamUsage> streamUsages;
733 {
734 std::lock_guard<std::mutex> streamUsagelock(clientCbStreamUsageMapMutex_);
735 if (clientCbStreamUsageMap_.count(clientId) > 0) {
736 streamUsages = VolumeUtils::GetOverlapStreamUsageSet(clientCbStreamUsageMap_[clientId], volumeType);
737 }
738 }
739 for (auto streamUsage : streamUsages) {
740 StreamVolumeEvent streamVolumeEvent;
741 streamVolumeEvent.streamUsage = streamUsage;
742 streamVolumeEvent.volume = volumeEvent.volume;
743 streamVolumeEvent.updateUi = volumeEvent.updateUi;
744 streamVolumeEvent.volumeGroupId = volumeEvent.volumeGroupId;
745 streamVolumeEvent.networkId = volumeEvent.networkId;
746 streamVolumeEvent.volumeMode = volumeEvent.volumeMode;
747 audioPolicyClient->OnStreamVolumeChange(streamVolumeEvent);
748 }
749 }
750
HandleVolumeKeyEventToRssWhenAccountsChange(std::shared_ptr<EventContextObj> & eventContextObj)751 void AudioPolicyServerHandler::HandleVolumeKeyEventToRssWhenAccountsChange(
752 std::shared_ptr<EventContextObj> &eventContextObj)
753 {
754 auto it = audioPolicyClientProxyAPSCbsMap_.find(pidOfRss_);
755 if (it != audioPolicyClientProxyAPSCbsMap_.end()) {
756 std::shared_ptr<AudioPolicyClientHolder> volumeChangeCb = it->second;
757 if (volumeChangeCb == nullptr) {
758 AUDIO_ERR_LOG("volumeChangeCb: nullptr for client : %{public}d", it->first);
759 return;
760 }
761 AUDIO_PRERELEASE_LOGI("Trigger volumeChangeCb clientPid : %{public}d, volumeType : %{public}d," \
762 " volume : %{public}d, updateUi : %{public}d ", it->first,
763 static_cast<int32_t>(eventContextObj->volumeEvent.volumeType), eventContextObj->volumeEvent.volume,
764 static_cast<int32_t>(eventContextObj->volumeEvent.updateUi));
765 if (clientCallbacksMap_.count(it->first) > 0 &&
766 clientCallbacksMap_[it->first].count(CALLBACK_SET_VOLUME_KEY_EVENT) > 0 &&
767 clientCallbacksMap_[it->first][CALLBACK_SET_VOLUME_KEY_EVENT]) {
768 volumeChangeCb->OnVolumeKeyEvent(eventContextObj->volumeEvent);
769 }
770 }
771 }
772
HandleVolumeKeyEvent(const AppExecFwk::InnerEvent::Pointer & event)773 void AudioPolicyServerHandler::HandleVolumeKeyEvent(const AppExecFwk::InnerEvent::Pointer &event)
774 {
775 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
776 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
777 std::lock_guard<std::mutex> lock(handleMapMutex_);
778 if (eventContextObj->volumeEvent.notifyRssWhenAccountsChange) {
779 return HandleVolumeKeyEventToRssWhenAccountsChange(eventContextObj);
780 }
781 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
782 std::shared_ptr<AudioPolicyClientHolder> volumeChangeCb = it->second;
783 if (volumeChangeCb == nullptr) {
784 AUDIO_ERR_LOG("volumeChangeCb: nullptr for client : %{public}d", it->first);
785 continue;
786 }
787 if (VolumeUtils::GetVolumeTypeFromStreamType(eventContextObj->volumeEvent.volumeType) == STREAM_SYSTEM &&
788 !volumeChangeCb->hasSystemPermission_) {
789 AUDIO_DEBUG_LOG("volumeChangeCb: Non system applications do not send system callbacks");
790 continue;
791 }
792 AUDIO_PRERELEASE_LOGI("Trigger volumeChangeCb clientPid : %{public}d, volumeType : %{public}d," \
793 " volume : %{public}d, updateUi : %{public}d ", it->first,
794 static_cast<int32_t>(eventContextObj->volumeEvent.volumeType), eventContextObj->volumeEvent.volume,
795 static_cast<int32_t>(eventContextObj->volumeEvent.updateUi));
796 if (clientCallbacksMap_.count(it->first) > 0 &&
797 clientCallbacksMap_[it->first].count(CALLBACK_SET_VOLUME_KEY_EVENT) > 0 &&
798 clientCallbacksMap_[it->first][CALLBACK_SET_VOLUME_KEY_EVENT]) {
799 volumeChangeCb->OnVolumeKeyEvent(eventContextObj->volumeEvent);
800 }
801 if (clientCallbacksMap_.count(it->first) > 0 &&
802 clientCallbacksMap_[it->first].count(CALLBACK_SYSTEM_VOLUME_CHANGE) > 0 &&
803 clientCallbacksMap_[it->first][CALLBACK_SYSTEM_VOLUME_CHANGE]) {
804 volumeChangeCb->OnSystemVolumeChange(eventContextObj->volumeEvent);
805 }
806 if (clientCallbacksMap_.count(it->first) > 0 &&
807 clientCallbacksMap_[it->first].count(CALLBACK_SET_VOLUME_DEGREE_CHANGE) > 0 &&
808 clientCallbacksMap_[it->first][CALLBACK_SET_VOLUME_DEGREE_CHANGE]) {
809 volumeChangeCb->OnVolumeDegreeEvent(eventContextObj->volumeEvent);
810 }
811 HandleVolumeChangeCallback(it->first, volumeChangeCb, eventContextObj->volumeEvent);
812 }
813 }
814
HandleAudioSessionDeactiveCallback(const AppExecFwk::InnerEvent::Pointer & event)815 void AudioPolicyServerHandler::HandleAudioSessionDeactiveCallback(const AppExecFwk::InnerEvent::Pointer &event)
816 {
817 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
818 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
819 std::lock_guard<std::mutex> lock(handleMapMutex_);
820 int32_t clientPid = eventContextObj->sessionDeactivePair.first;
821 auto iterator = audioPolicyClientProxyAPSCbsMap_.find(clientPid);
822 if (iterator == audioPolicyClientProxyAPSCbsMap_.end()) {
823 AUDIO_ERR_LOG("AudioSessionDeactiveCallback: no client callback for client pid %{public}d", clientPid);
824 return;
825 }
826 if (clientCallbacksMap_.count(iterator->first) > 0 &&
827 clientCallbacksMap_[iterator->first].count(CALLBACK_AUDIO_SESSION) > 0 &&
828 clientCallbacksMap_[iterator->first][CALLBACK_AUDIO_SESSION]) {
829 // the client has registered audio session callback.
830 std::shared_ptr<AudioPolicyClientHolder> audioSessionCb = iterator->second;
831 if (audioSessionCb == nullptr) {
832 AUDIO_ERR_LOG("AudioSessionDeactiveCallback: nullptr for client pid %{public}d", clientPid);
833 return;
834 }
835 AUDIO_INFO_LOG("Trigger AudioSessionDeactiveCallback for client pid : %{public}d", clientPid);
836 audioSessionCb->OnAudioSessionDeactive(eventContextObj->sessionDeactivePair.second);
837 } else {
838 AUDIO_ERR_LOG("AudioSessionDeactiveCallback: no registered callback for pid %{public}d", clientPid);
839 }
840 }
841
HandleRequestCateGoryEvent(const AppExecFwk::InnerEvent::Pointer & event)842 void AudioPolicyServerHandler::HandleRequestCateGoryEvent(const AppExecFwk::InnerEvent::Pointer &event)
843 {
844 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
845 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
846
847 std::lock_guard<std::mutex> lock(handleMapMutex_);
848 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
849 if (clientCallbacksMap_.count(it->first) > 0 &&
850 clientCallbacksMap_[it->first].count(CALLBACK_FOCUS_INFO_CHANGE) > 0 &&
851 clientCallbacksMap_[it->first][CALLBACK_FOCUS_INFO_CHANGE]) {
852 it->second->OnAudioFocusRequested(eventContextObj->audioInterrupt);
853 }
854 }
855 }
856
HandleAbandonCateGoryEvent(const AppExecFwk::InnerEvent::Pointer & event)857 void AudioPolicyServerHandler::HandleAbandonCateGoryEvent(const AppExecFwk::InnerEvent::Pointer &event)
858 {
859 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
860 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
861 std::lock_guard<std::mutex> lock(handleMapMutex_);
862 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
863 if (clientCallbacksMap_.count(it->first) > 0 &&
864 clientCallbacksMap_[it->first].count(CALLBACK_FOCUS_INFO_CHANGE) > 0 &&
865 clientCallbacksMap_[it->first][CALLBACK_FOCUS_INFO_CHANGE]) {
866 it->second->OnAudioFocusAbandoned(eventContextObj->audioInterrupt);
867 }
868 }
869 }
870
HandleFocusInfoChangeEvent(const AppExecFwk::InnerEvent::Pointer & event)871 void AudioPolicyServerHandler::HandleFocusInfoChangeEvent(const AppExecFwk::InnerEvent::Pointer &event)
872 {
873 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
874 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
875 AUDIO_INFO_LOG("focusInfoList :%{public}zu", eventContextObj->focusInfoList.size());
876 std::lock_guard<std::mutex> lock(handleMapMutex_);
877 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
878 if (clientCallbacksMap_.count(it->first) > 0 &&
879 clientCallbacksMap_[it->first].count(CALLBACK_FOCUS_INFO_CHANGE) > 0 &&
880 clientCallbacksMap_[it->first][CALLBACK_FOCUS_INFO_CHANGE]) {
881 it->second->OnAudioFocusInfoChange(eventContextObj->focusInfoList);
882 }
883 }
884 }
885
HandleActiveVolumeTypeChangeEvent(const AppExecFwk::InnerEvent::Pointer & event)886 void AudioPolicyServerHandler::HandleActiveVolumeTypeChangeEvent(const AppExecFwk::InnerEvent::Pointer &event)
887 {
888 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
889 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
890 std::lock_guard<std::mutex> lock(handleMapMutex_);
891 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
892 std::shared_ptr<AudioPolicyClientHolder> activeVolumeTypeChangeListenerCb = it->second;
893 if (activeVolumeTypeChangeListenerCb == nullptr) {
894 AUDIO_ERR_LOG("activeVolumeTypeChangeListenerCb: nullptr for client : %{public}d", it->first);
895 continue;
896 }
897 if (clientCallbacksMap_.count(it->first) > 0 &&
898 clientCallbacksMap_[it->first].count(CALLBACK_ACTIVE_VOLUME_TYPE_CHANGE) > 0 &&
899 clientCallbacksMap_[it->first][CALLBACK_ACTIVE_VOLUME_TYPE_CHANGE]) {
900 activeVolumeTypeChangeListenerCb->OnActiveVolumeTypeChanged(eventContextObj->volumeType);
901 }
902 }
903 }
904
HandleAppVolumeChangeEvent(const AppExecFwk::InnerEvent::Pointer & event)905 void AudioPolicyServerHandler::HandleAppVolumeChangeEvent(const AppExecFwk::InnerEvent::Pointer &event)
906 {
907 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
908 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
909 std::lock_guard<std::mutex> lock(handleMapMutex_);
910 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
911 std::shared_ptr<AudioPolicyClientHolder> appVolumeChangeListenerCb = it->second;
912 if (appVolumeChangeListenerCb == nullptr) {
913 AUDIO_ERR_LOG("appVolumeChangeListenerCb nullptr for client %{public}d", it->first);
914 continue;
915 }
916
917 AUDIO_INFO_LOG("appVolumeChangeListenerCb client %{public}d :volumeMode %{public}d :appUid%{public}d",
918 it->first, static_cast<int32_t>(eventContextObj->volumeEvent.volumeMode), eventContextObj->appUid);
919 if (clientCallbacksMap_.count(it->first) > 0 &&
920 clientCallbacksMap_[it->first].count(CALLBACK_APP_VOLUME_CHANGE) > 0 &&
921 clientCallbacksMap_[it->first][CALLBACK_APP_VOLUME_CHANGE]) {
922 appVolumeChangeListenerCb->OnAppVolumeChanged(eventContextObj->appUid, eventContextObj->volumeEvent);
923 }
924 if (clientCallbacksMap_.count(it->first) > 0 &&
925 clientCallbacksMap_[it->first].count(CALLBACK_SELF_APP_VOLUME_CHANGE) > 0 &&
926 clientCallbacksMap_[it->first][CALLBACK_SELF_APP_VOLUME_CHANGE]) {
927 appVolumeChangeListenerCb->OnAppVolumeChanged(eventContextObj->appUid, eventContextObj->volumeEvent);
928 }
929 }
930 }
931
HandleRingerModeUpdatedEvent(const AppExecFwk::InnerEvent::Pointer & event)932 void AudioPolicyServerHandler::HandleRingerModeUpdatedEvent(const AppExecFwk::InnerEvent::Pointer &event)
933 {
934 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
935 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
936 std::lock_guard<std::mutex> lock(handleMapMutex_);
937 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
938 std::shared_ptr<AudioPolicyClientHolder> ringerModeListenerCb = it->second;
939 if (ringerModeListenerCb == nullptr) {
940 AUDIO_ERR_LOG("ringerModeListenerCb nullptr for client %{public}d", it->first);
941 continue;
942 }
943
944 AUDIO_INFO_LOG("Trigger ringerModeListenerCb client %{public}d :RingerMode %{public}d", it->first,
945 static_cast<int32_t>(eventContextObj->ringMode));
946 if (clientCallbacksMap_.count(it->first) > 0 &&
947 clientCallbacksMap_[it->first].count(CALLBACK_SET_RINGER_MODE) > 0 &&
948 clientCallbacksMap_[it->first][CALLBACK_SET_RINGER_MODE]) {
949 ringerModeListenerCb->OnRingerModeUpdated(eventContextObj->ringMode);
950 }
951 }
952 }
953
HandleMicStateUpdatedEvent(const AppExecFwk::InnerEvent::Pointer & event)954 void AudioPolicyServerHandler::HandleMicStateUpdatedEvent(const AppExecFwk::InnerEvent::Pointer &event)
955 {
956 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
957 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
958 std::lock_guard<std::mutex> lock(handleMapMutex_);
959 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
960 std::shared_ptr<AudioPolicyClientHolder> micStateChangeListenerCb = it->second;
961 if (micStateChangeListenerCb == nullptr) {
962 AUDIO_ERR_LOG("callback is nullptr for client %{public}d", it->first);
963 continue;
964 }
965 if (clientCallbacksMap_.count(it->first) > 0 &&
966 clientCallbacksMap_[it->first].count(CALLBACK_SET_MIC_STATE_CHANGE) > 0 &&
967 clientCallbacksMap_[it->first][CALLBACK_SET_MIC_STATE_CHANGE]) {
968 micStateChangeListenerCb->OnMicStateUpdated(eventContextObj->micStateChangeEvent);
969 }
970 }
971 }
972
HandleMicStateUpdatedEventWithClientId(const AppExecFwk::InnerEvent::Pointer & event)973 void AudioPolicyServerHandler::HandleMicStateUpdatedEventWithClientId(const AppExecFwk::InnerEvent::Pointer &event)
974 {
975 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
976 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
977 std::lock_guard<std::mutex> lock(handleMapMutex_);
978 int32_t clientId = eventContextObj->clientId;
979 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
980 if (it->first != clientId) {
981 AUDIO_DEBUG_LOG("This client %{public}d is not need to trigger the callback ", it->first);
982 continue;
983 }
984 std::shared_ptr<AudioPolicyClientHolder> micStateChangeListenerCb = it->second;
985 if (micStateChangeListenerCb == nullptr) {
986 AUDIO_ERR_LOG("callback is nullptr for client %{public}d", it->first);
987 continue;
988 }
989 if (clientCallbacksMap_.count(it->first) > 0 &&
990 clientCallbacksMap_[it->first].count(CALLBACK_SET_MIC_STATE_CHANGE) > 0 &&
991 clientCallbacksMap_[it->first][CALLBACK_SET_MIC_STATE_CHANGE]) {
992 micStateChangeListenerCb->OnMicStateUpdated(eventContextObj->micStateChangeEvent);
993 }
994 }
995 }
996
HandleInterruptEvent(const AppExecFwk::InnerEvent::Pointer & event)997 void AudioPolicyServerHandler::HandleInterruptEvent(const AppExecFwk::InnerEvent::Pointer &event)
998 {
999 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
1000 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1001
1002 std::unique_lock<std::mutex> lock(handleMapMutex_);
1003 std::shared_ptr<IAudioInterruptEventDispatcher> dispatcher = interruptEventDispatcher_.lock();
1004 lock.unlock();
1005 if (dispatcher != nullptr) {
1006 dispatcher->DispatchInterruptEventWithStreamId(0, eventContextObj->interruptEvent);
1007 }
1008 }
1009
HandleInterruptEventWithStreamId(const AppExecFwk::InnerEvent::Pointer & event)1010 void AudioPolicyServerHandler::HandleInterruptEventWithStreamId(const AppExecFwk::InnerEvent::Pointer &event)
1011 {
1012 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
1013 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1014
1015 std::unique_lock<std::mutex> lock(handleMapMutex_);
1016 std::shared_ptr<IAudioInterruptEventDispatcher> dispatcher = interruptEventDispatcher_.lock();
1017 lock.unlock();
1018 if (dispatcher != nullptr) {
1019 dispatcher->DispatchInterruptEventWithStreamId(eventContextObj->sessionId,
1020 eventContextObj->interruptEvent);
1021 }
1022 }
1023
HandleInterruptEventForAudioSession(const AppExecFwk::InnerEvent::Pointer & event)1024 void AudioPolicyServerHandler::HandleInterruptEventForAudioSession(const AppExecFwk::InnerEvent::Pointer &event)
1025 {
1026 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
1027 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1028 std::lock_guard<std::mutex> lock(handleMapMutex_);
1029 int32_t clientPid = eventContextObj->audioInterrupt.pid;
1030 auto iterator = audioPolicyClientProxyAPSCbsMap_.find(clientPid);
1031 if (iterator == audioPolicyClientProxyAPSCbsMap_.end()) {
1032 AUDIO_ERR_LOG("No client callback for client pid %{public}d", clientPid);
1033 return;
1034 }
1035
1036 InterruptHint hintType = eventContextObj->interruptEvent.hintType;
1037 AudioSessionStateChangedEvent stateChangedEvent;
1038 switch (hintType) {
1039 case INTERRUPT_HINT_RESUME:
1040 stateChangedEvent.stateChangeHint = AudioSessionStateChangeHint::RESUME;
1041 break;
1042 case INTERRUPT_HINT_PAUSE:
1043 stateChangedEvent.stateChangeHint = AudioSessionStateChangeHint::PAUSE;
1044 break;
1045 case INTERRUPT_HINT_STOP:
1046 // duckVolume = -1.0f, means timeout stop
1047 if (eventContextObj->interruptEvent.duckVolume == -1.0f) {
1048 eventContextObj->interruptEvent.duckVolume = 1.0f;
1049 stateChangedEvent.stateChangeHint = AudioSessionStateChangeHint::TIME_OUT_STOP;
1050 } else {
1051 stateChangedEvent.stateChangeHint = AudioSessionStateChangeHint::STOP;
1052 }
1053 break;
1054 case INTERRUPT_HINT_DUCK:
1055 stateChangedEvent.stateChangeHint = AudioSessionStateChangeHint::DUCK;
1056 break;
1057 case INTERRUPT_HINT_UNDUCK:
1058 stateChangedEvent.stateChangeHint = AudioSessionStateChangeHint::UNDUCK;
1059 break;
1060 default:
1061 AUDIO_ERR_LOG("Unspported hintType %{public}d", static_cast<int32_t>(hintType));
1062 return;
1063 }
1064
1065 if (clientCallbacksMap_.count(iterator->first) > 0 &&
1066 clientCallbacksMap_[iterator->first].count(CALLBACK_AUDIO_SESSION_STATE) > 0 &&
1067 clientCallbacksMap_[iterator->first][CALLBACK_AUDIO_SESSION_STATE]) {
1068 // the client has registered audio session callback.
1069 std::shared_ptr<AudioPolicyClientHolder> audioSessionCb = iterator->second;
1070 if (audioSessionCb == nullptr) {
1071 AUDIO_ERR_LOG("audioSessionCb is nullptr for client pid %{public}d", clientPid);
1072 return;
1073 }
1074 AUDIO_INFO_LOG("Trigger for client pid : %{public}d", clientPid);
1075 audioSessionCb->OnAudioSessionStateChanged(stateChangedEvent);
1076 } else {
1077 AUDIO_ERR_LOG("No registered callback for pid %{public}d", clientPid);
1078 }
1079 }
1080
HandleInterruptEventWithClientId(const AppExecFwk::InnerEvent::Pointer & event)1081 void AudioPolicyServerHandler::HandleInterruptEventWithClientId(const AppExecFwk::InnerEvent::Pointer &event)
1082 {
1083 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
1084 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1085
1086 std::lock_guard<std::mutex> lock(handleMapMutex_);
1087 std::shared_ptr<AudioInterruptCallback> policyListenerCb = amInterruptCbsMap_[eventContextObj->clientId];
1088 CHECK_AND_RETURN_LOG(policyListenerCb != nullptr, "policyListenerCb get nullptr");
1089 policyListenerCb->OnInterrupt(eventContextObj->interruptEvent);
1090 }
1091
HandlePreferredOutputDeviceUpdated()1092 void AudioPolicyServerHandler::HandlePreferredOutputDeviceUpdated()
1093 {
1094 std::lock_guard<std::mutex> lock(handleMapMutex_);
1095 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
1096 int32_t clientPid = it->first;
1097 std::vector<AudioRendererInfo> rendererInfoList = GetCallbackRendererInfoList(clientPid);
1098 for (auto rendererInfo : rendererInfoList) {
1099 auto deviceDescs = AudioPolicyService::GetAudioPolicyService().
1100 GetPreferredOutputDeviceDescInner(rendererInfo);
1101 if (!(it->second->hasBTPermission_)) {
1102 AudioPolicyService::GetAudioPolicyService().UpdateDescWhenNoBTPermission(deviceDescs);
1103 }
1104 if (clientCallbacksMap_.count(clientPid) > 0 &&
1105 clientCallbacksMap_[clientPid].count(CALLBACK_PREFERRED_OUTPUT_DEVICE_CHANGE) > 0 &&
1106 clientCallbacksMap_[clientPid][CALLBACK_PREFERRED_OUTPUT_DEVICE_CHANGE]) {
1107 CHECK_AND_RETURN_LOG(deviceDescs[0] != nullptr, "device is null.");
1108 AUDIO_INFO_LOG("Send PreferredOutputDevice deviceType[%{public}d] deviceId[%{public}d]" \
1109 "change to clientPid[%{public}d]",
1110 deviceDescs[0]->deviceType_, deviceDescs[0]->deviceId_, clientPid);
1111 it->second->OnPreferredOutputDeviceUpdated(rendererInfo, deviceDescs);
1112 }
1113 }
1114 }
1115 }
1116
HandlePreferredInputDeviceUpdated()1117 void AudioPolicyServerHandler::HandlePreferredInputDeviceUpdated()
1118 {
1119 std::lock_guard<std::mutex> lock(handleMapMutex_);
1120 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
1121 int32_t clientPid = it->first;
1122 std::vector<AudioCapturerInfo> capturerInfoList = GetCallbackCapturerInfoList(clientPid);
1123 for (auto capturerInfo : capturerInfoList) {
1124 auto deviceDescs = AudioPolicyService::GetAudioPolicyService().
1125 GetPreferredInputDeviceDescInner(capturerInfo);
1126 if (!(it->second->hasBTPermission_)) {
1127 AudioPolicyService::GetAudioPolicyService().UpdateDescWhenNoBTPermission(deviceDescs);
1128 }
1129 if (clientCallbacksMap_.count(clientPid) > 0 &&
1130 clientCallbacksMap_[clientPid].count(CALLBACK_PREFERRED_INPUT_DEVICE_CHANGE) > 0 &&
1131 clientCallbacksMap_[clientPid][CALLBACK_PREFERRED_INPUT_DEVICE_CHANGE]) {
1132 it->second->OnPreferredInputDeviceUpdated(capturerInfo, deviceDescs);
1133 }
1134 }
1135 }
1136 }
1137
HandleDistributedRoutingRoleChangeEvent(const AppExecFwk::InnerEvent::Pointer & event)1138 void AudioPolicyServerHandler::HandleDistributedRoutingRoleChangeEvent(const AppExecFwk::InnerEvent::Pointer &event)
1139 {
1140 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
1141 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1142 std::lock_guard<std::mutex> lock(handleMapMutex_);
1143 for (auto it = distributedRoutingRoleChangeCbsMap_.begin(); it != distributedRoutingRoleChangeCbsMap_.end(); it++) {
1144 it->second->OnDistributedRoutingRoleChange(eventContextObj->descriptor, eventContextObj->type);
1145 }
1146 }
1147
HandleAudioSessionDeviceChangeEvent(const AppExecFwk::InnerEvent::Pointer & event)1148 void AudioPolicyServerHandler::HandleAudioSessionDeviceChangeEvent(const AppExecFwk::InnerEvent::Pointer &event)
1149 {
1150 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
1151 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1152 std::unordered_map<int32_t, std::shared_ptr<AudioPolicyClientHolder>> audioPolicyClientProxyAPSCbsMap;
1153 std::unordered_map<int32_t, std::unordered_map<CallbackChange, bool>> clientCallbacksMap;
1154
1155 {
1156 std::lock_guard<std::mutex> lock(handleMapMutex_);
1157 audioPolicyClientProxyAPSCbsMap = audioPolicyClientProxyAPSCbsMap_;
1158 clientCallbacksMap = clientCallbacksMap_;
1159 }
1160
1161 std::shared_ptr<AudioSession> audioSession = nullptr;
1162 for (auto it = audioPolicyClientProxyAPSCbsMap.begin(); it != audioPolicyClientProxyAPSCbsMap.end(); ++it) {
1163 if ((eventContextObj->callerPid_ != -1) && (it->first != eventContextObj->callerPid_)) {
1164 AUDIO_INFO_LOG("current callerPid is %{public}d, not %{public}d", it->first, eventContextObj->callerPid_);
1165 continue;
1166 }
1167
1168 std::shared_ptr<AudioPolicyClientHolder> sessionDeviceChangeCb = it->second;
1169 if (sessionDeviceChangeCb == nullptr) {
1170 AUDIO_ERR_LOG("sessionDeviceChangeCb : nullptr for client : %{public}d", it->first);
1171 continue;
1172 }
1173
1174 if ((clientCallbacksMap.count(it->first) > 0) &&
1175 (clientCallbacksMap[it->first].count(CALLBACK_AUDIO_SESSION_DEVICE) > 0) &&
1176 (clientCallbacksMap[it->first][CALLBACK_AUDIO_SESSION_DEVICE])) {
1177 std::shared_ptr<AudioSessionService> audioSessionService = AudioSessionService::GetAudioSessionService();
1178 audioSession = audioSessionService->GetAudioSessionByPid(it->first);
1179 if ((audioSession == nullptr) || (!audioSession->IsActivated())) {
1180 continue;
1181 }
1182
1183 CurrentOutputDeviceChangedEvent deviceChangedEvent;
1184 AudioRendererInfo rendererInfo;
1185 rendererInfo.streamUsage = audioSession->GetSessionStreamUsage();
1186 deviceChangedEvent.devices = AudioCoreService::GetCoreService()->GetEventEntry()->
1187 GetPreferredOutputDeviceDescriptors(rendererInfo);
1188
1189 CHECK_AND_CONTINUE_LOG((deviceChangedEvent.devices.size() > 0) &&
1190 (deviceChangedEvent.devices[0] != nullptr), "get invalid preferred output devices list");
1191 CHECK_AND_CONTINUE_LOG((!audioSession->IsSessionOutputDeviceChanged(deviceChangedEvent.devices[0]) ||
1192 (eventContextObj->reason_ == AudioStreamDeviceChangeReason::AUDIO_SESSION_ACTIVATE)),
1193 "device of session %{public}d is not changed", it->first);
1194
1195 deviceChangedEvent.changeReason = eventContextObj->reason_;
1196 deviceChangedEvent.recommendedAction = audioSession->IsRecommendToStopAudio(eventContextObj) ?
1197 OutputDeviceChangeRecommendedAction::RECOMMEND_TO_STOP :
1198 OutputDeviceChangeRecommendedAction::RECOMMEND_TO_CONTINUE;
1199
1200 sessionDeviceChangeCb->OnAudioSessionCurrentDeviceChanged(deviceChangedEvent);
1201 }
1202 }
1203 }
1204
HandleRendererInfoEvent(const AppExecFwk::InnerEvent::Pointer & event)1205 void AudioPolicyServerHandler::HandleRendererInfoEvent(const AppExecFwk::InnerEvent::Pointer &event)
1206 {
1207 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
1208 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1209 std::lock_guard<std::mutex> lock(handleMapMutex_);
1210 Trace trace("AudioPolicyServerHandler::HandleRendererInfoEvent");
1211 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
1212 Trace traceFor("for pid:" + std::to_string(it->first));
1213 std::shared_ptr<AudioPolicyClientHolder> rendererStateChangeCb = it->second;
1214 if (rendererStateChangeCb == nullptr) {
1215 AUDIO_ERR_LOG("rendererStateChangeCb : nullptr for client : %{public}d", it->first);
1216 continue;
1217 }
1218 if (clientCallbacksMap_.count(it->first) > 0 &&
1219 clientCallbacksMap_[it->first].count(CALLBACK_RENDERER_STATE_CHANGE) > 0 &&
1220 clientCallbacksMap_[it->first][CALLBACK_RENDERER_STATE_CHANGE]) {
1221 Trace traceCallback("rendererStateChangeCb->OnRendererStateChange");
1222 rendererStateChangeCb->OnRendererStateChange(eventContextObj->audioRendererChangeInfos);
1223 }
1224 }
1225 AUDIO_INFO_LOG("pids: %{public}s size: %{public}zu", pidsStrForPrinting_.c_str(),
1226 audioPolicyClientProxyAPSCbsMap_.size());
1227 }
1228
HandleCapturerInfoEvent(const AppExecFwk::InnerEvent::Pointer & event)1229 void AudioPolicyServerHandler::HandleCapturerInfoEvent(const AppExecFwk::InnerEvent::Pointer &event)
1230 {
1231 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
1232 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1233 std::lock_guard<std::mutex> lock(handleMapMutex_);
1234 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
1235 std::shared_ptr<AudioPolicyClientHolder> capturerStateChangeCb = it->second;
1236 if (capturerStateChangeCb == nullptr) {
1237 AUDIO_ERR_LOG("capturerStateChangeCb : nullptr for client : %{public}d", it->first);
1238 continue;
1239 }
1240 if (clientCallbacksMap_.count(it->first) > 0 &&
1241 clientCallbacksMap_[it->first].count(CALLBACK_CAPTURER_STATE_CHANGE) > 0 &&
1242 clientCallbacksMap_[it->first][CALLBACK_CAPTURER_STATE_CHANGE]) {
1243 capturerStateChangeCb->OnCapturerStateChange(eventContextObj->audioCapturerChangeInfos);
1244 }
1245 }
1246 }
1247
HandleRendererDeviceChangeEvent(const AppExecFwk::InnerEvent::Pointer & event)1248 void AudioPolicyServerHandler::HandleRendererDeviceChangeEvent(const AppExecFwk::InnerEvent::Pointer &event)
1249 {
1250 std::shared_ptr<RendererDeviceChangeEvent> eventContextObj = event->GetSharedObject<RendererDeviceChangeEvent>();
1251 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1252 const auto &[pid, sessionId, outputDeviceInfo, reason] = *eventContextObj;
1253 Trace trace("AudioPolicyServerHandler::HandleRendererDeviceChangeEvent pid:" + std::to_string(pid));
1254 std::lock_guard<std::mutex> lock(handleMapMutex_);
1255 if (audioPolicyClientProxyAPSCbsMap_.count(pid) == 0) {
1256 return;
1257 }
1258 std::shared_ptr<AudioPolicyClientHolder> capturerStateChangeCb = audioPolicyClientProxyAPSCbsMap_.at(pid);
1259 if (capturerStateChangeCb == nullptr) {
1260 AUDIO_ERR_LOG("capturerStateChangeCb : nullptr for client : %{public}" PRId32 "", pid);
1261 return;
1262 }
1263 Trace traceCallback("capturerStateChangeCb->OnRendererDeviceChange sessionId:" + std::to_string(sessionId));
1264 if (clientCallbacksMap_.count(pid) > 0 &&
1265 clientCallbacksMap_[pid].count(CALLBACK_DEVICE_CHANGE_WITH_INFO) > 0 &&
1266 clientCallbacksMap_[pid][CALLBACK_DEVICE_CHANGE_WITH_INFO]) {
1267 capturerStateChangeCb->OnRendererDeviceChange(sessionId, outputDeviceInfo, reason);
1268 }
1269 }
1270
HandleCapturerCreateEvent(const AppExecFwk::InnerEvent::Pointer & event)1271 void AudioPolicyServerHandler::HandleCapturerCreateEvent(const AppExecFwk::InnerEvent::Pointer &event)
1272 {
1273 std::shared_ptr<CapturerCreateEvent> eventContextObj = event->GetSharedObject<CapturerCreateEvent>();
1274 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1275
1276 uint64_t sessionId = eventContextObj->sessionId_;
1277 SessionInfo sessionInfo{eventContextObj->capturerInfo_.sourceType, eventContextObj->streamInfo_.samplingRate,
1278 eventContextObj->streamInfo_.channels};
1279
1280 eventContextObj->error_ = AudioCoreService::GetCoreService()->GetEventEntry()->OnCapturerSessionAdded(sessionId,
1281 sessionInfo, eventContextObj->streamInfo_);
1282 }
1283
HandleCapturerRemovedEvent(const AppExecFwk::InnerEvent::Pointer & event)1284 void AudioPolicyServerHandler::HandleCapturerRemovedEvent(const AppExecFwk::InnerEvent::Pointer &event)
1285 {
1286 std::shared_ptr<uint64_t> eventContextObj = event->GetSharedObject<uint64_t>();
1287 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1288
1289 uint64_t sessionId = *eventContextObj;
1290
1291 AudioCoreService::GetCoreService()->GetEventEntry()->OnCapturerSessionRemoved(sessionId);
1292 }
1293
HandleWakeupCloseEvent(const AppExecFwk::InnerEvent::Pointer & event)1294 void AudioPolicyServerHandler::HandleWakeupCloseEvent(const AppExecFwk::InnerEvent::Pointer &event)
1295 {
1296 AudioCoreService::GetCoreService()->GetEventEntry()->CloseWakeUpAudioCapturer();
1297 }
1298
HandleSendRecreateRendererStreamEvent(const AppExecFwk::InnerEvent::Pointer & event)1299 void AudioPolicyServerHandler::HandleSendRecreateRendererStreamEvent(const AppExecFwk::InnerEvent::Pointer &event)
1300 {
1301 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
1302 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1303 std::lock_guard<std::mutex> lock(handleMapMutex_);
1304 RestoreInfo restoreInfo;
1305 restoreInfo.restoreReason = DEVICE_CHANGED;
1306 restoreInfo.deviceChangeReason = static_cast<int32_t>(eventContextObj->reason_);
1307 restoreInfo.routeFlag = static_cast<uint32_t>(eventContextObj->routeFlag);
1308 AudioPolicyService::GetAudioPolicyService().RestoreSession(eventContextObj->sessionId, restoreInfo);
1309 }
1310
HandleSendRecreateCapturerStreamEvent(const AppExecFwk::InnerEvent::Pointer & event)1311 void AudioPolicyServerHandler::HandleSendRecreateCapturerStreamEvent(const AppExecFwk::InnerEvent::Pointer &event)
1312 {
1313 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
1314 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1315 std::lock_guard<std::mutex> lock(handleMapMutex_);
1316 RestoreInfo restoreInfo;
1317 restoreInfo.restoreReason = DEVICE_CHANGED;
1318 restoreInfo.deviceChangeReason = static_cast<int32_t>(eventContextObj->reason_);
1319 restoreInfo.routeFlag = static_cast<uint32_t>(eventContextObj->routeFlag);
1320 AudioPolicyService::GetAudioPolicyService().RestoreSession(eventContextObj->sessionId, restoreInfo);
1321 }
1322
HandleNnStateChangeEvent(const AppExecFwk::InnerEvent::Pointer & event)1323 void AudioPolicyServerHandler::HandleNnStateChangeEvent(const AppExecFwk::InnerEvent::Pointer &event)
1324 {
1325 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
1326 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1327 std::lock_guard<std::mutex> lock(handleMapMutex_);
1328 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
1329 std::shared_ptr<AudioPolicyClientHolder> nnStateChangeCb = it->second;
1330 if (nnStateChangeCb == nullptr) {
1331 AUDIO_ERR_LOG("nnStateChangeCb : nullptr for client : %{public}d", it->first);
1332 continue;
1333 }
1334 if (clientCallbacksMap_.count(it->first) > 0 &&
1335 clientCallbacksMap_[it->first].count(CALLBACK_NN_STATE_CHANGE) > 0 &&
1336 clientCallbacksMap_[it->first][CALLBACK_NN_STATE_CHANGE]) {
1337 nnStateChangeCb->OnNnStateChange(eventContextObj->nnState);
1338 }
1339 }
1340 }
1341
HandleHeadTrackingDeviceChangeEvent(const AppExecFwk::InnerEvent::Pointer & event)1342 void AudioPolicyServerHandler::HandleHeadTrackingDeviceChangeEvent(const AppExecFwk::InnerEvent::Pointer &event)
1343 {
1344 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
1345 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1346 std::lock_guard<std::mutex> lock(handleMapMutex_);
1347 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
1348 std::shared_ptr<AudioPolicyClientHolder> headTrackingDeviceChangeCb = it->second;
1349 if (headTrackingDeviceChangeCb == nullptr) {
1350 AUDIO_ERR_LOG("headTrackingDeviceChangeCb : nullptr for client : %{public}d", it->first);
1351 continue;
1352 }
1353 if (clientCallbacksMap_.count(it->first) > 0 &&
1354 clientCallbacksMap_[it->first].count(CALLBACK_HEAD_TRACKING_DATA_REQUESTED_CHANGE) > 0 &&
1355 clientCallbacksMap_[it->first][CALLBACK_HEAD_TRACKING_DATA_REQUESTED_CHANGE]) {
1356 headTrackingDeviceChangeCb->OnHeadTrackingDeviceChange(eventContextObj->headTrackingDeviceChangeInfo);
1357 }
1358 }
1359 }
1360
HandleSpatializatonEnabledChangeEvent(const AppExecFwk::InnerEvent::Pointer & event)1361 void AudioPolicyServerHandler::HandleSpatializatonEnabledChangeEvent(const AppExecFwk::InnerEvent::Pointer &event)
1362 {
1363 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
1364 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1365 std::lock_guard<std::mutex> lock(handleMapMutex_);
1366 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
1367 std::shared_ptr<AudioPolicyClientHolder> spatializationEnabledChangeCb = it->second;
1368 if (spatializationEnabledChangeCb == nullptr) {
1369 AUDIO_ERR_LOG("spatializationEnabledChangeCb : nullptr for client : %{public}d", it->first);
1370 continue;
1371 }
1372 if (clientCallbacksMap_.count(it->first) > 0 &&
1373 clientCallbacksMap_[it->first].count(CALLBACK_SPATIALIZATION_ENABLED_CHANGE) > 0 &&
1374 clientCallbacksMap_[it->first][CALLBACK_SPATIALIZATION_ENABLED_CHANGE]) {
1375 spatializationEnabledChangeCb->OnSpatializationEnabledChange(eventContextObj->spatializationEnabled);
1376 }
1377 }
1378 }
1379
HandleSpatializatonEnabledChangeForAnyDeviceEvent(const AppExecFwk::InnerEvent::Pointer & event)1380 void AudioPolicyServerHandler::HandleSpatializatonEnabledChangeForAnyDeviceEvent(
1381 const AppExecFwk::InnerEvent::Pointer &event)
1382 {
1383 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
1384 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1385 std::lock_guard<std::mutex> lock(handleMapMutex_);
1386 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
1387 std::shared_ptr<AudioPolicyClientHolder> spatializationEnabledChangeCb = it->second;
1388 if (spatializationEnabledChangeCb == nullptr) {
1389 AUDIO_ERR_LOG("spatializationEnabledChangeCb : nullptr for client : %{public}d", it->first);
1390 continue;
1391 }
1392 if (clientCallbacksMap_.count(it->first) > 0 &&
1393 clientCallbacksMap_[it->first].count(CALLBACK_SPATIALIZATION_ENABLED_CHANGE) > 0 &&
1394 clientCallbacksMap_[it->first][CALLBACK_SPATIALIZATION_ENABLED_CHANGE]) {
1395 spatializationEnabledChangeCb->OnSpatializationEnabledChangeForAnyDevice(eventContextObj->descriptor,
1396 eventContextObj->spatializationEnabled);
1397 }
1398 }
1399 }
1400
HandleSpatializatonEnabledChangeForCurrentDeviceEvent(const AppExecFwk::InnerEvent::Pointer & event)1401 void AudioPolicyServerHandler::HandleSpatializatonEnabledChangeForCurrentDeviceEvent(
1402 const AppExecFwk::InnerEvent::Pointer &event)
1403 {
1404 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
1405 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1406 std::lock_guard<std::mutex> lock(handleMapMutex_);
1407 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
1408 std::shared_ptr<AudioPolicyClientHolder> spatializationEnabledChangeForCurrentDeviceCb = it->second;
1409 if (spatializationEnabledChangeForCurrentDeviceCb == nullptr) {
1410 AUDIO_ERR_LOG("spatializationEnabledChangeForCurrentDeviceCb : nullptr for client : %{public}d", it->first);
1411 continue;
1412 }
1413 if (clientCallbacksMap_.count(it->first) > 0 &&
1414 clientCallbacksMap_[it->first].count(CALLBACK_SPATIALIZATION_ENABLED_CHANGE_FOR_CURRENT_DEVICE) > 0 &&
1415 clientCallbacksMap_[it->first][CALLBACK_SPATIALIZATION_ENABLED_CHANGE_FOR_CURRENT_DEVICE]) {
1416 spatializationEnabledChangeForCurrentDeviceCb->OnSpatializationEnabledChangeForCurrentDevice(
1417 eventContextObj->spatializationEnabled);
1418 }
1419 }
1420 }
1421
HandleHeadTrackingEnabledChangeEvent(const AppExecFwk::InnerEvent::Pointer & event)1422 void AudioPolicyServerHandler::HandleHeadTrackingEnabledChangeEvent(const AppExecFwk::InnerEvent::Pointer &event)
1423 {
1424 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
1425 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1426 std::lock_guard<std::mutex> lock(handleMapMutex_);
1427 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
1428 std::shared_ptr<AudioPolicyClientHolder> headTrackingEnabledChangeCb = it->second;
1429 if (headTrackingEnabledChangeCb == nullptr) {
1430 AUDIO_ERR_LOG("headTrackingEnabledChangeCb : nullptr for client : %{public}d", it->first);
1431 continue;
1432 }
1433 if (clientCallbacksMap_.count(it->first) > 0 &&
1434 clientCallbacksMap_[it->first].count(CALLBACK_HEAD_TRACKING_ENABLED_CHANGE) > 0 &&
1435 clientCallbacksMap_[it->first][CALLBACK_HEAD_TRACKING_ENABLED_CHANGE]) {
1436 headTrackingEnabledChangeCb->OnHeadTrackingEnabledChange(eventContextObj->headTrackingEnabled);
1437 }
1438 }
1439 }
1440
HandleAudioSceneChange(const AppExecFwk::InnerEvent::Pointer & event)1441 void AudioPolicyServerHandler::HandleAudioSceneChange(const AppExecFwk::InnerEvent::Pointer &event)
1442 {
1443 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
1444 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1445 std::lock_guard<std::mutex> lock(handleMapMutex_);
1446 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
1447 std::shared_ptr<AudioPolicyClientHolder> audioSceneChangeCb = it->second;
1448 if (audioSceneChangeCb == nullptr) {
1449 AUDIO_ERR_LOG("audioSceneChangeCb : nullptr for client : %{public}d", it->first);
1450 continue;
1451 }
1452 if (clientCallbacksMap_.count(it->first) > 0 &&
1453 clientCallbacksMap_[it->first].count(CALLBACK_SET_AUDIO_SCENE_CHANGE) > 0 &&
1454 clientCallbacksMap_[it->first][CALLBACK_SET_AUDIO_SCENE_CHANGE]) {
1455 audioSceneChangeCb->OnAudioSceneChange(eventContextObj->audioScene);
1456 }
1457 }
1458 }
1459
HandleHeadTrackingEnabledChangeForAnyDeviceEvent(const AppExecFwk::InnerEvent::Pointer & event)1460 void AudioPolicyServerHandler::HandleHeadTrackingEnabledChangeForAnyDeviceEvent(
1461 const AppExecFwk::InnerEvent::Pointer &event)
1462 {
1463 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
1464 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1465 std::lock_guard<std::mutex> lock(handleMapMutex_);
1466 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
1467 std::shared_ptr<AudioPolicyClientHolder> headTrackingEnabledChangeCb = it->second;
1468 if (headTrackingEnabledChangeCb == nullptr) {
1469 AUDIO_ERR_LOG("headTrackingEnabledChangeCb : nullptr for client : %{public}d", it->first);
1470 continue;
1471 }
1472 if (clientCallbacksMap_.count(it->first) > 0 &&
1473 clientCallbacksMap_[it->first].count(CALLBACK_HEAD_TRACKING_ENABLED_CHANGE) > 0 &&
1474 clientCallbacksMap_[it->first][CALLBACK_HEAD_TRACKING_ENABLED_CHANGE]) {
1475 headTrackingEnabledChangeCb->OnHeadTrackingEnabledChangeForAnyDevice(eventContextObj->descriptor,
1476 eventContextObj->headTrackingEnabled);
1477 }
1478 }
1479 }
1480
HandlePipeStreamCleanEvent(const AppExecFwk::InnerEvent::Pointer & event)1481 void AudioPolicyServerHandler::HandlePipeStreamCleanEvent(const AppExecFwk::InnerEvent::Pointer &event)
1482 {
1483 std::shared_ptr<int32_t> eventContextObj = event->GetSharedObject<int32_t>();
1484 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1485 AudioPipeType pipeType = static_cast<AudioPipeType>(*eventContextObj);
1486 AudioPolicyService::GetAudioPolicyService().DynamicUnloadModule(pipeType);
1487 }
1488
HandleFormatUnsupportedErrorEvent(const AppExecFwk::InnerEvent::Pointer & event)1489 void AudioPolicyServerHandler::HandleFormatUnsupportedErrorEvent(const AppExecFwk::InnerEvent::Pointer &event)
1490 {
1491 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
1492 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1493 std::lock_guard<std::mutex> lock(handleMapMutex_);
1494 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
1495 std::shared_ptr<AudioPolicyClientHolder> formatUnsupportedErrorCb = it->second;
1496 if (formatUnsupportedErrorCb == nullptr) {
1497 AUDIO_ERR_LOG("formatUnsupportedErrorCb : nullptr for client : %{public}d", it->first);
1498 continue;
1499 }
1500 if (clientCallbacksMap_.count(it->first) > 0 &&
1501 clientCallbacksMap_[it->first].count(CALLBACK_FORMAT_UNSUPPORTED_ERROR) > 0 &&
1502 clientCallbacksMap_[it->first][CALLBACK_FORMAT_UNSUPPORTED_ERROR]) {
1503 formatUnsupportedErrorCb->OnFormatUnsupportedError(eventContextObj->errorCode);
1504 }
1505 }
1506 }
1507
1508 // Run with event-runner mutex hold, lock any mutex that SendSyncEvent-calling holds may cause dead lock.
HandleServiceEvent(const uint32_t & eventId,const AppExecFwk::InnerEvent::Pointer & event)1509 void AudioPolicyServerHandler::HandleServiceEvent(const uint32_t &eventId,
1510 const AppExecFwk::InnerEvent::Pointer &event)
1511 {
1512 HandleOtherServiceEvent(eventId, event);
1513 switch (eventId) {
1514 case EventAudioServerCmd::AUDIO_DEVICE_CHANGE:
1515 HandleDeviceChangedCallback(event);
1516 break;
1517 case EventAudioServerCmd::PREFERRED_OUTPUT_DEVICE_UPDATED:
1518 HandlePreferredOutputDeviceUpdated();
1519 break;
1520 case EventAudioServerCmd::PREFERRED_INPUT_DEVICE_UPDATED:
1521 HandlePreferredInputDeviceUpdated();
1522 break;
1523 case EventAudioServerCmd::AVAILABLE_AUDIO_DEVICE_CHANGE:
1524 HandleAvailableDeviceChange(event);
1525 break;
1526 case EventAudioServerCmd::RENDERER_INFO_EVENT:
1527 HandleRendererInfoEvent(event);
1528 break;
1529 case EventAudioServerCmd::CAPTURER_INFO_EVENT:
1530 HandleCapturerInfoEvent(event);
1531 break;
1532 case EventAudioServerCmd::RENDERER_DEVICE_CHANGE_EVENT:
1533 HandleRendererDeviceChangeEvent(event);
1534 break;
1535 case EventAudioServerCmd::ON_CAPTURER_CREATE:
1536 HandleCapturerCreateEvent(event);
1537 break;
1538 case EventAudioServerCmd::ON_CAPTURER_REMOVED:
1539 HandleCapturerRemovedEvent(event);
1540 break;
1541 case EventAudioServerCmd::ON_WAKEUP_CLOSE:
1542 HandleWakeupCloseEvent(event);
1543 break;
1544 case EventAudioServerCmd::RECREATE_RENDERER_STREAM_EVENT:
1545 HandleSendRecreateRendererStreamEvent(event);
1546 break;
1547 case EventAudioServerCmd::RECREATE_CAPTURER_STREAM_EVENT:
1548 HandleSendRecreateCapturerStreamEvent(event);
1549 break;
1550 case EventAudioServerCmd::PIPE_STREAM_CLEAN_EVENT:
1551 HandlePipeStreamCleanEvent(event);
1552 break;
1553 default:
1554 break;
1555 }
1556 }
1557
HandleOtherServiceEvent(const uint32_t & eventId,const AppExecFwk::InnerEvent::Pointer & event)1558 void AudioPolicyServerHandler::HandleOtherServiceEvent(const uint32_t &eventId,
1559 const AppExecFwk::InnerEvent::Pointer &event)
1560 {
1561 switch (eventId) {
1562 case EventAudioServerCmd::SPATIALIZATION_ENABLED_CHANGE_FOR_ANY_DEVICE:
1563 HandleSpatializatonEnabledChangeForAnyDeviceEvent(event);
1564 break;
1565 case EventAudioServerCmd::HEAD_TRACKING_ENABLED_CHANGE_FOR_ANY_DEVICE:
1566 HandleHeadTrackingEnabledChangeForAnyDeviceEvent(event);
1567 break;
1568 case EventAudioServerCmd::AUDIO_SESSION_DEACTIVE_EVENT:
1569 HandleAudioSessionDeactiveCallback(event);
1570 break;
1571 case EventAudioServerCmd::MICROPHONE_BLOCKED:
1572 HandleMicrophoneBlockedCallback(event);
1573 break;
1574 case EventAudioServerCmd::NN_STATE_CHANGE:
1575 HandleNnStateChangeEvent(event);
1576 break;
1577 case EventAudioServerCmd::AUDIO_ZONE_EVENT:
1578 HandleAudioZoneEvent(event);
1579 break;
1580 case EventAudioServerCmd::AUDIO_SCENE_CHANGE:
1581 HandleAudioSceneChange(event);
1582 break;
1583 case EventAudioServerCmd::SPATIALIZATION_ENABLED_CHANGE_FOR_CURRENT_DEVICE:
1584 HandleSpatializatonEnabledChangeForCurrentDeviceEvent(event);
1585 break;
1586 case EventAudioServerCmd::APP_VOLUME_CHANGE_EVENT:
1587 HandleAppVolumeChangeEvent(event);
1588 break;
1589 case EventAudioServerCmd::ACTIVE_VOLUME_TYPE_CHANGE_EVENT:
1590 HandleActiveVolumeTypeChangeEvent(event);
1591 break;
1592 case EventAudioServerCmd::FORMAT_UNSUPPORTED_ERROR:
1593 HandleFormatUnsupportedErrorEvent(event);
1594 break;
1595 case EventAudioServerCmd::SESSION_DEVICE_CHANGE:
1596 HandleAudioSessionDeviceChangeEvent(event);
1597 break;
1598 default:
1599 break;
1600 }
1601 }
1602
ProcessEvent(const AppExecFwk::InnerEvent::Pointer & event)1603 void AudioPolicyServerHandler::ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event)
1604 {
1605 uint32_t eventId = event->GetInnerEventId();
1606 HandleServiceEvent(eventId, event);
1607 switch (eventId) {
1608 case EventAudioServerCmd::VOLUME_KEY_EVENT:
1609 HandleVolumeKeyEvent(event);
1610 break;
1611 case EventAudioServerCmd::REQUEST_CATEGORY_EVENT:
1612 HandleRequestCateGoryEvent(event);
1613 break;
1614 case EventAudioServerCmd::ABANDON_CATEGORY_EVENT:
1615 HandleAbandonCateGoryEvent(event);
1616 break;
1617 case EventAudioServerCmd::FOCUS_INFOCHANGE:
1618 HandleFocusInfoChangeEvent(event);
1619 break;
1620 case EventAudioServerCmd::RINGER_MODEUPDATE_EVENT:
1621 HandleRingerModeUpdatedEvent(event);
1622 break;
1623 case EventAudioServerCmd::MIC_STATE_CHANGE_EVENT:
1624 HandleMicStateUpdatedEvent(event);
1625 break;
1626 case EventAudioServerCmd::MIC_STATE_CHANGE_EVENT_WITH_CLIENTID:
1627 HandleMicStateUpdatedEventWithClientId(event);
1628 break;
1629 case EventAudioServerCmd::INTERRUPT_EVENT:
1630 HandleInterruptEvent(event);
1631 break;
1632 case EventAudioServerCmd::INTERRUPT_EVENT_WITH_STREAMID:
1633 HandleInterruptEventWithStreamId(event);
1634 break;
1635 case EventAudioServerCmd::INTERRUPT_EVENT_FOR_AUDIO_SESSION:
1636 HandleInterruptEventForAudioSession(event);
1637 break;
1638 case EventAudioServerCmd::INTERRUPT_EVENT_WITH_CLIENTID:
1639 HandleInterruptEventWithClientId(event);
1640 break;
1641 case EventAudioServerCmd::DISTRIBUTED_ROUTING_ROLE_CHANGE:
1642 HandleDistributedRoutingRoleChangeEvent(event);
1643 break;
1644 case EventAudioServerCmd::HEAD_TRACKING_DEVICE_CHANGE:
1645 HandleHeadTrackingDeviceChangeEvent(event);
1646 break;
1647 case EventAudioServerCmd::SPATIALIZATION_ENABLED_CHANGE:
1648 HandleSpatializatonEnabledChangeEvent(event);
1649 break;
1650 case EventAudioServerCmd::HEAD_TRACKING_ENABLED_CHANGE:
1651 HandleHeadTrackingEnabledChangeEvent(event);
1652 break;
1653 default:
1654 break;
1655 }
1656 }
1657
SetClientCallbacksEnable(const CallbackChange & callbackchange,const bool & enable)1658 int32_t AudioPolicyServerHandler::SetClientCallbacksEnable(const CallbackChange &callbackchange, const bool &enable)
1659 {
1660 if (callbackchange <= CALLBACK_UNKNOWN || callbackchange >= CALLBACK_MAX) {
1661 AUDIO_ERR_LOG("Illegal parameter");
1662 return AUDIO_ERR;
1663 }
1664
1665 int32_t clientId = IPCSkeleton::GetCallingPid();
1666 if (IPCSkeleton::GetCallingUid() == RSS_UID) {
1667 pidOfRss_ = clientId;
1668 }
1669 lock_guard<mutex> runnerlock(handleMapMutex_);
1670 clientCallbacksMap_[clientId][callbackchange] = enable;
1671 string str = (enable ? "true" : "false");
1672 AUDIO_INFO_LOG("Set clientId:%{public}d, callbacks:%{public}d, enable:%{public}s",
1673 clientId, callbackchange, str.c_str());
1674 return AUDIO_OK;
1675 }
1676
SetCallbackRendererInfo(const AudioRendererInfo & rendererInfo)1677 int32_t AudioPolicyServerHandler::SetCallbackRendererInfo(const AudioRendererInfo &rendererInfo)
1678 {
1679 int32_t clientPid = IPCSkeleton::GetCallingPid();
1680 lock_guard<mutex> lock(clientCbRendererInfoMapMutex_);
1681 auto &rendererList = clientCbRendererInfoMap_[clientPid];
1682 auto it = std::find_if(rendererList.begin(), rendererList.end(),
1683 [&rendererInfo](const AudioRendererInfo &existingRenderer) {
1684 return existingRenderer.streamUsage == rendererInfo.streamUsage;
1685 });
1686 if (it == rendererList.end()) {
1687 rendererList.push_back(rendererInfo);
1688 }
1689 return AUDIO_OK;
1690 }
1691
GetCallbackRendererInfoList(int32_t clientPid)1692 std::vector<AudioRendererInfo> AudioPolicyServerHandler::GetCallbackRendererInfoList(int32_t clientPid)
1693 {
1694 lock_guard<mutex> lock(clientCbRendererInfoMapMutex_);
1695 auto it = clientCbRendererInfoMap_.find(clientPid);
1696 if (it == clientCbRendererInfoMap_.end()) {
1697 return {};
1698 }
1699 return it->second;
1700 }
1701
SetCallbackCapturerInfo(const AudioCapturerInfo & capturerInfo)1702 int32_t AudioPolicyServerHandler::SetCallbackCapturerInfo(const AudioCapturerInfo &capturerInfo)
1703 {
1704 int32_t clientPid = IPCSkeleton::GetCallingPid();
1705 lock_guard<mutex> lock(clientCbCapturerInfoMapMutex_);
1706 auto &capturerList = clientCbCapturerInfoMap_[clientPid];
1707 auto it = std::find_if(capturerList.begin(), capturerList.end(),
1708 [&capturerInfo](const AudioCapturerInfo &existingCapturer) {
1709 return existingCapturer.sourceType == capturerInfo.sourceType;
1710 });
1711 if (it == capturerList.end()) {
1712 capturerList.push_back(capturerInfo);
1713 }
1714 return AUDIO_OK;
1715 }
1716
GetCallbackCapturerInfoList(int32_t clientPid)1717 std::vector<AudioCapturerInfo> AudioPolicyServerHandler::GetCallbackCapturerInfoList(int32_t clientPid)
1718 {
1719 lock_guard<mutex> lock(clientCbCapturerInfoMapMutex_);
1720 auto it = clientCbCapturerInfoMap_.find(clientPid);
1721 if (it == clientCbCapturerInfoMap_.end()) {
1722 return {};
1723 }
1724 return it->second;
1725 }
1726
SetAudioZoneEventDispatcher(const std::shared_ptr<IAudioZoneEventDispatcher> dispatcher)1727 void AudioPolicyServerHandler::SetAudioZoneEventDispatcher(const std::shared_ptr<IAudioZoneEventDispatcher> dispatcher)
1728 {
1729 audioZoneEventDispatcher_ = dispatcher;
1730 }
1731
SendAudioZoneEvent(std::shared_ptr<AudioZoneEvent> event)1732 bool AudioPolicyServerHandler::SendAudioZoneEvent(std::shared_ptr<AudioZoneEvent> event)
1733 {
1734 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
1735 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
1736 eventContextObj->audioZoneEvent = event;
1737 AUDIO_INFO_LOG("send audio zone event");
1738 lock_guard<mutex> runnerlock(runnerMutex_);
1739 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::AUDIO_ZONE_EVENT,
1740 eventContextObj));
1741 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send audio zone event failed");
1742 return ret;
1743 }
1744
HandleAudioZoneEvent(const AppExecFwk::InnerEvent::Pointer & event)1745 void AudioPolicyServerHandler::HandleAudioZoneEvent(const AppExecFwk::InnerEvent::Pointer &event)
1746 {
1747 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
1748 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1749
1750 std::unique_lock<std::mutex> lock(handleMapMutex_);
1751 std::shared_ptr<IAudioZoneEventDispatcher> dispatcher = audioZoneEventDispatcher_.lock();
1752 lock.unlock();
1753 CHECK_AND_RETURN_LOG(dispatcher != nullptr, "dispatcher is nullptr");
1754 dispatcher->DispatchEvent(eventContextObj->audioZoneEvent);
1755 }
1756
SetCallbackStreamUsageInfo(const std::set<StreamUsage> & streamUsages)1757 int32_t AudioPolicyServerHandler::SetCallbackStreamUsageInfo(const std::set<StreamUsage> &streamUsages)
1758 {
1759 int32_t clientId = IPCSkeleton::GetCallingPid();
1760 AUDIO_INFO_LOG("Set clientId:%{public}d, streamUsages size:%{public}d", clientId, (int32_t)streamUsages.size());
1761 lock_guard<mutex> lock(clientCbStreamUsageMapMutex_);
1762 if (streamUsages.empty() && clientCbStreamUsageMap_.count(clientId)) {
1763 clientCbStreamUsageMap_.erase(clientId);
1764 } else {
1765 clientCbStreamUsageMap_[clientId] = streamUsages;
1766 }
1767 return AUDIO_OK;
1768 }
1769 } // namespace AudioStandard
1770 } // namespace OHOS
1771