1 /*
2  * Copyright (c) 2023-2024 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_utils.h"
22 
23 namespace OHOS {
24 namespace AudioStandard {
25 
26 namespace  {
27     constexpr int32_t MAX_DELAY_TIME = 4 * 1000;
28 }
29 
GeneratePidsStrForPrinting(const std::unordered_map<int32_t,sptr<IAudioPolicyClient>> & unorderedMap)30 static std::string GeneratePidsStrForPrinting(
31     const std::unordered_map<int32_t, sptr<IAudioPolicyClient>> &unorderedMap)
32 {
33     std::string retString = "[";
34     for (const auto &[pid, iAudioPolicyClient] : unorderedMap) {
35         retString += (std::to_string(pid) + ',');
36     }
37     retString += ']';
38     return retString;
39 }
40 
AudioPolicyServerHandler()41 AudioPolicyServerHandler::AudioPolicyServerHandler() : AppExecFwk::EventHandler(
42     AppExecFwk::EventRunner::Create("OS_APAsyncRunner"))
43 {
44     AUDIO_DEBUG_LOG("ctor");
45 }
46 
~AudioPolicyServerHandler()47 AudioPolicyServerHandler::~AudioPolicyServerHandler()
48 {
49     AUDIO_WARNING_LOG("dtor should not happen");
50 };
51 
Init(std::shared_ptr<IAudioInterruptEventDispatcher> dispatcher)52 void AudioPolicyServerHandler::Init(std::shared_ptr<IAudioInterruptEventDispatcher> dispatcher)
53 {
54     interruptEventDispatcher_ = dispatcher;
55 }
56 
AddAudioPolicyClientProxyMap(int32_t clientPid,const sptr<IAudioPolicyClient> & cb)57 void AudioPolicyServerHandler::AddAudioPolicyClientProxyMap(int32_t clientPid, const sptr<IAudioPolicyClient>& cb)
58 {
59     std::lock_guard<std::mutex> lock(runnerMutex_);
60     auto [it, res] = audioPolicyClientProxyAPSCbsMap_.try_emplace(clientPid, cb);
61     if (!res) {
62         if (cb == it->second) {
63             AUDIO_WARNING_LOG("Duplicate registration");
64         } else {
65             AUDIO_ERR_LOG("client registers multiple callbacks, the callback may be lost.");
66         }
67     }
68     pidsStrForPrinting_ = GeneratePidsStrForPrinting(audioPolicyClientProxyAPSCbsMap_);
69     AUDIO_INFO_LOG("group data num [%{public}zu] pid [%{public}d] map %{public}s",
70         audioPolicyClientProxyAPSCbsMap_.size(), clientPid, pidsStrForPrinting_.c_str());
71 }
72 
RemoveAudioPolicyClientProxyMap(pid_t clientPid)73 void AudioPolicyServerHandler::RemoveAudioPolicyClientProxyMap(pid_t clientPid)
74 {
75     std::lock_guard<std::mutex> lock(runnerMutex_);
76     audioPolicyClientProxyAPSCbsMap_.erase(clientPid);
77     clientCallbacksMap_.erase(clientPid);
78     pidsStrForPrinting_ = GeneratePidsStrForPrinting(audioPolicyClientProxyAPSCbsMap_);
79     AUDIO_INFO_LOG("RemoveAudioPolicyClientProxyMap, group data num [%{public}zu] map %{public}s",
80         audioPolicyClientProxyAPSCbsMap_.size(), pidsStrForPrinting_.c_str());
81 }
82 
AddExternInterruptCbsMap(int32_t clientId,const std::shared_ptr<AudioInterruptCallback> & callback)83 void AudioPolicyServerHandler::AddExternInterruptCbsMap(int32_t clientId,
84     const std::shared_ptr<AudioInterruptCallback> &callback)
85 {
86     std::lock_guard<std::mutex> lock(runnerMutex_);
87     amInterruptCbsMap_[clientId] = callback;
88     AUDIO_INFO_LOG("AddExternInterruptCbsMap, group data num [%{public}zu]",
89         amInterruptCbsMap_.size());
90 }
91 
RemoveExternInterruptCbsMap(int32_t clientId)92 int32_t AudioPolicyServerHandler::RemoveExternInterruptCbsMap(int32_t clientId)
93 {
94     std::lock_guard<std::mutex> lock(runnerMutex_);
95     if (amInterruptCbsMap_.erase(clientId) == 0) {
96         AUDIO_ERR_LOG("RemoveExternInterruptCbsMap client %{public}d not present", clientId);
97         return ERR_INVALID_OPERATION;
98     }
99     return SUCCESS;
100 }
101 
AddAvailableDeviceChangeMap(int32_t clientId,const AudioDeviceUsage usage,const sptr<IStandardAudioPolicyManagerListener> & callback)102 void AudioPolicyServerHandler::AddAvailableDeviceChangeMap(int32_t clientId, const AudioDeviceUsage usage,
103     const sptr<IStandardAudioPolicyManagerListener> &callback)
104 {
105     std::lock_guard<std::mutex> lock(runnerMutex_);
106     availableDeviceChangeCbsMap_[{clientId, usage}] = callback;
107     AUDIO_INFO_LOG("AddAvailableDeviceChangeMap, group data num [%{public}zu]", availableDeviceChangeCbsMap_.size());
108 }
109 
RemoveAvailableDeviceChangeMap(const int32_t clientId,AudioDeviceUsage usage)110 void AudioPolicyServerHandler::RemoveAvailableDeviceChangeMap(const int32_t clientId, AudioDeviceUsage usage)
111 {
112     std::lock_guard<std::mutex> lock(runnerMutex_);
113     if (availableDeviceChangeCbsMap_.erase({clientId, usage}) == 0) {
114         AUDIO_INFO_LOG("client not present in %{public}s", __func__);
115     }
116     // for routing manager napi remove all device change callback
117     if (usage == AudioDeviceUsage::D_ALL_DEVICES) {
118         for (auto it = availableDeviceChangeCbsMap_.begin(); it != availableDeviceChangeCbsMap_.end();) {
119             if ((*it).first.first == clientId) {
120                 it = availableDeviceChangeCbsMap_.erase(it);
121             } else {
122                 it++;
123             }
124         }
125     }
126     AUDIO_INFO_LOG("RemoveAvailableDeviceChangeMap, group data num [%{public}zu]",
127         availableDeviceChangeCbsMap_.size());
128 }
129 
AddDistributedRoutingRoleChangeCbsMap(int32_t clientId,const sptr<IStandardAudioRoutingManagerListener> & callback)130 void AudioPolicyServerHandler::AddDistributedRoutingRoleChangeCbsMap(int32_t clientId,
131     const sptr<IStandardAudioRoutingManagerListener> &callback)
132 {
133     std::lock_guard<std::mutex> lock(runnerMutex_);
134     if (callback != nullptr) {
135         distributedRoutingRoleChangeCbsMap_[clientId] = callback;
136     }
137     AUDIO_DEBUG_LOG("SetDistributedRoutingRoleCallback: distributedRoutingRoleChangeCbsMap_ size: %{public}zu",
138         distributedRoutingRoleChangeCbsMap_.size());
139 }
140 
RemoveDistributedRoutingRoleChangeCbsMap(int32_t clientId)141 int32_t AudioPolicyServerHandler::RemoveDistributedRoutingRoleChangeCbsMap(int32_t clientId)
142 {
143     std::lock_guard<std::mutex> lock(runnerMutex_);
144     if (distributedRoutingRoleChangeCbsMap_.erase(clientId) == 0) {
145         AUDIO_ERR_LOG("RemoveDistributedRoutingRoleChangeCbsMap clientPid %{public}d not present", clientId);
146         return ERR_INVALID_OPERATION;
147     }
148 
149     AUDIO_DEBUG_LOG("UnsetDistributedRoutingRoleCallback: distributedRoutingRoleChangeCbsMap_ size: %{public}zu",
150         distributedRoutingRoleChangeCbsMap_.size());
151     return SUCCESS;
152 }
153 
AddConcurrencyEventDispatcher(std::shared_ptr<IAudioConcurrencyEventDispatcher> dispatcher)154 void AudioPolicyServerHandler::AddConcurrencyEventDispatcher(std::shared_ptr<IAudioConcurrencyEventDispatcher>
155     dispatcher)
156 {
157     concurrencyEventDispatcher_ = dispatcher;
158 }
159 
SendDeviceChangedCallback(const std::vector<sptr<AudioDeviceDescriptor>> & desc,bool isConnected)160 bool AudioPolicyServerHandler::SendDeviceChangedCallback(const std::vector<sptr<AudioDeviceDescriptor>> &desc,
161     bool isConnected)
162 {
163     Trace trace("AudioPolicyServerHandler::SendDeviceChangedCallback");
164     std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
165     CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
166     eventContextObj->deviceChangeAction.type = isConnected ? DeviceChangeType::CONNECT : DeviceChangeType::DISCONNECT;
167     eventContextObj->deviceChangeAction.deviceDescriptors = desc;
168 
169     lock_guard<mutex> runnerlock(runnerMutex_);
170     bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::AUDIO_DEVICE_CHANGE, eventContextObj));
171     CHECK_AND_RETURN_RET_LOG(ret, ret, "SendDeviceChangedCallback event failed");
172     return ret;
173 }
174 
SendMicrophoneBlockedCallback(const std::vector<sptr<AudioDeviceDescriptor>> & desc,DeviceBlockStatus status)175 bool AudioPolicyServerHandler::SendMicrophoneBlockedCallback(const std::vector<sptr<AudioDeviceDescriptor>> &desc,
176     DeviceBlockStatus status)
177 {
178     Trace trace("AudioPolicyServerHandler::SendMicrophoneBlockedCallback");
179     std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
180     CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
181     eventContextObj->microphoneBlockedInfo.blockStatus = status;
182     eventContextObj->microphoneBlockedInfo.devices = desc;
183 
184     lock_guard<mutex> runnerlock(runnerMutex_);
185     bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::MICROPHONE_BLOCKED, eventContextObj));
186     CHECK_AND_RETURN_RET_LOG(ret, ret, "SendMicrophoneBlockedCallback event failed");
187     return ret;
188 }
189 
SendAvailableDeviceChange(const std::vector<sptr<AudioDeviceDescriptor>> & desc,bool isConnected)190 bool AudioPolicyServerHandler::SendAvailableDeviceChange(const std::vector<sptr<AudioDeviceDescriptor>> &desc,
191     bool isConnected)
192 {
193     std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
194     CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
195     eventContextObj->deviceChangeAction.type = isConnected ? DeviceChangeType::CONNECT : DeviceChangeType::DISCONNECT;
196     eventContextObj->deviceChangeAction.deviceDescriptors = desc;
197 
198     lock_guard<mutex> runnerlock(runnerMutex_);
199     bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::AVAILABLE_AUDIO_DEVICE_CHANGE,
200         eventContextObj));
201     CHECK_AND_RETURN_RET_LOG(ret, ret, "SendAvailableDeviceChange event failed");
202     return ret;
203 }
204 
SendVolumeKeyEventCallback(const VolumeEvent & volumeEvent)205 bool AudioPolicyServerHandler::SendVolumeKeyEventCallback(const VolumeEvent &volumeEvent)
206 {
207     std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
208     CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
209     eventContextObj->volumeEvent = volumeEvent;
210     lock_guard<mutex> runnerlock(runnerMutex_);
211     bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::VOLUME_KEY_EVENT, eventContextObj));
212     CHECK_AND_RETURN_RET_LOG(ret, ret, "SendVolumeKeyEventCallback event failed");
213     return ret;
214 }
215 
SendAudioSessionDeactiveCallback(const std::pair<int32_t,AudioSessionDeactiveEvent> & sessionDeactivePair)216 bool AudioPolicyServerHandler::SendAudioSessionDeactiveCallback(
217     const std::pair<int32_t, AudioSessionDeactiveEvent> &sessionDeactivePair)
218 {
219     std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
220     CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
221     eventContextObj->sessionDeactivePair = sessionDeactivePair;
222     lock_guard<mutex> runnerlock(runnerMutex_);
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 
SendMicStateUpdatedCallback(const MicStateChangeEvent & micStateChangeEvent)263 bool AudioPolicyServerHandler::SendMicStateUpdatedCallback(const MicStateChangeEvent &micStateChangeEvent)
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->micStateChangeEvent = micStateChangeEvent;
268     lock_guard<mutex> runnerlock(runnerMutex_);
269     bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::MIC_STATE_CHANGE_EVENT, eventContextObj));
270     CHECK_AND_RETURN_RET_LOG(ret, ret, "Send MIC_STATE_CHANGE_EVENT event failed");
271     return ret;
272 }
273 
SendMicStateWithClientIdCallback(const MicStateChangeEvent & micStateChangeEvent,int32_t clientId)274 bool AudioPolicyServerHandler::SendMicStateWithClientIdCallback(const MicStateChangeEvent &micStateChangeEvent,
275     int32_t clientId)
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->micStateChangeEvent = micStateChangeEvent;
280     eventContextObj->clientId = clientId;
281     lock_guard<mutex> runnerlock(runnerMutex_);
282     bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::MIC_STATE_CHANGE_EVENT_WITH_CLIENTID,
283         eventContextObj));
284     CHECK_AND_RETURN_RET_LOG(ret, ret, "Send MIC_STATE_CHANGE_EVENT_WITH_CLIENTID event failed");
285     return ret;
286 }
287 
SendInterruptEventInternalCallback(const InterruptEventInternal & interruptEvent)288 bool AudioPolicyServerHandler::SendInterruptEventInternalCallback(const InterruptEventInternal &interruptEvent)
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->interruptEvent = interruptEvent;
293     lock_guard<mutex> runnerlock(runnerMutex_);
294     bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::INTERRUPT_EVENT, eventContextObj));
295     CHECK_AND_RETURN_RET_LOG(ret, ret, "Send INTERRUPT_EVENT event failed");
296     return ret;
297 }
298 
SendInterruptEventWithSessionIdCallback(const InterruptEventInternal & interruptEvent,const uint32_t & sessionId)299 bool AudioPolicyServerHandler::SendInterruptEventWithSessionIdCallback(const InterruptEventInternal &interruptEvent,
300     const uint32_t &sessionId)
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->interruptEvent = interruptEvent;
305     eventContextObj->sessionId = sessionId;
306     lock_guard<mutex> runnerlock(runnerMutex_);
307     bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::INTERRUPT_EVENT_WITH_SESSIONID,
308         eventContextObj));
309     CHECK_AND_RETURN_RET_LOG(ret, ret, "Send INTERRUPT_EVENT_WITH_SESSIONID event failed");
310     return ret;
311 }
312 
SendInterruptEventWithClientIdCallback(const InterruptEventInternal & interruptEvent,const int32_t & clientId)313 bool AudioPolicyServerHandler::SendInterruptEventWithClientIdCallback(const InterruptEventInternal &interruptEvent,
314     const int32_t &clientId)
315 {
316     std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
317     CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
318     eventContextObj->interruptEvent = interruptEvent;
319     eventContextObj->clientId = clientId;
320     lock_guard<mutex> runnerlock(runnerMutex_);
321     bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::INTERRUPT_EVENT_WITH_CLIENTID,
322         eventContextObj));
323     CHECK_AND_RETURN_RET_LOG(ret, ret, "Send INTERRUPT_EVENT_WITH_CLIENTID event failed");
324     return ret;
325 }
326 
SendPreferredOutputDeviceUpdated()327 bool AudioPolicyServerHandler::SendPreferredOutputDeviceUpdated()
328 {
329     lock_guard<mutex> runnerlock(runnerMutex_);
330     bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::PREFERRED_OUTPUT_DEVICE_UPDATED));
331     CHECK_AND_RETURN_RET_LOG(ret, ret, "SendPreferredOutputDeviceUpdated event failed");
332     return ret;
333 }
334 
SendPreferredInputDeviceUpdated()335 bool AudioPolicyServerHandler::SendPreferredInputDeviceUpdated()
336 {
337     lock_guard<mutex> runnerlock(runnerMutex_);
338     bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::PREFERRED_INPUT_DEVICE_UPDATED));
339     CHECK_AND_RETURN_RET_LOG(ret, ret, "SendPreferredInputDeviceUpdated event failed");
340     return ret;
341 }
342 
SendDistributedRoutingRoleChange(const sptr<AudioDeviceDescriptor> descriptor,const CastType & type)343 bool AudioPolicyServerHandler::SendDistributedRoutingRoleChange(const sptr<AudioDeviceDescriptor> descriptor,
344     const CastType &type)
345 {
346     std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
347     CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
348     eventContextObj->descriptor = descriptor;
349     eventContextObj->type = type;
350     lock_guard<mutex> runnerlock(runnerMutex_);
351     bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::DISTRIBUTED_ROUTING_ROLE_CHANGE,
352         eventContextObj));
353     CHECK_AND_RETURN_RET_LOG(ret, ret, "SendDistributedRoutingRoleChange event failed");
354     return ret;
355 }
356 
SendRendererInfoEvent(const std::vector<std::unique_ptr<AudioRendererChangeInfo>> & audioRendererChangeInfos)357 bool AudioPolicyServerHandler::SendRendererInfoEvent(
358     const std::vector<std::unique_ptr<AudioRendererChangeInfo>> &audioRendererChangeInfos)
359 {
360     std::vector<std::unique_ptr<AudioRendererChangeInfo>> rendererChangeInfos;
361     for (const auto &changeInfo : audioRendererChangeInfos) {
362         rendererChangeInfos.push_back(std::make_unique<AudioRendererChangeInfo>(*changeInfo));
363     }
364 
365     std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
366     CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
367     eventContextObj->audioRendererChangeInfos = move(rendererChangeInfos);
368 
369     lock_guard<mutex> runnerlock(runnerMutex_);
370     bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::RENDERER_INFO_EVENT,
371         eventContextObj));
372     CHECK_AND_RETURN_RET_LOG(ret, ret, "SendRendererInfoEvent event failed");
373     return ret;
374 }
375 
SendCapturerInfoEvent(const std::vector<std::unique_ptr<AudioCapturerChangeInfo>> & audioCapturerChangeInfos)376 bool AudioPolicyServerHandler::SendCapturerInfoEvent(
377     const std::vector<std::unique_ptr<AudioCapturerChangeInfo>> &audioCapturerChangeInfos)
378 {
379     std::vector<std::unique_ptr<AudioCapturerChangeInfo>> capturerChangeInfos;
380     for (const auto &changeInfo : audioCapturerChangeInfos) {
381         capturerChangeInfos.push_back(std::make_unique<AudioCapturerChangeInfo>(*changeInfo));
382     }
383 
384     std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
385     CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
386     eventContextObj->audioCapturerChangeInfos = move(capturerChangeInfos);
387 
388     lock_guard<mutex> runnerlock(runnerMutex_);
389     bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::CAPTURER_INFO_EVENT,
390         eventContextObj));
391     CHECK_AND_RETURN_RET_LOG(ret, ret, "SendRendererInfoEvent event failed");
392     return ret;
393 }
394 
SendRendererDeviceChangeEvent(const int32_t clientPid,const uint32_t sessionId,const DeviceInfo & outputDeviceInfo,const AudioStreamDeviceChangeReasonExt reason)395 bool AudioPolicyServerHandler::SendRendererDeviceChangeEvent(const int32_t clientPid, const uint32_t sessionId,
396     const DeviceInfo &outputDeviceInfo, const AudioStreamDeviceChangeReasonExt reason)
397 {
398     std::shared_ptr<RendererDeviceChangeEvent> eventContextObj = std::make_shared<RendererDeviceChangeEvent>(
399         clientPid, sessionId, outputDeviceInfo, reason);
400     CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
401 
402     lock_guard<mutex> runnerlock(runnerMutex_);
403     bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::RENDERER_DEVICE_CHANGE_EVENT,
404         eventContextObj));
405     CHECK_AND_RETURN_RET_LOG(ret, ret, "SendRendererDeviceChangeEvent event failed");
406     return ret;
407 }
408 
SendCapturerCreateEvent(AudioCapturerInfo capturerInfo,AudioStreamInfo streamInfo,uint64_t sessionId,bool isSync,int32_t & error)409 bool AudioPolicyServerHandler::SendCapturerCreateEvent(AudioCapturerInfo capturerInfo,
410     AudioStreamInfo streamInfo, uint64_t sessionId, bool isSync, int32_t &error)
411 {
412     auto eventContextObj = std::make_shared<CapturerCreateEvent>(capturerInfo, streamInfo, sessionId, SUCCESS);
413     CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
414 
415     bool ret;
416     if (isSync) {
417         ret = SendSyncEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::ON_CAPTURER_CREATE,
418             eventContextObj));
419         error = eventContextObj->error_;
420     } else {
421         ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::ON_CAPTURER_CREATE,
422             eventContextObj));
423         error = SUCCESS;
424     }
425     CHECK_AND_RETURN_RET_LOG(ret, ret, "failed");
426     return ret;
427 }
428 
SendCapturerRemovedEvent(uint64_t sessionId,bool isSync)429 bool AudioPolicyServerHandler::SendCapturerRemovedEvent(uint64_t sessionId, bool isSync)
430 {
431     auto eventContextObj = std::make_shared<uint64_t>(sessionId);
432     CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
433 
434     bool ret;
435     if (isSync) {
436         ret = SendSyncEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::ON_CAPTURER_REMOVED,
437             eventContextObj));
438     } else {
439         ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::ON_CAPTURER_REMOVED,
440             eventContextObj));
441     }
442     CHECK_AND_RETURN_RET_LOG(ret, ret, "failed");
443     return ret;
444 }
445 
SendWakeupCloseEvent(bool isSync)446 bool AudioPolicyServerHandler::SendWakeupCloseEvent(bool isSync)
447 {
448     bool ret;
449     if (isSync) {
450         ret = SendSyncEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::ON_WAKEUP_CLOSE));
451     } else {
452         ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::ON_WAKEUP_CLOSE));
453     }
454     CHECK_AND_RETURN_RET_LOG(ret, ret, "failed");
455     return ret;
456 }
457 
SendRecreateRendererStreamEvent(int32_t clientId,uint32_t sessionID,int32_t streamFlag,const AudioStreamDeviceChangeReasonExt reason)458 bool AudioPolicyServerHandler::SendRecreateRendererStreamEvent(int32_t clientId, uint32_t sessionID, int32_t streamFlag,
459     const AudioStreamDeviceChangeReasonExt reason)
460 {
461     std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
462     CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
463     eventContextObj->clientId = clientId;
464     eventContextObj->sessionId = sessionID;
465     eventContextObj->streamFlag = streamFlag;
466     eventContextObj->reason_ = reason;
467     return SendSyncEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::RECREATE_RENDERER_STREAM_EVENT,
468         eventContextObj));
469 }
470 
SendRecreateCapturerStreamEvent(int32_t clientId,uint32_t sessionID,int32_t streamFlag,const AudioStreamDeviceChangeReasonExt reason)471 bool AudioPolicyServerHandler::SendRecreateCapturerStreamEvent(int32_t clientId, uint32_t sessionID, int32_t streamFlag,
472     const AudioStreamDeviceChangeReasonExt reason)
473 {
474     std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
475     CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
476     eventContextObj->clientId = clientId;
477     eventContextObj->sessionId = sessionID;
478     eventContextObj->streamFlag = streamFlag;
479     eventContextObj->reason_ = reason;
480     return SendSyncEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::RECREATE_CAPTURER_STREAM_EVENT,
481         eventContextObj));
482 }
483 
SendHeadTrackingDeviceChangeEvent(const std::unordered_map<std::string,bool> & changeInfo)484 bool AudioPolicyServerHandler::SendHeadTrackingDeviceChangeEvent(
485     const std::unordered_map<std::string, bool> &changeInfo)
486 {
487     std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
488     CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
489     eventContextObj->headTrackingDeviceChangeInfo = changeInfo;
490     lock_guard<mutex> runnerlock(runnerMutex_);
491     bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::HEAD_TRACKING_DEVICE_CHANGE,
492         eventContextObj));
493     CHECK_AND_RETURN_RET_LOG(ret, ret, "Send HEAD_TRACKING_DEVICE_CHANGE event failed");
494     return ret;
495 }
496 
SendSpatializatonEnabledChangeEvent(const bool & enabled)497 bool AudioPolicyServerHandler::SendSpatializatonEnabledChangeEvent(const bool &enabled)
498 {
499     std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
500     CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
501     eventContextObj->spatializationEnabled = enabled;
502     lock_guard<mutex> runnerlock(runnerMutex_);
503     bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::SPATIALIZATION_ENABLED_CHANGE,
504         eventContextObj));
505     CHECK_AND_RETURN_RET_LOG(ret, ret, "Send SPATIALIZATION_ENABLED_CHANGE event failed");
506     return ret;
507 }
508 
SendSpatializatonEnabledChangeForAnyDeviceEvent(const sptr<AudioDeviceDescriptor> & selectedAudioDevice,const bool & enabled)509 bool AudioPolicyServerHandler::SendSpatializatonEnabledChangeForAnyDeviceEvent(const sptr<AudioDeviceDescriptor>
510     &selectedAudioDevice, const bool &enabled)
511 {
512     std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
513     CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
514     eventContextObj->spatializationEnabled = enabled;
515     eventContextObj->descriptor = selectedAudioDevice;
516     lock_guard<mutex> runnerlock(runnerMutex_);
517     bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::SPATIALIZATION_ENABLED_CHANGE_FOR_ANY_DEVICE,
518         eventContextObj));
519     CHECK_AND_RETURN_RET_LOG(ret, ret, "Send SPATIALIZATION_ENABLED_CHANGE event failed");
520     return ret;
521 }
522 
SendHeadTrackingEnabledChangeEvent(const bool & enabled)523 bool AudioPolicyServerHandler::SendHeadTrackingEnabledChangeEvent(const bool &enabled)
524 {
525     std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
526     CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
527     eventContextObj->headTrackingEnabled = enabled;
528     lock_guard<mutex> runnerlock(runnerMutex_);
529     bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::HEAD_TRACKING_ENABLED_CHANGE,
530         eventContextObj));
531     CHECK_AND_RETURN_RET_LOG(ret, ret, "Send HEAD_TRACKING_ENABLED_CHANGE event failed");
532     return ret;
533 }
534 
SendKvDataUpdate(const bool & isFirstBoot)535 bool AudioPolicyServerHandler::SendKvDataUpdate(const bool &isFirstBoot)
536 {
537     auto eventContextObj = std::make_shared<bool>(isFirstBoot);
538     lock_guard<mutex> runnerlock(runnerMutex_);
539     bool ret = true;
540     if (isFirstBoot) {
541         ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::DATABASE_UPDATE, eventContextObj),
542             MAX_DELAY_TIME);
543     } else {
544         ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::DATABASE_UPDATE, eventContextObj));
545     }
546     CHECK_AND_RETURN_RET_LOG(ret, ret, "SendKvDataUpdate event failed");
547     return ret;
548 }
549 
SendHeadTrackingEnabledChangeForAnyDeviceEvent(const sptr<AudioDeviceDescriptor> & selectedAudioDevice,const bool & enabled)550 bool AudioPolicyServerHandler::SendHeadTrackingEnabledChangeForAnyDeviceEvent(const sptr<AudioDeviceDescriptor>
551     &selectedAudioDevice,
552     const bool &enabled)
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->headTrackingEnabled = enabled;
557     eventContextObj->descriptor = selectedAudioDevice;
558     lock_guard<mutex> runnerlock(runnerMutex_);
559     bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::HEAD_TRACKING_ENABLED_CHANGE_FOR_ANY_DEVICE,
560         eventContextObj));
561     CHECK_AND_RETURN_RET_LOG(ret, ret, "Send HEAD_TRACKING_ENABLED_CHANGE event failed");
562     return ret;
563 }
564 
SendPipeStreamCleanEvent(AudioPipeType pipeType)565 bool AudioPolicyServerHandler::SendPipeStreamCleanEvent(AudioPipeType pipeType)
566 {
567     auto eventContextObj = std::make_shared<int32_t>(pipeType);
568     lock_guard<mutex> runnerlock(runnerMutex_);
569     bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::PIPE_STREAM_CLEAN_EVENT,
570         eventContextObj));
571     CHECK_AND_RETURN_RET_LOG(ret, ret, "Send PIPE_STREAM_CLEAN_EVENT event failed");
572     return ret;
573 }
574 
SendConcurrencyEventWithSessionIDCallback(const uint32_t sessionID)575 bool AudioPolicyServerHandler::SendConcurrencyEventWithSessionIDCallback(const uint32_t sessionID)
576 {
577     AUDIO_INFO_LOG("session %{public}u send concurrency event", sessionID);
578     std::shared_ptr<EventContextObj> eventContextObj = std::make_shared<EventContextObj>();
579     CHECK_AND_RETURN_RET_LOG(eventContextObj != nullptr, false, "EventContextObj get nullptr");
580     eventContextObj->sessionId = sessionID;
581     lock_guard<mutex> runnerlock(runnerMutex_);
582     bool ret = SendEvent(AppExecFwk::InnerEvent::Get(EventAudioServerCmd::CONCURRENCY_EVENT_WITH_SESSIONID,
583         eventContextObj));
584     CHECK_AND_RETURN_RET_LOG(ret, ret, "Send CONCURRENCY_EVENT_WITH_SESSIONID event failed");
585     return ret;
586 }
587 
HandleDeviceChangedCallback(const AppExecFwk::InnerEvent::Pointer & event)588 void AudioPolicyServerHandler::HandleDeviceChangedCallback(const AppExecFwk::InnerEvent::Pointer &event)
589 {
590     std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
591     CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
592     std::lock_guard<std::mutex> lock(runnerMutex_);
593     for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
594         if (it->second && eventContextObj->deviceChangeAction.deviceDescriptors.size() > 0) {
595             DeviceChangeAction deviceChangeAction = eventContextObj->deviceChangeAction;
596             if (!(it->second->hasBTPermission_)) {
597                 AudioPolicyService::GetAudioPolicyService().
598                     UpdateDescWhenNoBTPermission(deviceChangeAction.deviceDescriptors);
599             }
600             if (clientCallbacksMap_.count(it->first) > 0 &&
601                 clientCallbacksMap_[it->first].count(CALLBACK_SET_DEVICE_CHANGE) > 0 &&
602                 clientCallbacksMap_[it->first][CALLBACK_SET_DEVICE_CHANGE]) {
603                 it->second->OnDeviceChange(deviceChangeAction);
604             }
605         }
606     }
607 }
608 
HandleMicrophoneBlockedCallback(const AppExecFwk::InnerEvent::Pointer & event)609 void AudioPolicyServerHandler::HandleMicrophoneBlockedCallback(const AppExecFwk::InnerEvent::Pointer &event)
610 {
611     std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
612     CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
613     std::lock_guard<std::mutex> lock(runnerMutex_);
614 
615     for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
616         if (it->second && eventContextObj->microphoneBlockedInfo.devices.size() > 0) {
617             MicrophoneBlockedInfo microphoneBlockedInfo = eventContextObj->microphoneBlockedInfo;
618             if (clientCallbacksMap_.count(it->first) > 0 &&
619                 clientCallbacksMap_[it->first].count(CALLBACK_SET_MICROPHONE_BLOCKED) > 0 &&
620                 clientCallbacksMap_[it->first][CALLBACK_SET_MICROPHONE_BLOCKED]) {
621                 it->second->OnMicrophoneBlocked(microphoneBlockedInfo);
622             }
623         }
624     }
625 }
626 
HandleAvailableDeviceChange(const AppExecFwk::InnerEvent::Pointer & event)627 void AudioPolicyServerHandler::HandleAvailableDeviceChange(const AppExecFwk::InnerEvent::Pointer &event)
628 {
629     std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
630     CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
631     std::lock_guard<std::mutex> lock(runnerMutex_);
632     for (auto it = availableDeviceChangeCbsMap_.begin(); it != availableDeviceChangeCbsMap_.end(); ++it) {
633         AudioDeviceUsage usage = it->first.second;
634         eventContextObj->deviceChangeAction.deviceDescriptors = AudioPolicyService::GetAudioPolicyService().
635             DeviceFilterByUsageInner(it->first.second, eventContextObj->deviceChangeAction.deviceDescriptors);
636         if (it->second && eventContextObj->deviceChangeAction.deviceDescriptors.size() > 0) {
637             if (!(it->second->hasBTPermission_)) {
638                 AudioPolicyService::GetAudioPolicyService().
639                     UpdateDescWhenNoBTPermission(eventContextObj->deviceChangeAction.deviceDescriptors);
640             }
641             it->second->OnAvailableDeviceChange(usage, eventContextObj->deviceChangeAction);
642         }
643     }
644 }
645 
HandleVolumeKeyEvent(const AppExecFwk::InnerEvent::Pointer & event)646 void AudioPolicyServerHandler::HandleVolumeKeyEvent(const AppExecFwk::InnerEvent::Pointer &event)
647 {
648     std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
649     CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
650     std::lock_guard<std::mutex> lock(runnerMutex_);
651     for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
652         sptr<IAudioPolicyClient> volumeChangeCb = it->second;
653         if (volumeChangeCb == nullptr) {
654             AUDIO_ERR_LOG("volumeChangeCb: nullptr for client : %{public}d", it->first);
655             continue;
656         }
657         AUDIO_PRERELEASE_LOGI("Trigger volumeChangeCb clientPid : %{public}d, volumeType : %{public}d," \
658             " volume : %{public}d, updateUi : %{public}d ", it->first,
659             static_cast<int32_t>(eventContextObj->volumeEvent.volumeType), eventContextObj->volumeEvent.volume,
660             static_cast<int32_t>(eventContextObj->volumeEvent.updateUi));
661         if (clientCallbacksMap_.count(it->first) > 0 &&
662             clientCallbacksMap_[it->first].count(CALLBACK_SET_VOLUME_KEY_EVENT) > 0 &&
663             clientCallbacksMap_[it->first][CALLBACK_SET_VOLUME_KEY_EVENT]) {
664             volumeChangeCb->OnVolumeKeyEvent(eventContextObj->volumeEvent);
665         }
666     }
667 }
668 
HandleAudioSessionDeactiveCallback(const AppExecFwk::InnerEvent::Pointer & event)669 void AudioPolicyServerHandler::HandleAudioSessionDeactiveCallback(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(runnerMutex_);
674     int32_t clientPid = eventContextObj->sessionDeactivePair.first;
675     auto iterator = audioPolicyClientProxyAPSCbsMap_.find(clientPid);
676     if (iterator == audioPolicyClientProxyAPSCbsMap_.end()) {
677         AUDIO_ERR_LOG("AudioSessionDeactiveCallback: no client callback for client pid %{public}d", clientPid);
678         return;
679     }
680     if (clientCallbacksMap_.count(iterator->first) > 0 &&
681         clientCallbacksMap_[iterator->first].count(CALLBACK_AUDIO_SESSION) > 0 &&
682         clientCallbacksMap_[iterator->first][CALLBACK_AUDIO_SESSION]) {
683         // the client has registered audio session callback.
684         sptr<IAudioPolicyClient> audioSessionCb = iterator->second;
685         if (audioSessionCb == nullptr) {
686             AUDIO_ERR_LOG("AudioSessionDeactiveCallback: nullptr for client pid %{public}d", clientPid);
687             return;
688         }
689         AUDIO_INFO_LOG("Trigger AudioSessionDeactiveCallback for client pid : %{public}d", clientPid);
690         audioSessionCb->OnAudioSessionDeactive(eventContextObj->sessionDeactivePair.second);
691     } else {
692         AUDIO_ERR_LOG("AudioSessionDeactiveCallback: no registered callback for pid %{public}d", clientPid);
693     }
694 }
695 
HandleRequestCateGoryEvent(const AppExecFwk::InnerEvent::Pointer & event)696 void AudioPolicyServerHandler::HandleRequestCateGoryEvent(const AppExecFwk::InnerEvent::Pointer &event)
697 {
698     std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
699     CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
700 
701     std::lock_guard<std::mutex> lock(runnerMutex_);
702     for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
703         if (clientCallbacksMap_.count(it->first) > 0 &&
704             clientCallbacksMap_[it->first].count(CALLBACK_FOCUS_INFO_CHANGE) > 0 &&
705             clientCallbacksMap_[it->first][CALLBACK_FOCUS_INFO_CHANGE]) {
706             it->second->OnAudioFocusRequested(eventContextObj->audioInterrupt);
707         }
708     }
709 }
710 
HandleAbandonCateGoryEvent(const AppExecFwk::InnerEvent::Pointer & event)711 void AudioPolicyServerHandler::HandleAbandonCateGoryEvent(const AppExecFwk::InnerEvent::Pointer &event)
712 {
713     std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
714     CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
715     std::lock_guard<std::mutex> lock(runnerMutex_);
716     for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
717         if (clientCallbacksMap_.count(it->first) > 0 &&
718             clientCallbacksMap_[it->first].count(CALLBACK_FOCUS_INFO_CHANGE) > 0 &&
719             clientCallbacksMap_[it->first][CALLBACK_FOCUS_INFO_CHANGE]) {
720             it->second->OnAudioFocusAbandoned(eventContextObj->audioInterrupt);
721         }
722     }
723 }
724 
HandleFocusInfoChangeEvent(const AppExecFwk::InnerEvent::Pointer & event)725 void AudioPolicyServerHandler::HandleFocusInfoChangeEvent(const AppExecFwk::InnerEvent::Pointer &event)
726 {
727     std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
728     CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
729     AUDIO_INFO_LOG("HandleFocusInfoChangeEvent focusInfoList :%{public}zu", eventContextObj->focusInfoList.size());
730     std::lock_guard<std::mutex> lock(runnerMutex_);
731     for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
732         if (clientCallbacksMap_.count(it->first) > 0 &&
733             clientCallbacksMap_[it->first].count(CALLBACK_FOCUS_INFO_CHANGE) > 0 &&
734             clientCallbacksMap_[it->first][CALLBACK_FOCUS_INFO_CHANGE]) {
735             it->second->OnAudioFocusInfoChange(eventContextObj->focusInfoList);
736         }
737     }
738 }
739 
HandleRingerModeUpdatedEvent(const AppExecFwk::InnerEvent::Pointer & event)740 void AudioPolicyServerHandler::HandleRingerModeUpdatedEvent(const AppExecFwk::InnerEvent::Pointer &event)
741 {
742     std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
743     CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
744     std::lock_guard<std::mutex> lock(runnerMutex_);
745     for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
746         sptr<IAudioPolicyClient> ringerModeListenerCb = it->second;
747         if (ringerModeListenerCb == nullptr) {
748             AUDIO_ERR_LOG("ringerModeListenerCb nullptr for client %{public}d", it->first);
749             continue;
750         }
751 
752         AUDIO_DEBUG_LOG("ringerModeListenerCb client %{public}d", it->first);
753         if (clientCallbacksMap_.count(it->first) > 0 &&
754             clientCallbacksMap_[it->first].count(CALLBACK_SET_RINGER_MODE) > 0 &&
755             clientCallbacksMap_[it->first][CALLBACK_SET_RINGER_MODE]) {
756             ringerModeListenerCb->OnRingerModeUpdated(eventContextObj->ringMode);
757         }
758     }
759 }
760 
HandleMicStateUpdatedEvent(const AppExecFwk::InnerEvent::Pointer & event)761 void AudioPolicyServerHandler::HandleMicStateUpdatedEvent(const AppExecFwk::InnerEvent::Pointer &event)
762 {
763     std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
764     CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
765     std::lock_guard<std::mutex> lock(runnerMutex_);
766     for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
767         sptr<IAudioPolicyClient> micStateChangeListenerCb = it->second;
768         if (micStateChangeListenerCb == nullptr) {
769             AUDIO_ERR_LOG("callback is nullptr for client %{public}d", it->first);
770             continue;
771         }
772         if (clientCallbacksMap_.count(it->first) > 0 &&
773             clientCallbacksMap_[it->first].count(CALLBACK_SET_MIC_STATE_CHANGE) > 0 &&
774             clientCallbacksMap_[it->first][CALLBACK_SET_MIC_STATE_CHANGE]) {
775             micStateChangeListenerCb->OnMicStateUpdated(eventContextObj->micStateChangeEvent);
776         }
777     }
778 }
779 
HandleMicStateUpdatedEventWithClientId(const AppExecFwk::InnerEvent::Pointer & event)780 void AudioPolicyServerHandler::HandleMicStateUpdatedEventWithClientId(const AppExecFwk::InnerEvent::Pointer &event)
781 {
782     std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
783     CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
784     std::lock_guard<std::mutex> lock(runnerMutex_);
785     int32_t clientId = eventContextObj->clientId;
786     for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
787         if (it->first != clientId) {
788             AUDIO_DEBUG_LOG("This client %{public}d is not need to trigger the callback ", it->first);
789             continue;
790         }
791         sptr<IAudioPolicyClient> micStateChangeListenerCb = it->second;
792         if (micStateChangeListenerCb == nullptr) {
793             AUDIO_ERR_LOG("callback is nullptr for client %{public}d", it->first);
794             continue;
795         }
796         if (clientCallbacksMap_.count(it->first) > 0 &&
797             clientCallbacksMap_[it->first].count(CALLBACK_SET_MIC_STATE_CHANGE) > 0 &&
798             clientCallbacksMap_[it->first][CALLBACK_SET_MIC_STATE_CHANGE]) {
799             micStateChangeListenerCb->OnMicStateUpdated(eventContextObj->micStateChangeEvent);
800         }
801     }
802 }
803 
HandleInterruptEvent(const AppExecFwk::InnerEvent::Pointer & event)804 void AudioPolicyServerHandler::HandleInterruptEvent(const AppExecFwk::InnerEvent::Pointer &event)
805 {
806     std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
807     CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
808 
809     std::unique_lock<std::mutex> lock(runnerMutex_);
810     std::shared_ptr<IAudioInterruptEventDispatcher> dispatcher = interruptEventDispatcher_.lock();
811     lock.unlock();
812     if (dispatcher != nullptr) {
813         dispatcher->DispatchInterruptEventWithSessionId(0, eventContextObj->interruptEvent);
814     }
815 }
816 
HandleInterruptEventWithSessionId(const AppExecFwk::InnerEvent::Pointer & event)817 void AudioPolicyServerHandler::HandleInterruptEventWithSessionId(const AppExecFwk::InnerEvent::Pointer &event)
818 {
819     std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
820     CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
821 
822     std::unique_lock<std::mutex> lock(runnerMutex_);
823     std::shared_ptr<IAudioInterruptEventDispatcher> dispatcher = interruptEventDispatcher_.lock();
824     lock.unlock();
825     if (dispatcher != nullptr) {
826         dispatcher->DispatchInterruptEventWithSessionId(eventContextObj->sessionId,
827             eventContextObj->interruptEvent);
828     }
829 }
830 
HandleInterruptEventWithClientId(const AppExecFwk::InnerEvent::Pointer & event)831 void AudioPolicyServerHandler::HandleInterruptEventWithClientId(const AppExecFwk::InnerEvent::Pointer &event)
832 {
833     std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
834     CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
835 
836     std::lock_guard<std::mutex> lock(runnerMutex_);
837     std::shared_ptr<AudioInterruptCallback> policyListenerCb = amInterruptCbsMap_[eventContextObj->clientId];
838     CHECK_AND_RETURN_LOG(policyListenerCb != nullptr, "policyListenerCb get nullptr");
839     policyListenerCb->OnInterrupt(eventContextObj->interruptEvent);
840 }
841 
HandlePreferredOutputDeviceUpdated()842 void AudioPolicyServerHandler::HandlePreferredOutputDeviceUpdated()
843 {
844     std::lock_guard<std::mutex> lock(runnerMutex_);
845     for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
846         AudioRendererInfo rendererInfo;
847         auto deviceDescs = AudioPolicyService::GetAudioPolicyService().
848             GetPreferredOutputDeviceDescInner(rendererInfo);
849         if (!(it->second->hasBTPermission_)) {
850             AudioPolicyService::GetAudioPolicyService().UpdateDescWhenNoBTPermission(deviceDescs);
851         }
852         if (clientCallbacksMap_.count(it->first) > 0 &&
853             clientCallbacksMap_[it->first].count(CALLBACK_PREFERRED_OUTPUT_DEVICE_CHANGE) > 0 &&
854             clientCallbacksMap_[it->first][CALLBACK_PREFERRED_OUTPUT_DEVICE_CHANGE]) {
855             it->second->OnPreferredOutputDeviceUpdated(deviceDescs);
856         }
857     }
858 }
859 
HandlePreferredInputDeviceUpdated()860 void AudioPolicyServerHandler::HandlePreferredInputDeviceUpdated()
861 {
862     std::lock_guard<std::mutex> lock(runnerMutex_);
863     for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
864         AudioCapturerInfo captureInfo;
865         auto deviceDescs = AudioPolicyService::GetAudioPolicyService().GetPreferredInputDeviceDescInner(captureInfo);
866         if (!(it->second->hasBTPermission_)) {
867             AudioPolicyService::GetAudioPolicyService().UpdateDescWhenNoBTPermission(deviceDescs);
868         }
869         if (clientCallbacksMap_.count(it->first) > 0 &&
870             clientCallbacksMap_[it->first].count(CALLBACK_PREFERRED_INPUT_DEVICE_CHANGE) > 0 &&
871             clientCallbacksMap_[it->first][CALLBACK_PREFERRED_INPUT_DEVICE_CHANGE]) {
872             it->second->OnPreferredInputDeviceUpdated(deviceDescs);
873         }
874     }
875 }
876 
HandleDistributedRoutingRoleChangeEvent(const AppExecFwk::InnerEvent::Pointer & event)877 void AudioPolicyServerHandler::HandleDistributedRoutingRoleChangeEvent(const AppExecFwk::InnerEvent::Pointer &event)
878 {
879     std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
880     CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
881     std::lock_guard<std::mutex> lock(runnerMutex_);
882     for (auto it = distributedRoutingRoleChangeCbsMap_.begin(); it != distributedRoutingRoleChangeCbsMap_.end(); it++) {
883         it->second->OnDistributedRoutingRoleChange(eventContextObj->descriptor, eventContextObj->type);
884     }
885 }
886 
HandleRendererInfoEvent(const AppExecFwk::InnerEvent::Pointer & event)887 void AudioPolicyServerHandler::HandleRendererInfoEvent(const AppExecFwk::InnerEvent::Pointer &event)
888 {
889     std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
890     CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
891     std::lock_guard<std::mutex> lock(runnerMutex_);
892     Trace trace("AudioPolicyServerHandler::HandleRendererInfoEvent");
893     for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
894         Trace traceFor("for pid:" + std::to_string(it->first));
895         sptr<IAudioPolicyClient> rendererStateChangeCb = it->second;
896         if (rendererStateChangeCb == nullptr) {
897             AUDIO_ERR_LOG("rendererStateChangeCb : nullptr for client : %{public}d", it->first);
898             continue;
899         }
900         if (clientCallbacksMap_.count(it->first) > 0 &&
901             clientCallbacksMap_[it->first].count(CALLBACK_RENDERER_STATE_CHANGE) > 0 &&
902             clientCallbacksMap_[it->first][CALLBACK_RENDERER_STATE_CHANGE]) {
903                 Trace traceCallback("rendererStateChangeCb->OnRendererStateChange");
904             rendererStateChangeCb->OnRendererStateChange(eventContextObj->audioRendererChangeInfos);
905             ResetRingerModeMute(eventContextObj->audioRendererChangeInfos);
906         }
907     }
908     AUDIO_INFO_LOG("pids: %{public}s size: %{public}zu", pidsStrForPrinting_.c_str(),
909         audioPolicyClientProxyAPSCbsMap_.size());
910 }
911 
ResetRingerModeMute(const std::vector<std::unique_ptr<AudioRendererChangeInfo>> & audioRendererChangeInfos)912 void AudioPolicyServerHandler::ResetRingerModeMute(const std::vector<std::unique_ptr<AudioRendererChangeInfo>>
913     &audioRendererChangeInfos)
914 {
915     for (const std::unique_ptr<AudioRendererChangeInfo> &rendererChangeInfo: audioRendererChangeInfos) {
916         if (!rendererChangeInfo) {
917             AUDIO_ERR_LOG("Renderer change info null, something wrong!!");
918             continue;
919         }
920         StreamUsage streamUsage = rendererChangeInfo->rendererInfo.streamUsage;
921         RendererState rendererState = rendererChangeInfo->rendererState;
922         if (Util::IsRingerOrAlarmerStreamUsage(streamUsage) && (rendererState == RENDERER_PAUSED ||
923             rendererState == RENDERER_STOPPED || rendererState == RENDERER_RELEASED)) {
924             AUDIO_INFO_LOG("reset ringer mode mute, stream usage:%{public}d, renderer state:%{public}d",
925                 streamUsage, rendererState);
926             AudioPolicyService::GetAudioPolicyService().ResetRingerModeMute();
927         }
928     }
929 }
930 
HandleCapturerInfoEvent(const AppExecFwk::InnerEvent::Pointer & event)931 void AudioPolicyServerHandler::HandleCapturerInfoEvent(const AppExecFwk::InnerEvent::Pointer &event)
932 {
933     std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
934     CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
935     std::lock_guard<std::mutex> lock(runnerMutex_);
936     for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
937         sptr<IAudioPolicyClient> capturerStateChangeCb = it->second;
938         if (capturerStateChangeCb == nullptr) {
939             AUDIO_ERR_LOG("capturerStateChangeCb : nullptr for client : %{public}d", it->first);
940             continue;
941         }
942         if (clientCallbacksMap_.count(it->first) > 0 &&
943             clientCallbacksMap_[it->first].count(CALLBACK_CAPTURER_STATE_CHANGE) > 0 &&
944             clientCallbacksMap_[it->first][CALLBACK_CAPTURER_STATE_CHANGE]) {
945             capturerStateChangeCb->OnCapturerStateChange(eventContextObj->audioCapturerChangeInfos);
946         }
947     }
948 }
949 
HandleRendererDeviceChangeEvent(const AppExecFwk::InnerEvent::Pointer & event)950 void AudioPolicyServerHandler::HandleRendererDeviceChangeEvent(const AppExecFwk::InnerEvent::Pointer &event)
951 {
952     std::shared_ptr<RendererDeviceChangeEvent> eventContextObj = event->GetSharedObject<RendererDeviceChangeEvent>();
953     CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
954     const auto &[pid, sessionId, outputDeviceInfo, reason] = *eventContextObj;
955     Trace trace("AudioPolicyServerHandler::HandleRendererDeviceChangeEvent pid:" + std::to_string(pid));
956     std::lock_guard<std::mutex> lock(runnerMutex_);
957     if (audioPolicyClientProxyAPSCbsMap_.count(pid) == 0) {
958         return;
959     }
960     sptr<IAudioPolicyClient> capturerStateChangeCb = audioPolicyClientProxyAPSCbsMap_.at(pid);
961     if (capturerStateChangeCb == nullptr) {
962         AUDIO_ERR_LOG("capturerStateChangeCb : nullptr for client : %{public}" PRId32 "", pid);
963         return;
964     }
965     Trace traceCallback("capturerStateChangeCb->OnRendererDeviceChange sessionId:" + std::to_string(sessionId));
966     if (clientCallbacksMap_.count(pid) > 0 &&
967         clientCallbacksMap_[pid].count(CALLBACK_DEVICE_CHANGE_WITH_INFO) > 0 &&
968         clientCallbacksMap_[pid][CALLBACK_DEVICE_CHANGE_WITH_INFO]) {
969         capturerStateChangeCb->OnRendererDeviceChange(sessionId, outputDeviceInfo, reason);
970     }
971 }
972 
HandleCapturerCreateEvent(const AppExecFwk::InnerEvent::Pointer & event)973 void AudioPolicyServerHandler::HandleCapturerCreateEvent(const AppExecFwk::InnerEvent::Pointer &event)
974 {
975     std::shared_ptr<CapturerCreateEvent> eventContextObj = event->GetSharedObject<CapturerCreateEvent>();
976     CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
977 
978     uint64_t sessionId = eventContextObj->sessionId_;
979     SessionInfo sessionInfo{eventContextObj->capturerInfo_.sourceType, eventContextObj->streamInfo_.samplingRate,
980         eventContextObj->streamInfo_.channels};
981 
982     eventContextObj->error_ = AudioPolicyService::GetAudioPolicyService().OnCapturerSessionAdded(sessionId,
983         sessionInfo, eventContextObj->streamInfo_);
984 }
985 
HandleCapturerRemovedEvent(const AppExecFwk::InnerEvent::Pointer & event)986 void AudioPolicyServerHandler::HandleCapturerRemovedEvent(const AppExecFwk::InnerEvent::Pointer &event)
987 {
988     std::shared_ptr<uint64_t> eventContextObj = event->GetSharedObject<uint64_t>();
989     CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
990 
991     uint64_t sessionId = *eventContextObj;
992 
993     AudioPolicyService::GetAudioPolicyService().OnCapturerSessionRemoved(sessionId);
994 }
995 
HandleWakeupCloseEvent(const AppExecFwk::InnerEvent::Pointer & event)996 void AudioPolicyServerHandler::HandleWakeupCloseEvent(const AppExecFwk::InnerEvent::Pointer &event)
997 {
998     AudioPolicyService::GetAudioPolicyService().CloseWakeUpAudioCapturer();
999 }
1000 
HandleSendRecreateRendererStreamEvent(const AppExecFwk::InnerEvent::Pointer & event)1001 void AudioPolicyServerHandler::HandleSendRecreateRendererStreamEvent(const AppExecFwk::InnerEvent::Pointer &event)
1002 {
1003     std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
1004     CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1005     std::lock_guard<std::mutex> lock(runnerMutex_);
1006     if (audioPolicyClientProxyAPSCbsMap_.count(eventContextObj->clientId) == 0) {
1007         AUDIO_ERR_LOG("No client id %{public}d", eventContextObj->clientId);
1008         return;
1009     }
1010     sptr<IAudioPolicyClient> rendererCb = audioPolicyClientProxyAPSCbsMap_.at(eventContextObj->clientId);
1011     CHECK_AND_RETURN_LOG(rendererCb != nullptr, "Callback for id %{public}d is null", eventContextObj->clientId);
1012 
1013     if (clientCallbacksMap_.count(eventContextObj->clientId) > 0 &&
1014         clientCallbacksMap_[eventContextObj->clientId].count(CALLBACK_DEVICE_CHANGE_WITH_INFO) > 0 &&
1015         clientCallbacksMap_[eventContextObj->clientId][CALLBACK_DEVICE_CHANGE_WITH_INFO]) {
1016         rendererCb->OnRecreateRendererStreamEvent(eventContextObj->sessionId, eventContextObj->streamFlag,
1017             eventContextObj->reason_);
1018     }
1019 }
1020 
HandleSendRecreateCapturerStreamEvent(const AppExecFwk::InnerEvent::Pointer & event)1021 void AudioPolicyServerHandler::HandleSendRecreateCapturerStreamEvent(const AppExecFwk::InnerEvent::Pointer &event)
1022 {
1023     std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
1024     CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1025     std::lock_guard<std::mutex> lock(runnerMutex_);
1026     if (audioPolicyClientProxyAPSCbsMap_.count(eventContextObj->clientId) == 0) {
1027         AUDIO_ERR_LOG("No client id %{public}d", eventContextObj->clientId);
1028         return;
1029     }
1030     sptr<IAudioPolicyClient> capturerCb = audioPolicyClientProxyAPSCbsMap_.at(eventContextObj->clientId);
1031     CHECK_AND_RETURN_LOG(capturerCb != nullptr, "Callback for id %{public}d is null", eventContextObj->clientId);
1032 
1033     if (clientCallbacksMap_.count(eventContextObj->clientId) > 0 &&
1034         clientCallbacksMap_[eventContextObj->clientId].count(CALLBACK_DEVICE_CHANGE_WITH_INFO) > 0 &&
1035         clientCallbacksMap_[eventContextObj->clientId][CALLBACK_DEVICE_CHANGE_WITH_INFO]) {
1036         capturerCb->OnRecreateCapturerStreamEvent(eventContextObj->sessionId, eventContextObj->streamFlag,
1037             eventContextObj->reason_);
1038     }
1039 }
1040 
HandleHeadTrackingDeviceChangeEvent(const AppExecFwk::InnerEvent::Pointer & event)1041 void AudioPolicyServerHandler::HandleHeadTrackingDeviceChangeEvent(const AppExecFwk::InnerEvent::Pointer &event)
1042 {
1043     std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
1044     CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1045     std::lock_guard<std::mutex> lock(runnerMutex_);
1046     for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
1047         sptr<IAudioPolicyClient> headTrackingDeviceChangeCb = it->second;
1048         if (headTrackingDeviceChangeCb == nullptr) {
1049             AUDIO_ERR_LOG("headTrackingDeviceChangeCb : nullptr for client : %{public}d", it->first);
1050             continue;
1051         }
1052         if (clientCallbacksMap_.count(it->first) > 0 &&
1053             clientCallbacksMap_[it->first].count(CALLBACK_HEAD_TRACKING_DATA_REQUESTED_CHANGE) > 0 &&
1054             clientCallbacksMap_[it->first][CALLBACK_HEAD_TRACKING_DATA_REQUESTED_CHANGE]) {
1055             headTrackingDeviceChangeCb->OnHeadTrackingDeviceChange(eventContextObj->headTrackingDeviceChangeInfo);
1056         }
1057     }
1058 }
1059 
HandleSpatializatonEnabledChangeEvent(const AppExecFwk::InnerEvent::Pointer & event)1060 void AudioPolicyServerHandler::HandleSpatializatonEnabledChangeEvent(const AppExecFwk::InnerEvent::Pointer &event)
1061 {
1062     std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
1063     CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1064     std::lock_guard<std::mutex> lock(runnerMutex_);
1065     for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
1066         sptr<IAudioPolicyClient> spatializationEnabledChangeCb = it->second;
1067         if (spatializationEnabledChangeCb == nullptr) {
1068             AUDIO_ERR_LOG("spatializationEnabledChangeCb : nullptr for client : %{public}d", it->first);
1069             continue;
1070         }
1071         if (clientCallbacksMap_.count(it->first) > 0 &&
1072             clientCallbacksMap_[it->first].count(CALLBACK_SPATIALIZATION_ENABLED_CHANGE) > 0 &&
1073             clientCallbacksMap_[it->first][CALLBACK_SPATIALIZATION_ENABLED_CHANGE]) {
1074             spatializationEnabledChangeCb->OnSpatializationEnabledChange(eventContextObj->spatializationEnabled);
1075         }
1076     }
1077 }
1078 
HandleSpatializatonEnabledChangeForAnyDeviceEvent(const AppExecFwk::InnerEvent::Pointer & event)1079 void AudioPolicyServerHandler::HandleSpatializatonEnabledChangeForAnyDeviceEvent(
1080     const AppExecFwk::InnerEvent::Pointer &event)
1081 {
1082     std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
1083     CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1084     std::lock_guard<std::mutex> lock(runnerMutex_);
1085     for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
1086         sptr<IAudioPolicyClient> spatializationEnabledChangeCb = it->second;
1087         if (spatializationEnabledChangeCb == nullptr) {
1088             AUDIO_ERR_LOG("spatializationEnabledChangeCb : nullptr for client : %{public}d", it->first);
1089             continue;
1090         }
1091         if (clientCallbacksMap_.count(it->first) > 0 &&
1092             clientCallbacksMap_[it->first].count(CALLBACK_SPATIALIZATION_ENABLED_CHANGE) > 0 &&
1093             clientCallbacksMap_[it->first][CALLBACK_SPATIALIZATION_ENABLED_CHANGE]) {
1094             spatializationEnabledChangeCb->OnSpatializationEnabledChangeForAnyDevice(eventContextObj->descriptor,
1095                 eventContextObj->spatializationEnabled);
1096         }
1097     }
1098 }
1099 
HandleHeadTrackingEnabledChangeEvent(const AppExecFwk::InnerEvent::Pointer & event)1100 void AudioPolicyServerHandler::HandleHeadTrackingEnabledChangeEvent(const AppExecFwk::InnerEvent::Pointer &event)
1101 {
1102     std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
1103     CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1104     std::lock_guard<std::mutex> lock(runnerMutex_);
1105     for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
1106         sptr<IAudioPolicyClient> headTrackingEnabledChangeCb = it->second;
1107         if (headTrackingEnabledChangeCb == nullptr) {
1108             AUDIO_ERR_LOG("headTrackingEnabledChangeCb : nullptr for client : %{public}d", it->first);
1109             continue;
1110         }
1111         if (clientCallbacksMap_.count(it->first) > 0 &&
1112             clientCallbacksMap_[it->first].count(CALLBACK_HEAD_TRACKING_ENABLED_CHANGE) > 0 &&
1113             clientCallbacksMap_[it->first][CALLBACK_HEAD_TRACKING_ENABLED_CHANGE]) {
1114             headTrackingEnabledChangeCb->OnHeadTrackingEnabledChange(eventContextObj->headTrackingEnabled);
1115         }
1116     }
1117 }
1118 
HandleUpdateKvDataEvent(const AppExecFwk::InnerEvent::Pointer & event)1119 void AudioPolicyServerHandler::HandleUpdateKvDataEvent(const AppExecFwk::InnerEvent::Pointer &event)
1120 {
1121     std::shared_ptr<bool> eventContextObj = event->GetSharedObject<bool>();
1122     CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1123     bool isFristBoot = *eventContextObj;
1124     AudioPolicyManagerFactory::GetAudioPolicyManager().HandleKvData(isFristBoot);
1125 }
1126 
HandleHeadTrackingEnabledChangeForAnyDeviceEvent(const AppExecFwk::InnerEvent::Pointer & event)1127 void AudioPolicyServerHandler::HandleHeadTrackingEnabledChangeForAnyDeviceEvent(
1128     const AppExecFwk::InnerEvent::Pointer &event)
1129 {
1130     std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
1131     CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1132     std::lock_guard<std::mutex> lock(runnerMutex_);
1133     for (auto it = audioPolicyClientProxyAPSCbsMap_.begin(); it != audioPolicyClientProxyAPSCbsMap_.end(); ++it) {
1134         sptr<IAudioPolicyClient> headTrackingEnabledChangeCb = it->second;
1135         if (headTrackingEnabledChangeCb == nullptr) {
1136             AUDIO_ERR_LOG("headTrackingEnabledChangeCb : nullptr for client : %{public}d", it->first);
1137             continue;
1138         }
1139         if (clientCallbacksMap_.count(it->first) > 0 &&
1140             clientCallbacksMap_[it->first].count(CALLBACK_HEAD_TRACKING_ENABLED_CHANGE) > 0 &&
1141             clientCallbacksMap_[it->first][CALLBACK_HEAD_TRACKING_ENABLED_CHANGE]) {
1142             headTrackingEnabledChangeCb->OnHeadTrackingEnabledChangeForAnyDevice(eventContextObj->descriptor,
1143                 eventContextObj->headTrackingEnabled);
1144         }
1145     }
1146 }
1147 
HandlePipeStreamCleanEvent(const AppExecFwk::InnerEvent::Pointer & event)1148 void AudioPolicyServerHandler::HandlePipeStreamCleanEvent(const AppExecFwk::InnerEvent::Pointer &event)
1149 {
1150     std::shared_ptr<int32_t> eventContextObj = event->GetSharedObject<int32_t>();
1151     CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1152     AudioPipeType pipeType = static_cast<AudioPipeType>(*eventContextObj);
1153     AudioPolicyService::GetAudioPolicyService().DynamicUnloadModule(pipeType);
1154 }
1155 
HandleConcurrencyEventWithSessionID(const AppExecFwk::InnerEvent::Pointer & event)1156 void AudioPolicyServerHandler::HandleConcurrencyEventWithSessionID(const AppExecFwk::InnerEvent::Pointer &event)
1157 {
1158     std::shared_ptr<EventContextObj> eventContextObj = event->GetSharedObject<EventContextObj>();
1159     CHECK_AND_RETURN_LOG(eventContextObj != nullptr, "EventContextObj get nullptr");
1160 
1161     std::unique_lock<std::mutex> lock(runnerMutex_);
1162     std::shared_ptr<IAudioConcurrencyEventDispatcher> dispatcher = concurrencyEventDispatcher_.lock();
1163     lock.unlock();
1164     if (dispatcher != nullptr) {
1165         dispatcher->DispatchConcurrencyEventWithSessionId(eventContextObj->sessionId);
1166     }
1167 }
1168 
HandleServiceEvent(const uint32_t & eventId,const AppExecFwk::InnerEvent::Pointer & event)1169 void AudioPolicyServerHandler::HandleServiceEvent(const uint32_t &eventId,
1170     const AppExecFwk::InnerEvent::Pointer &event)
1171 {
1172     HandleOtherServiceEvent(eventId, event);
1173     switch (eventId) {
1174         case EventAudioServerCmd::AUDIO_DEVICE_CHANGE:
1175             HandleDeviceChangedCallback(event);
1176             break;
1177         case EventAudioServerCmd::PREFERRED_OUTPUT_DEVICE_UPDATED:
1178             HandlePreferredOutputDeviceUpdated();
1179             break;
1180         case EventAudioServerCmd::PREFERRED_INPUT_DEVICE_UPDATED:
1181             HandlePreferredInputDeviceUpdated();
1182             break;
1183         case EventAudioServerCmd::AVAILABLE_AUDIO_DEVICE_CHANGE:
1184             HandleAvailableDeviceChange(event);
1185             break;
1186         case EventAudioServerCmd::RENDERER_INFO_EVENT:
1187             HandleRendererInfoEvent(event);
1188             break;
1189         case EventAudioServerCmd::CAPTURER_INFO_EVENT:
1190             HandleCapturerInfoEvent(event);
1191             break;
1192         case EventAudioServerCmd::RENDERER_DEVICE_CHANGE_EVENT:
1193             HandleRendererDeviceChangeEvent(event);
1194             break;
1195         case EventAudioServerCmd::ON_CAPTURER_CREATE:
1196             HandleCapturerCreateEvent(event);
1197             break;
1198         case EventAudioServerCmd::ON_CAPTURER_REMOVED:
1199             HandleCapturerRemovedEvent(event);
1200             break;
1201         case EventAudioServerCmd::ON_WAKEUP_CLOSE:
1202             HandleWakeupCloseEvent(event);
1203             break;
1204         case EventAudioServerCmd::RECREATE_RENDERER_STREAM_EVENT:
1205             HandleSendRecreateRendererStreamEvent(event);
1206             break;
1207         case EventAudioServerCmd::RECREATE_CAPTURER_STREAM_EVENT:
1208             HandleSendRecreateCapturerStreamEvent(event);
1209             break;
1210         case EventAudioServerCmd::DATABASE_UPDATE:
1211             HandleUpdateKvDataEvent(event);
1212             break;
1213         case EventAudioServerCmd::PIPE_STREAM_CLEAN_EVENT:
1214             HandlePipeStreamCleanEvent(event);
1215             break;
1216         default:
1217             break;
1218     }
1219 }
1220 
HandleOtherServiceEvent(const uint32_t & eventId,const AppExecFwk::InnerEvent::Pointer & event)1221 void AudioPolicyServerHandler::HandleOtherServiceEvent(const uint32_t &eventId,
1222     const AppExecFwk::InnerEvent::Pointer &event)
1223 {
1224     switch (eventId) {
1225         case EventAudioServerCmd::CONCURRENCY_EVENT_WITH_SESSIONID:
1226             HandleConcurrencyEventWithSessionID(event);
1227             break;
1228         case EventAudioServerCmd::SPATIALIZATION_ENABLED_CHANGE_FOR_ANY_DEVICE:
1229             HandleSpatializatonEnabledChangeForAnyDeviceEvent(event);
1230             break;
1231         case EventAudioServerCmd::HEAD_TRACKING_ENABLED_CHANGE_FOR_ANY_DEVICE:
1232             HandleHeadTrackingEnabledChangeForAnyDeviceEvent(event);
1233             break;
1234         case EventAudioServerCmd::AUDIO_SESSION_DEACTIVE_EVENT:
1235             HandleAudioSessionDeactiveCallback(event);
1236             break;
1237         case EventAudioServerCmd::MICROPHONE_BLOCKED:
1238             HandleMicrophoneBlockedCallback(event);
1239             break;
1240         default:
1241             break;
1242     }
1243 }
1244 
ProcessEvent(const AppExecFwk::InnerEvent::Pointer & event)1245 void AudioPolicyServerHandler::ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event)
1246 {
1247     uint32_t eventId = event->GetInnerEventId();
1248     HandleServiceEvent(eventId, event);
1249     switch (eventId) {
1250         case EventAudioServerCmd::VOLUME_KEY_EVENT:
1251             HandleVolumeKeyEvent(event);
1252             break;
1253         case EventAudioServerCmd::REQUEST_CATEGORY_EVENT:
1254             HandleRequestCateGoryEvent(event);
1255             break;
1256         case EventAudioServerCmd::ABANDON_CATEGORY_EVENT:
1257             HandleAbandonCateGoryEvent(event);
1258             break;
1259         case EventAudioServerCmd::FOCUS_INFOCHANGE:
1260             HandleFocusInfoChangeEvent(event);
1261             break;
1262         case EventAudioServerCmd::RINGER_MODEUPDATE_EVENT:
1263             HandleRingerModeUpdatedEvent(event);
1264             break;
1265         case EventAudioServerCmd::MIC_STATE_CHANGE_EVENT:
1266             HandleMicStateUpdatedEvent(event);
1267             break;
1268         case EventAudioServerCmd::MIC_STATE_CHANGE_EVENT_WITH_CLIENTID:
1269             HandleMicStateUpdatedEventWithClientId(event);
1270             break;
1271         case EventAudioServerCmd::INTERRUPT_EVENT:
1272             HandleInterruptEvent(event);
1273             break;
1274         case EventAudioServerCmd::INTERRUPT_EVENT_WITH_SESSIONID:
1275             HandleInterruptEventWithSessionId(event);
1276             break;
1277         case EventAudioServerCmd::INTERRUPT_EVENT_WITH_CLIENTID:
1278             HandleInterruptEventWithClientId(event);
1279             break;
1280         case EventAudioServerCmd::DISTRIBUTED_ROUTING_ROLE_CHANGE:
1281             HandleDistributedRoutingRoleChangeEvent(event);
1282             break;
1283         case EventAudioServerCmd::HEAD_TRACKING_DEVICE_CHANGE:
1284             HandleHeadTrackingDeviceChangeEvent(event);
1285             break;
1286         case EventAudioServerCmd::SPATIALIZATION_ENABLED_CHANGE:
1287             HandleSpatializatonEnabledChangeEvent(event);
1288             break;
1289         case EventAudioServerCmd::HEAD_TRACKING_ENABLED_CHANGE:
1290             HandleHeadTrackingEnabledChangeEvent(event);
1291             break;
1292         default:
1293             break;
1294     }
1295 }
1296 
SetClientCallbacksEnable(const CallbackChange & callbackchange,const bool & enable)1297 int32_t AudioPolicyServerHandler::SetClientCallbacksEnable(const CallbackChange &callbackchange, const bool &enable)
1298 {
1299     if (callbackchange <= CALLBACK_UNKNOWN || callbackchange >= CALLBACK_MAX) {
1300         AUDIO_ERR_LOG("Illegal parameter");
1301         return AUDIO_ERR;
1302     }
1303 
1304     int32_t clientId = IPCSkeleton::GetCallingPid();
1305     lock_guard<mutex> runnerlock(runnerMutex_);
1306     clientCallbacksMap_[clientId][callbackchange] = enable;
1307     string str = (enable ? "true" : "false");
1308     AUDIO_INFO_LOG("Set clientId:%{public}d, callbacks:%{public}d, enable:%{public}s",
1309         clientId, callbackchange, str.c_str());
1310     return AUDIO_OK;
1311 }
1312 } // namespace AudioStandard
1313 } // namespace OHOS
1314