1 /*
2  * Copyright (c) 2022-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 "AudioStreamCollector"
17 #endif
18 
19 #include "audio_stream_collector.h"
20 
21 #include "audio_client_tracker_callback_proxy.h"
22 #include "audio_spatialization_service.h"
23 #include "audio_utils.h"
24 
25 #include "media_monitor_manager.h"
26 
27 namespace OHOS {
28 namespace AudioStandard {
29 using namespace std;
30 
31 const map<pair<ContentType, StreamUsage>, AudioStreamType> AudioStreamCollector::streamTypeMap_ =
32     AudioStreamCollector::CreateStreamMap();
33 
CreateStreamMap()34 map<pair<ContentType, StreamUsage>, AudioStreamType> AudioStreamCollector::CreateStreamMap()
35 {
36     map<pair<ContentType, StreamUsage>, AudioStreamType> streamMap;
37     // Mapping relationships from content and usage to stream type in design
38     streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_UNKNOWN)] = STREAM_MUSIC;
39     streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_VOICE_COMMUNICATION)] = STREAM_VOICE_COMMUNICATION;
40     streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_VIDEO_COMMUNICATION)] = STREAM_VOICE_COMMUNICATION;
41     streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_VOICE_MODEM_COMMUNICATION)] = STREAM_VOICE_CALL;
42     streamMap[make_pair(CONTENT_TYPE_PROMPT, STREAM_USAGE_SYSTEM)] = STREAM_SYSTEM;
43     streamMap[make_pair(CONTENT_TYPE_MUSIC, STREAM_USAGE_NOTIFICATION_RINGTONE)] = STREAM_RING;
44     streamMap[make_pair(CONTENT_TYPE_MUSIC, STREAM_USAGE_MEDIA)] = STREAM_MUSIC;
45     streamMap[make_pair(CONTENT_TYPE_MOVIE, STREAM_USAGE_MEDIA)] = STREAM_MOVIE;
46     streamMap[make_pair(CONTENT_TYPE_GAME, STREAM_USAGE_MEDIA)] = STREAM_GAME;
47     streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_MEDIA)] = STREAM_SPEECH;
48     streamMap[make_pair(CONTENT_TYPE_MUSIC, STREAM_USAGE_ALARM)] = STREAM_ALARM;
49     streamMap[make_pair(CONTENT_TYPE_PROMPT, STREAM_USAGE_NOTIFICATION)] = STREAM_NOTIFICATION;
50     streamMap[make_pair(CONTENT_TYPE_PROMPT, STREAM_USAGE_ENFORCED_TONE)] = STREAM_SYSTEM_ENFORCED;
51     streamMap[make_pair(CONTENT_TYPE_DTMF, STREAM_USAGE_VOICE_COMMUNICATION)] = STREAM_DTMF;
52     streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_VOICE_ASSISTANT)] = STREAM_VOICE_ASSISTANT;
53     streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_ACCESSIBILITY)] = STREAM_ACCESSIBILITY;
54     streamMap[make_pair(CONTENT_TYPE_ULTRASONIC, STREAM_USAGE_SYSTEM)] = STREAM_ULTRASONIC;
55 
56     // Old mapping relationships from content and usage to stream type
57     streamMap[make_pair(CONTENT_TYPE_MUSIC, STREAM_USAGE_VOICE_ASSISTANT)] = STREAM_VOICE_ASSISTANT;
58     streamMap[make_pair(CONTENT_TYPE_SONIFICATION, STREAM_USAGE_UNKNOWN)] = STREAM_NOTIFICATION;
59     streamMap[make_pair(CONTENT_TYPE_SONIFICATION, STREAM_USAGE_MEDIA)] = STREAM_NOTIFICATION;
60     streamMap[make_pair(CONTENT_TYPE_SONIFICATION, STREAM_USAGE_NOTIFICATION_RINGTONE)] = STREAM_RING;
61     streamMap[make_pair(CONTENT_TYPE_RINGTONE, STREAM_USAGE_UNKNOWN)] = STREAM_RING;
62     streamMap[make_pair(CONTENT_TYPE_RINGTONE, STREAM_USAGE_MEDIA)] = STREAM_RING;
63     streamMap[make_pair(CONTENT_TYPE_RINGTONE, STREAM_USAGE_NOTIFICATION_RINGTONE)] = STREAM_RING;
64 
65     // Only use stream usage to choose stream type
66     streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_MEDIA)] = STREAM_MUSIC;
67     streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_MUSIC)] = STREAM_MUSIC;
68     streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VOICE_COMMUNICATION)] = STREAM_VOICE_COMMUNICATION;
69     streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VIDEO_COMMUNICATION)] = STREAM_VOICE_COMMUNICATION;
70     streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VOICE_MODEM_COMMUNICATION)] = STREAM_VOICE_CALL;
71     streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VOICE_ASSISTANT)] = STREAM_VOICE_ASSISTANT;
72     streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_ALARM)] = STREAM_ALARM;
73     streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VOICE_MESSAGE)] = STREAM_VOICE_MESSAGE;
74     streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_NOTIFICATION_RINGTONE)] = STREAM_RING;
75     streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_RINGTONE)] = STREAM_RING;
76     streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_NOTIFICATION)] = STREAM_NOTIFICATION;
77     streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_ACCESSIBILITY)] = STREAM_ACCESSIBILITY;
78     streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_SYSTEM)] = STREAM_SYSTEM;
79     streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_MOVIE)] = STREAM_MOVIE;
80     streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_GAME)] = STREAM_GAME;
81     streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_AUDIOBOOK)] = STREAM_SPEECH;
82     streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_NAVIGATION)] = STREAM_NAVIGATION;
83     streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_DTMF)] = STREAM_DTMF;
84     streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_ENFORCED_TONE)] = STREAM_SYSTEM_ENFORCED;
85     streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_ULTRASONIC)] = STREAM_ULTRASONIC;
86     streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VOICE_RINGTONE)] = STREAM_VOICE_RING;
87     streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VOICE_CALL_ASSISTANT)] = STREAM_VOICE_CALL_ASSISTANT;
88 
89     return streamMap;
90 }
91 
AudioStreamCollector()92 AudioStreamCollector::AudioStreamCollector() : audioSystemMgr_
93     (AudioSystemManager::GetInstance())
94 {
95     audioPolicyServerHandler_ = DelayedSingleton<AudioPolicyServerHandler>::GetInstance();
96     audioConcurrencyService_ = std::make_shared<AudioConcurrencyService>();
97     audioPolicyServerHandler_->AddConcurrencyEventDispatcher(audioConcurrencyService_);
98     audioConcurrencyService_->Init();
99     audioConcurrencyService_->SetCallbackHandler(audioPolicyServerHandler_);
100     AUDIO_INFO_LOG("AudioStreamCollector()");
101 }
102 
~AudioStreamCollector()103 AudioStreamCollector::~AudioStreamCollector()
104 {
105     AUDIO_INFO_LOG("~AudioStreamCollector()");
106 }
107 
AddRendererStream(AudioStreamChangeInfo & streamChangeInfo)108 int32_t AudioStreamCollector::AddRendererStream(AudioStreamChangeInfo &streamChangeInfo)
109 {
110     AUDIO_INFO_LOG("Add playback client uid %{public}d sessionId %{public}d",
111         streamChangeInfo.audioRendererChangeInfo.clientUID, streamChangeInfo.audioRendererChangeInfo.sessionId);
112 
113     rendererStatequeue_.insert({{streamChangeInfo.audioRendererChangeInfo.clientUID,
114         streamChangeInfo.audioRendererChangeInfo.sessionId},
115         streamChangeInfo.audioRendererChangeInfo.rendererState});
116 
117     unique_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_unique<AudioRendererChangeInfo>();
118     if (!rendererChangeInfo) {
119         AUDIO_ERR_LOG("AddRendererStream Memory Allocation Failed");
120         return ERR_MEMORY_ALLOC_FAILED;
121     }
122     rendererChangeInfo->createrUID = streamChangeInfo.audioRendererChangeInfo.createrUID;
123     rendererChangeInfo->clientUID = streamChangeInfo.audioRendererChangeInfo.clientUID;
124     rendererChangeInfo->sessionId = streamChangeInfo.audioRendererChangeInfo.sessionId;
125     rendererChangeInfo->callerPid = streamChangeInfo.audioRendererChangeInfo.callerPid;
126     rendererChangeInfo->tokenId = static_cast<int32_t>(IPCSkeleton::GetCallingTokenID());
127     rendererChangeInfo->rendererState = streamChangeInfo.audioRendererChangeInfo.rendererState;
128     rendererChangeInfo->rendererInfo = streamChangeInfo.audioRendererChangeInfo.rendererInfo;
129     rendererChangeInfo->outputDeviceInfo = streamChangeInfo.audioRendererChangeInfo.outputDeviceInfo;
130     rendererChangeInfo->channelCount = streamChangeInfo.audioRendererChangeInfo.channelCount;
131     audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
132 
133     CHECK_AND_RETURN_RET_LOG(audioPolicyServerHandler_ != nullptr, ERR_MEMORY_ALLOC_FAILED,
134         "audioPolicyServerHandler_ is nullptr, callback error");
135     audioPolicyServerHandler_->SendRendererInfoEvent(audioRendererChangeInfos_);
136     AudioSpatializationService::GetAudioSpatializationService().UpdateRendererInfo(audioRendererChangeInfos_);
137     return SUCCESS;
138 }
139 
GetRendererStreamInfo(AudioStreamChangeInfo & streamChangeInfo,AudioRendererChangeInfo & rendererInfo)140 void AudioStreamCollector::GetRendererStreamInfo(AudioStreamChangeInfo &streamChangeInfo,
141     AudioRendererChangeInfo &rendererInfo)
142 {
143     for (auto it = audioRendererChangeInfos_.begin(); it != audioRendererChangeInfos_.end(); it++) {
144         if ((*it)->clientUID == streamChangeInfo.audioRendererChangeInfo.clientUID &&
145             (*it)->sessionId == streamChangeInfo.audioRendererChangeInfo.sessionId) {
146             rendererInfo.outputDeviceInfo = (*it)->outputDeviceInfo;
147             return;
148         }
149     }
150 }
151 
GetCapturerStreamInfo(AudioStreamChangeInfo & streamChangeInfo,AudioCapturerChangeInfo & capturerInfo)152 void AudioStreamCollector::GetCapturerStreamInfo(AudioStreamChangeInfo &streamChangeInfo,
153     AudioCapturerChangeInfo &capturerInfo)
154 {
155     for (auto it = audioCapturerChangeInfos_.begin(); it != audioCapturerChangeInfos_.end(); it++) {
156         if ((*it)->clientUID == streamChangeInfo.audioCapturerChangeInfo.clientUID &&
157             (*it)->sessionId == streamChangeInfo.audioCapturerChangeInfo.sessionId) {
158             capturerInfo.inputDeviceInfo = (*it)->inputDeviceInfo;
159             return;
160         }
161     }
162 }
163 
GetPipeType(const int32_t sessionId,AudioPipeType & pipeType)164 int32_t AudioStreamCollector::GetPipeType(const int32_t sessionId, AudioPipeType &pipeType)
165 {
166     std::lock_guard<std::mutex> lock(streamsInfoMutex_);
167     const auto &it = std::find_if(audioRendererChangeInfos_.begin(), audioRendererChangeInfos_.end(),
168         [&sessionId](const std::unique_ptr<AudioRendererChangeInfo> &changeInfo) {
169             return changeInfo->sessionId == sessionId;
170         });
171     if (it == audioRendererChangeInfos_.end()) {
172         AUDIO_WARNING_LOG("invalid session id: %{public}d", sessionId);
173         return ERROR;
174     }
175 
176     pipeType = (*it)->rendererInfo.pipeType;
177     return SUCCESS;
178 }
179 
ExistStreamForPipe(AudioPipeType pipeType)180 bool AudioStreamCollector::ExistStreamForPipe(AudioPipeType pipeType)
181 {
182     const auto &it = std::find_if(audioRendererChangeInfos_.begin(), audioRendererChangeInfos_.end(),
183         [&pipeType](const std::unique_ptr<AudioRendererChangeInfo> &changeInfo) {
184             return changeInfo->rendererInfo.pipeType == pipeType;
185         });
186     if (it == audioRendererChangeInfos_.end()) {
187         return false;
188     }
189     return true;
190 }
191 
GetRendererDeviceInfo(const int32_t sessionId,DeviceInfo & outputDeviceInfo)192 int32_t AudioStreamCollector::GetRendererDeviceInfo(const int32_t sessionId, DeviceInfo &outputDeviceInfo)
193 {
194     std::lock_guard<std::mutex> lock(streamsInfoMutex_);
195     const auto &it = std::find_if(audioRendererChangeInfos_.begin(), audioRendererChangeInfos_.end(),
196         [&sessionId](const std::unique_ptr<AudioRendererChangeInfo> &changeInfo) {
197             return changeInfo->sessionId == sessionId;
198         });
199     if (it == audioRendererChangeInfos_.end()) {
200         AUDIO_WARNING_LOG("invalid session id: %{public}d", sessionId);
201         return ERROR;
202     }
203     outputDeviceInfo = (*it)->outputDeviceInfo;
204     return SUCCESS;
205 }
206 
AddCapturerStream(AudioStreamChangeInfo & streamChangeInfo)207 int32_t AudioStreamCollector::AddCapturerStream(AudioStreamChangeInfo &streamChangeInfo)
208 {
209     AUDIO_INFO_LOG("Add recording client uid %{public}d sessionId %{public}d",
210         streamChangeInfo.audioCapturerChangeInfo.clientUID, streamChangeInfo.audioCapturerChangeInfo.sessionId);
211 
212     capturerStatequeue_.insert({{streamChangeInfo.audioCapturerChangeInfo.clientUID,
213         streamChangeInfo.audioCapturerChangeInfo.sessionId},
214         streamChangeInfo.audioCapturerChangeInfo.capturerState});
215 
216     unique_ptr<AudioCapturerChangeInfo> capturerChangeInfo = make_unique<AudioCapturerChangeInfo>();
217     if (!capturerChangeInfo) {
218         AUDIO_ERR_LOG("AddCapturerStream Memory Allocation Failed");
219         return ERR_MEMORY_ALLOC_FAILED;
220     }
221     capturerChangeInfo->createrUID = streamChangeInfo.audioCapturerChangeInfo.createrUID;
222     capturerChangeInfo->clientUID = streamChangeInfo.audioCapturerChangeInfo.clientUID;
223     capturerChangeInfo->sessionId = streamChangeInfo.audioCapturerChangeInfo.sessionId;
224     capturerChangeInfo->callerPid = streamChangeInfo.audioCapturerChangeInfo.callerPid;
225     capturerChangeInfo->muted = streamChangeInfo.audioCapturerChangeInfo.muted;
226     capturerChangeInfo->appTokenId = streamChangeInfo.audioCapturerChangeInfo.appTokenId;
227 
228     capturerChangeInfo->capturerState = streamChangeInfo.audioCapturerChangeInfo.capturerState;
229     capturerChangeInfo->capturerInfo = streamChangeInfo.audioCapturerChangeInfo.capturerInfo;
230     capturerChangeInfo->inputDeviceInfo = streamChangeInfo.audioCapturerChangeInfo.inputDeviceInfo;
231     audioCapturerChangeInfos_.push_back(move(capturerChangeInfo));
232 
233     CHECK_AND_RETURN_RET_LOG(audioPolicyServerHandler_ != nullptr, ERR_MEMORY_ALLOC_FAILED,
234         "audioPolicyServerHandler_ is nullptr, callback error");
235     audioPolicyServerHandler_->SendCapturerInfoEvent(audioCapturerChangeInfos_);
236     return SUCCESS;
237 }
238 
RegisterTracker(AudioMode & mode,AudioStreamChangeInfo & streamChangeInfo,const sptr<IRemoteObject> & object)239 int32_t AudioStreamCollector::RegisterTracker(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo,
240     const sptr<IRemoteObject> &object)
241 {
242     AUDIO_DEBUG_LOG("RegisterTracker mode %{public}d", mode);
243 
244     int32_t clientId;
245     std::lock_guard<std::mutex> lock(streamsInfoMutex_);
246     if (mode == AUDIO_MODE_PLAYBACK) {
247         AddRendererStream(streamChangeInfo);
248         clientId = streamChangeInfo.audioRendererChangeInfo.sessionId;
249     } else {
250         // mode = AUDIO_MODE_RECORD
251         AddCapturerStream(streamChangeInfo);
252         clientId = streamChangeInfo.audioCapturerChangeInfo.sessionId;
253     }
254 
255     sptr<IStandardClientTracker> listener = iface_cast<IStandardClientTracker>(object);
256     CHECK_AND_RETURN_RET_LOG(listener != nullptr,
257         ERR_INVALID_PARAM, "AudioStreamCollector: client tracker obj cast failed");
258     std::shared_ptr<AudioClientTracker> callback = std::make_shared<ClientTrackerCallbackListener>(listener);
259     CHECK_AND_RETURN_RET_LOG(callback != nullptr,
260         ERR_INVALID_PARAM, "AudioStreamCollector: failed to create tracker cb obj");
261     clientTracker_[clientId] = callback;
262     WriterStreamChangeSysEvent(mode, streamChangeInfo);
263     return SUCCESS;
264 }
265 
SetRendererStreamParam(AudioStreamChangeInfo & streamChangeInfo,unique_ptr<AudioRendererChangeInfo> & rendererChangeInfo)266 void AudioStreamCollector::SetRendererStreamParam(AudioStreamChangeInfo &streamChangeInfo,
267     unique_ptr<AudioRendererChangeInfo> &rendererChangeInfo)
268 {
269     rendererChangeInfo->createrUID = streamChangeInfo.audioRendererChangeInfo.createrUID;
270     rendererChangeInfo->clientUID = streamChangeInfo.audioRendererChangeInfo.clientUID;
271     rendererChangeInfo->sessionId = streamChangeInfo.audioRendererChangeInfo.sessionId;
272     rendererChangeInfo->callerPid = streamChangeInfo.audioRendererChangeInfo.callerPid;
273     rendererChangeInfo->clientPid = streamChangeInfo.audioRendererChangeInfo.clientPid;
274     rendererChangeInfo->tokenId = static_cast<int32_t>(IPCSkeleton::GetCallingTokenID());
275     rendererChangeInfo->rendererState = streamChangeInfo.audioRendererChangeInfo.rendererState;
276     rendererChangeInfo->rendererInfo = streamChangeInfo.audioRendererChangeInfo.rendererInfo;
277     rendererChangeInfo->outputDeviceInfo = streamChangeInfo.audioRendererChangeInfo.outputDeviceInfo;
278     rendererChangeInfo->prerunningState = streamChangeInfo.audioRendererChangeInfo.prerunningState;
279 }
280 
SetCapturerStreamParam(AudioStreamChangeInfo & streamChangeInfo,unique_ptr<AudioCapturerChangeInfo> & capturerChangeInfo)281 void AudioStreamCollector::SetCapturerStreamParam(AudioStreamChangeInfo &streamChangeInfo,
282     unique_ptr<AudioCapturerChangeInfo> &capturerChangeInfo)
283 {
284     capturerChangeInfo->createrUID = streamChangeInfo.audioCapturerChangeInfo.createrUID;
285     capturerChangeInfo->clientUID = streamChangeInfo.audioCapturerChangeInfo.clientUID;
286     capturerChangeInfo->sessionId = streamChangeInfo.audioCapturerChangeInfo.sessionId;
287     capturerChangeInfo->callerPid = streamChangeInfo.audioCapturerChangeInfo.callerPid;
288     capturerChangeInfo->clientPid = streamChangeInfo.audioCapturerChangeInfo.clientPid;
289     capturerChangeInfo->muted = streamChangeInfo.audioCapturerChangeInfo.muted;
290     capturerChangeInfo->capturerState = streamChangeInfo.audioCapturerChangeInfo.capturerState;
291     capturerChangeInfo->capturerInfo = streamChangeInfo.audioCapturerChangeInfo.capturerInfo;
292     capturerChangeInfo->inputDeviceInfo = streamChangeInfo.audioCapturerChangeInfo.inputDeviceInfo;
293 }
294 
ResetRendererStreamDeviceInfo(const AudioDeviceDescriptor & updatedDesc)295 void AudioStreamCollector::ResetRendererStreamDeviceInfo(const AudioDeviceDescriptor& updatedDesc)
296 {
297     AUDIO_INFO_LOG("ResetRendererStreamDeviceInfo, deviceType:[%{public}d]", updatedDesc.deviceType_);
298     for (auto it = audioRendererChangeInfos_.begin(); it != audioRendererChangeInfos_.end(); it++) {
299         if ((*it)->outputDeviceInfo.deviceType == updatedDesc.deviceType_ &&
300             (*it)->outputDeviceInfo.macAddress == updatedDesc.macAddress_ &&
301             (*it)->outputDeviceInfo.networkId == updatedDesc.networkId_ &&
302             (*it)->rendererState != RENDERER_RUNNING) {
303             (*it)->outputDeviceInfo.deviceType = DEVICE_TYPE_NONE;
304             (*it)->outputDeviceInfo.macAddress = "";
305             (*it)->outputDeviceInfo.networkId = LOCAL_NETWORK_ID;
306         }
307     }
308 }
309 
ResetCapturerStreamDeviceInfo(const AudioDeviceDescriptor & updatedDesc)310 void AudioStreamCollector::ResetCapturerStreamDeviceInfo(const AudioDeviceDescriptor& updatedDesc)
311 {
312     AUDIO_INFO_LOG("ResetCapturerStreamDeviceInfo, deviceType:[%{public}d]", updatedDesc.deviceType_);
313     for (auto it = audioCapturerChangeInfos_.begin(); it != audioCapturerChangeInfos_.end(); it++) {
314         if ((*it)->inputDeviceInfo.deviceType == updatedDesc.deviceType_ &&
315             (*it)->inputDeviceInfo.macAddress == updatedDesc.macAddress_ &&
316             (*it)->inputDeviceInfo.networkId == updatedDesc.networkId_ &&
317             (*it)->capturerState != CAPTURER_RUNNING) {
318             (*it)->inputDeviceInfo.deviceType = DEVICE_TYPE_NONE;
319             (*it)->inputDeviceInfo.macAddress = "";
320             (*it)->inputDeviceInfo.networkId = LOCAL_NETWORK_ID;
321         }
322     }
323 }
324 
CheckRendererStateInfoChanged(AudioStreamChangeInfo & streamChangeInfo)325 bool AudioStreamCollector::CheckRendererStateInfoChanged(AudioStreamChangeInfo &streamChangeInfo)
326 {
327     if (rendererStatequeue_.find(make_pair(streamChangeInfo.audioRendererChangeInfo.clientUID,
328         streamChangeInfo.audioRendererChangeInfo.sessionId)) != rendererStatequeue_.end()) {
329         if (streamChangeInfo.audioRendererChangeInfo.rendererState ==
330             rendererStatequeue_[make_pair(streamChangeInfo.audioRendererChangeInfo.clientUID,
331                 streamChangeInfo.audioRendererChangeInfo.sessionId)]) {
332             // Renderer state not changed
333             return false;
334         }
335     } else {
336         AUDIO_INFO_LOG("client %{public}d not found ", streamChangeInfo.audioRendererChangeInfo.clientUID);
337     }
338     return true;
339 }
340 
CheckRendererInfoChanged(AudioStreamChangeInfo & streamChangeInfo)341 bool AudioStreamCollector::CheckRendererInfoChanged(AudioStreamChangeInfo &streamChangeInfo)
342 {
343     int32_t sessionId = streamChangeInfo.audioRendererChangeInfo.sessionId;
344     const auto &it = std::find_if(audioRendererChangeInfos_.begin(), audioRendererChangeInfos_.end(),
345         [&sessionId](const std::unique_ptr<AudioRendererChangeInfo> &changeInfo) {
346             return changeInfo->sessionId == sessionId;
347         });
348     if (it == audioRendererChangeInfos_.end()) {
349         return true;
350     }
351 
352     bool changed = false;
353     bool isOffloadAllowed = (*it)->rendererInfo.isOffloadAllowed;
354     if (isOffloadAllowed != streamChangeInfo.audioRendererChangeInfo.rendererInfo.isOffloadAllowed) {
355         changed = true;
356     }
357     AudioPipeType pipeType = (*it)->rendererInfo.pipeType;
358     if (pipeType != streamChangeInfo.audioRendererChangeInfo.rendererInfo.pipeType) {
359         changed = true;
360     }
361     return changed;
362 }
363 
UpdateRendererStream(AudioStreamChangeInfo & streamChangeInfo)364 int32_t AudioStreamCollector::UpdateRendererStream(AudioStreamChangeInfo &streamChangeInfo)
365 {
366     AUDIO_INFO_LOG("UpdateRendererStream client %{public}d state %{public}d session %{public}d",
367         streamChangeInfo.audioRendererChangeInfo.clientUID, streamChangeInfo.audioRendererChangeInfo.rendererState,
368         streamChangeInfo.audioRendererChangeInfo.sessionId);
369     bool stateChanged = CheckRendererStateInfoChanged(streamChangeInfo);
370     bool infoChanged = CheckRendererInfoChanged(streamChangeInfo);
371     CHECK_AND_RETURN_RET(stateChanged || infoChanged, SUCCESS);
372 
373     // Update the renderer info in audioRendererChangeInfos_
374     for (auto it = audioRendererChangeInfos_.begin(); it != audioRendererChangeInfos_.end(); it++) {
375         AudioRendererChangeInfo audioRendererChangeInfo = **it;
376         if (audioRendererChangeInfo.clientUID == streamChangeInfo.audioRendererChangeInfo.clientUID &&
377             audioRendererChangeInfo.sessionId == streamChangeInfo.audioRendererChangeInfo.sessionId) {
378             rendererStatequeue_[make_pair(audioRendererChangeInfo.clientUID, audioRendererChangeInfo.sessionId)] =
379                 streamChangeInfo.audioRendererChangeInfo.rendererState;
380             streamChangeInfo.audioRendererChangeInfo.rendererInfo.pipeType = (*it)->rendererInfo.pipeType;
381             AUDIO_DEBUG_LOG("update client %{public}d session %{public}d", audioRendererChangeInfo.clientUID,
382                 audioRendererChangeInfo.sessionId);
383             unique_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_unique<AudioRendererChangeInfo>();
384             CHECK_AND_RETURN_RET_LOG(rendererChangeInfo != nullptr, ERR_MEMORY_ALLOC_FAILED,
385                 "Memory Allocation Failed");
386             SetRendererStreamParam(streamChangeInfo, rendererChangeInfo);
387             rendererChangeInfo->channelCount = (*it)->channelCount;
388             if (rendererChangeInfo->outputDeviceInfo.deviceType == DEVICE_TYPE_INVALID) {
389                 streamChangeInfo.audioRendererChangeInfo.outputDeviceInfo = (*it)->outputDeviceInfo;
390                 rendererChangeInfo->outputDeviceInfo = (*it)->outputDeviceInfo;
391             }
392             *it = move(rendererChangeInfo);
393 
394             if (audioPolicyServerHandler_ != nullptr && stateChanged) {
395                 audioPolicyServerHandler_->SendRendererInfoEvent(audioRendererChangeInfos_);
396             }
397             AudioSpatializationService::GetAudioSpatializationService().UpdateRendererInfo(audioRendererChangeInfos_);
398 
399             if (streamChangeInfo.audioRendererChangeInfo.rendererState == RENDERER_RELEASED) {
400                 audioRendererChangeInfos_.erase(it);
401                 rendererStatequeue_.erase(make_pair(audioRendererChangeInfo.clientUID,
402                     audioRendererChangeInfo.sessionId));
403                 clientTracker_.erase(audioRendererChangeInfo.sessionId);
404             }
405             return SUCCESS;
406         }
407     }
408 
409     AUDIO_INFO_LOG("UpdateRendererStream: Not found clientUid:%{public}d sessionId:%{public}d",
410         streamChangeInfo.audioRendererChangeInfo.clientUID, streamChangeInfo.audioRendererChangeInfo.clientUID);
411     return SUCCESS;
412 }
413 
414 
UpdateRendererStreamInternal(AudioStreamChangeInfo & streamChangeInfo)415 int32_t AudioStreamCollector::UpdateRendererStreamInternal(AudioStreamChangeInfo &streamChangeInfo)
416 {
417     // Update the renderer internal info in audioRendererChangeInfos_
418     for (auto it = audioRendererChangeInfos_.begin(); it != audioRendererChangeInfos_.end(); it++) {
419         AudioRendererChangeInfo audioRendererChangeInfo = **it;
420         if ((*it)->clientUID == streamChangeInfo.audioRendererChangeInfo.clientUID &&
421             (*it)->sessionId == streamChangeInfo.audioRendererChangeInfo.sessionId) {
422             AUDIO_DEBUG_LOG("update client %{public}d session %{public}d", (*it)->clientUID, (*it)->sessionId);
423             (*it)->prerunningState = streamChangeInfo.audioRendererChangeInfo.prerunningState;
424             return SUCCESS;
425         }
426     }
427 
428     AUDIO_ERR_LOG("Not found clientUid:%{public}d sessionId:%{public}d",
429         streamChangeInfo.audioRendererChangeInfo.clientUID, streamChangeInfo.audioRendererChangeInfo.sessionId);
430     return ERROR;
431 }
432 
UpdateCapturerStream(AudioStreamChangeInfo & streamChangeInfo)433 int32_t AudioStreamCollector::UpdateCapturerStream(AudioStreamChangeInfo &streamChangeInfo)
434 {
435     AUDIO_INFO_LOG("UpdateCapturerStream client %{public}d state %{public}d session %{public}d",
436         streamChangeInfo.audioCapturerChangeInfo.clientUID, streamChangeInfo.audioCapturerChangeInfo.capturerState,
437         streamChangeInfo.audioCapturerChangeInfo.sessionId);
438 
439     if (capturerStatequeue_.find(make_pair(streamChangeInfo.audioCapturerChangeInfo.clientUID,
440         streamChangeInfo.audioCapturerChangeInfo.sessionId)) != capturerStatequeue_.end()) {
441         if (streamChangeInfo.audioCapturerChangeInfo.capturerState ==
442             capturerStatequeue_[make_pair(streamChangeInfo.audioCapturerChangeInfo.clientUID,
443                 streamChangeInfo.audioCapturerChangeInfo.sessionId)]) {
444             // Capturer state not changed
445             return SUCCESS;
446         }
447     }
448 
449     // Update the capturer info in audioCapturerChangeInfos_
450     for (auto it = audioCapturerChangeInfos_.begin(); it != audioCapturerChangeInfos_.end(); it++) {
451         AudioCapturerChangeInfo audioCapturerChangeInfo = **it;
452         if (audioCapturerChangeInfo.clientUID == streamChangeInfo.audioCapturerChangeInfo.clientUID &&
453             audioCapturerChangeInfo.sessionId == streamChangeInfo.audioCapturerChangeInfo.sessionId) {
454             capturerStatequeue_[make_pair(audioCapturerChangeInfo.clientUID, audioCapturerChangeInfo.sessionId)] =
455                 streamChangeInfo.audioCapturerChangeInfo.capturerState;
456 
457             AUDIO_DEBUG_LOG("Session is updated for client %{public}d session %{public}d",
458                 streamChangeInfo.audioCapturerChangeInfo.clientUID,
459                 streamChangeInfo.audioCapturerChangeInfo.sessionId);
460 
461             unique_ptr<AudioCapturerChangeInfo> capturerChangeInfo = make_unique<AudioCapturerChangeInfo>();
462             CHECK_AND_RETURN_RET_LOG(capturerChangeInfo != nullptr,
463                 ERR_MEMORY_ALLOC_FAILED, "CapturerChangeInfo Memory Allocation Failed");
464             SetCapturerStreamParam(streamChangeInfo, capturerChangeInfo);
465             if (capturerChangeInfo->inputDeviceInfo.deviceType == DEVICE_TYPE_INVALID) {
466                 streamChangeInfo.audioCapturerChangeInfo.inputDeviceInfo = (*it)->inputDeviceInfo;
467                 capturerChangeInfo->inputDeviceInfo = (*it)->inputDeviceInfo;
468             }
469             capturerChangeInfo->appTokenId = (*it)->appTokenId;
470             *it = move(capturerChangeInfo);
471             if (audioPolicyServerHandler_ != nullptr) {
472                 audioPolicyServerHandler_->SendCapturerInfoEvent(audioCapturerChangeInfos_);
473             }
474             if (streamChangeInfo.audioCapturerChangeInfo.capturerState ==  CAPTURER_RELEASED) {
475                 audioCapturerChangeInfos_.erase(it);
476                 capturerStatequeue_.erase(make_pair(audioCapturerChangeInfo.clientUID,
477                     audioCapturerChangeInfo.sessionId));
478                 clientTracker_.erase(audioCapturerChangeInfo.sessionId);
479             }
480             return SUCCESS;
481         }
482     }
483     AUDIO_DEBUG_LOG("UpdateCapturerStream: clientUI not in audioCapturerChangeInfos_::%{public}d",
484         streamChangeInfo.audioCapturerChangeInfo.clientUID);
485     return SUCCESS;
486 }
487 
UpdateRendererDeviceInfo(DeviceInfo & outputDeviceInfo)488 int32_t AudioStreamCollector::UpdateRendererDeviceInfo(DeviceInfo &outputDeviceInfo)
489 {
490     bool deviceInfoUpdated = false;
491 
492     for (auto it = audioRendererChangeInfos_.begin(); it != audioRendererChangeInfos_.end(); it++) {
493         if (!(*it)->outputDeviceInfo.IsSameDeviceInfo(outputDeviceInfo)) {
494             AUDIO_DEBUG_LOG("UpdateRendererDeviceInfo: old device: %{public}d new device: %{public}d",
495                 (*it)->outputDeviceInfo.deviceType, outputDeviceInfo.deviceType);
496             (*it)->outputDeviceInfo = outputDeviceInfo;
497             deviceInfoUpdated = true;
498         }
499     }
500 
501     if (deviceInfoUpdated && audioPolicyServerHandler_ != nullptr) {
502         audioPolicyServerHandler_->SendRendererInfoEvent(audioRendererChangeInfos_);
503     }
504     if (deviceInfoUpdated) {
505         AudioSpatializationService::GetAudioSpatializationService().UpdateRendererInfo(audioRendererChangeInfos_);
506     }
507 
508     return SUCCESS;
509 }
510 
UpdateCapturerDeviceInfo(DeviceInfo & inputDeviceInfo)511 int32_t AudioStreamCollector::UpdateCapturerDeviceInfo(DeviceInfo &inputDeviceInfo)
512 {
513     bool deviceInfoUpdated = false;
514 
515     for (auto it = audioCapturerChangeInfos_.begin(); it != audioCapturerChangeInfos_.end(); it++) {
516         if (!(*it)->inputDeviceInfo.IsSameDeviceInfo(inputDeviceInfo)) {
517             AUDIO_DEBUG_LOG("UpdateCapturerDeviceInfo: old device: %{public}d new device: %{public}d",
518                 (*it)->inputDeviceInfo.deviceType, inputDeviceInfo.deviceType);
519             (*it)->inputDeviceInfo = inputDeviceInfo;
520             deviceInfoUpdated = true;
521         }
522     }
523 
524     if (deviceInfoUpdated && audioPolicyServerHandler_ != nullptr) {
525         audioPolicyServerHandler_->SendCapturerInfoEvent(audioCapturerChangeInfos_);
526     }
527 
528     return SUCCESS;
529 }
530 
UpdateRendererDeviceInfo(int32_t clientUID,int32_t sessionId,DeviceInfo & outputDeviceInfo)531 int32_t AudioStreamCollector::UpdateRendererDeviceInfo(int32_t clientUID, int32_t sessionId,
532     DeviceInfo &outputDeviceInfo)
533 {
534     std::lock_guard<std::mutex> lock(streamsInfoMutex_);
535     bool deviceInfoUpdated = false;
536 
537     for (auto it = audioRendererChangeInfos_.begin(); it != audioRendererChangeInfos_.end(); it++) {
538         if ((*it)->clientUID == clientUID && (*it)->sessionId == sessionId &&
539             !(*it)->outputDeviceInfo.IsSameDeviceInfo(outputDeviceInfo)) {
540             AUDIO_DEBUG_LOG("uid %{public}d sessionId %{public}d update device: old %{public}d, new %{public}d",
541                 clientUID, sessionId, (*it)->outputDeviceInfo.deviceType, outputDeviceInfo.deviceType);
542             (*it)->outputDeviceInfo = outputDeviceInfo;
543             deviceInfoUpdated = true;
544         }
545     }
546 
547     if (deviceInfoUpdated && audioPolicyServerHandler_ != nullptr) {
548         audioPolicyServerHandler_->SendRendererInfoEvent(audioRendererChangeInfos_);
549     }
550     if (deviceInfoUpdated) {
551         AudioSpatializationService::GetAudioSpatializationService().UpdateRendererInfo(audioRendererChangeInfos_);
552     }
553     return SUCCESS;
554 }
555 
UpdateRendererPipeInfo(const int32_t sessionId,const AudioPipeType pipeType)556 int32_t AudioStreamCollector::UpdateRendererPipeInfo(const int32_t sessionId, const AudioPipeType pipeType)
557 {
558     std::lock_guard<std::mutex> lock(streamsInfoMutex_);
559     bool pipeTypeUpdated = false;
560 
561     for (auto it = audioRendererChangeInfos_.begin(); it != audioRendererChangeInfos_.end(); it++) {
562         if ((*it)->sessionId == sessionId && (*it)->rendererInfo.pipeType != pipeType) {
563             AUDIO_INFO_LOG("sessionId %{public}d update pipeType: old %{public}d, new %{public}d",
564                 sessionId, (*it)->rendererInfo.pipeType, pipeType);
565             (*it)->rendererInfo.pipeType = pipeType;
566             pipeTypeUpdated = true;
567         }
568     }
569 
570     if (pipeTypeUpdated && audioPolicyServerHandler_ != nullptr) {
571         audioPolicyServerHandler_->SendRendererInfoEvent(audioRendererChangeInfos_);
572     }
573     if (pipeTypeUpdated) {
574         AudioSpatializationService::GetAudioSpatializationService().UpdateRendererInfo(audioRendererChangeInfos_);
575     }
576     return SUCCESS;
577 }
578 
UpdateCapturerDeviceInfo(int32_t clientUID,int32_t sessionId,DeviceInfo & inputDeviceInfo)579 int32_t AudioStreamCollector::UpdateCapturerDeviceInfo(int32_t clientUID, int32_t sessionId,
580     DeviceInfo &inputDeviceInfo)
581 {
582     std::lock_guard<std::mutex> lock(streamsInfoMutex_);
583     bool deviceInfoUpdated = false;
584 
585     for (auto it = audioCapturerChangeInfos_.begin(); it != audioCapturerChangeInfos_.end(); it++) {
586         if ((*it)->clientUID == clientUID && (*it)->sessionId == sessionId &&
587             !(*it)->inputDeviceInfo.IsSameDeviceInfo(inputDeviceInfo)) {
588             AUDIO_DEBUG_LOG("uid %{public}d sessionId %{public}d update device: old %{public}d, new %{public}d",
589                 (*it)->clientUID, (*it)->sessionId, (*it)->inputDeviceInfo.deviceType, inputDeviceInfo.deviceType);
590             (*it)->inputDeviceInfo = inputDeviceInfo;
591             deviceInfoUpdated = true;
592         }
593     }
594 
595     if (deviceInfoUpdated && audioPolicyServerHandler_ != nullptr) {
596         audioPolicyServerHandler_->SendCapturerInfoEvent(audioCapturerChangeInfos_);
597     }
598 
599     return SUCCESS;
600 }
601 
UpdateTracker(const AudioMode & mode,DeviceInfo & deviceInfo)602 int32_t AudioStreamCollector::UpdateTracker(const AudioMode &mode, DeviceInfo &deviceInfo)
603 {
604     std::lock_guard<std::mutex> lock(streamsInfoMutex_);
605     if (mode == AUDIO_MODE_PLAYBACK) {
606         UpdateRendererDeviceInfo(deviceInfo);
607     } else {
608         UpdateCapturerDeviceInfo(deviceInfo);
609     }
610 
611     return SUCCESS;
612 }
613 
UpdateTracker(AudioMode & mode,AudioStreamChangeInfo & streamChangeInfo)614 int32_t AudioStreamCollector::UpdateTracker(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo)
615 {
616     std::lock_guard<std::mutex> lock(streamsInfoMutex_);
617     // update the stream change info
618     if (mode == AUDIO_MODE_PLAYBACK) {
619         UpdateRendererStream(streamChangeInfo);
620     } else {
621     // mode = AUDIO_MODE_RECORD
622         UpdateCapturerStream(streamChangeInfo);
623     }
624     WriterStreamChangeSysEvent(mode, streamChangeInfo);
625     return SUCCESS;
626 }
627 
UpdateTrackerInternal(AudioMode & mode,AudioStreamChangeInfo & streamChangeInfo)628 int32_t AudioStreamCollector::UpdateTrackerInternal(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo)
629 {
630     std::lock_guard<std::mutex> lock(streamsInfoMutex_);
631     // update the stream change internal info
632     if (mode == AUDIO_MODE_PLAYBACK) {
633         return UpdateRendererStreamInternal(streamChangeInfo);
634     }
635     return SUCCESS;
636 }
637 
GetStreamType(ContentType contentType,StreamUsage streamUsage)638 AudioStreamType AudioStreamCollector::GetStreamType(ContentType contentType, StreamUsage streamUsage)
639 {
640     AudioStreamType streamType = STREAM_MUSIC;
641     auto pos = streamTypeMap_.find(std::make_pair(contentType, streamUsage));
642     if (pos != streamTypeMap_.end()) {
643         streamType = pos->second;
644     }
645 
646     if (streamType == STREAM_MEDIA) {
647         streamType = STREAM_MUSIC;
648     }
649 
650     return streamType;
651 }
652 
GetStreamType(int32_t sessionId)653 AudioStreamType AudioStreamCollector::GetStreamType(int32_t sessionId)
654 {
655     AudioStreamType streamType = STREAM_MUSIC;
656     std::lock_guard<std::mutex> lock(streamsInfoMutex_);
657     for (const auto &changeInfo : audioRendererChangeInfos_) {
658         if (changeInfo->sessionId == sessionId) {
659             streamType = GetStreamType(changeInfo->rendererInfo.contentType, changeInfo->rendererInfo.streamUsage);
660         }
661     }
662     return streamType;
663 }
664 
GetSessionIdsOnRemoteDeviceByStreamUsage(StreamUsage streamUsage)665 std::set<int32_t> AudioStreamCollector::GetSessionIdsOnRemoteDeviceByStreamUsage(StreamUsage streamUsage)
666 {
667     std::set<int32_t> sessionIdSet;
668     std::lock_guard<std::mutex> lock(streamsInfoMutex_);
669     for (const auto &changeInfo : audioRendererChangeInfos_) {
670         if (changeInfo->rendererInfo.streamUsage == streamUsage &&
671             changeInfo->outputDeviceInfo.deviceType == DEVICE_TYPE_SPEAKER &&
672             changeInfo->outputDeviceInfo.networkId != LOCAL_NETWORK_ID) {
673             sessionIdSet.insert(changeInfo->sessionId);
674         }
675     }
676     return sessionIdSet;
677 }
678 
GetSessionIdsOnRemoteDeviceBySourceType(SourceType sourceType)679 std::set<int32_t> AudioStreamCollector::GetSessionIdsOnRemoteDeviceBySourceType(SourceType sourceType)
680 {
681     std::set<int32_t> sessionIdSet;
682     std::lock_guard<std::mutex> lock(streamsInfoMutex_);
683     for (const auto &changeInfo : audioCapturerChangeInfos_) {
684         if (changeInfo->capturerInfo.sourceType == sourceType &&
685             changeInfo->inputDeviceInfo.deviceType == DEVICE_TYPE_MIC &&
686             changeInfo->inputDeviceInfo.networkId != LOCAL_NETWORK_ID) {
687             sessionIdSet.insert(changeInfo->sessionId);
688         }
689     }
690     return sessionIdSet;
691 }
692 
GetSessionIdsOnRemoteDeviceByDeviceType(DeviceType deviceType)693 std::set<int32_t> AudioStreamCollector::GetSessionIdsOnRemoteDeviceByDeviceType(DeviceType deviceType)
694 {
695     std::set<int32_t> sessionIdSet;
696     std::lock_guard<std::mutex> lock(streamsInfoMutex_);
697     for (const auto &changeInfo : audioRendererChangeInfos_) {
698         if (changeInfo->outputDeviceInfo.deviceType == deviceType) {
699             sessionIdSet.insert(changeInfo->sessionId);
700         }
701     }
702     return sessionIdSet;
703 }
704 
GetSessionIdsPauseOnRemoteDeviceByRemote(InterruptHint hintType)705 int32_t AudioStreamCollector::GetSessionIdsPauseOnRemoteDeviceByRemote(InterruptHint hintType)
706 {
707     int32_t sessionIdVec = -1;
708     std::lock_guard<std::mutex> lock(streamsInfoMutex_);
709     for (const auto &changeInfo : audioRendererChangeInfos_) {
710         if (changeInfo->outputDeviceInfo.deviceType == DEVICE_TYPE_REMOTE_CAST &&
711             changeInfo->rendererState == RendererState::RENDERER_RUNNING) {
712             return changeInfo->sessionId;
713         }
714     }
715     return sessionIdVec;
716 }
717 
IsOffloadAllowed(const int32_t sessionId)718 bool AudioStreamCollector::IsOffloadAllowed(const int32_t sessionId)
719 {
720     std::lock_guard<std::mutex> lock(streamsInfoMutex_);
721     const auto &it = std::find_if(audioRendererChangeInfos_.begin(), audioRendererChangeInfos_.end(),
722         [&sessionId](const std::unique_ptr<AudioRendererChangeInfo> &changeInfo) {
723             return changeInfo->sessionId == sessionId;
724         });
725     if (it == audioRendererChangeInfos_.end()) {
726         AUDIO_WARNING_LOG("invalid session id: %{public}d", sessionId);
727         return false;
728     }
729     return (*it)->rendererInfo.isOffloadAllowed;
730 }
731 
GetChannelCount(int32_t sessionId)732 int32_t AudioStreamCollector::GetChannelCount(int32_t sessionId)
733 {
734     int32_t channelCount = 0;
735     std::lock_guard<std::mutex> lock(streamsInfoMutex_);
736     const auto &it = std::find_if(audioRendererChangeInfos_.begin(), audioRendererChangeInfos_.end(),
737         [&sessionId](const std::unique_ptr<AudioRendererChangeInfo> &changeInfo) {
738             return changeInfo->sessionId == sessionId;
739         });
740     if (it != audioRendererChangeInfos_.end()) {
741         channelCount = (*it)->channelCount;
742     }
743     return channelCount;
744 }
745 
GetCurrentRendererChangeInfos(std::vector<unique_ptr<AudioRendererChangeInfo>> & rendererChangeInfos)746 int32_t AudioStreamCollector::GetCurrentRendererChangeInfos(
747     std::vector<unique_ptr<AudioRendererChangeInfo>> &rendererChangeInfos)
748 {
749     std::lock_guard<std::mutex> lock(streamsInfoMutex_);
750     for (const auto &changeInfo : audioRendererChangeInfos_) {
751         rendererChangeInfos.push_back(make_unique<AudioRendererChangeInfo>(*changeInfo));
752     }
753     AUDIO_DEBUG_LOG("GetCurrentRendererChangeInfos returned");
754 
755     return SUCCESS;
756 }
757 
GetCurrentCapturerChangeInfos(std::vector<unique_ptr<AudioCapturerChangeInfo>> & capturerChangeInfos)758 int32_t AudioStreamCollector::GetCurrentCapturerChangeInfos(
759     std::vector<unique_ptr<AudioCapturerChangeInfo>> &capturerChangeInfos)
760 {
761     AUDIO_DEBUG_LOG("GetCurrentCapturerChangeInfos");
762     std::lock_guard<std::mutex> lock(streamsInfoMutex_);
763     for (const auto &changeInfo : audioCapturerChangeInfos_) {
764         capturerChangeInfos.push_back(make_unique<AudioCapturerChangeInfo>(*changeInfo));
765         AUDIO_DEBUG_LOG("GetCurrentCapturerChangeInfos returned");
766     }
767 
768     return SUCCESS;
769 }
770 
RegisteredRendererTrackerClientDied(const int32_t uid)771 void AudioStreamCollector::RegisteredRendererTrackerClientDied(const int32_t uid)
772 {
773     int32_t sessionID = -1;
774     auto audioRendererBegin = audioRendererChangeInfos_.begin();
775     while (audioRendererBegin != audioRendererChangeInfos_.end()) {
776         const auto &audioRendererChangeInfo = *audioRendererBegin;
777         if (audioRendererChangeInfo == nullptr ||
778             (audioRendererChangeInfo->clientUID != uid && audioRendererChangeInfo->createrUID != uid)) {
779             audioRendererBegin++;
780             continue;
781         }
782         sessionID = audioRendererChangeInfo->sessionId;
783         audioRendererChangeInfo->rendererState = RENDERER_RELEASED;
784         WriteRenderStreamReleaseSysEvent(audioRendererChangeInfo);
785         if (audioPolicyServerHandler_ != nullptr) {
786             audioPolicyServerHandler_->SendRendererInfoEvent(audioRendererChangeInfos_);
787         }
788         AudioSpatializationService::GetAudioSpatializationService().UpdateRendererInfo(audioRendererChangeInfos_);
789         rendererStatequeue_.erase(make_pair(audioRendererChangeInfo->clientUID, audioRendererChangeInfo->sessionId));
790         auto temp = audioRendererBegin;
791         audioRendererBegin = audioRendererChangeInfos_.erase(temp);
792         if ((sessionID != -1) && clientTracker_.erase(sessionID)) {
793             AUDIO_INFO_LOG("TrackerClientDied:client %{public}d cleared", sessionID);
794         }
795     }
796 }
797 
RegisteredCapturerTrackerClientDied(const int32_t uid)798 void AudioStreamCollector::RegisteredCapturerTrackerClientDied(const int32_t uid)
799 {
800     int32_t sessionID = -1;
801     auto audioCapturerBegin = audioCapturerChangeInfos_.begin();
802     while (audioCapturerBegin != audioCapturerChangeInfos_.end()) {
803         const auto &audioCapturerChangeInfo = *audioCapturerBegin;
804         if (audioCapturerChangeInfo == nullptr ||
805             (audioCapturerChangeInfo->clientUID != uid && audioCapturerChangeInfo->createrUID != uid)) {
806             audioCapturerBegin++;
807             continue;
808         }
809         sessionID = audioCapturerChangeInfo->sessionId;
810         audioCapturerChangeInfo->capturerState = CAPTURER_RELEASED;
811         WriteCaptureStreamReleaseSysEvent(audioCapturerChangeInfo);
812         if (audioPolicyServerHandler_ != nullptr) {
813             audioPolicyServerHandler_->SendCapturerInfoEvent(audioCapturerChangeInfos_);
814         }
815         capturerStatequeue_.erase(make_pair(audioCapturerChangeInfo->clientUID, audioCapturerChangeInfo->sessionId));
816         auto temp = audioCapturerBegin;
817         audioCapturerBegin = audioCapturerChangeInfos_.erase(temp);
818         if ((sessionID != -1) && clientTracker_.erase(sessionID)) {
819             AUDIO_INFO_LOG("TrackerClientDied:client %{public}d cleared", sessionID);
820         }
821     }
822 }
823 
RegisteredTrackerClientDied(int32_t uid)824 void AudioStreamCollector::RegisteredTrackerClientDied(int32_t uid)
825 {
826     AUDIO_INFO_LOG("TrackerClientDied:client:%{public}d Died", uid);
827 
828     // Send the release state event notification for all streams of died client to registered app
829     std::lock_guard<std::mutex> lock(streamsInfoMutex_);
830     RegisteredRendererTrackerClientDied(uid);
831     RegisteredCapturerTrackerClientDied(uid);
832 }
833 
GetAndCompareStreamType(StreamUsage targetUsage,AudioRendererInfo rendererInfo)834 bool AudioStreamCollector::GetAndCompareStreamType(StreamUsage targetUsage, AudioRendererInfo rendererInfo)
835 {
836     AudioStreamType requiredType = GetStreamType(CONTENT_TYPE_UNKNOWN, targetUsage);
837     AUDIO_INFO_LOG("GetAndCompareStreamType:requiredType:%{public}d ", requiredType);
838     AudioStreamType defaultStreamType = STREAM_MUSIC;
839     auto pos = streamTypeMap_.find(make_pair(rendererInfo.contentType, rendererInfo.streamUsage));
840     if (pos != streamTypeMap_.end()) {
841         defaultStreamType = pos->second;
842     }
843     return defaultStreamType == requiredType;
844 }
845 
GetUid(int32_t sessionId)846 int32_t AudioStreamCollector::GetUid(int32_t sessionId)
847 {
848     int32_t defaultUid = -1;
849     std::lock_guard<std::mutex> lock(streamsInfoMutex_);
850     const auto &it = std::find_if(audioRendererChangeInfos_.begin(), audioRendererChangeInfos_.end(),
851         [&sessionId](const std::unique_ptr<AudioRendererChangeInfo> &changeInfo) {
852             return changeInfo->sessionId == sessionId;
853         });
854     if (it != audioRendererChangeInfos_.end()) {
855         defaultUid = (*it)->createrUID;
856     }
857     return defaultUid;
858 }
859 
UpdateStreamState(int32_t clientUid,StreamSetStateEventInternal & streamSetStateEventInternal)860 int32_t AudioStreamCollector::UpdateStreamState(int32_t clientUid,
861     StreamSetStateEventInternal &streamSetStateEventInternal)
862 {
863     std::lock_guard<std::mutex> lock(streamsInfoMutex_);
864     for (const auto &changeInfo : audioRendererChangeInfos_) {
865         if (changeInfo->clientUID == clientUid &&
866             streamSetStateEventInternal.streamUsage == changeInfo->rendererInfo.streamUsage) {
867             AUDIO_INFO_LOG("UpdateStreamState Found matching uid=%{public}d and usage=%{public}d",
868                 clientUid, streamSetStateEventInternal.streamUsage);
869             std::shared_ptr<AudioClientTracker> callback = clientTracker_[changeInfo->sessionId];
870             if (callback == nullptr) {
871                 AUDIO_ERR_LOG("UpdateStreamState callback failed sId:%{public}d",
872                     changeInfo->sessionId);
873                 continue;
874             }
875             if (streamSetStateEventInternal.streamSetState == StreamSetState::STREAM_PAUSE) {
876                 callback->PausedStreamImpl(streamSetStateEventInternal);
877             } else if (streamSetStateEventInternal.streamSetState == StreamSetState::STREAM_RESUME) {
878                 callback->ResumeStreamImpl(streamSetStateEventInternal);
879             }
880         }
881     }
882 
883     return SUCCESS;
884 }
885 
IsStreamActive(AudioStreamType volumeType)886 bool AudioStreamCollector::IsStreamActive(AudioStreamType volumeType)
887 {
888     std::lock_guard<std::mutex> lock(streamsInfoMutex_);
889     bool result = false;
890     for (auto &changeInfo: audioRendererChangeInfos_) {
891         if (changeInfo->rendererState != RENDERER_RUNNING) {
892             continue;
893         }
894         AudioVolumeType rendererVolumeType = GetVolumeTypeFromContentUsage((changeInfo->rendererInfo).contentType,
895             (changeInfo->rendererInfo).streamUsage);
896         if (rendererVolumeType == volumeType) {
897             // An active stream has been found, return true directly.
898             AUDIO_INFO_LOG("matched clientUid: %{public}d id: %{public}d",
899                 changeInfo->clientUID, changeInfo->sessionId);
900             return true;
901         }
902     }
903     return result;
904 }
905 
GetRunningStream(AudioStreamType certainType,int32_t certainChannelCount)906 int32_t AudioStreamCollector::GetRunningStream(AudioStreamType certainType, int32_t certainChannelCount)
907 {
908     std::lock_guard<std::mutex> lock(streamsInfoMutex_);
909     int32_t runningStream = -1;
910     if ((certainType == STREAM_DEFAULT) && (certainChannelCount == 0)) {
911         for (auto &changeInfo : audioRendererChangeInfos_) {
912             if (changeInfo->rendererState == RENDERER_RUNNING) {
913                 runningStream = changeInfo->sessionId;
914                 break;
915             }
916         }
917     } else if (certainChannelCount == 0) {
918         for (auto &changeInfo : audioRendererChangeInfos_) {
919             if ((changeInfo->rendererState == RENDERER_RUNNING) &&
920                     (certainType == GetStreamType(changeInfo->rendererInfo.contentType,
921                     changeInfo->rendererInfo.streamUsage))) {
922                 runningStream = changeInfo->sessionId;
923                 break;
924             }
925         }
926     } else {
927         for (auto &changeInfo : audioRendererChangeInfos_) {
928             if ((changeInfo->rendererState == RENDERER_RUNNING) &&
929                     (certainType == GetStreamType(changeInfo->rendererInfo.contentType,
930                     changeInfo->rendererInfo.streamUsage)) && (certainChannelCount == changeInfo->channelCount)) {
931                 runningStream = changeInfo->sessionId;
932                 break;
933             }
934         }
935     }
936     return runningStream;
937 }
938 
GetVolumeTypeFromContentUsage(ContentType contentType,StreamUsage streamUsage)939 AudioStreamType AudioStreamCollector::GetVolumeTypeFromContentUsage(ContentType contentType, StreamUsage streamUsage)
940 {
941     AudioStreamType streamType = STREAM_MUSIC;
942     auto pos = streamTypeMap_.find(make_pair(contentType, streamUsage));
943     if (pos != streamTypeMap_.end()) {
944         streamType = pos->second;
945     }
946     return VolumeUtils::GetVolumeTypeFromStreamType(streamType);
947 }
948 
GetStreamTypeFromSourceType(SourceType sourceType)949 AudioStreamType AudioStreamCollector::GetStreamTypeFromSourceType(SourceType sourceType)
950 {
951     switch (sourceType) {
952         case SOURCE_TYPE_MIC:
953         case SOURCE_TYPE_UNPROCESSED:
954             return STREAM_MUSIC;
955         case SOURCE_TYPE_VOICE_COMMUNICATION:
956             return STREAM_VOICE_CALL;
957         case SOURCE_TYPE_ULTRASONIC:
958             return STREAM_ULTRASONIC;
959         case SOURCE_TYPE_WAKEUP:
960             return STREAM_WAKEUP;
961         case SOURCE_TYPE_CAMCORDER:
962             return STREAM_CAMCORDER;
963         default:
964             return STREAM_MUSIC;
965     }
966 }
967 
SetLowPowerVolume(int32_t streamId,float volume)968 int32_t AudioStreamCollector::SetLowPowerVolume(int32_t streamId, float volume)
969 {
970     std::lock_guard<std::mutex> lock(streamsInfoMutex_);
971     CHECK_AND_RETURN_RET_LOG(!(clientTracker_.count(streamId) == 0),
972         ERR_INVALID_PARAM, "SetLowPowerVolume streamId invalid.");
973     std::shared_ptr<AudioClientTracker> callback = clientTracker_[streamId];
974     CHECK_AND_RETURN_RET_LOG(callback != nullptr,
975         ERR_INVALID_PARAM, "SetLowPowerVolume callback failed");
976     callback->SetLowPowerVolumeImpl(volume);
977     return SUCCESS;
978 }
979 
GetLowPowerVolume(int32_t streamId)980 float AudioStreamCollector::GetLowPowerVolume(int32_t streamId)
981 {
982     std::lock_guard<std::mutex> lock(streamsInfoMutex_);
983     float ret = 1.0; // invalue volume
984     CHECK_AND_RETURN_RET_LOG(!(clientTracker_.count(streamId) == 0),
985         ret, "GetLowPowerVolume streamId invalid.");
986     float volume;
987     std::shared_ptr<AudioClientTracker> callback = clientTracker_[streamId];
988     CHECK_AND_RETURN_RET_LOG(callback != nullptr,
989         ret, "GetLowPowerVolume callback failed");
990     callback->GetLowPowerVolumeImpl(volume);
991     return volume;
992 }
993 
SetOffloadMode(int32_t streamId,int32_t state,bool isAppBack)994 int32_t AudioStreamCollector::SetOffloadMode(int32_t streamId, int32_t state, bool isAppBack)
995 {
996     std::shared_ptr<AudioClientTracker> callback;
997     {
998         std::lock_guard<std::mutex> lock(streamsInfoMutex_);
999         CHECK_AND_RETURN_RET_LOG(!(clientTracker_.count(streamId) == 0),
1000             ERR_INVALID_PARAM, "streamId (%{public}d) invalid.", streamId);
1001         callback = clientTracker_[streamId];
1002         CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM, "callback failed");
1003     }
1004     callback->SetOffloadModeImpl(state, isAppBack);
1005     return SUCCESS;
1006 }
1007 
UnsetOffloadMode(int32_t streamId)1008 int32_t AudioStreamCollector::UnsetOffloadMode(int32_t streamId)
1009 {
1010     std::shared_ptr<AudioClientTracker> callback;
1011     {
1012         std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1013         CHECK_AND_RETURN_RET_LOG(!(clientTracker_.count(streamId) == 0),
1014             ERR_INVALID_PARAM, "streamId (%{public}d) invalid.", streamId);
1015         callback = clientTracker_[streamId];
1016         CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM, "callback failed");
1017     }
1018     callback->UnsetOffloadModeImpl();
1019     return SUCCESS;
1020 }
1021 
GetSingleStreamVolume(int32_t streamId)1022 float AudioStreamCollector::GetSingleStreamVolume(int32_t streamId)
1023 {
1024     std::shared_ptr<AudioClientTracker> callback;
1025     {
1026         std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1027         float ret = 1.0; // invalue volume
1028         CHECK_AND_RETURN_RET_LOG(!(clientTracker_.count(streamId) == 0),
1029             ret, "GetSingleStreamVolume streamId invalid.");
1030         callback = clientTracker_[streamId];
1031         CHECK_AND_RETURN_RET_LOG(callback != nullptr,
1032             ret, "GetSingleStreamVolume callback failed");
1033     }
1034     float volume;
1035     callback->GetSingleStreamVolumeImpl(volume);
1036     return volume;
1037 }
1038 
UpdateCapturerInfoMuteStatus(int32_t uid,bool muteStatus)1039 int32_t AudioStreamCollector::UpdateCapturerInfoMuteStatus(int32_t uid, bool muteStatus)
1040 {
1041     std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1042     bool capturerInfoUpdated = false;
1043     for (auto it = audioCapturerChangeInfos_.begin(); it != audioCapturerChangeInfos_.end(); it++) {
1044         if ((*it)->clientUID == uid || uid == 0) {
1045             (*it)->muted = muteStatus;
1046             capturerInfoUpdated = true;
1047             std::shared_ptr<Media::MediaMonitor::EventBean> bean = std::make_shared<Media::MediaMonitor::EventBean>(
1048                 Media::MediaMonitor::ModuleId::AUDIO, Media::MediaMonitor::EventId::CAPTURE_MUTE_STATUS_CHANGE,
1049                 Media::MediaMonitor::EventType::BEHAVIOR_EVENT);
1050             bean->Add("ISOUTPUT", 0);
1051             bean->Add("STREAMID", (*it)->sessionId);
1052             bean->Add("STREAM_TYPE", (*it)->capturerInfo.sourceType);
1053             bean->Add("DEVICETYPE", (*it)->inputDeviceInfo.deviceType);
1054             bean->Add("MUTED", (*it)->muted);
1055             Media::MediaMonitor::MediaMonitorManager::GetInstance().WriteLogMsg(bean);
1056         }
1057     }
1058 
1059     if (capturerInfoUpdated && audioPolicyServerHandler_ != nullptr) {
1060         audioPolicyServerHandler_->SendCapturerInfoEvent(audioCapturerChangeInfos_);
1061     }
1062 
1063     return SUCCESS;
1064 }
1065 
SetAudioConcurrencyCallback(const uint32_t sessionID,const sptr<IRemoteObject> & object)1066 int32_t AudioStreamCollector::SetAudioConcurrencyCallback(const uint32_t sessionID, const sptr<IRemoteObject> &object)
1067 {
1068     return audioConcurrencyService_->SetAudioConcurrencyCallback(sessionID, object);
1069 }
1070 
UnsetAudioConcurrencyCallback(const uint32_t sessionID)1071 int32_t AudioStreamCollector::UnsetAudioConcurrencyCallback(const uint32_t sessionID)
1072 {
1073     return audioConcurrencyService_->UnsetAudioConcurrencyCallback(sessionID);
1074 }
1075 
ActivateAudioConcurrency(const AudioPipeType & pipeType)1076 int32_t AudioStreamCollector::ActivateAudioConcurrency(const AudioPipeType &pipeType)
1077 {
1078     std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1079     return audioConcurrencyService_->ActivateAudioConcurrency(pipeType,
1080         audioRendererChangeInfos_, audioCapturerChangeInfos_);
1081 }
1082 
WriterStreamChangeSysEvent(AudioMode & mode,AudioStreamChangeInfo & streamChangeInfo)1083 void AudioStreamCollector::WriterStreamChangeSysEvent(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo)
1084 {
1085     if (mode == AUDIO_MODE_PLAYBACK) {
1086         WriterRenderStreamChangeSysEvent(streamChangeInfo);
1087     } else {
1088         WriterCaptureStreamChangeSysEvent(streamChangeInfo);
1089     }
1090 }
1091 
WriterRenderStreamChangeSysEvent(AudioStreamChangeInfo & streamChangeInfo)1092 void AudioStreamCollector::WriterRenderStreamChangeSysEvent(AudioStreamChangeInfo &streamChangeInfo)
1093 {
1094     bool isOutput = true;
1095     AudioStreamType streamType = GetVolumeTypeFromContentUsage(
1096         streamChangeInfo.audioRendererChangeInfo.rendererInfo.contentType,
1097         streamChangeInfo.audioRendererChangeInfo.rendererInfo.streamUsage);
1098     uint64_t transactionId = audioSystemMgr_->GetTransactionId(
1099         streamChangeInfo.audioRendererChangeInfo.outputDeviceInfo.deviceType, OUTPUT_DEVICE);
1100 
1101     uint8_t effectChainType = EFFECT_CHAIN_TYPE_MAP.count(
1102         streamChangeInfo.audioRendererChangeInfo.rendererInfo.sceneType) ?
1103         EFFECT_CHAIN_TYPE_MAP.at(streamChangeInfo.audioRendererChangeInfo.rendererInfo.sceneType) :
1104         EFFECT_CHAIN_TYPE_MAP.at("UNKNOWN");
1105 
1106     std::shared_ptr<Media::MediaMonitor::EventBean> bean = std::make_shared<Media::MediaMonitor::EventBean>(
1107         Media::MediaMonitor::AUDIO, Media::MediaMonitor::STREAM_CHANGE,
1108         Media::MediaMonitor::BEHAVIOR_EVENT);
1109     bean->Add("ISOUTPUT", isOutput ? 1 : 0);
1110     bean->Add("STREAMID", streamChangeInfo.audioRendererChangeInfo.sessionId);
1111     bean->Add("UID", streamChangeInfo.audioRendererChangeInfo.clientUID);
1112     bean->Add("PID", streamChangeInfo.audioRendererChangeInfo.clientPid);
1113     bean->Add("TRANSACTIONID", transactionId);
1114     bean->Add("STREAMTYPE", streamType);
1115     bean->Add("STATE", streamChangeInfo.audioRendererChangeInfo.rendererState);
1116     bean->Add("DEVICETYPE", streamChangeInfo.audioRendererChangeInfo.outputDeviceInfo.deviceType);
1117     bean->Add("BT_TYPE", streamChangeInfo.audioRendererChangeInfo.outputDeviceInfo.deviceCategory);
1118     bean->Add("PIPE_TYPE", streamChangeInfo.audioRendererChangeInfo.rendererInfo.pipeType);
1119     bean->Add("STREAM_TYPE", streamChangeInfo.audioRendererChangeInfo.rendererInfo.streamUsage);
1120     bean->Add("SAMPLE_RATE", streamChangeInfo.audioRendererChangeInfo.rendererInfo.samplingRate);
1121     bean->Add("NETWORKID", ConvertNetworkId(streamChangeInfo.audioRendererChangeInfo.outputDeviceInfo.networkId));
1122     bean->Add("ENCODING_TYPE", streamChangeInfo.audioRendererChangeInfo.rendererInfo.encodingType);
1123     bean->Add("CHANNEL_LAYOUT", streamChangeInfo.audioRendererChangeInfo.rendererInfo.channelLayout);
1124     bean->Add("EFFECT_CHAIN", effectChainType);
1125     Media::MediaMonitor::MediaMonitorManager::GetInstance().WriteLogMsg(bean);
1126 }
1127 
WriterCaptureStreamChangeSysEvent(AudioStreamChangeInfo & streamChangeInfo)1128 void AudioStreamCollector::WriterCaptureStreamChangeSysEvent(AudioStreamChangeInfo &streamChangeInfo)
1129 {
1130     bool isOutput = false;
1131     AudioStreamType streamType = GetStreamTypeFromSourceType(
1132         streamChangeInfo.audioCapturerChangeInfo.capturerInfo.sourceType);
1133     uint64_t transactionId = audioSystemMgr_->GetTransactionId(
1134         streamChangeInfo.audioCapturerChangeInfo.inputDeviceInfo.deviceType, INPUT_DEVICE);
1135 
1136     uint8_t effectChainType = EFFECT_CHAIN_TYPE_MAP.count(
1137         streamChangeInfo.audioCapturerChangeInfo.capturerInfo.sceneType) ?
1138         EFFECT_CHAIN_TYPE_MAP.at(streamChangeInfo.audioCapturerChangeInfo.capturerInfo.sceneType) :
1139         EFFECT_CHAIN_TYPE_MAP.at("UNKNOWN");
1140 
1141     std::shared_ptr<Media::MediaMonitor::EventBean> bean = std::make_shared<Media::MediaMonitor::EventBean>(
1142         Media::MediaMonitor::AUDIO, Media::MediaMonitor::STREAM_CHANGE,
1143         Media::MediaMonitor::BEHAVIOR_EVENT);
1144     bean->Add("ISOUTPUT", isOutput ? 1 : 0);
1145     bean->Add("STREAMID", streamChangeInfo.audioCapturerChangeInfo.sessionId);
1146     bean->Add("UID", streamChangeInfo.audioCapturerChangeInfo.clientUID);
1147     bean->Add("PID", streamChangeInfo.audioCapturerChangeInfo.clientPid);
1148     bean->Add("TRANSACTIONID", transactionId);
1149     bean->Add("STREAMTYPE", streamType);
1150     bean->Add("STATE", streamChangeInfo.audioCapturerChangeInfo.capturerState);
1151     bean->Add("DEVICETYPE", streamChangeInfo.audioCapturerChangeInfo.inputDeviceInfo.deviceType);
1152     bean->Add("BT_TYPE", streamChangeInfo.audioCapturerChangeInfo.inputDeviceInfo.deviceCategory);
1153     bean->Add("PIPE_TYPE", streamChangeInfo.audioCapturerChangeInfo.capturerInfo.pipeType);
1154     bean->Add("STREAM_TYPE", streamChangeInfo.audioCapturerChangeInfo.capturerInfo.sourceType);
1155     bean->Add("SAMPLE_RATE", streamChangeInfo.audioCapturerChangeInfo.capturerInfo.samplingRate);
1156     bean->Add("MUTED", streamChangeInfo.audioCapturerChangeInfo.muted);
1157     bean->Add("NETWORKID", ConvertNetworkId(streamChangeInfo.audioCapturerChangeInfo.inputDeviceInfo.networkId));
1158     bean->Add("ENCODING_TYPE", streamChangeInfo.audioCapturerChangeInfo.capturerInfo.encodingType);
1159     bean->Add("CHANNEL_LAYOUT", streamChangeInfo.audioCapturerChangeInfo.capturerInfo.channelLayout);
1160     bean->Add("EFFECT_CHAIN", effectChainType);
1161     Media::MediaMonitor::MediaMonitorManager::GetInstance().WriteLogMsg(bean);
1162 }
1163 
1164 
WriteRenderStreamReleaseSysEvent(const std::unique_ptr<AudioRendererChangeInfo> & audioRendererChangeInfo)1165 void AudioStreamCollector::WriteRenderStreamReleaseSysEvent(
1166     const std::unique_ptr<AudioRendererChangeInfo> &audioRendererChangeInfo)
1167 {
1168     AudioStreamType streamType = GetVolumeTypeFromContentUsage(audioRendererChangeInfo->rendererInfo.contentType,
1169         audioRendererChangeInfo->rendererInfo.streamUsage);
1170     uint64_t transactionId = audioSystemMgr_->GetTransactionId(
1171         audioRendererChangeInfo->outputDeviceInfo.deviceType, OUTPUT_DEVICE);
1172 
1173     uint8_t effectChainType = EFFECT_CHAIN_TYPE_MAP.count(
1174         audioRendererChangeInfo->rendererInfo.sceneType) ?
1175         EFFECT_CHAIN_TYPE_MAP.at(audioRendererChangeInfo->rendererInfo.sceneType) :
1176         EFFECT_CHAIN_TYPE_MAP.at("UNKNOWN");
1177 
1178     std::shared_ptr<Media::MediaMonitor::EventBean> bean = std::make_shared<Media::MediaMonitor::EventBean>(
1179         Media::MediaMonitor::AUDIO, Media::MediaMonitor::STREAM_CHANGE,
1180         Media::MediaMonitor::BEHAVIOR_EVENT);
1181     bean->Add("ISOUTPUT", 1);
1182     bean->Add("STREAMID", audioRendererChangeInfo->sessionId);
1183     bean->Add("UID", audioRendererChangeInfo->clientUID);
1184     bean->Add("PID", audioRendererChangeInfo->clientPid);
1185     bean->Add("TRANSACTIONID", transactionId);
1186     bean->Add("STREAMTYPE", streamType);
1187     bean->Add("STATE", audioRendererChangeInfo->rendererState);
1188     bean->Add("DEVICETYPE", audioRendererChangeInfo->outputDeviceInfo.deviceType);
1189     bean->Add("BT_TYPE", audioRendererChangeInfo->outputDeviceInfo.deviceCategory);
1190     bean->Add("PIPE_TYPE", audioRendererChangeInfo->rendererInfo.pipeType);
1191     bean->Add("STREAM_TYPE", audioRendererChangeInfo->rendererInfo.streamUsage);
1192     bean->Add("SAMPLE_RATE", audioRendererChangeInfo->rendererInfo.samplingRate);
1193     bean->Add("NETWORKID", ConvertNetworkId(audioRendererChangeInfo->outputDeviceInfo.networkId));
1194     bean->Add("ENCODING_TYPE", audioRendererChangeInfo->rendererInfo.encodingType);
1195     bean->Add("CHANNEL_LAYOUT", audioRendererChangeInfo->rendererInfo.channelLayout);
1196     bean->Add("EFFECT_CHAIN", effectChainType);
1197     Media::MediaMonitor::MediaMonitorManager::GetInstance().WriteLogMsg(bean);
1198 }
1199 
WriteCaptureStreamReleaseSysEvent(const std::unique_ptr<AudioCapturerChangeInfo> & audioCapturerChangeInfo)1200 void AudioStreamCollector::WriteCaptureStreamReleaseSysEvent(
1201     const std::unique_ptr<AudioCapturerChangeInfo> &audioCapturerChangeInfo)
1202 {
1203     AudioStreamType streamType = GetStreamTypeFromSourceType(audioCapturerChangeInfo->capturerInfo.sourceType);
1204     uint64_t transactionId = audioSystemMgr_->GetTransactionId(
1205         audioCapturerChangeInfo->inputDeviceInfo.deviceType, INPUT_DEVICE);
1206 
1207     uint8_t effectChainType = EFFECT_CHAIN_TYPE_MAP.count(
1208         audioCapturerChangeInfo->capturerInfo.sceneType) ?
1209         EFFECT_CHAIN_TYPE_MAP.at(audioCapturerChangeInfo->capturerInfo.sceneType) :
1210         EFFECT_CHAIN_TYPE_MAP.at("UNKNOWN");
1211 
1212     std::shared_ptr<Media::MediaMonitor::EventBean> bean = std::make_shared<Media::MediaMonitor::EventBean>(
1213         Media::MediaMonitor::AUDIO, Media::MediaMonitor::STREAM_CHANGE,
1214         Media::MediaMonitor::BEHAVIOR_EVENT);
1215     bean->Add("ISOUTPUT", 1);
1216     bean->Add("STREAMID", audioCapturerChangeInfo->sessionId);
1217     bean->Add("UID", audioCapturerChangeInfo->clientUID);
1218     bean->Add("PID", audioCapturerChangeInfo->clientPid);
1219     bean->Add("TRANSACTIONID", transactionId);
1220     bean->Add("STREAMTYPE", streamType);
1221     bean->Add("STATE", audioCapturerChangeInfo->capturerState);
1222     bean->Add("DEVICETYPE", audioCapturerChangeInfo->inputDeviceInfo.deviceType);
1223     bean->Add("BT_TYPE", audioCapturerChangeInfo->inputDeviceInfo.deviceCategory);
1224     bean->Add("PIPE_TYPE", audioCapturerChangeInfo->capturerInfo.pipeType);
1225     bean->Add("STREAM_TYPE", audioCapturerChangeInfo->capturerInfo.sourceType);
1226     bean->Add("SAMPLE_RATE", audioCapturerChangeInfo->capturerInfo.samplingRate);
1227     bean->Add("MUTED", audioCapturerChangeInfo->muted);
1228     bean->Add("NETWORKID", ConvertNetworkId(audioCapturerChangeInfo->inputDeviceInfo.networkId));
1229     bean->Add("ENCODING_TYPE", audioCapturerChangeInfo->capturerInfo.encodingType);
1230     bean->Add("CHANNEL_LAYOUT", audioCapturerChangeInfo->capturerInfo.channelLayout);
1231     bean->Add("EFFECT_CHAIN", effectChainType);
1232     Media::MediaMonitor::MediaMonitorManager::GetInstance().WriteLogMsg(bean);
1233 }
1234 
IsCallStreamUsage(StreamUsage usage)1235 bool AudioStreamCollector::IsCallStreamUsage(StreamUsage usage)
1236 {
1237     if (usage == STREAM_USAGE_VOICE_COMMUNICATION || usage == STREAM_USAGE_VIDEO_COMMUNICATION ||
1238         usage == STREAM_USAGE_VOICE_MODEM_COMMUNICATION) {
1239         return true;
1240     }
1241     return false;
1242 }
1243 
GetRunningStreamUsageNoUltrasonic()1244 StreamUsage AudioStreamCollector::GetRunningStreamUsageNoUltrasonic()
1245 {
1246     std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1247     for (const auto &changeInfo : audioRendererChangeInfos_) {
1248         if (changeInfo->rendererState == RENDERER_RUNNING &&
1249             changeInfo->rendererInfo.streamUsage != STREAM_USAGE_ULTRASONIC) {
1250             return changeInfo->rendererInfo.streamUsage;
1251         }
1252     }
1253     return STREAM_USAGE_INVALID;
1254 }
1255 
GetRunningSourceTypeNoUltrasonic()1256 SourceType AudioStreamCollector::GetRunningSourceTypeNoUltrasonic()
1257 {
1258     std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1259     for (const auto &changeInfo : audioCapturerChangeInfos_) {
1260         if (changeInfo->capturerState == CAPTURER_RUNNING &&
1261             changeInfo->capturerInfo.sourceType != SOURCE_TYPE_ULTRASONIC) {
1262             return changeInfo->capturerInfo.sourceType;
1263         }
1264     }
1265     return SOURCE_TYPE_INVALID;
1266 }
1267 
GetLastestRunningCallStreamUsage()1268 StreamUsage AudioStreamCollector::GetLastestRunningCallStreamUsage()
1269 {
1270     std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1271     for (const auto &changeInfo : audioRendererChangeInfos_) {
1272         StreamUsage usage = changeInfo->rendererInfo.streamUsage;
1273         RendererState state = changeInfo->rendererState;
1274         if ((IsCallStreamUsage(usage) && state == RENDERER_RUNNING) ||
1275             (usage == STREAM_USAGE_VOICE_MODEM_COMMUNICATION && state == RENDERER_PREPARED)) {
1276             return usage;
1277         }
1278     }
1279     return STREAM_USAGE_UNKNOWN;
1280 }
1281 
GetAllRendererSessionIDForUID(int32_t uid)1282 std::vector<uint32_t> AudioStreamCollector::GetAllRendererSessionIDForUID(int32_t uid)
1283 {
1284     std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1285     std::vector<uint32_t> sessionIDSet;
1286     for (const auto &changeInfo : audioRendererChangeInfos_) {
1287         if (changeInfo->clientUID == uid) {
1288             sessionIDSet.push_back(changeInfo->sessionId);
1289         }
1290     }
1291     return sessionIDSet;
1292 }
1293 
ChangeVoipCapturerStreamToNormal()1294 bool AudioStreamCollector::ChangeVoipCapturerStreamToNormal()
1295 {
1296     std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1297     int count = std::count_if(audioCapturerChangeInfos_.begin(), audioCapturerChangeInfos_.end(),
1298         [](const auto &changeInfo) {
1299             const auto &sourceType = changeInfo->capturerInfo.sourceType;
1300             return sourceType == SOURCE_TYPE_VOICE_COMMUNICATION || sourceType == SOURCE_TYPE_MIC ||
1301                 sourceType == SOURCE_TYPE_VOICE_MESSAGE || sourceType == SOURCE_TYPE_VOICE_TRANSCRIPTION;
1302         });
1303 
1304     AUDIO_INFO_LOG("Has capture stream count: %{public}d", count);
1305     // becasue self has been added
1306     return count > 1;
1307 }
1308 
HasVoipRendererStream()1309 bool AudioStreamCollector::HasVoipRendererStream()
1310 {
1311     std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1312     // judge stream original flage is AUDIO_FLAG_VOIP_FAST
1313     bool hasVoip = std::any_of(audioRendererChangeInfos_.begin(), audioRendererChangeInfos_.end(),
1314         [](const auto &changeInfo) {
1315             return changeInfo->rendererInfo.originalFlag == AUDIO_FLAG_VOIP_FAST;
1316         });
1317 
1318     AUDIO_INFO_LOG("Has Fast Voip stream : %{public}d", hasVoip);
1319     return hasVoip;
1320 }
1321 
HasRunningRendererStream()1322 bool AudioStreamCollector::HasRunningRendererStream()
1323 {
1324     std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1325     // judge stream state is running
1326     bool hasRunningRendererStream = std::any_of(audioRendererChangeInfos_.begin(), audioRendererChangeInfos_.end(),
1327         [](const auto &changeInfo) {
1328             return ((changeInfo->rendererState == RENDERER_RUNNING) || (changeInfo->rendererInfo.streamUsage ==
1329                 STREAM_USAGE_VOICE_MODEM_COMMUNICATION && changeInfo->rendererState == RENDERER_PREPARED));
1330         });
1331     AUDIO_INFO_LOG("Has Running Renderer stream : %{public}d", hasRunningRendererStream);
1332     return hasRunningRendererStream;
1333 }
1334 
HasRunningRecognitionCapturerStream()1335 bool AudioStreamCollector::HasRunningRecognitionCapturerStream()
1336 {
1337     std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1338     // judge stream state is running
1339     bool hasRunningRecognitionCapturerStream = std::any_of(audioCapturerChangeInfos_.begin(),
1340         audioCapturerChangeInfos_.end(),
1341         [](const auto &changeInfo) {
1342             return ((changeInfo->capturerState == CAPTURER_RUNNING) && (changeInfo->capturerInfo.sourceType ==
1343                 SOURCE_TYPE_VOICE_RECOGNITION));
1344         });
1345 
1346     AUDIO_INFO_LOG("Has Running Recognition stream : %{public}d", hasRunningRecognitionCapturerStream);
1347     return hasRunningRecognitionCapturerStream;
1348 }
1349 } // namespace AudioStandard
1350 } // namespace OHOS
1351