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
IsOffloadAllowed(const int32_t sessionId)665 bool AudioStreamCollector::IsOffloadAllowed(const int32_t sessionId)
666 {
667 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
668 const auto &it = std::find_if(audioRendererChangeInfos_.begin(), audioRendererChangeInfos_.end(),
669 [&sessionId](const std::unique_ptr<AudioRendererChangeInfo> &changeInfo) {
670 return changeInfo->sessionId == sessionId;
671 });
672 if (it == audioRendererChangeInfos_.end()) {
673 AUDIO_WARNING_LOG("invalid session id: %{public}d", sessionId);
674 return false;
675 }
676 return (*it)->rendererInfo.isOffloadAllowed;
677 }
678
GetChannelCount(int32_t sessionId)679 int32_t AudioStreamCollector::GetChannelCount(int32_t sessionId)
680 {
681 int32_t channelCount = 0;
682 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
683 const auto &it = std::find_if(audioRendererChangeInfos_.begin(), audioRendererChangeInfos_.end(),
684 [&sessionId](const std::unique_ptr<AudioRendererChangeInfo> &changeInfo) {
685 return changeInfo->sessionId == sessionId;
686 });
687 if (it != audioRendererChangeInfos_.end()) {
688 channelCount = (*it)->channelCount;
689 }
690 return channelCount;
691 }
692
GetCurrentRendererChangeInfos(std::vector<unique_ptr<AudioRendererChangeInfo>> & rendererChangeInfos)693 int32_t AudioStreamCollector::GetCurrentRendererChangeInfos(
694 std::vector<unique_ptr<AudioRendererChangeInfo>> &rendererChangeInfos)
695 {
696 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
697 for (const auto &changeInfo : audioRendererChangeInfos_) {
698 rendererChangeInfos.push_back(make_unique<AudioRendererChangeInfo>(*changeInfo));
699 }
700 AUDIO_DEBUG_LOG("GetCurrentRendererChangeInfos returned");
701
702 return SUCCESS;
703 }
704
GetCurrentCapturerChangeInfos(std::vector<unique_ptr<AudioCapturerChangeInfo>> & capturerChangeInfos)705 int32_t AudioStreamCollector::GetCurrentCapturerChangeInfos(
706 std::vector<unique_ptr<AudioCapturerChangeInfo>> &capturerChangeInfos)
707 {
708 AUDIO_DEBUG_LOG("GetCurrentCapturerChangeInfos");
709 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
710 for (const auto &changeInfo : audioCapturerChangeInfos_) {
711 capturerChangeInfos.push_back(make_unique<AudioCapturerChangeInfo>(*changeInfo));
712 AUDIO_DEBUG_LOG("GetCurrentCapturerChangeInfos returned");
713 }
714
715 return SUCCESS;
716 }
717
RegisteredRendererTrackerClientDied(const int32_t uid)718 void AudioStreamCollector::RegisteredRendererTrackerClientDied(const int32_t uid)
719 {
720 int32_t sessionID = -1;
721 auto audioRendererBegin = audioRendererChangeInfos_.begin();
722 while (audioRendererBegin != audioRendererChangeInfos_.end()) {
723 const auto &audioRendererChangeInfo = *audioRendererBegin;
724 if (audioRendererChangeInfo == nullptr ||
725 (audioRendererChangeInfo->clientUID != uid && audioRendererChangeInfo->createrUID != uid)) {
726 audioRendererBegin++;
727 continue;
728 }
729 sessionID = audioRendererChangeInfo->sessionId;
730 audioRendererChangeInfo->rendererState = RENDERER_RELEASED;
731 WriteRenderStreamReleaseSysEvent(audioRendererChangeInfo);
732 if (audioPolicyServerHandler_ != nullptr) {
733 audioPolicyServerHandler_->SendRendererInfoEvent(audioRendererChangeInfos_);
734 }
735 AudioSpatializationService::GetAudioSpatializationService().UpdateRendererInfo(audioRendererChangeInfos_);
736 rendererStatequeue_.erase(make_pair(audioRendererChangeInfo->clientUID, audioRendererChangeInfo->sessionId));
737 auto temp = audioRendererBegin;
738 audioRendererBegin = audioRendererChangeInfos_.erase(temp);
739 if ((sessionID != -1) && clientTracker_.erase(sessionID)) {
740 AUDIO_INFO_LOG("TrackerClientDied:client %{public}d cleared", sessionID);
741 }
742 }
743 }
744
RegisteredCapturerTrackerClientDied(const int32_t uid)745 void AudioStreamCollector::RegisteredCapturerTrackerClientDied(const int32_t uid)
746 {
747 int32_t sessionID = -1;
748 auto audioCapturerBegin = audioCapturerChangeInfos_.begin();
749 while (audioCapturerBegin != audioCapturerChangeInfos_.end()) {
750 const auto &audioCapturerChangeInfo = *audioCapturerBegin;
751 if (audioCapturerChangeInfo == nullptr ||
752 (audioCapturerChangeInfo->clientUID != uid && audioCapturerChangeInfo->createrUID != uid)) {
753 audioCapturerBegin++;
754 continue;
755 }
756 sessionID = audioCapturerChangeInfo->sessionId;
757 audioCapturerChangeInfo->capturerState = CAPTURER_RELEASED;
758 WriteCaptureStreamReleaseSysEvent(audioCapturerChangeInfo);
759 if (audioPolicyServerHandler_ != nullptr) {
760 audioPolicyServerHandler_->SendCapturerInfoEvent(audioCapturerChangeInfos_);
761 }
762 capturerStatequeue_.erase(make_pair(audioCapturerChangeInfo->clientUID, audioCapturerChangeInfo->sessionId));
763 auto temp = audioCapturerBegin;
764 audioCapturerBegin = audioCapturerChangeInfos_.erase(temp);
765 if ((sessionID != -1) && clientTracker_.erase(sessionID)) {
766 AUDIO_INFO_LOG("TrackerClientDied:client %{public}d cleared", sessionID);
767 }
768 }
769 }
770
RegisteredTrackerClientDied(int32_t uid)771 void AudioStreamCollector::RegisteredTrackerClientDied(int32_t uid)
772 {
773 AUDIO_INFO_LOG("TrackerClientDied:client:%{public}d Died", uid);
774
775 // Send the release state event notification for all streams of died client to registered app
776 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
777 RegisteredRendererTrackerClientDied(uid);
778 RegisteredCapturerTrackerClientDied(uid);
779 }
780
GetAndCompareStreamType(StreamUsage targetUsage,AudioRendererInfo rendererInfo)781 bool AudioStreamCollector::GetAndCompareStreamType(StreamUsage targetUsage, AudioRendererInfo rendererInfo)
782 {
783 AudioStreamType requiredType = GetStreamType(CONTENT_TYPE_UNKNOWN, targetUsage);
784 AUDIO_INFO_LOG("GetAndCompareStreamType:requiredType:%{public}d ", requiredType);
785 AudioStreamType defaultStreamType = STREAM_MUSIC;
786 auto pos = streamTypeMap_.find(make_pair(rendererInfo.contentType, rendererInfo.streamUsage));
787 if (pos != streamTypeMap_.end()) {
788 defaultStreamType = pos->second;
789 }
790 return defaultStreamType == requiredType;
791 }
792
GetUid(int32_t sessionId)793 int32_t AudioStreamCollector::GetUid(int32_t sessionId)
794 {
795 int32_t defaultUid = -1;
796 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
797 const auto &it = std::find_if(audioRendererChangeInfos_.begin(), audioRendererChangeInfos_.end(),
798 [&sessionId](const std::unique_ptr<AudioRendererChangeInfo> &changeInfo) {
799 return changeInfo->sessionId == sessionId;
800 });
801 if (it != audioRendererChangeInfos_.end()) {
802 defaultUid = (*it)->createrUID;
803 }
804 return defaultUid;
805 }
806
UpdateStreamState(int32_t clientUid,StreamSetStateEventInternal & streamSetStateEventInternal)807 int32_t AudioStreamCollector::UpdateStreamState(int32_t clientUid,
808 StreamSetStateEventInternal &streamSetStateEventInternal)
809 {
810 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
811 for (const auto &changeInfo : audioRendererChangeInfos_) {
812 if (changeInfo->clientUID == clientUid &&
813 streamSetStateEventInternal.streamUsage == changeInfo->rendererInfo.streamUsage) {
814 AUDIO_INFO_LOG("UpdateStreamState Found matching uid=%{public}d and usage=%{public}d",
815 clientUid, streamSetStateEventInternal.streamUsage);
816 std::shared_ptr<AudioClientTracker> callback = clientTracker_[changeInfo->sessionId];
817 if (callback == nullptr) {
818 AUDIO_ERR_LOG("UpdateStreamState callback failed sId:%{public}d",
819 changeInfo->sessionId);
820 continue;
821 }
822 if (streamSetStateEventInternal.streamSetState == StreamSetState::STREAM_PAUSE) {
823 callback->PausedStreamImpl(streamSetStateEventInternal);
824 } else if (streamSetStateEventInternal.streamSetState == StreamSetState::STREAM_RESUME) {
825 callback->ResumeStreamImpl(streamSetStateEventInternal);
826 }
827 }
828 }
829
830 return SUCCESS;
831 }
832
IsStreamActive(AudioStreamType volumeType)833 bool AudioStreamCollector::IsStreamActive(AudioStreamType volumeType)
834 {
835 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
836 bool result = false;
837 for (auto &changeInfo: audioRendererChangeInfos_) {
838 if (changeInfo->rendererState != RENDERER_RUNNING) {
839 continue;
840 }
841 AudioVolumeType rendererVolumeType = GetVolumeTypeFromContentUsage((changeInfo->rendererInfo).contentType,
842 (changeInfo->rendererInfo).streamUsage);
843 if (rendererVolumeType == volumeType) {
844 // An active stream has been found, return true directly.
845 return true;
846 }
847 }
848 return result;
849 }
850
GetRunningStream(AudioStreamType certainType,int32_t certainChannelCount)851 int32_t AudioStreamCollector::GetRunningStream(AudioStreamType certainType, int32_t certainChannelCount)
852 {
853 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
854 int32_t runningStream = -1;
855 if ((certainType == STREAM_DEFAULT) && (certainChannelCount == 0)) {
856 for (auto &changeInfo : audioRendererChangeInfos_) {
857 if (changeInfo->rendererState == RENDERER_RUNNING) {
858 runningStream = changeInfo->sessionId;
859 break;
860 }
861 }
862 } else if (certainChannelCount == 0) {
863 for (auto &changeInfo : audioRendererChangeInfos_) {
864 if ((changeInfo->rendererState == RENDERER_RUNNING) &&
865 (certainType == GetStreamType(changeInfo->rendererInfo.contentType,
866 changeInfo->rendererInfo.streamUsage))) {
867 runningStream = changeInfo->sessionId;
868 break;
869 }
870 }
871 } else {
872 for (auto &changeInfo : audioRendererChangeInfos_) {
873 if ((changeInfo->rendererState == RENDERER_RUNNING) &&
874 (certainType == GetStreamType(changeInfo->rendererInfo.contentType,
875 changeInfo->rendererInfo.streamUsage)) && (certainChannelCount == changeInfo->channelCount)) {
876 runningStream = changeInfo->sessionId;
877 break;
878 }
879 }
880 }
881 return runningStream;
882 }
883
GetVolumeTypeFromContentUsage(ContentType contentType,StreamUsage streamUsage)884 AudioStreamType AudioStreamCollector::GetVolumeTypeFromContentUsage(ContentType contentType, StreamUsage streamUsage)
885 {
886 AudioStreamType streamType = STREAM_MUSIC;
887 auto pos = streamTypeMap_.find(make_pair(contentType, streamUsage));
888 if (pos != streamTypeMap_.end()) {
889 streamType = pos->second;
890 }
891 return VolumeUtils::GetVolumeTypeFromStreamType(streamType);
892 }
893
GetStreamTypeFromSourceType(SourceType sourceType)894 AudioStreamType AudioStreamCollector::GetStreamTypeFromSourceType(SourceType sourceType)
895 {
896 switch (sourceType) {
897 case SOURCE_TYPE_MIC:
898 return STREAM_MUSIC;
899 case SOURCE_TYPE_VOICE_COMMUNICATION:
900 return STREAM_VOICE_CALL;
901 case SOURCE_TYPE_ULTRASONIC:
902 return STREAM_ULTRASONIC;
903 case SOURCE_TYPE_WAKEUP:
904 return STREAM_WAKEUP;
905 case SOURCE_TYPE_CAMCORDER:
906 return STREAM_CAMCORDER;
907 default:
908 return STREAM_MUSIC;
909 }
910 }
911
SetLowPowerVolume(int32_t streamId,float volume)912 int32_t AudioStreamCollector::SetLowPowerVolume(int32_t streamId, float volume)
913 {
914 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
915 CHECK_AND_RETURN_RET_LOG(!(clientTracker_.count(streamId) == 0),
916 ERR_INVALID_PARAM, "SetLowPowerVolume streamId invalid.");
917 std::shared_ptr<AudioClientTracker> callback = clientTracker_[streamId];
918 CHECK_AND_RETURN_RET_LOG(callback != nullptr,
919 ERR_INVALID_PARAM, "SetLowPowerVolume callback failed");
920 callback->SetLowPowerVolumeImpl(volume);
921 return SUCCESS;
922 }
923
GetLowPowerVolume(int32_t streamId)924 float AudioStreamCollector::GetLowPowerVolume(int32_t streamId)
925 {
926 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
927 float ret = 1.0; // invalue volume
928 CHECK_AND_RETURN_RET_LOG(!(clientTracker_.count(streamId) == 0),
929 ret, "GetLowPowerVolume streamId invalid.");
930 float volume;
931 std::shared_ptr<AudioClientTracker> callback = clientTracker_[streamId];
932 CHECK_AND_RETURN_RET_LOG(callback != nullptr,
933 ret, "GetLowPowerVolume callback failed");
934 callback->GetLowPowerVolumeImpl(volume);
935 return volume;
936 }
937
SetOffloadMode(int32_t streamId,int32_t state,bool isAppBack)938 int32_t AudioStreamCollector::SetOffloadMode(int32_t streamId, int32_t state, bool isAppBack)
939 {
940 std::shared_ptr<AudioClientTracker> callback;
941 {
942 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
943 CHECK_AND_RETURN_RET_LOG(!(clientTracker_.count(streamId) == 0),
944 ERR_INVALID_PARAM, "streamId (%{public}d) invalid.", streamId);
945 callback = clientTracker_[streamId];
946 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM, "callback failed");
947 }
948 callback->SetOffloadModeImpl(state, isAppBack);
949 return SUCCESS;
950 }
951
UnsetOffloadMode(int32_t streamId)952 int32_t AudioStreamCollector::UnsetOffloadMode(int32_t streamId)
953 {
954 std::shared_ptr<AudioClientTracker> callback;
955 {
956 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
957 CHECK_AND_RETURN_RET_LOG(!(clientTracker_.count(streamId) == 0),
958 ERR_INVALID_PARAM, "streamId (%{public}d) invalid.", streamId);
959 callback = clientTracker_[streamId];
960 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM, "callback failed");
961 }
962 callback->UnsetOffloadModeImpl();
963 return SUCCESS;
964 }
965
GetSingleStreamVolume(int32_t streamId)966 float AudioStreamCollector::GetSingleStreamVolume(int32_t streamId)
967 {
968 std::shared_ptr<AudioClientTracker> callback;
969 {
970 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
971 float ret = 1.0; // invalue volume
972 CHECK_AND_RETURN_RET_LOG(!(clientTracker_.count(streamId) == 0),
973 ret, "GetSingleStreamVolume streamId invalid.");
974 callback = clientTracker_[streamId];
975 CHECK_AND_RETURN_RET_LOG(callback != nullptr,
976 ret, "GetSingleStreamVolume callback failed");
977 }
978 float volume;
979 callback->GetSingleStreamVolumeImpl(volume);
980 return volume;
981 }
982
UpdateCapturerInfoMuteStatus(int32_t uid,bool muteStatus)983 int32_t AudioStreamCollector::UpdateCapturerInfoMuteStatus(int32_t uid, bool muteStatus)
984 {
985 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
986 bool capturerInfoUpdated = false;
987 for (auto it = audioCapturerChangeInfos_.begin(); it != audioCapturerChangeInfos_.end(); it++) {
988 if ((*it)->clientUID == uid || uid == 0) {
989 (*it)->muted = muteStatus;
990 capturerInfoUpdated = true;
991 std::shared_ptr<Media::MediaMonitor::EventBean> bean = std::make_shared<Media::MediaMonitor::EventBean>(
992 Media::MediaMonitor::ModuleId::AUDIO, Media::MediaMonitor::EventId::CAPTURE_MUTE_STATUS_CHANGE,
993 Media::MediaMonitor::EventType::BEHAVIOR_EVENT);
994 bean->Add("ISOUTPUT", 0);
995 bean->Add("STREAMID", (*it)->sessionId);
996 bean->Add("STREAM_TYPE", (*it)->capturerInfo.sourceType);
997 bean->Add("DEVICETYPE", (*it)->inputDeviceInfo.deviceType);
998 bean->Add("MUTED", (*it)->muted);
999 Media::MediaMonitor::MediaMonitorManager::GetInstance().WriteLogMsg(bean);
1000 }
1001 }
1002
1003 if (capturerInfoUpdated && audioPolicyServerHandler_ != nullptr) {
1004 audioPolicyServerHandler_->SendCapturerInfoEvent(audioCapturerChangeInfos_);
1005 }
1006
1007 return SUCCESS;
1008 }
1009
SetAudioConcurrencyCallback(const uint32_t sessionID,const sptr<IRemoteObject> & object)1010 int32_t AudioStreamCollector::SetAudioConcurrencyCallback(const uint32_t sessionID, const sptr<IRemoteObject> &object)
1011 {
1012 return audioConcurrencyService_->SetAudioConcurrencyCallback(sessionID, object);
1013 }
1014
UnsetAudioConcurrencyCallback(const uint32_t sessionID)1015 int32_t AudioStreamCollector::UnsetAudioConcurrencyCallback(const uint32_t sessionID)
1016 {
1017 return audioConcurrencyService_->UnsetAudioConcurrencyCallback(sessionID);
1018 }
1019
ActivateAudioConcurrency(const AudioPipeType & pipeType)1020 int32_t AudioStreamCollector::ActivateAudioConcurrency(const AudioPipeType &pipeType)
1021 {
1022 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1023 return audioConcurrencyService_->ActivateAudioConcurrency(pipeType,
1024 audioRendererChangeInfos_, audioCapturerChangeInfos_);
1025 }
1026
WriterStreamChangeSysEvent(AudioMode & mode,AudioStreamChangeInfo & streamChangeInfo)1027 void AudioStreamCollector::WriterStreamChangeSysEvent(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo)
1028 {
1029 if (mode == AUDIO_MODE_PLAYBACK) {
1030 WriterRenderStreamChangeSysEvent(streamChangeInfo);
1031 } else {
1032 WriterCaptureStreamChangeSysEvent(streamChangeInfo);
1033 }
1034 }
1035
WriterRenderStreamChangeSysEvent(AudioStreamChangeInfo & streamChangeInfo)1036 void AudioStreamCollector::WriterRenderStreamChangeSysEvent(AudioStreamChangeInfo &streamChangeInfo)
1037 {
1038 bool isOutput = true;
1039 AudioStreamType streamType = GetVolumeTypeFromContentUsage(
1040 streamChangeInfo.audioRendererChangeInfo.rendererInfo.contentType,
1041 streamChangeInfo.audioRendererChangeInfo.rendererInfo.streamUsage);
1042 uint64_t transactionId = audioSystemMgr_->GetTransactionId(
1043 streamChangeInfo.audioRendererChangeInfo.outputDeviceInfo.deviceType, OUTPUT_DEVICE);
1044
1045 uint8_t effectChainType = EFFECT_CHAIN_TYPE_MAP.count(
1046 streamChangeInfo.audioRendererChangeInfo.rendererInfo.sceneType) ?
1047 EFFECT_CHAIN_TYPE_MAP.at(streamChangeInfo.audioRendererChangeInfo.rendererInfo.sceneType) :
1048 EFFECT_CHAIN_TYPE_MAP.at("UNKNOWN");
1049
1050 std::shared_ptr<Media::MediaMonitor::EventBean> bean = std::make_shared<Media::MediaMonitor::EventBean>(
1051 Media::MediaMonitor::AUDIO, Media::MediaMonitor::STREAM_CHANGE,
1052 Media::MediaMonitor::BEHAVIOR_EVENT);
1053 bean->Add("ISOUTPUT", isOutput ? 1 : 0);
1054 bean->Add("STREAMID", streamChangeInfo.audioRendererChangeInfo.sessionId);
1055 bean->Add("UID", streamChangeInfo.audioRendererChangeInfo.clientUID);
1056 bean->Add("PID", streamChangeInfo.audioRendererChangeInfo.clientPid);
1057 bean->Add("TRANSACTIONID", transactionId);
1058 bean->Add("STREAMTYPE", streamType);
1059 bean->Add("STATE", streamChangeInfo.audioRendererChangeInfo.rendererState);
1060 bean->Add("DEVICETYPE", streamChangeInfo.audioRendererChangeInfo.outputDeviceInfo.deviceType);
1061 bean->Add("BT_TYPE", streamChangeInfo.audioRendererChangeInfo.outputDeviceInfo.deviceCategory);
1062 bean->Add("PIPE_TYPE", streamChangeInfo.audioRendererChangeInfo.rendererInfo.pipeType);
1063 bean->Add("STREAM_TYPE", streamChangeInfo.audioRendererChangeInfo.rendererInfo.streamUsage);
1064 bean->Add("SAMPLE_RATE", streamChangeInfo.audioRendererChangeInfo.rendererInfo.samplingRate);
1065 bean->Add("NETWORKID", ConvertNetworkId(streamChangeInfo.audioRendererChangeInfo.outputDeviceInfo.networkId));
1066 bean->Add("ENCODING_TYPE", streamChangeInfo.audioRendererChangeInfo.rendererInfo.encodingType);
1067 bean->Add("CHANNEL_LAYOUT", streamChangeInfo.audioRendererChangeInfo.rendererInfo.channelLayout);
1068 bean->Add("EFFECT_CHAIN", effectChainType);
1069 Media::MediaMonitor::MediaMonitorManager::GetInstance().WriteLogMsg(bean);
1070 }
1071
WriterCaptureStreamChangeSysEvent(AudioStreamChangeInfo & streamChangeInfo)1072 void AudioStreamCollector::WriterCaptureStreamChangeSysEvent(AudioStreamChangeInfo &streamChangeInfo)
1073 {
1074 bool isOutput = false;
1075 AudioStreamType streamType = GetStreamTypeFromSourceType(
1076 streamChangeInfo.audioCapturerChangeInfo.capturerInfo.sourceType);
1077 uint64_t transactionId = audioSystemMgr_->GetTransactionId(
1078 streamChangeInfo.audioCapturerChangeInfo.inputDeviceInfo.deviceType, INPUT_DEVICE);
1079
1080 uint8_t effectChainType = EFFECT_CHAIN_TYPE_MAP.count(
1081 streamChangeInfo.audioCapturerChangeInfo.capturerInfo.sceneType) ?
1082 EFFECT_CHAIN_TYPE_MAP.at(streamChangeInfo.audioCapturerChangeInfo.capturerInfo.sceneType) :
1083 EFFECT_CHAIN_TYPE_MAP.at("UNKNOWN");
1084
1085 std::shared_ptr<Media::MediaMonitor::EventBean> bean = std::make_shared<Media::MediaMonitor::EventBean>(
1086 Media::MediaMonitor::AUDIO, Media::MediaMonitor::STREAM_CHANGE,
1087 Media::MediaMonitor::BEHAVIOR_EVENT);
1088 bean->Add("ISOUTPUT", isOutput ? 1 : 0);
1089 bean->Add("STREAMID", streamChangeInfo.audioCapturerChangeInfo.sessionId);
1090 bean->Add("UID", streamChangeInfo.audioCapturerChangeInfo.clientUID);
1091 bean->Add("PID", streamChangeInfo.audioCapturerChangeInfo.clientPid);
1092 bean->Add("TRANSACTIONID", transactionId);
1093 bean->Add("STREAMTYPE", streamType);
1094 bean->Add("STATE", streamChangeInfo.audioCapturerChangeInfo.capturerState);
1095 bean->Add("DEVICETYPE", streamChangeInfo.audioCapturerChangeInfo.inputDeviceInfo.deviceType);
1096 bean->Add("BT_TYPE", streamChangeInfo.audioCapturerChangeInfo.inputDeviceInfo.deviceCategory);
1097 bean->Add("PIPE_TYPE", streamChangeInfo.audioCapturerChangeInfo.capturerInfo.pipeType);
1098 bean->Add("STREAM_TYPE", streamChangeInfo.audioCapturerChangeInfo.capturerInfo.sourceType);
1099 bean->Add("SAMPLE_RATE", streamChangeInfo.audioCapturerChangeInfo.capturerInfo.samplingRate);
1100 bean->Add("MUTED", streamChangeInfo.audioCapturerChangeInfo.muted);
1101 bean->Add("NETWORKID", ConvertNetworkId(streamChangeInfo.audioCapturerChangeInfo.inputDeviceInfo.networkId));
1102 bean->Add("ENCODING_TYPE", streamChangeInfo.audioCapturerChangeInfo.capturerInfo.encodingType);
1103 bean->Add("CHANNEL_LAYOUT", streamChangeInfo.audioCapturerChangeInfo.capturerInfo.channelLayout);
1104 bean->Add("EFFECT_CHAIN", effectChainType);
1105 Media::MediaMonitor::MediaMonitorManager::GetInstance().WriteLogMsg(bean);
1106 }
1107
1108
WriteRenderStreamReleaseSysEvent(const std::unique_ptr<AudioRendererChangeInfo> & audioRendererChangeInfo)1109 void AudioStreamCollector::WriteRenderStreamReleaseSysEvent(
1110 const std::unique_ptr<AudioRendererChangeInfo> &audioRendererChangeInfo)
1111 {
1112 AudioStreamType streamType = GetVolumeTypeFromContentUsage(audioRendererChangeInfo->rendererInfo.contentType,
1113 audioRendererChangeInfo->rendererInfo.streamUsage);
1114 uint64_t transactionId = audioSystemMgr_->GetTransactionId(
1115 audioRendererChangeInfo->outputDeviceInfo.deviceType, OUTPUT_DEVICE);
1116
1117 uint8_t effectChainType = EFFECT_CHAIN_TYPE_MAP.count(
1118 audioRendererChangeInfo->rendererInfo.sceneType) ?
1119 EFFECT_CHAIN_TYPE_MAP.at(audioRendererChangeInfo->rendererInfo.sceneType) :
1120 EFFECT_CHAIN_TYPE_MAP.at("UNKNOWN");
1121
1122 std::shared_ptr<Media::MediaMonitor::EventBean> bean = std::make_shared<Media::MediaMonitor::EventBean>(
1123 Media::MediaMonitor::AUDIO, Media::MediaMonitor::STREAM_CHANGE,
1124 Media::MediaMonitor::BEHAVIOR_EVENT);
1125 bean->Add("ISOUTPUT", 1);
1126 bean->Add("STREAMID", audioRendererChangeInfo->sessionId);
1127 bean->Add("UID", audioRendererChangeInfo->clientUID);
1128 bean->Add("PID", audioRendererChangeInfo->clientPid);
1129 bean->Add("TRANSACTIONID", transactionId);
1130 bean->Add("STREAMTYPE", streamType);
1131 bean->Add("STATE", audioRendererChangeInfo->rendererState);
1132 bean->Add("DEVICETYPE", audioRendererChangeInfo->outputDeviceInfo.deviceType);
1133 bean->Add("BT_TYPE", audioRendererChangeInfo->outputDeviceInfo.deviceCategory);
1134 bean->Add("PIPE_TYPE", audioRendererChangeInfo->rendererInfo.pipeType);
1135 bean->Add("STREAM_TYPE", audioRendererChangeInfo->rendererInfo.streamUsage);
1136 bean->Add("SAMPLE_RATE", audioRendererChangeInfo->rendererInfo.samplingRate);
1137 bean->Add("NETWORKID", ConvertNetworkId(audioRendererChangeInfo->outputDeviceInfo.networkId));
1138 bean->Add("ENCODING_TYPE", audioRendererChangeInfo->rendererInfo.encodingType);
1139 bean->Add("CHANNEL_LAYOUT", audioRendererChangeInfo->rendererInfo.channelLayout);
1140 bean->Add("EFFECT_CHAIN", effectChainType);
1141 Media::MediaMonitor::MediaMonitorManager::GetInstance().WriteLogMsg(bean);
1142 }
1143
WriteCaptureStreamReleaseSysEvent(const std::unique_ptr<AudioCapturerChangeInfo> & audioCapturerChangeInfo)1144 void AudioStreamCollector::WriteCaptureStreamReleaseSysEvent(
1145 const std::unique_ptr<AudioCapturerChangeInfo> &audioCapturerChangeInfo)
1146 {
1147 AudioStreamType streamType = GetStreamTypeFromSourceType(audioCapturerChangeInfo->capturerInfo.sourceType);
1148 uint64_t transactionId = audioSystemMgr_->GetTransactionId(
1149 audioCapturerChangeInfo->inputDeviceInfo.deviceType, INPUT_DEVICE);
1150
1151 uint8_t effectChainType = EFFECT_CHAIN_TYPE_MAP.count(
1152 audioCapturerChangeInfo->capturerInfo.sceneType) ?
1153 EFFECT_CHAIN_TYPE_MAP.at(audioCapturerChangeInfo->capturerInfo.sceneType) :
1154 EFFECT_CHAIN_TYPE_MAP.at("UNKNOWN");
1155
1156 std::shared_ptr<Media::MediaMonitor::EventBean> bean = std::make_shared<Media::MediaMonitor::EventBean>(
1157 Media::MediaMonitor::AUDIO, Media::MediaMonitor::STREAM_CHANGE,
1158 Media::MediaMonitor::BEHAVIOR_EVENT);
1159 bean->Add("ISOUTPUT", 1);
1160 bean->Add("STREAMID", audioCapturerChangeInfo->sessionId);
1161 bean->Add("UID", audioCapturerChangeInfo->clientUID);
1162 bean->Add("PID", audioCapturerChangeInfo->clientPid);
1163 bean->Add("TRANSACTIONID", transactionId);
1164 bean->Add("STREAMTYPE", streamType);
1165 bean->Add("STATE", audioCapturerChangeInfo->capturerState);
1166 bean->Add("DEVICETYPE", audioCapturerChangeInfo->inputDeviceInfo.deviceType);
1167 bean->Add("BT_TYPE", audioCapturerChangeInfo->inputDeviceInfo.deviceCategory);
1168 bean->Add("PIPE_TYPE", audioCapturerChangeInfo->capturerInfo.pipeType);
1169 bean->Add("STREAM_TYPE", audioCapturerChangeInfo->capturerInfo.sourceType);
1170 bean->Add("SAMPLE_RATE", audioCapturerChangeInfo->capturerInfo.samplingRate);
1171 bean->Add("MUTED", audioCapturerChangeInfo->muted);
1172 bean->Add("NETWORKID", ConvertNetworkId(audioCapturerChangeInfo->inputDeviceInfo.networkId));
1173 bean->Add("ENCODING_TYPE", audioCapturerChangeInfo->capturerInfo.encodingType);
1174 bean->Add("CHANNEL_LAYOUT", audioCapturerChangeInfo->capturerInfo.channelLayout);
1175 bean->Add("EFFECT_CHAIN", effectChainType);
1176 Media::MediaMonitor::MediaMonitorManager::GetInstance().WriteLogMsg(bean);
1177 }
1178
IsCallStreamUsage(StreamUsage usage)1179 bool AudioStreamCollector::IsCallStreamUsage(StreamUsage usage)
1180 {
1181 if (usage == STREAM_USAGE_VOICE_COMMUNICATION || usage == STREAM_USAGE_VIDEO_COMMUNICATION ||
1182 usage == STREAM_USAGE_VOICE_MODEM_COMMUNICATION) {
1183 return true;
1184 }
1185 return false;
1186 }
1187
GetLastestRunningCallStreamUsage()1188 StreamUsage AudioStreamCollector::GetLastestRunningCallStreamUsage()
1189 {
1190 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1191 for (const auto &changeInfo : audioRendererChangeInfos_) {
1192 StreamUsage usage = changeInfo->rendererInfo.streamUsage;
1193 RendererState state = changeInfo->rendererState;
1194 if ((IsCallStreamUsage(usage) && state == RENDERER_RUNNING) ||
1195 (usage == STREAM_USAGE_VOICE_MODEM_COMMUNICATION && state == RENDERER_PREPARED)) {
1196 return usage;
1197 }
1198 }
1199 return STREAM_USAGE_UNKNOWN;
1200 }
1201
GetAllRendererSessionIDForUID(int32_t uid)1202 std::vector<uint32_t> AudioStreamCollector::GetAllRendererSessionIDForUID(int32_t uid)
1203 {
1204 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1205 std::vector<uint32_t> sessionIDSet;
1206 for (const auto &changeInfo : audioRendererChangeInfos_) {
1207 if (changeInfo->clientUID == uid) {
1208 sessionIDSet.push_back(changeInfo->sessionId);
1209 }
1210 }
1211 return sessionIDSet;
1212 }
1213
ChangeVoipCapturerStreamToNormal()1214 bool AudioStreamCollector::ChangeVoipCapturerStreamToNormal()
1215 {
1216 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1217 int count = std::count_if(audioCapturerChangeInfos_.begin(), audioCapturerChangeInfos_.end(),
1218 [](const auto &changeInfo) {
1219 const auto &sourceType = changeInfo->capturerInfo.sourceType;
1220 return sourceType == SOURCE_TYPE_VOICE_COMMUNICATION || sourceType == SOURCE_TYPE_MIC ||
1221 sourceType == SOURCE_TYPE_VOICE_MESSAGE || sourceType == SOURCE_TYPE_VOICE_TRANSCRIPTION;
1222 });
1223
1224 AUDIO_INFO_LOG("Has capture stream count: %{public}d", count);
1225 // becasue self has been added
1226 return count > 1;
1227 }
1228
HasVoipRendererStream()1229 bool AudioStreamCollector::HasVoipRendererStream()
1230 {
1231 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1232 // judge stream original flage is AUDIO_FLAG_VOIP_FAST
1233 bool hasVoip = std::any_of(audioRendererChangeInfos_.begin(), audioRendererChangeInfos_.end(),
1234 [](const auto &changeInfo) {
1235 return changeInfo->rendererInfo.originalFlag == AUDIO_FLAG_VOIP_FAST;
1236 });
1237
1238 AUDIO_INFO_LOG("Has Fast Voip stream : %{public}d", hasVoip);
1239 return hasVoip;
1240 }
1241 } // namespace AudioStandard
1242 } // namespace OHOS
1243