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
22 namespace OHOS {
23 namespace AudioStandard {
GeneratePidsStrForPrinting(const std::unordered_map<int32_t,sptr<IAudioPolicyClient>> & unorderedMap)24 static std::string GeneratePidsStrForPrinting(
25 const std::unordered_map<int32_t, sptr<IAudioPolicyClient>> &unorderedMap)
26 {
27 std::string retString = "[";
28 for (const auto &[pid, iAudioPolicyClient] : unorderedMap) {
29 retString += (std::to_string(pid) + ',');
30 }
31 retString += ']';
32 return retString;
33 }
34
AudioPolicyServerHandler()35 AudioPolicyServerHandler::AudioPolicyServerHandler() : AppExecFwk::EventHandler(
36 AppExecFwk::EventRunner::Create("OS_APAsyncRunner", AppExecFwk::ThreadMode::FFRT))
37 {
38 AUDIO_DEBUG_LOG("ctor");
39 }
40
~AudioPolicyServerHandler()41 AudioPolicyServerHandler::~AudioPolicyServerHandler()
42 {
43 AUDIO_WARNING_LOG("dtor should not happen");
44 };
45
Init(std::shared_ptr<IAudioInterruptEventDispatcher> dispatcher)46 void AudioPolicyServerHandler::Init(std::shared_ptr<IAudioInterruptEventDispatcher> dispatcher)
47 {
48 interruptEventDispatcher_ = dispatcher;
49 }
50
AddAudioPolicyClientProxyMap(int32_t clientPid,const sptr<IAudioPolicyClient> & cb)51 void AudioPolicyServerHandler::AddAudioPolicyClientProxyMap(int32_t clientPid, const sptr<IAudioPolicyClient>& cb)
52 {
53 std::lock_guard<std::mutex> lock(handleMapMutex_);
54 auto [it, res] = audioPolicyClientProxyAPSCbsMap_.try_emplace(clientPid, cb);
55 if (!res) {
56 if (cb == it->second) {
57 AUDIO_WARNING_LOG("Duplicate registration");
58 } else {
59 AUDIO_ERR_LOG("client registers multiple callbacks, the callback may be lost.");
60 }
61 }
62 pidsStrForPrinting_ = GeneratePidsStrForPrinting(audioPolicyClientProxyAPSCbsMap_);
63 AUDIO_INFO_LOG("group data num [%{public}zu] pid [%{public}d] map %{public}s",
64 audioPolicyClientProxyAPSCbsMap_.size(), clientPid, pidsStrForPrinting_.c_str());
65 }
66
RemoveAudioPolicyClientProxyMap(pid_t clientPid)67 void AudioPolicyServerHandler::RemoveAudioPolicyClientProxyMap(pid_t clientPid)
68 {
69 std::lock_guard<std::mutex> lock(handleMapMutex_);
70 audioPolicyClientProxyAPSCbsMap_.erase(clientPid);
71 clientCallbacksMap_.erase(clientPid);
72 pidsStrForPrinting_ = GeneratePidsStrForPrinting(audioPolicyClientProxyAPSCbsMap_);
73 AUDIO_INFO_LOG("RemoveAudioPolicyClientProxyMap, group data num [%{public}zu] map %{public}s",
74 audioPolicyClientProxyAPSCbsMap_.size(), pidsStrForPrinting_.c_str());
75 }
76
AddExternInterruptCbsMap(int32_t clientId,const std::shared_ptr<AudioInterruptCallback> & callback)77 void AudioPolicyServerHandler::AddExternInterruptCbsMap(int32_t clientId,
78 const std::shared_ptr<AudioInterruptCallback> &callback)
79 {
80 std::lock_guard<std::mutex> lock(handleMapMutex_);
81 amInterruptCbsMap_[clientId] = callback;
82 AUDIO_INFO_LOG("AddExternInterruptCbsMap, group data num [%{public}zu]",
83 amInterruptCbsMap_.size());
84 }
85
RemoveExternInterruptCbsMap(int32_t clientId)86 int32_t AudioPolicyServerHandler::RemoveExternInterruptCbsMap(int32_t clientId)
87 {
88 std::lock_guard<std::mutex> lock(handleMapMutex_);
89 if (amInterruptCbsMap_.erase(clientId) == 0) {
90 AUDIO_ERR_LOG("RemoveExternInterruptCbsMap client %{public}d not present", clientId);
91 return ERR_INVALID_OPERATION;
92 }
93 return SUCCESS;
94 }
95
AddAvailableDeviceChangeMap(int32_t clientId,const AudioDeviceUsage usage,const sptr<IStandardAudioPolicyManagerListener> & callback)96 void AudioPolicyServerHandler::AddAvailableDeviceChangeMap(int32_t clientId, const AudioDeviceUsage usage,
97 const sptr<IStandardAudioPolicyManagerListener> &callback)
98 {
99 std::lock_guard<std::mutex> lock(handleMapMutex_);
100 availableDeviceChangeCbsMap_[{clientId, usage}] = callback;
101 AUDIO_INFO_LOG("AddAvailableDeviceChangeMap, group data num [%{public}zu]", availableDeviceChangeCbsMap_.size());
102 }
103
RemoveAvailableDeviceChangeMap(const int32_t clientId,AudioDeviceUsage usage)104 void AudioPolicyServerHandler::RemoveAvailableDeviceChangeMap(const int32_t clientId, AudioDeviceUsage usage)
105 {
106 std::lock_guard<std::mutex> lock(handleMapMutex_);
107 if (availableDeviceChangeCbsMap_.erase({clientId, usage}) == 0) {
108 AUDIO_INFO_LOG("client not present in %{public}s", __func__);
109 }
110 // for routing manager napi remove all device change callback
111 if (usage == AudioDeviceUsage::D_ALL_DEVICES) {
112 for (auto it = availableDeviceChangeCbsMap_.begin(); it != availableDeviceChangeCbsMap_.end();) {
113 if ((*it).first.first == clientId) {
114 it = availableDeviceChangeCbsMap_.erase(it);
115 } else {
116 it++;
117 }
118 }
119 }
120 AUDIO_INFO_LOG("RemoveAvailableDeviceChangeMap, group data num [%{public}zu]",
121 availableDeviceChangeCbsMap_.size());
122 }
123
AddDistributedRoutingRoleChangeCbsMap(int32_t clientId,const sptr<IStandardAudioRoutingManagerListener> & callback)124 void AudioPolicyServerHandler::AddDistributedRoutingRoleChangeCbsMap(int32_t clientId,
125 const sptr<IStandardAudioRoutingManagerListener> &callback)
126 {
127 std::lock_guard<std::mutex> lock(handleMapMutex_);
128 if (callback != nullptr) {
129 distributedRoutingRoleChangeCbsMap_[clientId] = callback;
130 }
131 AUDIO_DEBUG_LOG("SetDistributedRoutingRoleCallback: distributedRoutingRoleChangeCbsMap_ size: %{public}zu",
132 distributedRoutingRoleChangeCbsMap_.size());
133 }
134
RemoveDistributedRoutingRoleChangeCbsMap(int32_t clientId)135 int32_t AudioPolicyServerHandler::RemoveDistributedRoutingRoleChangeCbsMap(int32_t clientId)
136 {
137 std::lock_guard<std::mutex> lock(handleMapMutex_);
138 if (distributedRoutingRoleChangeCbsMap_.erase(clientId) == 0) {
139 AUDIO_ERR_LOG("RemoveDistributedRoutingRoleChangeCbsMap clientPid %{public}d not present", clientId);
140 return ERR_INVALID_OPERATION;
141 }
142
143 AUDIO_DEBUG_LOG("UnsetDistributedRoutingRoleCallback: distributedRoutingRoleChangeCbsMap_ size: %{public}zu",
144 distributedRoutingRoleChangeCbsMap_.size());
145 return SUCCESS;
146 }
147
AddConcurrencyEventDispatcher(std::shared_ptr<IAudioConcurrencyEventDispatcher> dispatcher)148 void AudioPolicyServerHandler::AddConcurrencyEventDispatcher(
149 std::shared_ptr<IAudioConcurrencyEventDispatcher> dispatcher)
150 {
151 concurrencyEventDispatcher_ = dispatcher;
152 }
153
SendDeviceChangedCallback(const std::vector<std::shared_ptr<AudioDeviceDescriptor>> & desc,bool isConnected)154 bool AudioPolicyServerHandler::SendDeviceChangedCallback(
155 const std::vector<std::shared_ptr<AudioDeviceDescriptor>> &desc, bool isConnected)
156 {
157 Trace trace("AudioPolicyServerHandler::SendDeviceChangedCallback");
158 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
159 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
160 eventContextObj->deviceChangeAction.type = isConnected ? DeviceChangeType::CONNECT : DeviceChangeType::DISCONNECT;
161 eventContextObj->deviceChangeAction.deviceDescriptors = desc;
162
163 lock_guard<mutex> runnerlock(runnerMutex_);
164 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::AUDIO_DEVICE_CHANGE, eventContextObj));
165 CHECK_AND_RETURN_RET_LOG(ret, ret, "SendDeviceChangedCallback event failed");
166 return ret;
167 }
168
SendMicrophoneBlockedCallback(const std::vector<std::shared_ptr<AudioDeviceDescriptor>> & desc,DeviceBlockStatus status)169 bool AudioPolicyServerHandler::SendMicrophoneBlockedCallback(
170 const std::vector<std::shared_ptr<AudioDeviceDescriptor>> &desc, DeviceBlockStatus status)
171 {
172 Trace trace("AudioPolicyServerHandler::SendMicrophoneBlockedCallback");
173 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
174 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
175 eventContextObj->microphoneBlockedInfo.blockStatus = status;
176 eventContextObj->microphoneBlockedInfo.devices = desc;
177
178 lock_guard<mutex> runnerlock(runnerMutex_);
179 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::MICROPHONE_BLOCKED, eventContextObj));
180 CHECK_AND_RETURN_RET_LOG(ret, ret, "SendMicrophoneBlockedCallback event failed");
181 return ret;
182 }
183
SendAvailableDeviceChange(const std::vector<std::shared_ptr<AudioDeviceDescriptor>> & desc,bool isConnected)184 bool AudioPolicyServerHandler::SendAvailableDeviceChange(
185 const std::vector<std::shared_ptr<AudioDeviceDescriptor>> &desc, bool isConnected)
186 {
187 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
188 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
189 eventContextObj->deviceChangeAction.type = isConnected ? DeviceChangeType::CONNECT : DeviceChangeType::DISCONNECT;
190 eventContextObj->deviceChangeAction.deviceDescriptors = desc;
191
192 lock_guard<mutex> runnerlock(runnerMutex_);
193 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::AVAILABLE_AUDIO_DEVICE_CHANGE,
194 eventContextObj));
195 CHECK_AND_RETURN_RET_LOG(ret, ret, "SendAvailableDeviceChange event failed");
196 return ret;
197 }
198
SendVolumeKeyEventCallback(const VolumeEvent & volumeEvent)199 bool AudioPolicyServerHandler::SendVolumeKeyEventCallback(const VolumeEvent &volumeEvent)
200 {
201 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
202 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
203 if (volumeEvent.volumeType == AudioStreamType::STREAM_VOICE_CALL_ASSISTANT) {
204 return false;
205 }
206 eventContextObj->volumeEvent = volumeEvent;
207 lock_guard<mutex> runnerlock(runnerMutex_);
208 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::VOLUME_KEY_EVENT, eventContextObj));
209 CHECK_AND_RETURN_RET_LOG(ret, ret, "SendVolumeKeyEventCallback event failed");
210 return ret;
211 }
212
SendAudioSessionDeactiveCallback(const std::pair<int32_t,AudioSessionDeactiveEvent> & sessionDeactivePair)213 bool AudioPolicyServerHandler::SendAudioSessionDeactiveCallback(
214 const std::pair<int32_t, AudioSessionDeactiveEvent> &sessionDeactivePair)
215 {
216 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
217 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
218 eventContextObj->sessionDeactivePair = sessionDeactivePair;
219 lock_guard<mutex> runnerlock(runnerMutex_);
220 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::AUDIO_SESSION_DEACTIVE_EVENT,
221 eventContextObj));
222 CHECK_AND_RETURN_RET_LOG(ret, ret, "SendAudioSessionDeactiveCallback event failed");
223 return ret;
224 }
225
SendAudioFocusInfoChangeCallback(int32_t callbackCategory,const AudioInterrupt & audioInterrupt,const std::list<std::pair<AudioInterrupt,AudioFocuState>> & focusInfoList)226 bool AudioPolicyServerHandler::SendAudioFocusInfoChangeCallback(int32_t callbackCategory,
227 const AudioInterrupt &audioInterrupt, const std::list<std::pair<AudioInterrupt, AudioFocuState>> &focusInfoList)
228 {
229 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
230 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
231 eventContextObj->audioInterrupt = audioInterrupt;
232 eventContextObj->focusInfoList = focusInfoList;
233 bool ret = false;
234
235 lock_guard<mutex> runnerlock(runnerMutex_);
236 if (callbackCategory == FocusCallbackCategory::REQUEST_CALLBACK_CATEGORY) {
237 ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::REQUEST_CATEGORY_EVENT, eventContextObj));
238 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send REQUEST_CATEGORY_EVENT event failed");
239 } else if (callbackCategory == FocusCallbackCategory::ABANDON_CALLBACK_CATEGORY) {
240 ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::ABANDON_CATEGORY_EVENT, eventContextObj));
241 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send ABANDON_CATEGORY_EVENT event failed");
242 }
243 ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::FOCUS_INFOCHANGE, eventContextObj));
244 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send FOCUS_INFOCHANGE event failed");
245
246 return ret;
247 }
248
SendRingerModeUpdatedCallback(const AudioRingerMode & ringMode)249 bool AudioPolicyServerHandler::SendRingerModeUpdatedCallback(const AudioRingerMode &ringMode)
250 {
251 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
252 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
253 eventContextObj->ringMode = ringMode;
254 lock_guard<mutex> runnerlock(runnerMutex_);
255 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::RINGER_MODEUPDATE_EVENT, eventContextObj));
256 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send RINGER_MODEUPDATE_EVENT event failed");
257 return ret;
258 }
259
SendAppVolumeChangeCallback(int32_t appUid,const VolumeEvent & volumeEvent)260 bool AudioPolicyServerHandler::SendAppVolumeChangeCallback(int32_t appUid, const VolumeEvent &volumeEvent)
261 {
262 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
263 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
264 eventContextObj->appUid = appUid;
265 eventContextObj->volumeEvent = volumeEvent;
266 lock_guard<mutex> runnerlock(runnerMutex_);
267 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::APP_VOLUME_CHANGE_EVENT,
268 eventContextObj));
269 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send RINGER_MODEUPDATE_EVENT event failed");
270 return ret;
271 }
272
SendMicStateUpdatedCallback(const MicStateChangeEvent & micStateChangeEvent)273 bool AudioPolicyServerHandler::SendMicStateUpdatedCallback(const MicStateChangeEvent &micStateChangeEvent)
274 {
275 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
276 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
277 eventContextObj->micStateChangeEvent = micStateChangeEvent;
278 lock_guard<mutex> runnerlock(runnerMutex_);
279 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::MIC_STATE_CHANGE_EVENT, eventContextObj));
280 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send MIC_STATE_CHANGE_EVENT event failed");
281 return ret;
282 }
283
SendMicStateWithClientIdCallback(const MicStateChangeEvent & micStateChangeEvent,int32_t clientId)284 bool AudioPolicyServerHandler::SendMicStateWithClientIdCallback(const MicStateChangeEvent &micStateChangeEvent,
285 int32_t clientId)
286 {
287 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
288 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
289 eventContextObj->micStateChangeEvent = micStateChangeEvent;
290 eventContextObj->clientId = clientId;
291 lock_guard<mutex> runnerlock(runnerMutex_);
292 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::MIC_STATE_CHANGE_EVENT_WITH_CLIENTID,
293 eventContextObj));
294 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send MIC_STATE_CHANGE_EVENT_WITH_CLIENTID event failed");
295 return ret;
296 }
297
SendInterruptEventInternalCallback(const InterruptEventInternal & interruptEvent)298 bool AudioPolicyServerHandler::SendInterruptEventInternalCallback(const InterruptEventInternal &interruptEvent)
299 {
300 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
301 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
302 eventContextObj->interruptEvent = interruptEvent;
303 lock_guard<mutex> runnerlock(runnerMutex_);
304 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::INTERRUPT_EVENT, eventContextObj));
305 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send INTERRUPT_EVENT event failed");
306 return ret;
307 }
308
SendInterruptEventWithStreamIdCallback(const InterruptEventInternal & interruptEvent,const uint32_t & streamId)309 bool AudioPolicyServerHandler::SendInterruptEventWithStreamIdCallback(const InterruptEventInternal &interruptEvent,
310 const uint32_t &streamId)
311 {
312 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
313 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
314 eventContextObj->interruptEvent = interruptEvent;
315 eventContextObj->sessionId = streamId;
316 lock_guard<mutex> runnerlock(runnerMutex_);
317 AUDIO_INFO_LOG("Send interrupt event with streamId callback");
318 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::INTERRUPT_EVENT_WITH_STREAMID,
319 eventContextObj));
320 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send INTERRUPT_EVENT_WITH_STREAMID event failed");
321 return ret;
322 }
323
SendInterruptEventWithClientIdCallback(const InterruptEventInternal & interruptEvent,const int32_t & clientId)324 bool AudioPolicyServerHandler::SendInterruptEventWithClientIdCallback(const InterruptEventInternal &interruptEvent,
325 const int32_t &clientId)
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->clientId = clientId;
331 lock_guard<mutex> runnerlock(runnerMutex_);
332 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::INTERRUPT_EVENT_WITH_CLIENTID,
333 eventContextObj));
334 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send INTERRUPT_EVENT_WITH_CLIENTID event failed");
335 return ret;
336 }
337
SendPreferredOutputDeviceUpdated()338 bool AudioPolicyServerHandler::SendPreferredOutputDeviceUpdated()
339 {
340 lock_guard<mutex> runnerlock(runnerMutex_);
341 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::PREFERRED_OUTPUT_DEVICE_UPDATED));
342 CHECK_AND_RETURN_RET_LOG(ret, ret, "SendPreferredOutputDeviceUpdated event failed");
343 return ret;
344 }
345
SendPreferredInputDeviceUpdated()346 bool AudioPolicyServerHandler::SendPreferredInputDeviceUpdated()
347 {
348 lock_guard<mutex> runnerlock(runnerMutex_);
349 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::PREFERRED_INPUT_DEVICE_UPDATED));
350 CHECK_AND_RETURN_RET_LOG(ret, ret, "SendPreferredInputDeviceUpdated event failed");
351 return ret;
352 }
353
SendDistributedRoutingRoleChange(const std::shared_ptr<AudioDeviceDescriptor> descriptor,const CastType & type)354 bool AudioPolicyServerHandler::SendDistributedRoutingRoleChange(
355 const std::shared_ptr<AudioDeviceDescriptor> descriptor, const CastType &type)
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->descriptor = descriptor;
360 eventContextObj->type = type;
361 lock_guard<mutex> runnerlock(runnerMutex_);
362 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::DISTRIBUTED_ROUTING_ROLE_CHANGE,
363 eventContextObj));
364 CHECK_AND_RETURN_RET_LOG(ret, ret, "SendDistributedRoutingRoleChange event failed");
365 return ret;
366 }
367
SendRendererInfoEvent(const std::vector<std::shared_ptr<AudioRendererChangeInfo>> & audioRendererChangeInfos)368 bool AudioPolicyServerHandler::SendRendererInfoEvent(
369 const std::vector<std::shared_ptr<AudioRendererChangeInfo>> &audioRendererChangeInfos)
370 {
371 std::vector<std::shared_ptr<AudioRendererChangeInfo>> rendererChangeInfos;
372 for (const auto &changeInfo : audioRendererChangeInfos) {
373 rendererChangeInfos.push_back(std::make_shared<AudioRendererChangeInfo>(*changeInfo));
374 }
375
376 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
377 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
378 eventContextObj->audioRendererChangeInfos = move(rendererChangeInfos);
379
380 lock_guard<mutex> runnerlock(runnerMutex_);
381 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::RENDERER_INFO_EVENT,
382 eventContextObj));
383 CHECK_AND_RETURN_RET_LOG(ret, ret, "SendRendererInfoEvent event failed");
384 return ret;
385 }
386
SendCapturerInfoEvent(const std::vector<std::shared_ptr<AudioCapturerChangeInfo>> & audioCapturerChangeInfos)387 bool AudioPolicyServerHandler::SendCapturerInfoEvent(
388 const std::vector<std::shared_ptr<AudioCapturerChangeInfo>> &audioCapturerChangeInfos)
389 {
390 std::vector<std::shared_ptr<AudioCapturerChangeInfo>> capturerChangeInfos;
391 for (const auto &changeInfo : audioCapturerChangeInfos) {
392 capturerChangeInfos.push_back(std::make_shared<AudioCapturerChangeInfo>(*changeInfo));
393 }
394
395 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
396 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
397 eventContextObj->audioCapturerChangeInfos = move(capturerChangeInfos);
398
399 lock_guard<mutex> runnerlock(runnerMutex_);
400 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::CAPTURER_INFO_EVENT,
401 eventContextObj));
402 CHECK_AND_RETURN_RET_LOG(ret, ret, "SendRendererInfoEvent event failed");
403 return ret;
404 }
405
SendRendererDeviceChangeEvent(const int32_t clientPid,const uint32_t sessionId,const AudioDeviceDescriptor & outputDeviceInfo,const AudioStreamDeviceChangeReasonExt reason)406 bool AudioPolicyServerHandler::SendRendererDeviceChangeEvent(const int32_t clientPid, const uint32_t sessionId,
407 const AudioDeviceDescriptor &outputDeviceInfo, const AudioStreamDeviceChangeReasonExt reason)
408 {
409 std::shared_ptr<RendererDeviceChangeEvent> eventContextObj = std::make_shared<RendererDeviceChangeEvent>(
410 clientPid, sessionId, outputDeviceInfo, reason);
411 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
412
413 lock_guard<mutex> runnerlock(runnerMutex_);
414 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::RENDERER_DEVICE_CHANGE_EVENT,
415 eventContextObj));
416 CHECK_AND_RETURN_RET_LOG(ret, ret, "SendRendererDeviceChangeEvent event failed");
417 return ret;
418 }
419
SendDistribuitedOutputChangeEvent(const AudioDeviceDescriptor & desc,bool isRemote)420 bool AudioPolicyServerHandler::SendDistribuitedOutputChangeEvent(const AudioDeviceDescriptor &desc, bool isRemote)
421 {
422 AUDIO_INFO_LOG("Send Event DISTRIBUTED_OUTPUT_CHANGE. isRemote=%{public}d", isRemote);
423 auto event = make_shared<DistributedOutputChangeEvent>(desc, isRemote);
424 lock_guard<mutex> runnerlock(runnerMutex_);
425 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::DISTRIBUTED_OUTPUT_CHANGE, event));
426 CHECK_AND_RETURN_RET_LOG(ret, ret, "SendDistribuitedOutputChangeEvent event failed");
427 return ret;
428 }
429
SendCapturerCreateEvent(AudioCapturerInfo capturerInfo,AudioStreamInfo streamInfo,uint64_t sessionId,bool isSync,int32_t & error)430 bool AudioPolicyServerHandler::SendCapturerCreateEvent(AudioCapturerInfo capturerInfo,
431 AudioStreamInfo streamInfo, uint64_t sessionId, bool isSync, int32_t &error)
432 {
433 auto eventContextObj = std::make_shared<CapturerCreateEvent>(capturerInfo, streamInfo, sessionId, SUCCESS);
434 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
435
436 bool ret;
437 if (isSync) {
438 ret = SendSyncEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::ON_CAPTURER_CREATE,
439 eventContextObj));
440 error = eventContextObj->error_;
441 } else {
442 ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::ON_CAPTURER_CREATE,
443 eventContextObj));
444 error = SUCCESS;
445 }
446 CHECK_AND_RETURN_RET_LOG(ret, ret, "failed");
447 return ret;
448 }
449
SendCapturerRemovedEvent(uint64_t sessionId,bool isSync)450 bool AudioPolicyServerHandler::SendCapturerRemovedEvent(uint64_t sessionId, bool isSync)
451 {
452 auto eventContextObj = std::make_shared<uint64_t>(sessionId);
453 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
454
455 bool ret;
456 if (isSync) {
457 ret = SendSyncEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::ON_CAPTURER_REMOVED,
458 eventContextObj));
459 } else {
460 ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::ON_CAPTURER_REMOVED,
461 eventContextObj));
462 }
463 CHECK_AND_RETURN_RET_LOG(ret, ret, "failed");
464 return ret;
465 }
466
SendWakeupCloseEvent(bool isSync)467 bool AudioPolicyServerHandler::SendWakeupCloseEvent(bool isSync)
468 {
469 bool ret;
470 if (isSync) {
471 ret = SendSyncEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::ON_WAKEUP_CLOSE));
472 } else {
473 ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::ON_WAKEUP_CLOSE));
474 }
475 CHECK_AND_RETURN_RET_LOG(ret, ret, "failed");
476 return ret;
477 }
478
SendRecreateRendererStreamEvent(int32_t clientId,uint32_t sessionID,int32_t streamFlag,const AudioStreamDeviceChangeReasonExt reason)479 bool AudioPolicyServerHandler::SendRecreateRendererStreamEvent(
480 int32_t clientId, uint32_t sessionID, int32_t streamFlag,
481 const AudioStreamDeviceChangeReasonExt reason)
482 {
483 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
484 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
485 eventContextObj->clientId = clientId;
486 eventContextObj->sessionId = sessionID;
487 eventContextObj->streamFlag = streamFlag;
488 eventContextObj->reason_ = reason;
489 return SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::RECREATE_RENDERER_STREAM_EVENT,
490 eventContextObj));
491 }
492
SendRecreateCapturerStreamEvent(int32_t clientId,uint32_t sessionID,int32_t streamFlag,const AudioStreamDeviceChangeReasonExt reason)493 bool AudioPolicyServerHandler::SendRecreateCapturerStreamEvent(
494 int32_t clientId, uint32_t sessionID, int32_t streamFlag,
495 const AudioStreamDeviceChangeReasonExt reason)
496 {
497 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
498 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
499 eventContextObj->clientId = clientId;
500 eventContextObj->sessionId = sessionID;
501 eventContextObj->streamFlag = streamFlag;
502 eventContextObj->reason_ = reason;
503 return SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::RECREATE_CAPTURER_STREAM_EVENT,
504 eventContextObj));
505 }
506
SendNnStateChangeCallback(const int32_t & state)507 bool AudioPolicyServerHandler::SendNnStateChangeCallback(const int32_t &state)
508 {
509 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
510 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
511 eventContextObj->nnState = state;
512 lock_guard<mutex> runnerlock(runnerMutex_);
513 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::NN_STATE_CHANGE, eventContextObj));
514 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send NN_STATE_CHANGE event failed");
515 return ret;
516 }
517
SendHeadTrackingDeviceChangeEvent(const std::unordered_map<std::string,bool> & changeInfo)518 bool AudioPolicyServerHandler::SendHeadTrackingDeviceChangeEvent(
519 const std::unordered_map<std::string, bool> &changeInfo)
520 {
521 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
522 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
523 eventContextObj->headTrackingDeviceChangeInfo = changeInfo;
524 lock_guard<mutex> runnerlock(runnerMutex_);
525 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::HEAD_TRACKING_DEVICE_CHANGE,
526 eventContextObj));
527 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send HEAD_TRACKING_DEVICE_CHANGE event failed");
528 return ret;
529 }
530
SendSpatializatonEnabledChangeEvent(const bool & enabled)531 bool AudioPolicyServerHandler::SendSpatializatonEnabledChangeEvent(const bool &enabled)
532 {
533 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
534 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
535 eventContextObj->spatializationEnabled = enabled;
536 lock_guard<mutex> runnerlock(runnerMutex_);
537 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::SPATIALIZATION_ENABLED_CHANGE,
538 eventContextObj));
539 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send SPATIALIZATION_ENABLED_CHANGE event failed");
540 return ret;
541 }
542
SendSpatializatonEnabledChangeForAnyDeviceEvent(const std::shared_ptr<AudioDeviceDescriptor> & selectedAudioDevice,const bool & enabled)543 bool AudioPolicyServerHandler::SendSpatializatonEnabledChangeForAnyDeviceEvent(
544 const std::shared_ptr<AudioDeviceDescriptor> &selectedAudioDevice, const bool &enabled)
545 {
546 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
547 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
548 eventContextObj->spatializationEnabled = enabled;
549 eventContextObj->descriptor = selectedAudioDevice;
550 lock_guard<mutex> runnerlock(runnerMutex_);
551 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::SPATIALIZATION_ENABLED_CHANGE_FOR_ANY_DEVICE,
552 eventContextObj));
553 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send SPATIALIZATION_ENABLED_CHANGE event failed");
554 return ret;
555 }
556
SendSpatializatonEnabledChangeForCurrentDeviceEvent(const bool & enabled)557 bool AudioPolicyServerHandler::SendSpatializatonEnabledChangeForCurrentDeviceEvent(const bool &enabled)
558 {
559 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
560 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
561 eventContextObj->spatializationEnabled = enabled;
562 lock_guard<mutex> runnerlock(runnerMutex_);
563 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(
564 EventAudioServerCmd::SPATIALIZATION_ENABLED_CHANGE_FOR_CURRENT_DEVICE, eventContextObj));
565 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send SPATIALIZATION_ENABLED_CHANGE_FOR_CURRENT_DEVICE event failed");
566 return ret;
567 }
568
SendHeadTrackingEnabledChangeEvent(const bool & enabled)569 bool AudioPolicyServerHandler::SendHeadTrackingEnabledChangeEvent(const bool &enabled)
570 {
571 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
572 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
573 eventContextObj->headTrackingEnabled = enabled;
574 lock_guard<mutex> runnerlock(runnerMutex_);
575 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::HEAD_TRACKING_ENABLED_CHANGE,
576 eventContextObj));
577 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send HEAD_TRACKING_ENABLED_CHANGE event failed");
578 return ret;
579 }
580
SendAudioSceneChangeEvent(const AudioScene & audioScene)581 bool AudioPolicyServerHandler::SendAudioSceneChangeEvent(const AudioScene &audioScene)
582 {
583 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
584 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
585 eventContextObj->audioScene = audioScene;
586 lock_guard<mutex> runnerlock(runnerMutex_);
587 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::AUDIO_SCENE_CHANGE,
588 eventContextObj));
589 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send HEAD_TRACKING_ENABLED_CHANGE event failed");
590 return ret;
591 }
592
SendHeadTrackingEnabledChangeForAnyDeviceEvent(const std::shared_ptr<AudioDeviceDescriptor> & selectedAudioDevice,const bool & enabled)593 bool AudioPolicyServerHandler::SendHeadTrackingEnabledChangeForAnyDeviceEvent(
594 const std::shared_ptr<AudioDeviceDescriptor> &selectedAudioDevice, const bool &enabled)
595 {
596 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
597 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
598 eventContextObj->headTrackingEnabled = enabled;
599 eventContextObj->descriptor = selectedAudioDevice;
600 lock_guard<mutex> runnerlock(runnerMutex_);
601 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::HEAD_TRACKING_ENABLED_CHANGE_FOR_ANY_DEVICE,
602 eventContextObj));
603 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send HEAD_TRACKING_ENABLED_CHANGE event failed");
604 return ret;
605 }
606
SendPipeStreamCleanEvent(AudioPipeType pipeType)607 bool AudioPolicyServerHandler::SendPipeStreamCleanEvent(AudioPipeType pipeType)
608 {
609 auto eventContextObj = std::make_shared<int32_t>(pipeType);
610 lock_guard<mutex> runnerlock(runnerMutex_);
611 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::PIPE_STREAM_CLEAN_EVENT,
612 eventContextObj));
613 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send PIPE_STREAM_CLEAN_EVENT event failed");
614 return ret;
615 }
616
SendConcurrencyEventWithSessionIDCallback(const uint32_t sessionID)617 bool AudioPolicyServerHandler::SendConcurrencyEventWithSessionIDCallback(const uint32_t sessionID)
618 {
619 AUDIO_INFO_LOG("session %{public}u send concurrency event", sessionID);
620 std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
621 CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
622 eventContextObj->sessionId = sessionID;
623 lock_guard<mutex> runnerlock(runnerMutex_);
624 bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::CONCURRENCY_EVENT_WITH_SESSIONID,
625 eventContextObj));
626 CHECK_AND_RETURN_RET_LOG(ret, ret, "Send CONCURRENCY_EVENT_WITH_SESSIONID event failed");
627 return ret;
628 }
629
HandleDeviceChangedCallback(const AppExecFwk::InnerEvent::Pointer & event)630 void AudioPolicyServerHandler::HandleDeviceChangedCallback(const AppExecFwk::InnerEvent::Pointer &event)
631 {
632 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
633 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
634 std::lock_guard<std::mutex> lock(handleMapMutex_);
635 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
636 if (it->second && eventContextObj->deviceChangeAction.deviceDescriptors.size() > 0) {
637 DeviceChangeAction deviceChangeAction = eventContextObj->deviceChangeAction;
638 if (!(it->second->hasBTPermission_)) {
639 AudioPolicyService::GetAudioPolicyService().
640 UpdateDescWhenNoBTPermission(deviceChangeAction.deviceDescriptors);
641 }
642 if (clientCallbacksMap_.count(it->first) > 0 &&
643 clientCallbacksMap_[it->first].count(CALLBACK_SET_DEVICE_CHANGE) > 0 &&
644 clientCallbacksMap_[it->first][CALLBACK_SET_DEVICE_CHANGE]) {
645 it->second->OnDeviceChange(deviceChangeAction);
646 }
647 }
648 }
649 }
650
HandleMicrophoneBlockedCallback(const AppExecFwk::InnerEvent::Pointer & event)651 void AudioPolicyServerHandler::HandleMicrophoneBlockedCallback(const AppExecFwk::InnerEvent::Pointer &event)
652 {
653 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
654 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
655 std::lock_guard<std::mutex> lock(handleMapMutex_);
656
657 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
658 if (it->second && eventContextObj->microphoneBlockedInfo.devices.size() > 0) {
659 MicrophoneBlockedInfo microphoneBlockedInfo = eventContextObj->microphoneBlockedInfo;
660 if (clientCallbacksMap_.count(it->first) > 0 &&
661 clientCallbacksMap_[it->first].count(CALLBACK_SET_MICROPHONE_BLOCKED) > 0 &&
662 clientCallbacksMap_[it->first][CALLBACK_SET_MICROPHONE_BLOCKED]) {
663 it->second->OnMicrophoneBlocked(microphoneBlockedInfo);
664 }
665 }
666 }
667 }
668
HandleAvailableDeviceChange(const AppExecFwk::InnerEvent::Pointer & event)669 void AudioPolicyServerHandler::HandleAvailableDeviceChange(const AppExecFwk::InnerEvent::Pointer &event)
670 {
671 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
672 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
673 std::lock_guard<std::mutex> lock(handleMapMutex_);
674 for (auto it = availableDeviceChangeCbsMap_.begin(); it != availableDeviceChangeCbsMap_.end(); ++it) {
675 AudioDeviceUsage usage = it->first.second;
676 DeviceChangeAction deviceChangeAction = eventContextObj->deviceChangeAction;
677 deviceChangeAction.deviceDescriptors = AudioPolicyService::GetAudioPolicyService().
678 DeviceFilterByUsageInner(it->first.second, deviceChangeAction.deviceDescriptors);
679 if (it->second && deviceChangeAction.deviceDescriptors.size() > 0) {
680 if (!(it->second->hasBTPermission_)) {
681 AudioPolicyService::GetAudioPolicyService().
682 UpdateDescWhenNoBTPermission(deviceChangeAction.deviceDescriptors);
683 }
684 it->second->OnAvailableDeviceChange(usage, deviceChangeAction);
685 }
686 }
687 }
688
HandleVolumeKeyEvent(const AppExecFwk::InnerEvent::Pointer & event)689 void AudioPolicyServerHandler::HandleVolumeKeyEvent(const AppExecFwk::InnerEvent::Pointer &event)
690 {
691 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
692 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
693 std::lock_guard<std::mutex> lock(handleMapMutex_);
694 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
695 sptr<IAudioPolicyClient> volumeChangeCb = it->second;
696 if (volumeChangeCb == nullptr) {
697 AUDIO_ERR_LOG("volumeChangeCb: nullptr for client : %{public}d", it->first);
698 continue;
699 }
700 if (VolumeUtils::GetVolumeTypeFromStreamType(eventContextObj->volumeEvent.volumeType) == STREAM_SYSTEM &&
701 !volumeChangeCb->hasSystemPermission_) {
702 AUDIO_DEBUG_LOG("volumeChangecb: Non system applications do not send system callbacks");
703 continue;
704 }
705 AUDIO_PRERELEASE_LOGI("Trigger volumeChangeCb clientPid : %{public}d, volumeType : %{public}d," \
706 " volume : %{public}d, updateUi : %{public}d ", it->first,
707 static_cast<int32_t>(eventContextObj->volumeEvent.volumeType), eventContextObj->volumeEvent.volume,
708 static_cast<int32_t>(eventContextObj->volumeEvent.updateUi));
709 if (clientCallbacksMap_.count(it->first) > 0 &&
710 clientCallbacksMap_[it->first].count(CALLBACK_SET_VOLUME_KEY_EVENT) > 0 &&
711 clientCallbacksMap_[it->first][CALLBACK_SET_VOLUME_KEY_EVENT]) {
712 volumeChangeCb->OnVolumeKeyEvent(eventContextObj->volumeEvent);
713 }
714 }
715 }
716
HandleAudioSessionDeactiveCallback(const AppExecFwk::InnerEvent::Pointer & event)717 void AudioPolicyServerHandler::HandleAudioSessionDeactiveCallback(const AppExecFwk::InnerEvent::Pointer &event)
718 {
719 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
720 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
721 std::lock_guard<std::mutex> lock(handleMapMutex_);
722 int32_t clientPid = eventContextObj->sessionDeactivePair.first;
723 auto iterator = audioPolicyClientProxyAPSCbsMap_.find(clientPid);
724 if (iterator == audioPolicyClientProxyAPSCbsMap_.end()) {
725 AUDIO_ERR_LOG("AudioSessionDeactiveCallback: no client callback for client pid %{public}d", clientPid);
726 return;
727 }
728 if (clientCallbacksMap_.count(iterator->first) > 0 &&
729 clientCallbacksMap_[iterator->first].count(CALLBACK_AUDIO_SESSION) > 0 &&
730 clientCallbacksMap_[iterator->first][CALLBACK_AUDIO_SESSION]) {
731 // the client has registered audio session callback.
732 sptr<IAudioPolicyClient> audioSessionCb = iterator->second;
733 if (audioSessionCb == nullptr) {
734 AUDIO_ERR_LOG("AudioSessionDeactiveCallback: nullptr for client pid %{public}d", clientPid);
735 return;
736 }
737 AUDIO_INFO_LOG("Trigger AudioSessionDeactiveCallback for client pid : %{public}d", clientPid);
738 audioSessionCb->OnAudioSessionDeactive(eventContextObj->sessionDeactivePair.second);
739 } else {
740 AUDIO_ERR_LOG("AudioSessionDeactiveCallback: no registered callback for pid %{public}d", clientPid);
741 }
742 }
743
HandleRequestCateGoryEvent(const AppExecFwk::InnerEvent::Pointer & event)744 void AudioPolicyServerHandler::HandleRequestCateGoryEvent(const AppExecFwk::InnerEvent::Pointer &event)
745 {
746 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
747 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
748
749 std::lock_guard<std::mutex> lock(handleMapMutex_);
750 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
751 if (clientCallbacksMap_.count(it->first) > 0 &&
752 clientCallbacksMap_[it->first].count(CALLBACK_FOCUS_INFO_CHANGE) > 0 &&
753 clientCallbacksMap_[it->first][CALLBACK_FOCUS_INFO_CHANGE]) {
754 it->second->OnAudioFocusRequested(eventContextObj->audioInterrupt);
755 }
756 }
757 }
758
HandleAbandonCateGoryEvent(const AppExecFwk::InnerEvent::Pointer & event)759 void AudioPolicyServerHandler::HandleAbandonCateGoryEvent(const AppExecFwk::InnerEvent::Pointer &event)
760 {
761 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
762 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
763 std::lock_guard<std::mutex> lock(handleMapMutex_);
764 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
765 if (clientCallbacksMap_.count(it->first) > 0 &&
766 clientCallbacksMap_[it->first].count(CALLBACK_FOCUS_INFO_CHANGE) > 0 &&
767 clientCallbacksMap_[it->first][CALLBACK_FOCUS_INFO_CHANGE]) {
768 it->second->OnAudioFocusAbandoned(eventContextObj->audioInterrupt);
769 }
770 }
771 }
772
HandleFocusInfoChangeEvent(const AppExecFwk::InnerEvent::Pointer & event)773 void AudioPolicyServerHandler::HandleFocusInfoChangeEvent(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 AUDIO_INFO_LOG("HandleFocusInfoChangeEvent focusInfoList :%{public}zu", eventContextObj->focusInfoList.size());
778 std::lock_guard<std::mutex> lock(handleMapMutex_);
779 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
780 if (clientCallbacksMap_.count(it->first) > 0 &&
781 clientCallbacksMap_[it->first].count(CALLBACK_FOCUS_INFO_CHANGE) > 0 &&
782 clientCallbacksMap_[it->first][CALLBACK_FOCUS_INFO_CHANGE]) {
783 it->second->OnAudioFocusInfoChange(eventContextObj->focusInfoList);
784 }
785 }
786 }
787
HandleAppVolumeChangeEvent(const AppExecFwk::InnerEvent::Pointer & event)788 void AudioPolicyServerHandler::HandleAppVolumeChangeEvent(const AppExecFwk::InnerEvent::Pointer &event)
789 {
790 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
791 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
792 std::lock_guard<std::mutex> lock(handleMapMutex_);
793 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
794 sptr<IAudioPolicyClient> appVolumeChangeListenerCb = it->second;
795 if (appVolumeChangeListenerCb == nullptr) {
796 AUDIO_ERR_LOG("appVolumeChangeListenerCb nullptr for client %{public}d", it->first);
797 continue;
798 }
799
800 AUDIO_INFO_LOG("appVolumeChangeListenerCb client %{public}d :volumeMode %{public}d :appUid%{public}d",
801 it->first, static_cast<int32_t>(eventContextObj->volumeEvent.volumeMode), eventContextObj->appUid);
802 if (clientCallbacksMap_.count(it->first) > 0 &&
803 clientCallbacksMap_[it->first].count(CALLBACK_APP_VOLUME_CHANGE) > 0 &&
804 clientCallbacksMap_[it->first][CALLBACK_APP_VOLUME_CHANGE]) {
805 appVolumeChangeListenerCb->OnAppVolumeChanged(eventContextObj->appUid, eventContextObj->volumeEvent);
806 }
807 if (clientCallbacksMap_.count(it->first) > 0 &&
808 clientCallbacksMap_[it->first].count(CALLBACK_SELF_APP_VOLUME_CHANGE) > 0 &&
809 clientCallbacksMap_[it->first][CALLBACK_SELF_APP_VOLUME_CHANGE]) {
810 appVolumeChangeListenerCb->OnAppVolumeChanged(eventContextObj->appUid, eventContextObj->volumeEvent);
811 }
812 }
813 }
814
HandleRingerModeUpdatedEvent(const AppExecFwk::InnerEvent::Pointer & event)815 void AudioPolicyServerHandler::HandleRingerModeUpdatedEvent(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 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
821 sptr<IAudioPolicyClient> ringerModeListenerCb = it->second;
822 if (ringerModeListenerCb == nullptr) {
823 AUDIO_ERR_LOG("ringerModeListenerCb nullptr for client %{public}d", it->first);
824 continue;
825 }
826
827 AUDIO_INFO_LOG("Trigger ringerModeListenerCb client %{public}d :RingerMode %{public}d", it->first,
828 static_cast<int32_t>(eventContextObj->ringMode));
829 if (clientCallbacksMap_.count(it->first) > 0 &&
830 clientCallbacksMap_[it->first].count(CALLBACK_SET_RINGER_MODE) > 0 &&
831 clientCallbacksMap_[it->first][CALLBACK_SET_RINGER_MODE]) {
832 ringerModeListenerCb->OnRingerModeUpdated(eventContextObj->ringMode);
833 }
834 }
835 }
836
HandleMicStateUpdatedEvent(const AppExecFwk::InnerEvent::Pointer & event)837 void AudioPolicyServerHandler::HandleMicStateUpdatedEvent(const AppExecFwk::InnerEvent::Pointer &event)
838 {
839 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
840 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
841 std::lock_guard<std::mutex> lock(handleMapMutex_);
842 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
843 sptr<IAudioPolicyClient> micStateChangeListenerCb = it->second;
844 if (micStateChangeListenerCb == nullptr) {
845 AUDIO_ERR_LOG("callback is nullptr for client %{public}d", it->first);
846 continue;
847 }
848 if (clientCallbacksMap_.count(it->first) > 0 &&
849 clientCallbacksMap_[it->first].count(CALLBACK_SET_MIC_STATE_CHANGE) > 0 &&
850 clientCallbacksMap_[it->first][CALLBACK_SET_MIC_STATE_CHANGE]) {
851 micStateChangeListenerCb->OnMicStateUpdated(eventContextObj->micStateChangeEvent);
852 }
853 }
854 }
855
HandleMicStateUpdatedEventWithClientId(const AppExecFwk::InnerEvent::Pointer & event)856 void AudioPolicyServerHandler::HandleMicStateUpdatedEventWithClientId(const AppExecFwk::InnerEvent::Pointer &event)
857 {
858 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
859 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
860 std::lock_guard<std::mutex> lock(handleMapMutex_);
861 int32_t clientId = eventContextObj->clientId;
862 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
863 if (it->first != clientId) {
864 AUDIO_DEBUG_LOG("This client %{public}d is not need to trigger the callback ", it->first);
865 continue;
866 }
867 sptr<IAudioPolicyClient> micStateChangeListenerCb = it->second;
868 if (micStateChangeListenerCb == nullptr) {
869 AUDIO_ERR_LOG("callback is nullptr for client %{public}d", it->first);
870 continue;
871 }
872 if (clientCallbacksMap_.count(it->first) > 0 &&
873 clientCallbacksMap_[it->first].count(CALLBACK_SET_MIC_STATE_CHANGE) > 0 &&
874 clientCallbacksMap_[it->first][CALLBACK_SET_MIC_STATE_CHANGE]) {
875 micStateChangeListenerCb->OnMicStateUpdated(eventContextObj->micStateChangeEvent);
876 }
877 }
878 }
879
HandleInterruptEvent(const AppExecFwk::InnerEvent::Pointer & event)880 void AudioPolicyServerHandler::HandleInterruptEvent(const AppExecFwk::InnerEvent::Pointer &event)
881 {
882 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
883 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
884
885 std::unique_lock<std::mutex> lock(handleMapMutex_);
886 std::shared_ptr<IAudioInterruptEventDispatcher> dispatcher = interruptEventDispatcher_.lock();
887 lock.unlock();
888 if (dispatcher != nullptr) {
889 dispatcher->DispatchInterruptEventWithStreamId(0, eventContextObj->interruptEvent);
890 }
891 }
892
HandleInterruptEventWithStreamId(const AppExecFwk::InnerEvent::Pointer & event)893 void AudioPolicyServerHandler::HandleInterruptEventWithStreamId(const AppExecFwk::InnerEvent::Pointer &event)
894 {
895 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
896 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
897
898 std::unique_lock<std::mutex> lock(handleMapMutex_);
899 std::shared_ptr<IAudioInterruptEventDispatcher> dispatcher = interruptEventDispatcher_.lock();
900 lock.unlock();
901 if (dispatcher != nullptr) {
902 dispatcher->DispatchInterruptEventWithStreamId(eventContextObj->sessionId,
903 eventContextObj->interruptEvent);
904 }
905 }
906
HandleInterruptEventWithClientId(const AppExecFwk::InnerEvent::Pointer & event)907 void AudioPolicyServerHandler::HandleInterruptEventWithClientId(const AppExecFwk::InnerEvent::Pointer &event)
908 {
909 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
910 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
911
912 std::lock_guard<std::mutex> lock(handleMapMutex_);
913 std::shared_ptr<AudioInterruptCallback> policyListenerCb = amInterruptCbsMap_[eventContextObj->clientId];
914 CHECK_AND_RETURN_LOG(policyListenerCb != nullptr, "policyListenerCb get nullptr");
915 policyListenerCb->OnInterrupt(eventContextObj->interruptEvent);
916 }
917
HandlePreferredOutputDeviceUpdated()918 void AudioPolicyServerHandler::HandlePreferredOutputDeviceUpdated()
919 {
920 std::lock_guard<std::mutex> lock(handleMapMutex_);
921 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
922 int32_t clientPid = it->first;
923 std::vector<AudioRendererInfo> rendererInfoList = GetCallbackRendererInfoList(clientPid);
924 for (auto rendererInfo : rendererInfoList) {
925 auto deviceDescs = AudioPolicyService::GetAudioPolicyService().
926 GetPreferredOutputDeviceDescInner(rendererInfo);
927 if (!(it->second->hasBTPermission_)) {
928 AudioPolicyService::GetAudioPolicyService().UpdateDescWhenNoBTPermission(deviceDescs);
929 }
930 if (clientCallbacksMap_.count(clientPid) > 0 &&
931 clientCallbacksMap_[clientPid].count(CALLBACK_PREFERRED_OUTPUT_DEVICE_CHANGE) > 0 &&
932 clientCallbacksMap_[clientPid][CALLBACK_PREFERRED_OUTPUT_DEVICE_CHANGE]) {
933 AUDIO_INFO_LOG("Send PreferredOutputDevice deviceType[%{public}d] change to clientPid[%{public}d]",
934 deviceDescs[0]->deviceType_, clientPid);
935 it->second->OnPreferredOutputDeviceUpdated(rendererInfo, deviceDescs);
936 }
937 }
938 }
939 }
940
HandlePreferredInputDeviceUpdated()941 void AudioPolicyServerHandler::HandlePreferredInputDeviceUpdated()
942 {
943 std::lock_guard<std::mutex> lock(handleMapMutex_);
944 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
945 int32_t clientPid = it->first;
946 std::vector<AudioCapturerInfo> capturerInfoList = GetCallbackCapturerInfoList(clientPid);
947 for (auto capturerInfo : capturerInfoList) {
948 auto deviceDescs = AudioPolicyService::GetAudioPolicyService().
949 GetPreferredInputDeviceDescInner(capturerInfo);
950 if (!(it->second->hasBTPermission_)) {
951 AudioPolicyService::GetAudioPolicyService().UpdateDescWhenNoBTPermission(deviceDescs);
952 }
953 if (clientCallbacksMap_.count(clientPid) > 0 &&
954 clientCallbacksMap_[clientPid].count(CALLBACK_PREFERRED_INPUT_DEVICE_CHANGE) > 0 &&
955 clientCallbacksMap_[clientPid][CALLBACK_PREFERRED_INPUT_DEVICE_CHANGE]) {
956 it->second->OnPreferredInputDeviceUpdated(capturerInfo, deviceDescs);
957 }
958 }
959 }
960 }
961
HandleDistributedRoutingRoleChangeEvent(const AppExecFwk::InnerEvent::Pointer & event)962 void AudioPolicyServerHandler::HandleDistributedRoutingRoleChangeEvent(const AppExecFwk::InnerEvent::Pointer &event)
963 {
964 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
965 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
966 std::lock_guard<std::mutex> lock(handleMapMutex_);
967 for (auto it = distributedRoutingRoleChangeCbsMap_.begin(); it != distributedRoutingRoleChangeCbsMap_.end(); it++) {
968 it->second->OnDistributedRoutingRoleChange(eventContextObj->descriptor, eventContextObj->type);
969 }
970 }
971
HandleRendererInfoEvent(const AppExecFwk::InnerEvent::Pointer & event)972 void AudioPolicyServerHandler::HandleRendererInfoEvent(const AppExecFwk::InnerEvent::Pointer &event)
973 {
974 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
975 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
976 std::lock_guard<std::mutex> lock(handleMapMutex_);
977 Trace trace("AudioPolicyServerHandler::HandleRendererInfoEvent");
978 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
979 Trace traceFor("for pid:" + std::to_string(it->first));
980 sptr<IAudioPolicyClient> rendererStateChangeCb = it->second;
981 if (rendererStateChangeCb == nullptr) {
982 AUDIO_ERR_LOG("rendererStateChangeCb : nullptr for client : %{public}d", it->first);
983 continue;
984 }
985 if (clientCallbacksMap_.count(it->first) > 0 &&
986 clientCallbacksMap_[it->first].count(CALLBACK_RENDERER_STATE_CHANGE) > 0 &&
987 clientCallbacksMap_[it->first][CALLBACK_RENDERER_STATE_CHANGE]) {
988 Trace traceCallback("rendererStateChangeCb->OnRendererStateChange");
989 rendererStateChangeCb->OnRendererStateChange(eventContextObj->audioRendererChangeInfos);
990 }
991 }
992 AUDIO_INFO_LOG("pids: %{public}s size: %{public}zu", pidsStrForPrinting_.c_str(),
993 audioPolicyClientProxyAPSCbsMap_.size());
994 }
995
HandleCapturerInfoEvent(const AppExecFwk::InnerEvent::Pointer & event)996 void AudioPolicyServerHandler::HandleCapturerInfoEvent(const AppExecFwk::InnerEvent::Pointer &event)
997 {
998 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
999 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1000 std::lock_guard<std::mutex> lock(handleMapMutex_);
1001 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
1002 sptr<IAudioPolicyClient> capturerStateChangeCb = it->second;
1003 if (capturerStateChangeCb == nullptr) {
1004 AUDIO_ERR_LOG("capturerStateChangeCb : nullptr for client : %{public}d", it->first);
1005 continue;
1006 }
1007 if (clientCallbacksMap_.count(it->first) > 0 &&
1008 clientCallbacksMap_[it->first].count(CALLBACK_CAPTURER_STATE_CHANGE) > 0 &&
1009 clientCallbacksMap_[it->first][CALLBACK_CAPTURER_STATE_CHANGE]) {
1010 capturerStateChangeCb->OnCapturerStateChange(eventContextObj->audioCapturerChangeInfos);
1011 }
1012 }
1013 }
1014
HandleRendererDeviceChangeEvent(const AppExecFwk::InnerEvent::Pointer & event)1015 void AudioPolicyServerHandler::HandleRendererDeviceChangeEvent(const AppExecFwk::InnerEvent::Pointer &event)
1016 {
1017 std::shared_ptr<RendererDeviceChangeEvent> eventContextObj = event->GetSharedObject<RendererDeviceChangeEvent>();
1018 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1019 const auto &[pid, sessionId, outputDeviceInfo, reason] = *eventContextObj;
1020 Trace trace("AudioPolicyServerHandler::HandleRendererDeviceChangeEvent pid:" + std::to_string(pid));
1021 std::lock_guard<std::mutex> lock(handleMapMutex_);
1022 if (audioPolicyClientProxyAPSCbsMap_.count(pid) == 0) {
1023 return;
1024 }
1025 sptr<IAudioPolicyClient> capturerStateChangeCb = audioPolicyClientProxyAPSCbsMap_.at(pid);
1026 if (capturerStateChangeCb == nullptr) {
1027 AUDIO_ERR_LOG("capturerStateChangeCb : nullptr for client : %{public}" PRId32 "", pid);
1028 return;
1029 }
1030 Trace traceCallback("capturerStateChangeCb->OnRendererDeviceChange sessionId:" + std::to_string(sessionId));
1031 if (clientCallbacksMap_.count(pid) > 0 &&
1032 clientCallbacksMap_[pid].count(CALLBACK_DEVICE_CHANGE_WITH_INFO) > 0 &&
1033 clientCallbacksMap_[pid][CALLBACK_DEVICE_CHANGE_WITH_INFO]) {
1034 capturerStateChangeCb->OnRendererDeviceChange(sessionId, outputDeviceInfo, reason);
1035 }
1036 }
1037
HandleDistributedOutputChange(const AppExecFwk::InnerEvent::Pointer & event)1038 void AudioPolicyServerHandler::HandleDistributedOutputChange(const AppExecFwk::InnerEvent::Pointer &event)
1039 {
1040 auto eventContextObj = event->GetSharedObject<DistributedOutputChangeEvent>();
1041 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "eventContextObj is nullptr");
1042 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
1043 sptr<IAudioPolicyClient> audioPolicyClient = it->second;
1044 CHECK_AND_RETURN_LOG(audioPolicyClient, "Client(Pid[%{public}d]) Callback is nullptr.", it->first);
1045 if (clientCallbacksMap_.count(it->first) > 0 &&
1046 clientCallbacksMap_[it->first].count(CALLBACK_DISTRIBUTED_OUTPUT_CHANGE) > 0 &&
1047 clientCallbacksMap_[it->first][CALLBACK_DISTRIBUTED_OUTPUT_CHANGE]) {
1048 audioPolicyClient->OnDistribuitedOutputChange(eventContextObj->deviceDesc_, eventContextObj->isRemote_);
1049 }
1050 }
1051 }
1052
HandleCapturerCreateEvent(const AppExecFwk::InnerEvent::Pointer & event)1053 void AudioPolicyServerHandler::HandleCapturerCreateEvent(const AppExecFwk::InnerEvent::Pointer &event)
1054 {
1055 std::shared_ptr<CapturerCreateEvent> eventContextObj = event->GetSharedObject<CapturerCreateEvent>();
1056 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1057
1058 uint64_t sessionId = eventContextObj->sessionId_;
1059 SessionInfo sessionInfo{eventContextObj->capturerInfo_.sourceType, eventContextObj->streamInfo_.samplingRate,
1060 eventContextObj->streamInfo_.channels};
1061
1062 eventContextObj->error_ = AudioPolicyService::GetAudioPolicyService().OnCapturerSessionAdded(sessionId,
1063 sessionInfo, eventContextObj->streamInfo_);
1064 }
1065
HandleCapturerRemovedEvent(const AppExecFwk::InnerEvent::Pointer & event)1066 void AudioPolicyServerHandler::HandleCapturerRemovedEvent(const AppExecFwk::InnerEvent::Pointer &event)
1067 {
1068 std::shared_ptr<uint64_t> eventContextObj = event->GetSharedObject<uint64_t>();
1069 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1070
1071 uint64_t sessionId = *eventContextObj;
1072
1073 AudioPolicyService::GetAudioPolicyService().OnCapturerSessionRemoved(sessionId);
1074 }
1075
HandleWakeupCloseEvent(const AppExecFwk::InnerEvent::Pointer & event)1076 void AudioPolicyServerHandler::HandleWakeupCloseEvent(const AppExecFwk::InnerEvent::Pointer &event)
1077 {
1078 AudioPolicyService::GetAudioPolicyService().CloseWakeUpAudioCapturer();
1079 }
1080
HandleSendRecreateRendererStreamEvent(const AppExecFwk::InnerEvent::Pointer & event)1081 void AudioPolicyServerHandler::HandleSendRecreateRendererStreamEvent(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 std::lock_guard<std::mutex> lock(handleMapMutex_);
1086 RestoreInfo restoreInfo;
1087 restoreInfo.restoreReason = DEVICE_CHANGED;
1088 restoreInfo.targetStreamFlag = eventContextObj->streamFlag;
1089 restoreInfo.deviceChangeReason = static_cast<int32_t>(eventContextObj->reason_);
1090 AudioPolicyService::GetAudioPolicyService().RestoreSession(eventContextObj->sessionId, restoreInfo);
1091 }
1092
HandleSendRecreateCapturerStreamEvent(const AppExecFwk::InnerEvent::Pointer & event)1093 void AudioPolicyServerHandler::HandleSendRecreateCapturerStreamEvent(const AppExecFwk::InnerEvent::Pointer &event)
1094 {
1095 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
1096 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1097 std::lock_guard<std::mutex> lock(handleMapMutex_);
1098 RestoreInfo restoreInfo;
1099 restoreInfo.restoreReason = DEVICE_CHANGED;
1100 restoreInfo.targetStreamFlag = eventContextObj->streamFlag;
1101 restoreInfo.deviceChangeReason = static_cast<int32_t>(eventContextObj->reason_);
1102 AudioPolicyService::GetAudioPolicyService().RestoreSession(eventContextObj->sessionId, restoreInfo);
1103 }
1104
HandleNnStateChangeEvent(const AppExecFwk::InnerEvent::Pointer & event)1105 void AudioPolicyServerHandler::HandleNnStateChangeEvent(const AppExecFwk::InnerEvent::Pointer &event)
1106 {
1107 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
1108 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1109 std::lock_guard<std::mutex> lock(handleMapMutex_);
1110 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
1111 sptr<IAudioPolicyClient> nnStateChangeCb = it->second;
1112 if (nnStateChangeCb == nullptr) {
1113 AUDIO_ERR_LOG("nnStateChangeCb : nullptr for client : %{public}d", it->first);
1114 continue;
1115 }
1116 if (clientCallbacksMap_.count(it->first) > 0 &&
1117 clientCallbacksMap_[it->first].count(CALLBACK_NN_STATE_CHANGE) > 0 &&
1118 clientCallbacksMap_[it->first][CALLBACK_NN_STATE_CHANGE]) {
1119 nnStateChangeCb->OnNnStateChange(eventContextObj->nnState);
1120 }
1121 }
1122 }
1123
HandleHeadTrackingDeviceChangeEvent(const AppExecFwk::InnerEvent::Pointer & event)1124 void AudioPolicyServerHandler::HandleHeadTrackingDeviceChangeEvent(const AppExecFwk::InnerEvent::Pointer &event)
1125 {
1126 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
1127 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1128 std::lock_guard<std::mutex> lock(handleMapMutex_);
1129 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
1130 sptr<IAudioPolicyClient> headTrackingDeviceChangeCb = it->second;
1131 if (headTrackingDeviceChangeCb == nullptr) {
1132 AUDIO_ERR_LOG("headTrackingDeviceChangeCb : nullptr for client : %{public}d", it->first);
1133 continue;
1134 }
1135 if (clientCallbacksMap_.count(it->first) > 0 &&
1136 clientCallbacksMap_[it->first].count(CALLBACK_HEAD_TRACKING_DATA_REQUESTED_CHANGE) > 0 &&
1137 clientCallbacksMap_[it->first][CALLBACK_HEAD_TRACKING_DATA_REQUESTED_CHANGE]) {
1138 headTrackingDeviceChangeCb->OnHeadTrackingDeviceChange(eventContextObj->headTrackingDeviceChangeInfo);
1139 }
1140 }
1141 }
1142
HandleSpatializatonEnabledChangeEvent(const AppExecFwk::InnerEvent::Pointer & event)1143 void AudioPolicyServerHandler::HandleSpatializatonEnabledChangeEvent(const AppExecFwk::InnerEvent::Pointer &event)
1144 {
1145 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
1146 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1147 std::lock_guard<std::mutex> lock(handleMapMutex_);
1148 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
1149 sptr<IAudioPolicyClient> spatializationEnabledChangeCb = it->second;
1150 if (spatializationEnabledChangeCb == nullptr) {
1151 AUDIO_ERR_LOG("spatializationEnabledChangeCb : nullptr for client : %{public}d", it->first);
1152 continue;
1153 }
1154 if (clientCallbacksMap_.count(it->first) > 0 &&
1155 clientCallbacksMap_[it->first].count(CALLBACK_SPATIALIZATION_ENABLED_CHANGE) > 0 &&
1156 clientCallbacksMap_[it->first][CALLBACK_SPATIALIZATION_ENABLED_CHANGE]) {
1157 spatializationEnabledChangeCb->OnSpatializationEnabledChange(eventContextObj->spatializationEnabled);
1158 }
1159 }
1160 }
1161
HandleSpatializatonEnabledChangeForAnyDeviceEvent(const AppExecFwk::InnerEvent::Pointer & event)1162 void AudioPolicyServerHandler::HandleSpatializatonEnabledChangeForAnyDeviceEvent(
1163 const AppExecFwk::InnerEvent::Pointer &event)
1164 {
1165 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
1166 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1167 std::lock_guard<std::mutex> lock(handleMapMutex_);
1168 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
1169 sptr<IAudioPolicyClient> spatializationEnabledChangeCb = it->second;
1170 if (spatializationEnabledChangeCb == nullptr) {
1171 AUDIO_ERR_LOG("spatializationEnabledChangeCb : nullptr for client : %{public}d", it->first);
1172 continue;
1173 }
1174 if (clientCallbacksMap_.count(it->first) > 0 &&
1175 clientCallbacksMap_[it->first].count(CALLBACK_SPATIALIZATION_ENABLED_CHANGE) > 0 &&
1176 clientCallbacksMap_[it->first][CALLBACK_SPATIALIZATION_ENABLED_CHANGE]) {
1177 spatializationEnabledChangeCb->OnSpatializationEnabledChangeForAnyDevice(eventContextObj->descriptor,
1178 eventContextObj->spatializationEnabled);
1179 }
1180 }
1181 }
1182
HandleSpatializatonEnabledChangeForCurrentDeviceEvent(const AppExecFwk::InnerEvent::Pointer & event)1183 void AudioPolicyServerHandler::HandleSpatializatonEnabledChangeForCurrentDeviceEvent(
1184 const AppExecFwk::InnerEvent::Pointer &event)
1185 {
1186 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
1187 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1188 std::lock_guard<std::mutex> lock(handleMapMutex_);
1189 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
1190 sptr<IAudioPolicyClient> spatializationEnabledChangeForCurrentDeviceCb = it->second;
1191 if (spatializationEnabledChangeForCurrentDeviceCb == nullptr) {
1192 AUDIO_ERR_LOG("spatializationEnabledChangeForCurrentDeviceCb : nullptr for client : %{public}d", it->first);
1193 continue;
1194 }
1195 if (clientCallbacksMap_.count(it->first) > 0 &&
1196 clientCallbacksMap_[it->first].count(CALLBACK_SPATIALIZATION_ENABLED_CHANGE_FOR_CURRENT_DEVICE) > 0 &&
1197 clientCallbacksMap_[it->first][CALLBACK_SPATIALIZATION_ENABLED_CHANGE_FOR_CURRENT_DEVICE]) {
1198 spatializationEnabledChangeForCurrentDeviceCb->OnSpatializationEnabledChangeForCurrentDevice(
1199 eventContextObj->spatializationEnabled);
1200 }
1201 }
1202 }
1203
HandleHeadTrackingEnabledChangeEvent(const AppExecFwk::InnerEvent::Pointer & event)1204 void AudioPolicyServerHandler::HandleHeadTrackingEnabledChangeEvent(const AppExecFwk::InnerEvent::Pointer &event)
1205 {
1206 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
1207 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1208 std::lock_guard<std::mutex> lock(handleMapMutex_);
1209 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
1210 sptr<IAudioPolicyClient> headTrackingEnabledChangeCb = it->second;
1211 if (headTrackingEnabledChangeCb == nullptr) {
1212 AUDIO_ERR_LOG("headTrackingEnabledChangeCb : nullptr for client : %{public}d", it->first);
1213 continue;
1214 }
1215 if (clientCallbacksMap_.count(it->first) > 0 &&
1216 clientCallbacksMap_[it->first].count(CALLBACK_HEAD_TRACKING_ENABLED_CHANGE) > 0 &&
1217 clientCallbacksMap_[it->first][CALLBACK_HEAD_TRACKING_ENABLED_CHANGE]) {
1218 headTrackingEnabledChangeCb->OnHeadTrackingEnabledChange(eventContextObj->headTrackingEnabled);
1219 }
1220 }
1221 }
1222
HandleAudioSceneChange(const AppExecFwk::InnerEvent::Pointer & event)1223 void AudioPolicyServerHandler::HandleAudioSceneChange(const AppExecFwk::InnerEvent::Pointer &event)
1224 {
1225 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
1226 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1227 std::lock_guard<std::mutex> lock(handleMapMutex_);
1228 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
1229 sptr<IAudioPolicyClient> audioSceneChangeCb = it->second;
1230 if (audioSceneChangeCb == nullptr) {
1231 AUDIO_ERR_LOG("audioSceneChangeCb : nullptr for client : %{public}d", it->first);
1232 continue;
1233 }
1234 if (clientCallbacksMap_.count(it->first) > 0 &&
1235 clientCallbacksMap_[it->first].count(CALLBACK_SET_AUDIO_SCENE_CHANGE) > 0 &&
1236 clientCallbacksMap_[it->first][CALLBACK_SET_AUDIO_SCENE_CHANGE]) {
1237 audioSceneChangeCb->OnAudioSceneChange(eventContextObj->audioScene);
1238 }
1239 }
1240 }
1241
HandleHeadTrackingEnabledChangeForAnyDeviceEvent(const AppExecFwk::InnerEvent::Pointer & event)1242 void AudioPolicyServerHandler::HandleHeadTrackingEnabledChangeForAnyDeviceEvent(
1243 const AppExecFwk::InnerEvent::Pointer &event)
1244 {
1245 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
1246 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1247 std::lock_guard<std::mutex> lock(handleMapMutex_);
1248 for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
1249 sptr<IAudioPolicyClient> headTrackingEnabledChangeCb = it->second;
1250 if (headTrackingEnabledChangeCb == nullptr) {
1251 AUDIO_ERR_LOG("headTrackingEnabledChangeCb : nullptr for client : %{public}d", it->first);
1252 continue;
1253 }
1254 if (clientCallbacksMap_.count(it->first) > 0 &&
1255 clientCallbacksMap_[it->first].count(CALLBACK_HEAD_TRACKING_ENABLED_CHANGE) > 0 &&
1256 clientCallbacksMap_[it->first][CALLBACK_HEAD_TRACKING_ENABLED_CHANGE]) {
1257 headTrackingEnabledChangeCb->OnHeadTrackingEnabledChangeForAnyDevice(eventContextObj->descriptor,
1258 eventContextObj->headTrackingEnabled);
1259 }
1260 }
1261 }
1262
HandlePipeStreamCleanEvent(const AppExecFwk::InnerEvent::Pointer & event)1263 void AudioPolicyServerHandler::HandlePipeStreamCleanEvent(const AppExecFwk::InnerEvent::Pointer &event)
1264 {
1265 std::shared_ptr<int32_t> eventContextObj = event->GetSharedObject<int32_t>();
1266 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1267 AudioPipeType pipeType = static_cast<AudioPipeType>(*eventContextObj);
1268 AudioPolicyService::GetAudioPolicyService().DynamicUnloadModule(pipeType);
1269 }
1270
HandleConcurrencyEventWithSessionID(const AppExecFwk::InnerEvent::Pointer & event)1271 void AudioPolicyServerHandler::HandleConcurrencyEventWithSessionID(const AppExecFwk::InnerEvent::Pointer &event)
1272 {
1273 std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
1274 CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1275
1276 std::unique_lock<std::mutex> lock(handleMapMutex_);
1277 RestoreInfo restoreInfo;
1278 restoreInfo.restoreReason = STREAM_CONCEDED;
1279 restoreInfo.targetStreamFlag = AUDIO_FLAG_FORCED_NORMAL;
1280 AudioPolicyService::GetAudioPolicyService().RestoreSession(eventContextObj->sessionId, restoreInfo);
1281 }
1282
1283 // 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)1284 void AudioPolicyServerHandler::HandleServiceEvent(const uint32_t &eventId,
1285 const AppExecFwk::InnerEvent::Pointer &event)
1286 {
1287 HandleOtherServiceEvent(eventId, event);
1288 switch (eventId) {
1289 case EventAudioServerCmd::AUDIO_DEVICE_CHANGE:
1290 HandleDeviceChangedCallback(event);
1291 break;
1292 case EventAudioServerCmd::PREFERRED_OUTPUT_DEVICE_UPDATED:
1293 HandlePreferredOutputDeviceUpdated();
1294 break;
1295 case EventAudioServerCmd::PREFERRED_INPUT_DEVICE_UPDATED:
1296 HandlePreferredInputDeviceUpdated();
1297 break;
1298 case EventAudioServerCmd::AVAILABLE_AUDIO_DEVICE_CHANGE:
1299 HandleAvailableDeviceChange(event);
1300 break;
1301 case EventAudioServerCmd::RENDERER_INFO_EVENT:
1302 HandleRendererInfoEvent(event);
1303 break;
1304 case EventAudioServerCmd::CAPTURER_INFO_EVENT:
1305 HandleCapturerInfoEvent(event);
1306 break;
1307 case EventAudioServerCmd::RENDERER_DEVICE_CHANGE_EVENT:
1308 HandleRendererDeviceChangeEvent(event);
1309 break;
1310 case EventAudioServerCmd::ON_CAPTURER_CREATE:
1311 HandleCapturerCreateEvent(event);
1312 break;
1313 case EventAudioServerCmd::ON_CAPTURER_REMOVED:
1314 HandleCapturerRemovedEvent(event);
1315 break;
1316 case EventAudioServerCmd::ON_WAKEUP_CLOSE:
1317 HandleWakeupCloseEvent(event);
1318 break;
1319 case EventAudioServerCmd::RECREATE_RENDERER_STREAM_EVENT:
1320 HandleSendRecreateRendererStreamEvent(event);
1321 break;
1322 case EventAudioServerCmd::RECREATE_CAPTURER_STREAM_EVENT:
1323 HandleSendRecreateCapturerStreamEvent(event);
1324 break;
1325 case EventAudioServerCmd::PIPE_STREAM_CLEAN_EVENT:
1326 HandlePipeStreamCleanEvent(event);
1327 break;
1328 default:
1329 break;
1330 }
1331 }
1332
HandleOtherServiceEvent(const uint32_t & eventId,const AppExecFwk::InnerEvent::Pointer & event)1333 void AudioPolicyServerHandler::HandleOtherServiceEvent(const uint32_t &eventId,
1334 const AppExecFwk::InnerEvent::Pointer &event)
1335 {
1336 switch (eventId) {
1337 case EventAudioServerCmd::CONCURRENCY_EVENT_WITH_SESSIONID:
1338 HandleConcurrencyEventWithSessionID(event);
1339 break;
1340 case EventAudioServerCmd::SPATIALIZATION_ENABLED_CHANGE_FOR_ANY_DEVICE:
1341 HandleSpatializatonEnabledChangeForAnyDeviceEvent(event);
1342 break;
1343 case EventAudioServerCmd::HEAD_TRACKING_ENABLED_CHANGE_FOR_ANY_DEVICE:
1344 HandleHeadTrackingEnabledChangeForAnyDeviceEvent(event);
1345 break;
1346 case EventAudioServerCmd::AUDIO_SESSION_DEACTIVE_EVENT:
1347 HandleAudioSessionDeactiveCallback(event);
1348 break;
1349 case EventAudioServerCmd::MICROPHONE_BLOCKED:
1350 HandleMicrophoneBlockedCallback(event);
1351 break;
1352 case EventAudioServerCmd::DISTRIBUTED_OUTPUT_CHANGE:
1353 HandleDistributedOutputChange(event);
1354 break;
1355 case EventAudioServerCmd::NN_STATE_CHANGE:
1356 HandleNnStateChangeEvent(event);
1357 break;
1358 case EventAudioServerCmd::AUDIO_SCENE_CHANGE:
1359 HandleAudioSceneChange(event);
1360 break;
1361 case EventAudioServerCmd::SPATIALIZATION_ENABLED_CHANGE_FOR_CURRENT_DEVICE:
1362 HandleSpatializatonEnabledChangeForCurrentDeviceEvent(event);
1363 break;
1364 case EventAudioServerCmd::APP_VOLUME_CHANGE_EVENT:
1365 HandleAppVolumeChangeEvent(event);
1366 break;
1367 default:
1368 break;
1369 }
1370 }
1371
ProcessEvent(const AppExecFwk::InnerEvent::Pointer & event)1372 void AudioPolicyServerHandler::ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event)
1373 {
1374 uint32_t eventId = event->GetInnerEventId();
1375 HandleServiceEvent(eventId, event);
1376 switch (eventId) {
1377 case EventAudioServerCmd::VOLUME_KEY_EVENT:
1378 HandleVolumeKeyEvent(event);
1379 break;
1380 case EventAudioServerCmd::REQUEST_CATEGORY_EVENT:
1381 HandleRequestCateGoryEvent(event);
1382 break;
1383 case EventAudioServerCmd::ABANDON_CATEGORY_EVENT:
1384 HandleAbandonCateGoryEvent(event);
1385 break;
1386 case EventAudioServerCmd::FOCUS_INFOCHANGE:
1387 HandleFocusInfoChangeEvent(event);
1388 break;
1389 case EventAudioServerCmd::RINGER_MODEUPDATE_EVENT:
1390 HandleRingerModeUpdatedEvent(event);
1391 break;
1392 case EventAudioServerCmd::MIC_STATE_CHANGE_EVENT:
1393 HandleMicStateUpdatedEvent(event);
1394 break;
1395 case EventAudioServerCmd::MIC_STATE_CHANGE_EVENT_WITH_CLIENTID:
1396 HandleMicStateUpdatedEventWithClientId(event);
1397 break;
1398 case EventAudioServerCmd::INTERRUPT_EVENT:
1399 HandleInterruptEvent(event);
1400 break;
1401 case EventAudioServerCmd::INTERRUPT_EVENT_WITH_STREAMID:
1402 HandleInterruptEventWithStreamId(event);
1403 break;
1404 case EventAudioServerCmd::INTERRUPT_EVENT_WITH_CLIENTID:
1405 HandleInterruptEventWithClientId(event);
1406 break;
1407 case EventAudioServerCmd::DISTRIBUTED_ROUTING_ROLE_CHANGE:
1408 HandleDistributedRoutingRoleChangeEvent(event);
1409 break;
1410 case EventAudioServerCmd::HEAD_TRACKING_DEVICE_CHANGE:
1411 HandleHeadTrackingDeviceChangeEvent(event);
1412 break;
1413 case EventAudioServerCmd::SPATIALIZATION_ENABLED_CHANGE:
1414 HandleSpatializatonEnabledChangeEvent(event);
1415 break;
1416 case EventAudioServerCmd::HEAD_TRACKING_ENABLED_CHANGE:
1417 HandleHeadTrackingEnabledChangeEvent(event);
1418 break;
1419 default:
1420 break;
1421 }
1422 }
1423
SetClientCallbacksEnable(const CallbackChange & callbackchange,const bool & enable)1424 int32_t AudioPolicyServerHandler::SetClientCallbacksEnable(const CallbackChange &callbackchange, const bool &enable)
1425 {
1426 if (callbackchange <= CALLBACK_UNKNOWN || callbackchange >= CALLBACK_MAX) {
1427 AUDIO_ERR_LOG("Illegal parameter");
1428 return AUDIO_ERR;
1429 }
1430
1431 int32_t clientId = IPCSkeleton::GetCallingPid();
1432 lock_guard<mutex> runnerlock(handleMapMutex_);
1433 clientCallbacksMap_[clientId][callbackchange] = enable;
1434 string str = (enable ? "true" : "false");
1435 AUDIO_INFO_LOG("Set clientId:%{public}d, callbacks:%{public}d, enable:%{public}s",
1436 clientId, callbackchange, str.c_str());
1437 return AUDIO_OK;
1438 }
1439
SetCallbackRendererInfo(const AudioRendererInfo & rendererInfo)1440 int32_t AudioPolicyServerHandler::SetCallbackRendererInfo(const AudioRendererInfo &rendererInfo)
1441 {
1442 int32_t clientPid = IPCSkeleton::GetCallingPid();
1443 lock_guard<mutex> lock(clientCbRendererInfoMapMutex_);
1444 auto &rendererList = clientCbRendererInfoMap_[clientPid];
1445 auto it = std::find_if(rendererList.begin(), rendererList.end(),
1446 [&rendererInfo](const AudioRendererInfo &existingRenderer) {
1447 return existingRenderer.streamUsage == rendererInfo.streamUsage;
1448 });
1449 if (it == rendererList.end()) {
1450 rendererList.push_back(rendererInfo);
1451 }
1452 return AUDIO_OK;
1453 }
1454
GetCallbackRendererInfoList(int32_t clientPid)1455 std::vector<AudioRendererInfo> AudioPolicyServerHandler::GetCallbackRendererInfoList(int32_t clientPid)
1456 {
1457 lock_guard<mutex> lock(clientCbRendererInfoMapMutex_);
1458 auto it = clientCbRendererInfoMap_.find(clientPid);
1459 if (it == clientCbRendererInfoMap_.end()) {
1460 return {};
1461 }
1462 return it->second;
1463 }
1464
SetCallbackCapturerInfo(const AudioCapturerInfo & capturerInfo)1465 int32_t AudioPolicyServerHandler::SetCallbackCapturerInfo(const AudioCapturerInfo &capturerInfo)
1466 {
1467 int32_t clientPid = IPCSkeleton::GetCallingPid();
1468 lock_guard<mutex> lock(clientCbCapturerInfoMapMutex_);
1469 auto &capturerList = clientCbCapturerInfoMap_[clientPid];
1470 auto it = std::find_if(capturerList.begin(), capturerList.end(),
1471 [&capturerInfo](const AudioCapturerInfo &existingCapturer) {
1472 return existingCapturer.sourceType == capturerInfo.sourceType;
1473 });
1474 if (it == capturerList.end()) {
1475 capturerList.push_back(capturerInfo);
1476 }
1477 return AUDIO_OK;
1478 }
1479
GetCallbackCapturerInfoList(int32_t clientPid)1480 std::vector<AudioCapturerInfo> AudioPolicyServerHandler::GetCallbackCapturerInfoList(int32_t clientPid)
1481 {
1482 lock_guard<mutex> lock(clientCbCapturerInfoMapMutex_);
1483 auto it = clientCbCapturerInfoMap_.find(clientPid);
1484 if (it == clientCbCapturerInfoMap_.end()) {
1485 return {};
1486 }
1487 return it->second;
1488 }
1489 } // namespace AudioStandard
1490 } // namespace OHOS
1491