1 /*
2 * Copyright (c) 2022-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #ifndef LOG_TAG
16 #define LOG_TAG "AudioStreamCollector"
17 #endif
18
19 #include "audio_stream_collector.h"
20
21 #include "audio_client_tracker_callback_service.h"
22 #include "audio_spatialization_service.h"
23 #include "audio_volume_manager.h"
24
25 #include "media_monitor_manager.h"
26
27 namespace OHOS {
28 namespace AudioStandard {
29 using namespace std;
30 const std::vector<StreamUsage> BACKGROUND_MUTE_STREAM_USAGE {
31 STREAM_USAGE_MUSIC,
32 STREAM_USAGE_MOVIE,
33 STREAM_USAGE_GAME,
34 STREAM_USAGE_AUDIOBOOK
35 };
36
37 constexpr uint32_t THP_EXTRA_SA_UID = 5000;
38 constexpr uint32_t MEDIA_UID = 1013;
39
40 const map<pair<ContentType, StreamUsage>, AudioStreamType> AudioStreamCollector::streamTypeMap_ =
41 AudioStreamCollector::CreateStreamMap();
42 const std::unordered_map<std::string, uint8_t> EFFECT_CHAIN_TYPE_MAP {
43 {"UNKNOWN", 0},
44 {"NONE", 1},
45 {"SCENE_OTHERS", 2},
46 {"SCENE_MUSIC", 3},
47 {"SCENE_MOVIE", 4},
48 {"SCENE_GAME", 5},
49 {"SCENE_SPEECH", 6},
50 {"SCENE_RING", 7},
51 {"SCENE_VOIP_DOWN", 8}
52 };
53
CreateStreamMap()54 map<pair<ContentType, StreamUsage>, AudioStreamType> AudioStreamCollector::CreateStreamMap()
55 {
56 map<pair<ContentType, StreamUsage>, AudioStreamType> streamMap;
57 // Mapping relationships from content and usage to stream type in design
58 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_UNKNOWN)] = STREAM_MUSIC;
59 streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_VOICE_COMMUNICATION)] = STREAM_VOICE_COMMUNICATION;
60 streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_VIDEO_COMMUNICATION)] = STREAM_VOICE_COMMUNICATION;
61 streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_VOICE_MODEM_COMMUNICATION)] = STREAM_VOICE_CALL;
62 streamMap[make_pair(CONTENT_TYPE_PROMPT, STREAM_USAGE_SYSTEM)] = STREAM_SYSTEM;
63 streamMap[make_pair(CONTENT_TYPE_MUSIC, STREAM_USAGE_NOTIFICATION_RINGTONE)] = STREAM_RING;
64 streamMap[make_pair(CONTENT_TYPE_MUSIC, STREAM_USAGE_MEDIA)] = STREAM_MUSIC;
65 streamMap[make_pair(CONTENT_TYPE_MOVIE, STREAM_USAGE_MEDIA)] = STREAM_MOVIE;
66 streamMap[make_pair(CONTENT_TYPE_GAME, STREAM_USAGE_MEDIA)] = STREAM_GAME;
67 streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_MEDIA)] = STREAM_SPEECH;
68 streamMap[make_pair(CONTENT_TYPE_MUSIC, STREAM_USAGE_ALARM)] = STREAM_ALARM;
69 streamMap[make_pair(CONTENT_TYPE_PROMPT, STREAM_USAGE_NOTIFICATION)] = STREAM_NOTIFICATION;
70 streamMap[make_pair(CONTENT_TYPE_PROMPT, STREAM_USAGE_ENFORCED_TONE)] = STREAM_SYSTEM_ENFORCED;
71 streamMap[make_pair(CONTENT_TYPE_DTMF, STREAM_USAGE_VOICE_COMMUNICATION)] = STREAM_DTMF;
72 streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_VOICE_ASSISTANT)] = STREAM_VOICE_ASSISTANT;
73 streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_ACCESSIBILITY)] = STREAM_ACCESSIBILITY;
74 streamMap[make_pair(CONTENT_TYPE_ULTRASONIC, STREAM_USAGE_SYSTEM)] = STREAM_ULTRASONIC;
75
76 // Old mapping relationships from content and usage to stream type
77 streamMap[make_pair(CONTENT_TYPE_MUSIC, STREAM_USAGE_VOICE_ASSISTANT)] = STREAM_VOICE_ASSISTANT;
78 streamMap[make_pair(CONTENT_TYPE_SONIFICATION, STREAM_USAGE_UNKNOWN)] = STREAM_NOTIFICATION;
79 streamMap[make_pair(CONTENT_TYPE_SONIFICATION, STREAM_USAGE_MEDIA)] = STREAM_NOTIFICATION;
80 streamMap[make_pair(CONTENT_TYPE_SONIFICATION, STREAM_USAGE_NOTIFICATION_RINGTONE)] = STREAM_RING;
81 streamMap[make_pair(CONTENT_TYPE_RINGTONE, STREAM_USAGE_UNKNOWN)] = STREAM_RING;
82 streamMap[make_pair(CONTENT_TYPE_RINGTONE, STREAM_USAGE_MEDIA)] = STREAM_RING;
83 streamMap[make_pair(CONTENT_TYPE_RINGTONE, STREAM_USAGE_NOTIFICATION_RINGTONE)] = STREAM_RING;
84
85 // Only use stream usage to choose stream type
86 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_MEDIA)] = STREAM_MUSIC;
87 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_MUSIC)] = STREAM_MUSIC;
88 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VOICE_COMMUNICATION)] = STREAM_VOICE_COMMUNICATION;
89 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VIDEO_COMMUNICATION)] = STREAM_VOICE_COMMUNICATION;
90 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VOICE_MODEM_COMMUNICATION)] = STREAM_VOICE_CALL;
91 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VOICE_ASSISTANT)] = STREAM_VOICE_ASSISTANT;
92 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_ALARM)] = STREAM_ALARM;
93 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VOICE_MESSAGE)] = STREAM_VOICE_MESSAGE;
94 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_NOTIFICATION_RINGTONE)] = STREAM_RING;
95 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_RINGTONE)] = STREAM_RING;
96 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_NOTIFICATION)] = STREAM_NOTIFICATION;
97 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_ACCESSIBILITY)] = STREAM_ACCESSIBILITY;
98 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_SYSTEM)] = STREAM_SYSTEM;
99 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_MOVIE)] = STREAM_MOVIE;
100 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_GAME)] = STREAM_GAME;
101 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_AUDIOBOOK)] = STREAM_SPEECH;
102 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_NAVIGATION)] = STREAM_NAVIGATION;
103 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_DTMF)] = STREAM_DTMF;
104 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_ENFORCED_TONE)] = STREAM_SYSTEM_ENFORCED;
105 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_ULTRASONIC)] = STREAM_ULTRASONIC;
106 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VOICE_RINGTONE)] = STREAM_VOICE_RING;
107 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VOICE_CALL_ASSISTANT)] = STREAM_VOICE_CALL_ASSISTANT;
108
109 return streamMap;
110 }
111
AudioStreamCollector()112 AudioStreamCollector::AudioStreamCollector() : audioAbilityMgr_
113 (AudioAbilityManager::GetInstance())
114 {
115 audioPolicyServerHandler_ = DelayedSingleton<AudioPolicyServerHandler>::GetInstance();
116 audioConcurrencyService_ = std::make_shared<AudioConcurrencyService>();
117 audioConcurrencyService_->Init();
118 AUDIO_INFO_LOG("AudioStreamCollector()");
119 }
120
~AudioStreamCollector()121 AudioStreamCollector::~AudioStreamCollector()
122 {
123 AUDIO_INFO_LOG("~AudioStreamCollector()");
124 }
125
AddRendererStream(AudioStreamChangeInfo & streamChangeInfo)126 int32_t AudioStreamCollector::AddRendererStream(AudioStreamChangeInfo &streamChangeInfo)
127 {
128 AUDIO_INFO_LOG("Add playback client uid %{public}d sessionId %{public}d",
129 streamChangeInfo.audioRendererChangeInfo.clientUID, streamChangeInfo.audioRendererChangeInfo.sessionId);
130
131 rendererStatequeue_.insert({{streamChangeInfo.audioRendererChangeInfo.clientUID,
132 streamChangeInfo.audioRendererChangeInfo.sessionId},
133 streamChangeInfo.audioRendererChangeInfo.rendererState});
134
135 shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
136 if (!rendererChangeInfo) {
137 AUDIO_ERR_LOG("AddRendererStream Memory Allocation Failed");
138 return ERR_MEMORY_ALLOC_FAILED;
139 }
140 rendererChangeInfo->createrUID = streamChangeInfo.audioRendererChangeInfo.createrUID;
141 rendererChangeInfo->clientUID = streamChangeInfo.audioRendererChangeInfo.clientUID;
142 rendererChangeInfo->sessionId = streamChangeInfo.audioRendererChangeInfo.sessionId;
143 rendererChangeInfo->callerPid = streamChangeInfo.audioRendererChangeInfo.callerPid;
144 rendererChangeInfo->clientPid = streamChangeInfo.audioRendererChangeInfo.clientPid;
145 rendererChangeInfo->tokenId = static_cast<int32_t>(IPCSkeleton::GetCallingTokenID());
146 rendererChangeInfo->rendererState = streamChangeInfo.audioRendererChangeInfo.rendererState;
147 rendererChangeInfo->rendererInfo = streamChangeInfo.audioRendererChangeInfo.rendererInfo;
148 rendererChangeInfo->outputDeviceInfo = streamChangeInfo.audioRendererChangeInfo.outputDeviceInfo;
149 rendererChangeInfo->channelCount = streamChangeInfo.audioRendererChangeInfo.channelCount;
150 rendererChangeInfo->appVolume = streamChangeInfo.audioRendererChangeInfo.appVolume;
151 audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
152
153 CHECK_AND_RETURN_RET_LOG(audioPolicyServerHandler_ != nullptr, ERR_MEMORY_ALLOC_FAILED,
154 "audioPolicyServerHandler_ is nullptr, callback error");
155 audioPolicyServerHandler_->SendRendererInfoEvent(audioRendererChangeInfos_);
156 AudioSpatializationService::GetAudioSpatializationService().UpdateRendererInfo(audioRendererChangeInfos_);
157 return SUCCESS;
158 }
159
GetRendererStreamInfo(AudioStreamChangeInfo & streamChangeInfo,AudioRendererChangeInfo & rendererInfo)160 void AudioStreamCollector::GetRendererStreamInfo(AudioStreamChangeInfo &streamChangeInfo,
161 AudioRendererChangeInfo &rendererInfo)
162 {
163 for (auto it = audioRendererChangeInfos_.begin(); it != audioRendererChangeInfos_.end(); it++) {
164 if ((*it)->clientUID == streamChangeInfo.audioRendererChangeInfo.clientUID &&
165 (*it)->sessionId == streamChangeInfo.audioRendererChangeInfo.sessionId) {
166 rendererInfo.outputDeviceInfo = (*it)->outputDeviceInfo;
167 return;
168 }
169 }
170 }
171
GetCapturerStreamInfo(AudioStreamChangeInfo & streamChangeInfo,AudioCapturerChangeInfo & capturerInfo)172 void AudioStreamCollector::GetCapturerStreamInfo(AudioStreamChangeInfo &streamChangeInfo,
173 AudioCapturerChangeInfo &capturerInfo)
174 {
175 for (auto it = audioCapturerChangeInfos_.begin(); it != audioCapturerChangeInfos_.end(); it++) {
176 if ((*it)->clientUID == streamChangeInfo.audioCapturerChangeInfo.clientUID &&
177 (*it)->sessionId == streamChangeInfo.audioCapturerChangeInfo.sessionId) {
178 capturerInfo.inputDeviceInfo = (*it)->inputDeviceInfo;
179 return;
180 }
181 }
182 }
183
GetPipeType(const int32_t sessionId,AudioPipeType & pipeType)184 int32_t AudioStreamCollector::GetPipeType(const int32_t sessionId, AudioPipeType &pipeType)
185 {
186 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
187 const auto &it = std::find_if(audioRendererChangeInfos_.begin(), audioRendererChangeInfos_.end(),
188 [&sessionId](const std::shared_ptr<AudioRendererChangeInfo> &changeInfo) {
189 return changeInfo->sessionId == sessionId;
190 });
191 if (it == audioRendererChangeInfos_.end()) {
192 AUDIO_WARNING_LOG("invalid session id: %{public}d", sessionId);
193 return ERROR;
194 }
195
196 pipeType = (*it)->rendererInfo.pipeType;
197 return SUCCESS;
198 }
199
ExistStreamForPipe(AudioPipeType pipeType)200 bool AudioStreamCollector::ExistStreamForPipe(AudioPipeType pipeType)
201 {
202 const auto &it = std::find_if(audioRendererChangeInfos_.begin(), audioRendererChangeInfos_.end(),
203 [&pipeType](const std::shared_ptr<AudioRendererChangeInfo> &changeInfo) {
204 return changeInfo->rendererInfo.pipeType == pipeType;
205 });
206 if (it == audioRendererChangeInfos_.end()) {
207 return false;
208 }
209 return true;
210 }
211
GetRendererDeviceInfo(const int32_t sessionId,AudioDeviceDescriptor & outputDeviceInfo)212 int32_t AudioStreamCollector::GetRendererDeviceInfo(const int32_t sessionId, AudioDeviceDescriptor &outputDeviceInfo)
213 {
214 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
215 const auto &it = std::find_if(audioRendererChangeInfos_.begin(), audioRendererChangeInfos_.end(),
216 [&sessionId](const std::shared_ptr<AudioRendererChangeInfo> &changeInfo) {
217 return changeInfo->sessionId == sessionId;
218 });
219 if (it == audioRendererChangeInfos_.end()) {
220 AUDIO_WARNING_LOG("invalid session id: %{public}d", sessionId);
221 return ERROR;
222 }
223 outputDeviceInfo = (*it)->outputDeviceInfo;
224 return SUCCESS;
225 }
226
AddCapturerStream(AudioStreamChangeInfo & streamChangeInfo)227 int32_t AudioStreamCollector::AddCapturerStream(AudioStreamChangeInfo &streamChangeInfo)
228 {
229 AUDIO_INFO_LOG("Add recording client uid %{public}d sessionId %{public}d",
230 streamChangeInfo.audioCapturerChangeInfo.clientUID, streamChangeInfo.audioCapturerChangeInfo.sessionId);
231
232 capturerStatequeue_.insert({{streamChangeInfo.audioCapturerChangeInfo.clientUID,
233 streamChangeInfo.audioCapturerChangeInfo.sessionId},
234 streamChangeInfo.audioCapturerChangeInfo.capturerState});
235
236 shared_ptr<AudioCapturerChangeInfo> capturerChangeInfo = make_shared<AudioCapturerChangeInfo>();
237 if (!capturerChangeInfo) {
238 AUDIO_ERR_LOG("AddCapturerStream Memory Allocation Failed");
239 return ERR_MEMORY_ALLOC_FAILED;
240 }
241 capturerChangeInfo->createrUID = streamChangeInfo.audioCapturerChangeInfo.createrUID;
242 capturerChangeInfo->clientUID = streamChangeInfo.audioCapturerChangeInfo.clientUID;
243 capturerChangeInfo->sessionId = streamChangeInfo.audioCapturerChangeInfo.sessionId;
244 capturerChangeInfo->callerPid = streamChangeInfo.audioCapturerChangeInfo.callerPid;
245 capturerChangeInfo->muted = streamChangeInfo.audioCapturerChangeInfo.muted;
246 capturerChangeInfo->appTokenId = streamChangeInfo.audioCapturerChangeInfo.appTokenId;
247
248 capturerChangeInfo->capturerState = streamChangeInfo.audioCapturerChangeInfo.capturerState;
249 capturerChangeInfo->capturerInfo = streamChangeInfo.audioCapturerChangeInfo.capturerInfo;
250 capturerChangeInfo->inputDeviceInfo = streamChangeInfo.audioCapturerChangeInfo.inputDeviceInfo;
251 audioCapturerChangeInfos_.push_back(move(capturerChangeInfo));
252
253 CHECK_AND_RETURN_RET_LOG(audioPolicyServerHandler_ != nullptr, ERR_MEMORY_ALLOC_FAILED,
254 "audioPolicyServerHandler_ is nullptr, callback error");
255 SendCapturerInfoEvent(audioCapturerChangeInfos_);
256 return SUCCESS;
257 }
258
SendCapturerInfoEvent(const std::vector<std::shared_ptr<AudioCapturerChangeInfo>> & audioCapturerChangeInfos)259 void AudioStreamCollector::SendCapturerInfoEvent(const std::vector<std::shared_ptr<AudioCapturerChangeInfo>>
260 &audioCapturerChangeInfos)
261 {
262 bool earseFlag = false;
263 for (const auto &capChangeinfoUPtr : audioCapturerChangeInfos) {
264 if (IsTransparentCapture(capChangeinfoUPtr->clientUID)) {
265 earseFlag = true;
266 break;
267 }
268 }
269 if (earseFlag == false) {
270 if (!audioCapturerChangeInfos.empty()) {
271 audioPolicyServerHandler_->SendCapturerInfoEvent(audioCapturerChangeInfos);
272 }
273 return;
274 }
275
276 std::vector<std::shared_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfoSent;
277 for (const auto &capChangeinfoUPtr : audioCapturerChangeInfos) {
278 if (IsTransparentCapture(capChangeinfoUPtr->clientUID)) {
279 AUDIO_INFO_LOG("bypass uid:%{public}d", capChangeinfoUPtr->clientUID);
280 } else {
281 audioCapturerChangeInfoSent.push_back(make_shared<AudioCapturerChangeInfo>(*capChangeinfoUPtr));
282 }
283 }
284 if (audioCapturerChangeInfoSent.empty()) {
285 return;
286 }
287 audioPolicyServerHandler_->SendCapturerInfoEvent(audioCapturerChangeInfoSent);
288 }
289
IsTransparentCapture(const uint32_t clientUid)290 bool AudioStreamCollector::IsTransparentCapture(const uint32_t clientUid)
291 {
292 if (clientUid == THP_EXTRA_SA_UID) {
293 return true;
294 }
295 return false;
296 }
297
RegisterTracker(AudioMode & mode,AudioStreamChangeInfo & streamChangeInfo,const sptr<IRemoteObject> & object)298 int32_t AudioStreamCollector::RegisterTracker(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo,
299 const sptr<IRemoteObject> &object)
300 {
301 AUDIO_DEBUG_LOG("RegisterTracker mode %{public}d", mode);
302
303 int32_t clientId;
304 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
305 if (mode == AUDIO_MODE_PLAYBACK) {
306 AddRendererStream(streamChangeInfo);
307 clientId = streamChangeInfo.audioRendererChangeInfo.sessionId;
308 } else {
309 // mode = AUDIO_MODE_RECORD
310 AddCapturerStream(streamChangeInfo);
311 clientId = streamChangeInfo.audioCapturerChangeInfo.sessionId;
312 }
313
314 sptr<IStandardClientTracker> listener = iface_cast<IStandardClientTracker>(object);
315 CHECK_AND_RETURN_RET_LOG(listener != nullptr,
316 ERR_INVALID_PARAM, "AudioStreamCollector: client tracker obj cast failed");
317 std::shared_ptr<AudioClientTracker> callback = std::make_shared<ClientTrackerCallbackListener>(listener);
318 CHECK_AND_RETURN_RET_LOG(callback != nullptr,
319 ERR_INVALID_PARAM, "AudioStreamCollector: failed to create tracker cb obj");
320 clientTracker_[clientId] = callback;
321 WriterStreamChangeSysEvent(mode, streamChangeInfo);
322 return SUCCESS;
323 }
324
SetRendererStreamParam(AudioStreamChangeInfo & streamChangeInfo,shared_ptr<AudioRendererChangeInfo> & rendererChangeInfo)325 void AudioStreamCollector::SetRendererStreamParam(AudioStreamChangeInfo &streamChangeInfo,
326 shared_ptr<AudioRendererChangeInfo> &rendererChangeInfo)
327 {
328 rendererChangeInfo->createrUID = streamChangeInfo.audioRendererChangeInfo.createrUID;
329 rendererChangeInfo->clientUID = streamChangeInfo.audioRendererChangeInfo.clientUID;
330 rendererChangeInfo->sessionId = streamChangeInfo.audioRendererChangeInfo.sessionId;
331 rendererChangeInfo->callerPid = streamChangeInfo.audioRendererChangeInfo.callerPid;
332 rendererChangeInfo->clientPid = streamChangeInfo.audioRendererChangeInfo.clientPid;
333 rendererChangeInfo->tokenId = static_cast<int32_t>(IPCSkeleton::GetCallingTokenID());
334 rendererChangeInfo->rendererState = streamChangeInfo.audioRendererChangeInfo.rendererState;
335 rendererChangeInfo->rendererInfo = streamChangeInfo.audioRendererChangeInfo.rendererInfo;
336 rendererChangeInfo->outputDeviceInfo = streamChangeInfo.audioRendererChangeInfo.outputDeviceInfo;
337 rendererChangeInfo->prerunningState = streamChangeInfo.audioRendererChangeInfo.prerunningState;
338 rendererChangeInfo->appVolume = streamChangeInfo.audioRendererChangeInfo.appVolume;
339 }
340
SetCapturerStreamParam(AudioStreamChangeInfo & streamChangeInfo,shared_ptr<AudioCapturerChangeInfo> & capturerChangeInfo)341 void AudioStreamCollector::SetCapturerStreamParam(AudioStreamChangeInfo &streamChangeInfo,
342 shared_ptr<AudioCapturerChangeInfo> &capturerChangeInfo)
343 {
344 capturerChangeInfo->createrUID = streamChangeInfo.audioCapturerChangeInfo.createrUID;
345 capturerChangeInfo->clientUID = streamChangeInfo.audioCapturerChangeInfo.clientUID;
346 capturerChangeInfo->sessionId = streamChangeInfo.audioCapturerChangeInfo.sessionId;
347 capturerChangeInfo->callerPid = streamChangeInfo.audioCapturerChangeInfo.callerPid;
348 capturerChangeInfo->clientPid = streamChangeInfo.audioCapturerChangeInfo.clientPid;
349 capturerChangeInfo->muted = streamChangeInfo.audioCapturerChangeInfo.muted;
350 capturerChangeInfo->capturerState = streamChangeInfo.audioCapturerChangeInfo.capturerState;
351 capturerChangeInfo->capturerInfo = streamChangeInfo.audioCapturerChangeInfo.capturerInfo;
352 capturerChangeInfo->inputDeviceInfo = streamChangeInfo.audioCapturerChangeInfo.inputDeviceInfo;
353 }
354
ResetRendererStreamDeviceInfo(const AudioDeviceDescriptor & updatedDesc)355 void AudioStreamCollector::ResetRendererStreamDeviceInfo(const AudioDeviceDescriptor& updatedDesc)
356 {
357 AUDIO_INFO_LOG("ResetRendererStreamDeviceInfo, deviceType:[%{public}d]", updatedDesc.deviceType_);
358 for (auto it = audioRendererChangeInfos_.begin(); it != audioRendererChangeInfos_.end(); it++) {
359 if ((*it)->outputDeviceInfo.deviceType_ == updatedDesc.deviceType_ &&
360 (*it)->outputDeviceInfo.macAddress_ == updatedDesc.macAddress_ &&
361 (*it)->outputDeviceInfo.networkId_ == updatedDesc.networkId_ &&
362 (*it)->rendererState != RENDERER_RUNNING) {
363 (*it)->outputDeviceInfo.deviceType_ = DEVICE_TYPE_NONE;
364 (*it)->outputDeviceInfo.macAddress_ = "";
365 (*it)->outputDeviceInfo.networkId_ = LOCAL_NETWORK_ID;
366 }
367 }
368 }
369
ResetCapturerStreamDeviceInfo(const AudioDeviceDescriptor & updatedDesc)370 void AudioStreamCollector::ResetCapturerStreamDeviceInfo(const AudioDeviceDescriptor& updatedDesc)
371 {
372 AUDIO_INFO_LOG("ResetCapturerStreamDeviceInfo, deviceType:[%{public}d]", updatedDesc.deviceType_);
373 for (auto it = audioCapturerChangeInfos_.begin(); it != audioCapturerChangeInfos_.end(); it++) {
374 if ((*it)->inputDeviceInfo.deviceType_ == updatedDesc.deviceType_ &&
375 (*it)->inputDeviceInfo.macAddress_ == updatedDesc.macAddress_ &&
376 (*it)->inputDeviceInfo.networkId_ == updatedDesc.networkId_ &&
377 (*it)->capturerState != CAPTURER_RUNNING) {
378 (*it)->inputDeviceInfo.deviceType_ = DEVICE_TYPE_NONE;
379 (*it)->inputDeviceInfo.macAddress_ = "";
380 (*it)->inputDeviceInfo.networkId_ = LOCAL_NETWORK_ID;
381 }
382 }
383 }
384
CheckRendererStateInfoChanged(AudioStreamChangeInfo & streamChangeInfo)385 bool AudioStreamCollector::CheckRendererStateInfoChanged(AudioStreamChangeInfo &streamChangeInfo)
386 {
387 if (rendererStatequeue_.find(make_pair(streamChangeInfo.audioRendererChangeInfo.clientUID,
388 streamChangeInfo.audioRendererChangeInfo.sessionId)) != rendererStatequeue_.end()) {
389 if (streamChangeInfo.audioRendererChangeInfo.rendererState ==
390 rendererStatequeue_[make_pair(streamChangeInfo.audioRendererChangeInfo.clientUID,
391 streamChangeInfo.audioRendererChangeInfo.sessionId)]) {
392 // Renderer state not changed
393 return false;
394 }
395 } else {
396 AUDIO_INFO_LOG("client %{public}d not found ", streamChangeInfo.audioRendererChangeInfo.clientUID);
397 }
398 return true;
399 }
400
CheckRendererInfoChanged(AudioStreamChangeInfo & streamChangeInfo)401 bool AudioStreamCollector::CheckRendererInfoChanged(AudioStreamChangeInfo &streamChangeInfo)
402 {
403 int32_t sessionId = streamChangeInfo.audioRendererChangeInfo.sessionId;
404 const auto &it = std::find_if(audioRendererChangeInfos_.begin(), audioRendererChangeInfos_.end(),
405 [&sessionId](const std::shared_ptr<AudioRendererChangeInfo> &changeInfo) {
406 return changeInfo->sessionId == sessionId;
407 });
408 if (it == audioRendererChangeInfos_.end()) {
409 return true;
410 }
411
412 bool changed = false;
413 bool isOffloadAllowed = (*it)->rendererInfo.isOffloadAllowed;
414 if (isOffloadAllowed != streamChangeInfo.audioRendererChangeInfo.rendererInfo.isOffloadAllowed) {
415 changed = true;
416 }
417 AudioPipeType pipeType = (*it)->rendererInfo.pipeType;
418 if (pipeType != streamChangeInfo.audioRendererChangeInfo.rendererInfo.pipeType) {
419 changed = true;
420 }
421 return changed;
422 }
423
UpdateRendererStream(AudioStreamChangeInfo & streamChangeInfo)424 int32_t AudioStreamCollector::UpdateRendererStream(AudioStreamChangeInfo &streamChangeInfo)
425 {
426 AUDIO_INFO_LOG("UpdateRendererStream client %{public}d state %{public}d session %{public}d",
427 streamChangeInfo.audioRendererChangeInfo.clientUID, streamChangeInfo.audioRendererChangeInfo.rendererState,
428 streamChangeInfo.audioRendererChangeInfo.sessionId);
429 bool stateChanged = CheckRendererStateInfoChanged(streamChangeInfo);
430 bool infoChanged = CheckRendererInfoChanged(streamChangeInfo);
431 CHECK_AND_RETURN_RET(stateChanged || infoChanged, SUCCESS);
432
433 // Update the renderer info in audioRendererChangeInfos_
434 for (auto it = audioRendererChangeInfos_.begin(); it != audioRendererChangeInfos_.end(); it++) {
435 AudioRendererChangeInfo audioRendererChangeInfo = **it;
436 if (audioRendererChangeInfo.clientUID == streamChangeInfo.audioRendererChangeInfo.clientUID &&
437 audioRendererChangeInfo.sessionId == streamChangeInfo.audioRendererChangeInfo.sessionId) {
438 rendererStatequeue_[make_pair(audioRendererChangeInfo.clientUID, audioRendererChangeInfo.sessionId)] =
439 streamChangeInfo.audioRendererChangeInfo.rendererState;
440 streamChangeInfo.audioRendererChangeInfo.rendererInfo.pipeType = (*it)->rendererInfo.pipeType;
441 AUDIO_DEBUG_LOG("update client %{public}d session %{public}d", audioRendererChangeInfo.clientUID,
442 audioRendererChangeInfo.sessionId);
443 shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
444 CHECK_AND_RETURN_RET_LOG(rendererChangeInfo != nullptr, ERR_MEMORY_ALLOC_FAILED,
445 "Memory Allocation Failed");
446 SetRendererStreamParam(streamChangeInfo, rendererChangeInfo);
447 rendererChangeInfo->channelCount = (*it)->channelCount;
448 rendererChangeInfo->backMute = (*it)->backMute;
449 if (rendererChangeInfo->outputDeviceInfo.deviceType_ == DEVICE_TYPE_INVALID) {
450 streamChangeInfo.audioRendererChangeInfo.outputDeviceInfo = (*it)->outputDeviceInfo;
451 rendererChangeInfo->outputDeviceInfo = (*it)->outputDeviceInfo;
452 }
453 *it = move(rendererChangeInfo);
454
455 if (audioPolicyServerHandler_ != nullptr && stateChanged) {
456 audioPolicyServerHandler_->SendRendererInfoEvent(audioRendererChangeInfos_);
457 }
458 AudioSpatializationService::GetAudioSpatializationService().UpdateRendererInfo(audioRendererChangeInfos_);
459 RendererState rendererState = streamChangeInfo.audioRendererChangeInfo.rendererState;
460 StreamUsage streamUsage = streamChangeInfo.audioRendererChangeInfo.rendererInfo.streamUsage;
461 ResetRingerModeMute(rendererState, streamUsage);
462 if (streamChangeInfo.audioRendererChangeInfo.rendererState == RENDERER_RELEASED) {
463 audioRendererChangeInfos_.erase(it);
464 rendererStatequeue_.erase(make_pair(audioRendererChangeInfo.clientUID,
465 audioRendererChangeInfo.sessionId));
466 clientTracker_.erase(audioRendererChangeInfo.sessionId);
467 }
468 return SUCCESS;
469 }
470 }
471
472 AUDIO_INFO_LOG("UpdateRendererStream: Not found clientUid:%{public}d sessionId:%{public}d",
473 streamChangeInfo.audioRendererChangeInfo.clientUID, streamChangeInfo.audioRendererChangeInfo.clientUID);
474 return SUCCESS;
475 }
476
ResetRingerModeMute(RendererState rendererState,StreamUsage streamUsage)477 void AudioStreamCollector::ResetRingerModeMute(RendererState rendererState, StreamUsage streamUsage)
478 {
479 if (Util::IsRingerOrAlarmerStreamUsage(streamUsage) && (rendererState == RENDERER_PAUSED ||
480 rendererState == RENDERER_STOPPED || rendererState == RENDERER_RELEASED) &&
481 !AudioVolumeManager::GetInstance().IsRingerModeMute()) {
482 AUDIO_INFO_LOG("reset ringer mode mute, stream usage:%{public}d, renderer state:%{public}d",
483 streamUsage, rendererState);
484 AudioVolumeManager::GetInstance().ResetRingerModeMute();
485 }
486 }
487
UpdateRendererStreamInternal(AudioStreamChangeInfo & streamChangeInfo)488 int32_t AudioStreamCollector::UpdateRendererStreamInternal(AudioStreamChangeInfo &streamChangeInfo)
489 {
490 // Update the renderer internal info in audioRendererChangeInfos_
491 for (auto it = audioRendererChangeInfos_.begin(); it != audioRendererChangeInfos_.end(); it++) {
492 AudioRendererChangeInfo audioRendererChangeInfo = **it;
493 if ((*it)->clientUID == streamChangeInfo.audioRendererChangeInfo.clientUID &&
494 (*it)->sessionId == streamChangeInfo.audioRendererChangeInfo.sessionId) {
495 AUDIO_DEBUG_LOG("update client %{public}d session %{public}d", (*it)->clientUID, (*it)->sessionId);
496 (*it)->prerunningState = streamChangeInfo.audioRendererChangeInfo.prerunningState;
497 return SUCCESS;
498 }
499 }
500
501 AUDIO_ERR_LOG("Not found clientUid:%{public}d sessionId:%{public}d",
502 streamChangeInfo.audioRendererChangeInfo.clientUID, streamChangeInfo.audioRendererChangeInfo.sessionId);
503 return ERROR;
504 }
505
UpdateCapturerStreamInternal(AudioStreamChangeInfo & streamChangeInfo)506 int32_t AudioStreamCollector::UpdateCapturerStreamInternal(AudioStreamChangeInfo &streamChangeInfo)
507 {
508 // Update the capturer internal info in audioCapturerChangeInfos_
509 for (auto it = audioCapturerChangeInfos_.begin(); it != audioCapturerChangeInfos_.end(); it++) {
510 AudioCapturerChangeInfo audioCapturerChangeInfo = **it;
511 if ((*it)->clientUID == streamChangeInfo.audioCapturerChangeInfo.clientUID &&
512 (*it)->sessionId == streamChangeInfo.audioCapturerChangeInfo.sessionId) {
513 AUDIO_DEBUG_LOG("update client %{public}d session %{public}d", (*it)->clientUID, (*it)->sessionId);
514 (*it)->prerunningState = streamChangeInfo.audioCapturerChangeInfo.prerunningState;
515 return SUCCESS;
516 }
517 }
518
519 AUDIO_ERR_LOG("Not found clientUid:%{public}d sessionId:%{public}d",
520 streamChangeInfo.audioCapturerChangeInfo.clientUID, streamChangeInfo.audioCapturerChangeInfo.sessionId);
521 return ERROR;
522 }
523
UpdateCapturerStream(AudioStreamChangeInfo & streamChangeInfo)524 int32_t AudioStreamCollector::UpdateCapturerStream(AudioStreamChangeInfo &streamChangeInfo)
525 {
526 AUDIO_INFO_LOG("UpdateCapturerStream client %{public}d state %{public}d session %{public}d",
527 streamChangeInfo.audioCapturerChangeInfo.clientUID, streamChangeInfo.audioCapturerChangeInfo.capturerState,
528 streamChangeInfo.audioCapturerChangeInfo.sessionId);
529
530 if (capturerStatequeue_.find(make_pair(streamChangeInfo.audioCapturerChangeInfo.clientUID,
531 streamChangeInfo.audioCapturerChangeInfo.sessionId)) != capturerStatequeue_.end()) {
532 if (streamChangeInfo.audioCapturerChangeInfo.capturerState ==
533 capturerStatequeue_[make_pair(streamChangeInfo.audioCapturerChangeInfo.clientUID,
534 streamChangeInfo.audioCapturerChangeInfo.sessionId)]) {
535 // Capturer state not changed
536 return SUCCESS;
537 }
538 }
539
540 // Update the capturer info in audioCapturerChangeInfos_
541 for (auto it = audioCapturerChangeInfos_.begin(); it != audioCapturerChangeInfos_.end(); it++) {
542 AudioCapturerChangeInfo audioCapturerChangeInfo = **it;
543 if (audioCapturerChangeInfo.clientUID == streamChangeInfo.audioCapturerChangeInfo.clientUID &&
544 audioCapturerChangeInfo.sessionId == streamChangeInfo.audioCapturerChangeInfo.sessionId) {
545 capturerStatequeue_[make_pair(audioCapturerChangeInfo.clientUID, audioCapturerChangeInfo.sessionId)] =
546 streamChangeInfo.audioCapturerChangeInfo.capturerState;
547
548 AUDIO_DEBUG_LOG("Session is updated for client %{public}d session %{public}d",
549 streamChangeInfo.audioCapturerChangeInfo.clientUID,
550 streamChangeInfo.audioCapturerChangeInfo.sessionId);
551
552 shared_ptr<AudioCapturerChangeInfo> capturerChangeInfo = make_shared<AudioCapturerChangeInfo>();
553 CHECK_AND_RETURN_RET_LOG(capturerChangeInfo != nullptr,
554 ERR_MEMORY_ALLOC_FAILED, "CapturerChangeInfo Memory Allocation Failed");
555 SetCapturerStreamParam(streamChangeInfo, capturerChangeInfo);
556 if (capturerChangeInfo->inputDeviceInfo.deviceType_ == DEVICE_TYPE_INVALID) {
557 streamChangeInfo.audioCapturerChangeInfo.inputDeviceInfo = (*it)->inputDeviceInfo;
558 capturerChangeInfo->inputDeviceInfo = (*it)->inputDeviceInfo;
559 }
560 capturerChangeInfo->appTokenId = (*it)->appTokenId;
561 *it = move(capturerChangeInfo);
562 if (audioPolicyServerHandler_ != nullptr) {
563 SendCapturerInfoEvent(audioCapturerChangeInfos_);
564 }
565 if (streamChangeInfo.audioCapturerChangeInfo.capturerState == CAPTURER_RELEASED) {
566 audioCapturerChangeInfos_.erase(it);
567 capturerStatequeue_.erase(make_pair(audioCapturerChangeInfo.clientUID,
568 audioCapturerChangeInfo.sessionId));
569 clientTracker_.erase(audioCapturerChangeInfo.sessionId);
570 }
571 return SUCCESS;
572 }
573 }
574 AUDIO_DEBUG_LOG("UpdateCapturerStream: clientUI not in audioCapturerChangeInfos_::%{public}d",
575 streamChangeInfo.audioCapturerChangeInfo.clientUID);
576 return SUCCESS;
577 }
578
UpdateRendererDeviceInfo(AudioDeviceDescriptor & outputDeviceInfo)579 int32_t AudioStreamCollector::UpdateRendererDeviceInfo(AudioDeviceDescriptor &outputDeviceInfo)
580 {
581 bool deviceInfoUpdated = false;
582
583 for (auto it = audioRendererChangeInfos_.begin(); it != audioRendererChangeInfos_.end(); it++) {
584 if (!(*it)->outputDeviceInfo.IsSameDeviceInfo(outputDeviceInfo)) {
585 AUDIO_DEBUG_LOG("UpdateRendererDeviceInfo: old device: %{public}d new device: %{public}d",
586 (*it)->outputDeviceInfo.deviceType_, outputDeviceInfo.deviceType_);
587 (*it)->outputDeviceInfo = outputDeviceInfo;
588 deviceInfoUpdated = true;
589 }
590 }
591
592 if (deviceInfoUpdated && audioPolicyServerHandler_ != nullptr) {
593 audioPolicyServerHandler_->SendRendererInfoEvent(audioRendererChangeInfos_);
594 }
595 if (deviceInfoUpdated) {
596 AudioSpatializationService::GetAudioSpatializationService().UpdateRendererInfo(audioRendererChangeInfos_);
597 }
598
599 return SUCCESS;
600 }
601
UpdateRendererDeviceInfo(std::shared_ptr<AudioDeviceDescriptor> outputDeviceInfo)602 int32_t AudioStreamCollector::UpdateRendererDeviceInfo(std::shared_ptr<AudioDeviceDescriptor> outputDeviceInfo)
603 {
604 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
605 bool deviceInfoUpdated = false;
606
607 for (auto it = audioRendererChangeInfos_.begin(); it != audioRendererChangeInfos_.end(); it++) {
608 if (!(*it)->outputDeviceInfo.IsSameDeviceDescPtr(outputDeviceInfo)) {
609 AUDIO_DEBUG_LOG("UpdateRendererDeviceInfo: old device: %{public}d new device: %{public}d",
610 (*it)->outputDeviceInfo.deviceType_, outputDeviceInfo->deviceType_);
611 (*it)->outputDeviceInfo = outputDeviceInfo;
612 deviceInfoUpdated = true;
613 }
614 }
615
616 if (deviceInfoUpdated && audioPolicyServerHandler_ != nullptr) {
617 audioPolicyServerHandler_->SendRendererInfoEvent(audioRendererChangeInfos_);
618 }
619 if (deviceInfoUpdated) {
620 AudioSpatializationService::GetAudioSpatializationService().UpdateRendererInfo(audioRendererChangeInfos_);
621 }
622
623 return SUCCESS;
624 }
625
UpdateCapturerDeviceInfo(AudioDeviceDescriptor & inputDeviceInfo)626 int32_t AudioStreamCollector::UpdateCapturerDeviceInfo(AudioDeviceDescriptor &inputDeviceInfo)
627 {
628 bool deviceInfoUpdated = false;
629
630 for (auto it = audioCapturerChangeInfos_.begin(); it != audioCapturerChangeInfos_.end(); it++) {
631 if (!(*it)->inputDeviceInfo.IsSameDeviceInfo(inputDeviceInfo)) {
632 AUDIO_DEBUG_LOG("UpdateCapturerDeviceInfo: old device: %{public}d new device: %{public}d",
633 (*it)->inputDeviceInfo.deviceType_, inputDeviceInfo.deviceType_);
634 (*it)->inputDeviceInfo = inputDeviceInfo;
635 deviceInfoUpdated = true;
636 }
637 }
638
639 if (deviceInfoUpdated && audioPolicyServerHandler_ != nullptr) {
640 SendCapturerInfoEvent(audioCapturerChangeInfos_);
641 }
642
643 return SUCCESS;
644 }
645
UpdateCapturerDeviceInfo(std::shared_ptr<AudioDeviceDescriptor> inputDeviceInfo)646 int32_t AudioStreamCollector::UpdateCapturerDeviceInfo(std::shared_ptr<AudioDeviceDescriptor> inputDeviceInfo)
647 {
648 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
649 bool deviceInfoUpdated = false;
650
651 for (auto it = audioCapturerChangeInfos_.begin(); it != audioCapturerChangeInfos_.end(); it++) {
652 if (!(*it)->inputDeviceInfo.IsSameDeviceDescPtr(inputDeviceInfo)) {
653 AUDIO_DEBUG_LOG("UpdateCapturerDeviceInfo: old device: %{public}d new device: %{public}d",
654 (*it)->inputDeviceInfo.deviceType_, inputDeviceInfo->deviceType_);
655 (*it)->inputDeviceInfo = inputDeviceInfo;
656 deviceInfoUpdated = true;
657 }
658 }
659
660 if (deviceInfoUpdated && audioPolicyServerHandler_ != nullptr) {
661 SendCapturerInfoEvent(audioCapturerChangeInfos_);
662 }
663
664 return SUCCESS;
665 }
666
UpdateRendererDeviceInfo(int32_t clientUID,int32_t sessionId,AudioDeviceDescriptor & outputDeviceInfo)667 int32_t AudioStreamCollector::UpdateRendererDeviceInfo(int32_t clientUID, int32_t sessionId,
668 AudioDeviceDescriptor &outputDeviceInfo)
669 {
670 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
671 bool deviceInfoUpdated = false;
672
673 for (auto it = audioRendererChangeInfos_.begin(); it != audioRendererChangeInfos_.end(); it++) {
674 if ((*it)->clientUID == clientUID && (*it)->sessionId == sessionId &&
675 !(*it)->outputDeviceInfo.IsSameDeviceInfo(outputDeviceInfo)) {
676 AUDIO_DEBUG_LOG("uid %{public}d sessionId %{public}d update device: old %{public}d, new %{public}d",
677 clientUID, sessionId, (*it)->outputDeviceInfo.deviceType_, outputDeviceInfo.deviceType_);
678 (*it)->outputDeviceInfo = outputDeviceInfo;
679 deviceInfoUpdated = true;
680 }
681 }
682
683 if (deviceInfoUpdated && audioPolicyServerHandler_ != nullptr) {
684 audioPolicyServerHandler_->SendRendererInfoEvent(audioRendererChangeInfos_);
685 }
686 if (deviceInfoUpdated) {
687 AudioSpatializationService::GetAudioSpatializationService().UpdateRendererInfo(audioRendererChangeInfos_);
688 }
689 return SUCCESS;
690 }
691
UpdateRendererPipeInfo(const int32_t sessionId,const AudioPipeType pipeType)692 int32_t AudioStreamCollector::UpdateRendererPipeInfo(const int32_t sessionId, const AudioPipeType pipeType)
693 {
694 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
695 bool pipeTypeUpdated = false;
696
697 for (auto it = audioRendererChangeInfos_.begin(); it != audioRendererChangeInfos_.end(); it++) {
698 if ((*it)->sessionId == sessionId && (*it)->rendererInfo.pipeType != pipeType) {
699 AUDIO_INFO_LOG("sessionId %{public}d update pipeType: old %{public}d, new %{public}d",
700 sessionId, (*it)->rendererInfo.pipeType, pipeType);
701 (*it)->rendererInfo.pipeType = pipeType;
702 pipeTypeUpdated = true;
703 }
704 }
705
706 if (pipeTypeUpdated && audioPolicyServerHandler_ != nullptr) {
707 audioPolicyServerHandler_->SendRendererInfoEvent(audioRendererChangeInfos_);
708 }
709 if (pipeTypeUpdated) {
710 AudioSpatializationService::GetAudioSpatializationService().UpdateRendererInfo(audioRendererChangeInfos_);
711 }
712 return SUCCESS;
713 }
714
UpdateCapturerDeviceInfo(int32_t clientUID,int32_t sessionId,AudioDeviceDescriptor & inputDeviceInfo)715 int32_t AudioStreamCollector::UpdateCapturerDeviceInfo(int32_t clientUID, int32_t sessionId,
716 AudioDeviceDescriptor &inputDeviceInfo)
717 {
718 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
719 bool deviceInfoUpdated = false;
720
721 for (auto it = audioCapturerChangeInfos_.begin(); it != audioCapturerChangeInfos_.end(); it++) {
722 if ((*it)->clientUID == clientUID && (*it)->sessionId == sessionId &&
723 !(*it)->inputDeviceInfo.IsSameDeviceInfo(inputDeviceInfo)) {
724 AUDIO_DEBUG_LOG("uid %{public}d sessionId %{public}d update device: old %{public}d, new %{public}d",
725 (*it)->clientUID, (*it)->sessionId, (*it)->inputDeviceInfo.deviceType_, inputDeviceInfo.deviceType_);
726 (*it)->inputDeviceInfo = inputDeviceInfo;
727 deviceInfoUpdated = true;
728 }
729 }
730
731 if (deviceInfoUpdated && audioPolicyServerHandler_ != nullptr) {
732 SendCapturerInfoEvent(audioCapturerChangeInfos_);
733 }
734
735 return SUCCESS;
736 }
737
UpdateTracker(const AudioMode & mode,AudioDeviceDescriptor & deviceInfo)738 int32_t AudioStreamCollector::UpdateTracker(const AudioMode &mode, AudioDeviceDescriptor &deviceInfo)
739 {
740 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
741 if (mode == AUDIO_MODE_PLAYBACK) {
742 UpdateRendererDeviceInfo(deviceInfo);
743 } else {
744 UpdateCapturerDeviceInfo(deviceInfo);
745 }
746
747 return SUCCESS;
748 }
749
UpdateAppVolume(int32_t appUid,int32_t volume)750 void AudioStreamCollector::UpdateAppVolume(int32_t appUid, int32_t volume)
751 {
752 for (auto itemInfo : audioRendererChangeInfos_) {
753 if (itemInfo->clientUID != appUid) {
754 continue;
755 }
756 itemInfo->appVolume = volume;
757 AUDIO_INFO_LOG("UpdateAppVolume success, appuid = %{public}d, volume = %{public}d", appUid, volume);
758 }
759 }
760
UpdateTracker(AudioMode & mode,AudioStreamChangeInfo & streamChangeInfo)761 int32_t AudioStreamCollector::UpdateTracker(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo)
762 {
763 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
764 // update the stream change info
765 if (mode == AUDIO_MODE_PLAYBACK) {
766 UpdateRendererStream(streamChangeInfo);
767 } else {
768 // mode = AUDIO_MODE_RECORD
769 UpdateCapturerStream(streamChangeInfo);
770 }
771 WriterStreamChangeSysEvent(mode, streamChangeInfo);
772 return SUCCESS;
773 }
774
UpdateTrackerInternal(AudioMode & mode,AudioStreamChangeInfo & streamChangeInfo)775 int32_t AudioStreamCollector::UpdateTrackerInternal(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo)
776 {
777 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
778 // update the stream change internal info
779 if (mode == AUDIO_MODE_PLAYBACK) {
780 return UpdateRendererStreamInternal(streamChangeInfo);
781 }
782 return UpdateCapturerStreamInternal(streamChangeInfo);
783 }
784
GetStreamType(ContentType contentType,StreamUsage streamUsage)785 AudioStreamType AudioStreamCollector::GetStreamType(ContentType contentType, StreamUsage streamUsage)
786 {
787 AudioStreamType streamType = STREAM_MUSIC;
788 auto pos = streamTypeMap_.find(std::make_pair(contentType, streamUsage));
789 if (pos != streamTypeMap_.end()) {
790 streamType = pos->second;
791 }
792
793 if (streamType == STREAM_MEDIA) {
794 streamType = STREAM_MUSIC;
795 }
796
797 return streamType;
798 }
799
GetStreamType(int32_t sessionId)800 AudioStreamType AudioStreamCollector::GetStreamType(int32_t sessionId)
801 {
802 AudioStreamType streamType = STREAM_MUSIC;
803 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
804 for (const auto &changeInfo : audioRendererChangeInfos_) {
805 if (changeInfo->sessionId == sessionId) {
806 streamType = GetStreamType(changeInfo->rendererInfo.contentType, changeInfo->rendererInfo.streamUsage);
807 }
808 }
809 return streamType;
810 }
811
GetSessionIdsOnRemoteDeviceByStreamUsage(StreamUsage streamUsage)812 std::set<int32_t> AudioStreamCollector::GetSessionIdsOnRemoteDeviceByStreamUsage(StreamUsage streamUsage)
813 {
814 std::set<int32_t> sessionIdSet;
815 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
816 for (const auto &changeInfo : audioRendererChangeInfos_) {
817 if (changeInfo->rendererInfo.streamUsage == streamUsage &&
818 changeInfo->outputDeviceInfo.deviceType_ == DEVICE_TYPE_SPEAKER &&
819 changeInfo->outputDeviceInfo.networkId_ != LOCAL_NETWORK_ID) {
820 sessionIdSet.insert(changeInfo->sessionId);
821 }
822 }
823 return sessionIdSet;
824 }
825
GetSessionIdsOnRemoteDeviceByDeviceType(DeviceType deviceType)826 std::set<int32_t> AudioStreamCollector::GetSessionIdsOnRemoteDeviceByDeviceType(DeviceType deviceType)
827 {
828 std::set<int32_t> sessionIdSet;
829 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
830 for (const auto &changeInfo : audioRendererChangeInfos_) {
831 if (changeInfo->outputDeviceInfo.deviceType_ == deviceType) {
832 sessionIdSet.insert(changeInfo->sessionId);
833 }
834 }
835 return sessionIdSet;
836 }
837
IsOffloadAllowed(const int32_t sessionId)838 bool AudioStreamCollector::IsOffloadAllowed(const int32_t sessionId)
839 {
840 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
841 const auto &it = std::find_if(audioRendererChangeInfos_.begin(), audioRendererChangeInfos_.end(),
842 [&sessionId](const std::shared_ptr<AudioRendererChangeInfo> &changeInfo) {
843 return changeInfo->sessionId == sessionId;
844 });
845 if (it == audioRendererChangeInfos_.end()) {
846 AUDIO_WARNING_LOG("invalid session id: %{public}d", sessionId);
847 return false;
848 }
849 return (*it)->rendererInfo.isOffloadAllowed;
850 }
851
GetChannelCount(int32_t sessionId)852 int32_t AudioStreamCollector::GetChannelCount(int32_t sessionId)
853 {
854 int32_t channelCount = 0;
855 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
856 const auto &it = std::find_if(audioRendererChangeInfos_.begin(), audioRendererChangeInfos_.end(),
857 [&sessionId](const std::shared_ptr<AudioRendererChangeInfo> &changeInfo) {
858 return changeInfo->sessionId == sessionId;
859 });
860 if (it != audioRendererChangeInfos_.end()) {
861 channelCount = (*it)->channelCount;
862 }
863 return channelCount;
864 }
865
GetRunningRendererInfos(std::vector<std::shared_ptr<AudioRendererChangeInfo>> & infos)866 int32_t AudioStreamCollector::GetRunningRendererInfos(std::vector<std::shared_ptr<AudioRendererChangeInfo>> &infos)
867 {
868 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
869 for (const auto &changeInfo : audioRendererChangeInfos_) {
870 if (changeInfo->rendererState == RENDERER_RUNNING) {
871 infos.push_back(make_shared<AudioRendererChangeInfo>(*changeInfo));
872 }
873 }
874
875 return SUCCESS;
876 }
877
GetCurrentRendererChangeInfos(std::vector<shared_ptr<AudioRendererChangeInfo>> & rendererChangeInfos)878 int32_t AudioStreamCollector::GetCurrentRendererChangeInfos(
879 std::vector<shared_ptr<AudioRendererChangeInfo>> &rendererChangeInfos)
880 {
881 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
882 for (const auto &changeInfo : audioRendererChangeInfos_) {
883 rendererChangeInfos.push_back(make_shared<AudioRendererChangeInfo>(*changeInfo));
884 }
885 AUDIO_DEBUG_LOG("GetCurrentRendererChangeInfos returned");
886
887 return SUCCESS;
888 }
889
GetCurrentCapturerChangeInfos(std::vector<shared_ptr<AudioCapturerChangeInfo>> & capturerChangeInfos)890 int32_t AudioStreamCollector::GetCurrentCapturerChangeInfos(
891 std::vector<shared_ptr<AudioCapturerChangeInfo>> &capturerChangeInfos)
892 {
893 AUDIO_DEBUG_LOG("GetCurrentCapturerChangeInfos");
894 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
895 for (const auto &changeInfo : audioCapturerChangeInfos_) {
896 if (!IsTransparentCapture(changeInfo->clientUID)) {
897 capturerChangeInfos.push_back(make_shared<AudioCapturerChangeInfo>(*changeInfo));
898 } else {
899 AUDIO_INFO_LOG("GetCurrentCapturerChangeInfos remove uid:%{public}d", changeInfo->clientUID);
900 }
901 AUDIO_DEBUG_LOG("GetCurrentCapturerChangeInfos returned");
902 }
903
904 return SUCCESS;
905 }
906
RegisteredRendererTrackerClientDied(const int32_t uid,const int32_t pid)907 void AudioStreamCollector::RegisteredRendererTrackerClientDied(const int32_t uid, const int32_t pid)
908 {
909 int32_t sessionID = -1;
910 auto audioRendererBegin = audioRendererChangeInfos_.begin();
911 while (audioRendererBegin != audioRendererChangeInfos_.end()) {
912 const auto &audioRendererChangeInfo = *audioRendererBegin;
913 if (audioRendererChangeInfo == nullptr ||
914 (audioRendererChangeInfo->clientUID != uid && audioRendererChangeInfo->createrUID != uid) ||
915 audioRendererChangeInfo->clientPid != pid) {
916 audioRendererBegin++;
917 continue;
918 }
919 sessionID = audioRendererChangeInfo->sessionId;
920 audioRendererChangeInfo->rendererState = RENDERER_RELEASED;
921 WriteRenderStreamReleaseSysEvent(audioRendererChangeInfo);
922 if (audioPolicyServerHandler_ != nullptr) {
923 audioPolicyServerHandler_->SendRendererInfoEvent(audioRendererChangeInfos_);
924 }
925 AudioSpatializationService::GetAudioSpatializationService().UpdateRendererInfo(audioRendererChangeInfos_);
926 rendererStatequeue_.erase(make_pair(audioRendererChangeInfo->clientUID,
927 audioRendererChangeInfo->sessionId));
928
929 auto temp = audioRendererBegin;
930 audioRendererBegin = audioRendererChangeInfos_.erase(temp);
931 if ((sessionID != -1) && clientTracker_.erase(sessionID)) {
932 AUDIO_INFO_LOG("TrackerClientDied:client %{public}d cleared", sessionID);
933 }
934 }
935 }
936
RegisteredCapturerTrackerClientDied(const int32_t uid)937 void AudioStreamCollector::RegisteredCapturerTrackerClientDied(const int32_t uid)
938 {
939 int32_t sessionID = -1;
940 auto audioCapturerBegin = audioCapturerChangeInfos_.begin();
941 while (audioCapturerBegin != audioCapturerChangeInfos_.end()) {
942 const auto &audioCapturerChangeInfo = *audioCapturerBegin;
943 if (audioCapturerChangeInfo == nullptr ||
944 (audioCapturerChangeInfo->clientUID != uid && audioCapturerChangeInfo->createrUID != uid)) {
945 audioCapturerBegin++;
946 continue;
947 }
948 sessionID = audioCapturerChangeInfo->sessionId;
949 audioCapturerChangeInfo->capturerState = CAPTURER_RELEASED;
950 WriteCaptureStreamReleaseSysEvent(audioCapturerChangeInfo);
951 if (audioPolicyServerHandler_ != nullptr) {
952 SendCapturerInfoEvent(audioCapturerChangeInfos_);
953 }
954 capturerStatequeue_.erase(make_pair(audioCapturerChangeInfo->clientUID,
955 audioCapturerChangeInfo->sessionId));
956 auto temp = audioCapturerBegin;
957 audioCapturerBegin = audioCapturerChangeInfos_.erase(temp);
958 if ((sessionID != -1) && clientTracker_.erase(sessionID)) {
959 AUDIO_INFO_LOG("TrackerClientDied:client %{public}d cleared", sessionID);
960 }
961 }
962 }
963
RegisteredTrackerClientDied(int32_t uid,int32_t pid)964 void AudioStreamCollector::RegisteredTrackerClientDied(int32_t uid, int32_t pid)
965 {
966 AUDIO_INFO_LOG("TrackerClientDied:client:%{public}d Died", uid);
967
968 // Send the release state event notification for all streams of died client to registered app
969 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
970 RegisteredRendererTrackerClientDied(uid, pid);
971 RegisteredCapturerTrackerClientDied(uid);
972 }
973
GetAndCompareStreamType(StreamUsage targetUsage,AudioRendererInfo rendererInfo)974 bool AudioStreamCollector::GetAndCompareStreamType(StreamUsage targetUsage, AudioRendererInfo rendererInfo)
975 {
976 AudioStreamType requiredType = GetStreamType(CONTENT_TYPE_UNKNOWN, targetUsage);
977 AUDIO_INFO_LOG("GetAndCompareStreamType:requiredType:%{public}d ", requiredType);
978 AudioStreamType defaultStreamType = STREAM_MUSIC;
979 auto pos = streamTypeMap_.find(make_pair(rendererInfo.contentType, rendererInfo.streamUsage));
980 if (pos != streamTypeMap_.end()) {
981 defaultStreamType = pos->second;
982 }
983 return defaultStreamType == requiredType;
984 }
985
GetUid(int32_t sessionId)986 int32_t AudioStreamCollector::GetUid(int32_t sessionId)
987 {
988 int32_t defaultUid = -1;
989 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
990 const auto &it = std::find_if(audioRendererChangeInfos_.begin(), audioRendererChangeInfos_.end(),
991 [&sessionId](const std::shared_ptr<AudioRendererChangeInfo> &changeInfo) {
992 return changeInfo->sessionId == sessionId;
993 });
994 if (it != audioRendererChangeInfos_.end()) {
995 defaultUid = (*it)->createrUID;
996 }
997 return defaultUid;
998 }
999
ResumeStreamState()1000 int32_t AudioStreamCollector::ResumeStreamState()
1001 {
1002 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1003 for (const auto &changeInfo : audioRendererChangeInfos_) {
1004 std::shared_ptr<AudioClientTracker> callback = clientTracker_[changeInfo->sessionId];
1005 if (callback == nullptr) {
1006 AUDIO_ERR_LOG("AVSession is not alive,UpdateStreamState callback failed sId:%{public}d",
1007 changeInfo->sessionId);
1008 continue;
1009 }
1010 StreamSetStateEventInternal setStateEvent = {};
1011 setStateEvent.streamSetState = StreamSetState::STREAM_UNMUTE;
1012 setStateEvent.streamUsage = changeInfo->rendererInfo.streamUsage;
1013 callback->UnmuteStreamImpl(setStateEvent);
1014 }
1015
1016 return SUCCESS;
1017 }
1018
UpdateStreamState(int32_t clientUid,StreamSetStateEventInternal & streamSetStateEventInternal)1019 int32_t AudioStreamCollector::UpdateStreamState(int32_t clientUid,
1020 StreamSetStateEventInternal &streamSetStateEventInternal)
1021 {
1022 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1023 for (const auto &changeInfo : audioRendererChangeInfos_) {
1024 if (changeInfo->clientUID == clientUid &&
1025 streamSetStateEventInternal.streamUsage == changeInfo->rendererInfo.streamUsage) {
1026 AUDIO_INFO_LOG("UpdateStreamState Found matching uid=%{public}d and usage=%{public}d",
1027 clientUid, streamSetStateEventInternal.streamUsage);
1028 if (std::count(BACKGROUND_MUTE_STREAM_USAGE.begin(), BACKGROUND_MUTE_STREAM_USAGE.end(),
1029 streamSetStateEventInternal.streamUsage) == 0) {
1030 continue;
1031 }
1032 std::shared_ptr<AudioClientTracker> callback = clientTracker_[changeInfo->sessionId];
1033 if (callback == nullptr) {
1034 AUDIO_ERR_LOG("UpdateStreamState callback failed sId:%{public}d",
1035 changeInfo->sessionId);
1036 continue;
1037 }
1038 if (streamSetStateEventInternal.streamSetState == StreamSetState::STREAM_PAUSE) {
1039 AUDIO_INFO_LOG("Paused the stream in uid=%{public}d", clientUid);
1040 callback->PausedStreamImpl(streamSetStateEventInternal);
1041 } else if (streamSetStateEventInternal.streamSetState == StreamSetState::STREAM_RESUME) {
1042 AUDIO_INFO_LOG("Resume the stream in uid=%{public}d", clientUid);
1043 callback->ResumeStreamImpl(streamSetStateEventInternal);
1044 } else if (streamSetStateEventInternal.streamSetState == StreamSetState::STREAM_MUTE &&
1045 !changeInfo->backMute) {
1046 AUDIO_INFO_LOG("Mute the stream in uid=%{public}d", clientUid);
1047 callback->MuteStreamImpl(streamSetStateEventInternal);
1048 changeInfo->backMute = true;
1049 } else if (streamSetStateEventInternal.streamSetState == StreamSetState::STREAM_UNMUTE &&
1050 changeInfo->backMute) {
1051 AUDIO_INFO_LOG("Unmute the stream in uid=%{public}d", clientUid);
1052 callback->UnmuteStreamImpl(streamSetStateEventInternal);
1053 changeInfo->backMute = false;
1054 }
1055 }
1056 }
1057
1058 return SUCCESS;
1059 }
1060
HandleAppStateChange(int32_t uid,int32_t pid,bool mute,bool & notifyMute,bool hasBackTask)1061 void AudioStreamCollector::HandleAppStateChange(int32_t uid, int32_t pid, bool mute, bool ¬ifyMute, bool hasBackTask)
1062 {
1063 if (VolumeUtils::IsPCVolumeEnable()) {
1064 return;
1065 }
1066 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1067 for (const auto &changeInfo : audioRendererChangeInfos_) {
1068 if (changeInfo != nullptr && changeInfo->clientUID == uid && changeInfo->clientPid == pid) {
1069 AUDIO_INFO_LOG(" uid=%{public}d and state=%{public}d", uid, mute);
1070 if (std::count(BACKGROUND_MUTE_STREAM_USAGE.begin(), BACKGROUND_MUTE_STREAM_USAGE.end(),
1071 changeInfo->rendererInfo.streamUsage) == 0) {
1072 continue;
1073 }
1074 CHECK_AND_CONTINUE(hasBackTask || mute);
1075 std::shared_ptr<AudioClientTracker> callback = clientTracker_[changeInfo->sessionId];
1076 if (callback == nullptr) {
1077 AUDIO_ERR_LOG(" callback failed sId:%{public}d", changeInfo->sessionId);
1078 continue;
1079 }
1080 StreamSetStateEventInternal setStateEvent = {};
1081 setStateEvent.streamSetState = StreamSetState::STREAM_PAUSE;
1082 setStateEvent.streamUsage = changeInfo->rendererInfo.streamUsage;
1083 if (mute && !changeInfo->backMute) {
1084 AUDIO_INFO_LOG("Mute the stream in uid=%{public}d", uid);
1085 setStateEvent.streamSetState = StreamSetState::STREAM_MUTE;
1086 callback->MuteStreamImpl(setStateEvent);
1087 changeInfo->backMute = true;
1088 notifyMute = true;
1089 } else if (!mute && changeInfo->backMute) {
1090 AUDIO_INFO_LOG("Unmute the stream in uid=%{public}d", uid);
1091 setStateEvent.streamSetState = StreamSetState::STREAM_UNMUTE;
1092 callback->UnmuteStreamImpl(setStateEvent);
1093 changeInfo->backMute = false;
1094 }
1095 }
1096 }
1097 }
1098
HandleKaraokeAppToBack(int32_t uid,int32_t pid)1099 void AudioStreamCollector::HandleKaraokeAppToBack(int32_t uid, int32_t pid)
1100 {
1101 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1102 for (const auto &changeInfo : audioRendererChangeInfos_) {
1103 if (changeInfo != nullptr && changeInfo->clientUID == uid && changeInfo->clientPid == pid &&
1104 changeInfo->rendererInfo.isLoopback) {
1105 AUDIO_INFO_LOG("KaraokeApp to back uid=%{public}d", uid);
1106 std::shared_ptr<AudioClientTracker> callback = clientTracker_[changeInfo->sessionId];
1107 if (callback == nullptr) {
1108 AUDIO_ERR_LOG(" callback failed sId:%{public}d", changeInfo->sessionId);
1109 continue;
1110 }
1111 AUDIO_INFO_LOG("Pause the stream in uid=%{public}d", uid);
1112 StreamSetStateEventInternal setStateEvent = {};
1113 setStateEvent.streamSetState = StreamSetState::STREAM_PAUSE;
1114 setStateEvent.streamUsage = changeInfo->rendererInfo.streamUsage;
1115 callback->PausedStreamImpl(setStateEvent);
1116 }
1117 }
1118 }
1119
HandleForegroundUnmute(int32_t uid,int32_t pid)1120 void AudioStreamCollector::HandleForegroundUnmute(int32_t uid, int32_t pid)
1121 {
1122 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1123 for (const auto &changeInfo : audioRendererChangeInfos_) {
1124 if (changeInfo != nullptr && changeInfo->clientUID == uid && changeInfo->clientPid == pid) {
1125 AUDIO_INFO_LOG(" uid=%{public}d pid=%{public}d is foreground, Don't need mute", uid, pid);
1126 std::shared_ptr<AudioClientTracker> callback = clientTracker_[changeInfo->sessionId];
1127 if (callback == nullptr) {
1128 AUDIO_ERR_LOG(" callback failed sId:%{public}d", changeInfo->sessionId);
1129 continue;
1130 }
1131 StreamSetStateEventInternal setStateEvent = {};
1132 setStateEvent.streamSetState = StreamSetState::STREAM_PAUSE;
1133 setStateEvent.streamUsage = changeInfo->rendererInfo.streamUsage;
1134 if (changeInfo->backMute) {
1135 AUDIO_INFO_LOG("Unmute the stream in uid=%{public}d", uid);
1136 setStateEvent.streamSetState = StreamSetState::STREAM_UNMUTE;
1137 callback->UnmuteStreamImpl(setStateEvent);
1138 changeInfo->backMute = false;
1139 }
1140 }
1141 }
1142 }
1143
HandleFreezeStateChange(int32_t pid,bool mute,bool hasSession)1144 void AudioStreamCollector::HandleFreezeStateChange(int32_t pid, bool mute, bool hasSession)
1145 {
1146 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1147 for (const auto &changeInfo : audioRendererChangeInfos_) {
1148 if (changeInfo != nullptr && changeInfo->clientPid == pid && changeInfo->createrUID != MEDIA_UID) {
1149 AUDIO_INFO_LOG(" pid=%{public}d state=%{public}d hasSession=%{public}d",
1150 pid, mute, hasSession);
1151 if (!hasSession && !mute && (std::count(BACKGROUND_MUTE_STREAM_USAGE.begin(),
1152 BACKGROUND_MUTE_STREAM_USAGE.end(), changeInfo->rendererInfo.streamUsage) != 0)) {
1153 continue;
1154 }
1155 std::shared_ptr<AudioClientTracker> callback = clientTracker_[changeInfo->sessionId];
1156 if (callback == nullptr) {
1157 AUDIO_ERR_LOG(" callback failed sId:%{public}d", changeInfo->sessionId);
1158 continue;
1159 }
1160 StreamSetStateEventInternal setStateEvent = {};
1161 setStateEvent.streamSetState = StreamSetState::STREAM_PAUSE;
1162 setStateEvent.streamUsage = changeInfo->rendererInfo.streamUsage;
1163 if (mute && !changeInfo->backMute) {
1164 AUDIO_INFO_LOG("Mute the stream in pid=%{public}d", pid);
1165 setStateEvent.streamSetState = StreamSetState::STREAM_MUTE;
1166 callback->MuteStreamImpl(setStateEvent);
1167 changeInfo->backMute = true;
1168 } else if (!mute && changeInfo->backMute) {
1169 AUDIO_INFO_LOG("Unmute the stream in pid=%{public}d", pid);
1170 setStateEvent.streamSetState = StreamSetState::STREAM_UNMUTE;
1171 callback->UnmuteStreamImpl(setStateEvent);
1172 changeInfo->backMute = false;
1173 }
1174 }
1175 }
1176 }
1177
HandleBackTaskStateChange(int32_t uid,bool hasSession)1178 void AudioStreamCollector::HandleBackTaskStateChange(int32_t uid, bool hasSession)
1179 {
1180 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1181 for (const auto &changeInfo : audioRendererChangeInfos_) {
1182 if (changeInfo != nullptr && changeInfo->clientUID == uid) {
1183 AUDIO_INFO_LOG(" uid=%{public}d and hasSession=%{public}d", uid, hasSession);
1184 if ((std::count(BACKGROUND_MUTE_STREAM_USAGE.begin(), BACKGROUND_MUTE_STREAM_USAGE.end(),
1185 changeInfo->rendererInfo.streamUsage) != 0) && !hasSession) {
1186 continue;
1187 }
1188 std::shared_ptr<AudioClientTracker> callback = clientTracker_[changeInfo->sessionId];
1189 if (callback == nullptr) {
1190 AUDIO_ERR_LOG(" callback failed sId:%{public}d", changeInfo->sessionId);
1191 continue;
1192 }
1193 StreamSetStateEventInternal setStateEvent = {};
1194 setStateEvent.streamSetState = StreamSetState::STREAM_PAUSE;
1195 setStateEvent.streamUsage = changeInfo->rendererInfo.streamUsage;
1196 if (changeInfo->backMute) {
1197 AUDIO_INFO_LOG("Unmute the stream in uid=%{public}d", uid);
1198 setStateEvent.streamSetState = StreamSetState::STREAM_UNMUTE;
1199 callback->UnmuteStreamImpl(setStateEvent);
1200 changeInfo->backMute = false;
1201 }
1202 }
1203 }
1204 }
1205
HandleStartStreamMuteState(int32_t uid,int32_t pid,bool mute,bool skipMedia)1206 void AudioStreamCollector::HandleStartStreamMuteState(int32_t uid, int32_t pid, bool mute, bool skipMedia)
1207 {
1208 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1209 for (const auto &changeInfo : audioRendererChangeInfos_) {
1210 if (changeInfo != nullptr && changeInfo->clientUID == uid && changeInfo->clientPid == pid) {
1211 AUDIO_INFO_LOG(" uid=%{public}d and state=%{public}d", uid, mute);
1212 if (skipMedia && std::count(BACKGROUND_MUTE_STREAM_USAGE.begin(), BACKGROUND_MUTE_STREAM_USAGE.end(),
1213 changeInfo->rendererInfo.streamUsage) != 0) {
1214 continue;
1215 }
1216 std::shared_ptr<AudioClientTracker> callback = clientTracker_[changeInfo->sessionId];
1217 if (callback == nullptr) {
1218 AUDIO_ERR_LOG(" callback failed sId:%{public}d", changeInfo->sessionId);
1219 continue;
1220 }
1221 StreamSetStateEventInternal setStateEvent = {};
1222 setStateEvent.streamSetState = StreamSetState::STREAM_PAUSE;
1223 setStateEvent.streamUsage = changeInfo->rendererInfo.streamUsage;
1224 if (mute && !changeInfo->backMute && changeInfo->createrUID != MEDIA_UID) {
1225 AUDIO_INFO_LOG("Mute the stream in uid=%{public}d", uid);
1226 setStateEvent.streamSetState = StreamSetState::STREAM_MUTE;
1227 callback->MuteStreamImpl(setStateEvent);
1228 changeInfo->backMute = true;
1229 } else if (!mute && changeInfo->backMute) {
1230 AUDIO_INFO_LOG("Unmute the stream in uid=%{public}d", uid);
1231 setStateEvent.streamSetState = StreamSetState::STREAM_UNMUTE;
1232 callback->UnmuteStreamImpl(setStateEvent);
1233 changeInfo->backMute = false;
1234 }
1235 }
1236 }
1237 }
1238
IsStreamActive(AudioStreamType volumeType)1239 bool AudioStreamCollector::IsStreamActive(AudioStreamType volumeType)
1240 {
1241 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1242 bool result = false;
1243 for (auto &changeInfo: audioRendererChangeInfos_) {
1244 if (changeInfo->rendererState != RENDERER_RUNNING) {
1245 continue;
1246 }
1247 AudioVolumeType rendererVolumeType = GetVolumeTypeFromContentUsage((changeInfo->rendererInfo).contentType,
1248 (changeInfo->rendererInfo).streamUsage);
1249 if (rendererVolumeType == volumeType) {
1250 // An active stream has been found, return true directly.
1251 AUDIO_INFO_LOG("matched clientUid: %{public}d id: %{public}d",
1252 changeInfo->clientUID, changeInfo->sessionId);
1253 return true;
1254 }
1255 }
1256 return result;
1257 }
1258
CheckVoiceCallActive(int32_t sessionId)1259 bool AudioStreamCollector::CheckVoiceCallActive(int32_t sessionId)
1260 {
1261 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1262 for (auto &changeInfo: audioRendererChangeInfos_) {
1263 if (changeInfo->rendererState != RENDERER_PREPARED) {
1264 continue;
1265 }
1266 if ((changeInfo->rendererInfo).streamUsage == STREAM_USAGE_VOICE_MODEM_COMMUNICATION &&
1267 changeInfo->sessionId != sessionId) {
1268 AUDIO_INFO_LOG("Find VoiceCall Stream : sessionid: %{public}d , No need mute", changeInfo->sessionId);
1269 return false;
1270 }
1271 }
1272 return true;
1273 }
1274
IsVoiceCallActive()1275 bool AudioStreamCollector::IsVoiceCallActive()
1276 {
1277 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1278 for (auto &changeInfo: audioRendererChangeInfos_) {
1279 if (changeInfo != nullptr &&
1280 (changeInfo->rendererInfo).streamUsage == STREAM_USAGE_VOICE_MODEM_COMMUNICATION &&
1281 changeInfo->rendererState == RENDERER_PREPARED) {
1282 return true;
1283 }
1284 }
1285 return false;
1286 }
1287
GetRunningStream(AudioStreamType certainType,int32_t certainChannelCount)1288 int32_t AudioStreamCollector::GetRunningStream(AudioStreamType certainType, int32_t certainChannelCount)
1289 {
1290 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1291 int32_t runningStream = -1;
1292 if ((certainType == STREAM_DEFAULT) && (certainChannelCount == 0)) {
1293 for (auto &changeInfo : audioRendererChangeInfos_) {
1294 if (changeInfo->rendererState == RENDERER_RUNNING) {
1295 runningStream = changeInfo->sessionId;
1296 break;
1297 }
1298 }
1299 } else if (certainChannelCount == 0) {
1300 for (auto &changeInfo : audioRendererChangeInfos_) {
1301 if ((changeInfo->rendererState == RENDERER_RUNNING) &&
1302 (certainType == GetStreamType(changeInfo->rendererInfo.contentType,
1303 changeInfo->rendererInfo.streamUsage))) {
1304 runningStream = changeInfo->sessionId;
1305 break;
1306 }
1307 }
1308 } else {
1309 for (auto &changeInfo : audioRendererChangeInfos_) {
1310 if ((changeInfo->rendererState == RENDERER_RUNNING) &&
1311 (certainType == GetStreamType(changeInfo->rendererInfo.contentType,
1312 changeInfo->rendererInfo.streamUsage)) && (certainChannelCount == changeInfo->channelCount)) {
1313 runningStream = changeInfo->sessionId;
1314 break;
1315 }
1316 }
1317 }
1318 return runningStream;
1319 }
1320
GetVolumeTypeFromContentUsage(ContentType contentType,StreamUsage streamUsage)1321 AudioStreamType AudioStreamCollector::GetVolumeTypeFromContentUsage(ContentType contentType, StreamUsage streamUsage)
1322 {
1323 AudioStreamType streamType = STREAM_MUSIC;
1324 auto pos = streamTypeMap_.find(make_pair(contentType, streamUsage));
1325 if (pos != streamTypeMap_.end()) {
1326 streamType = pos->second;
1327 }
1328 return VolumeUtils::GetVolumeTypeFromStreamType(streamType);
1329 }
1330
GetStreamTypeFromSourceType(SourceType sourceType)1331 AudioStreamType AudioStreamCollector::GetStreamTypeFromSourceType(SourceType sourceType)
1332 {
1333 switch (sourceType) {
1334 case SOURCE_TYPE_MIC:
1335 case SOURCE_TYPE_UNPROCESSED:
1336 case SOURCE_TYPE_LIVE:
1337 return STREAM_MUSIC;
1338 case SOURCE_TYPE_VOICE_COMMUNICATION:
1339 case SOURCE_TYPE_VOICE_CALL:
1340 return STREAM_VOICE_CALL;
1341 case SOURCE_TYPE_ULTRASONIC:
1342 return STREAM_ULTRASONIC;
1343 case SOURCE_TYPE_WAKEUP:
1344 return STREAM_WAKEUP;
1345 case SOURCE_TYPE_CAMCORDER:
1346 return STREAM_CAMCORDER;
1347 case SOURCE_TYPE_VOICE_RECOGNITION:
1348 case SOURCE_TYPE_PLAYBACK_CAPTURE:
1349 case SOURCE_TYPE_REMOTE_CAST:
1350 case SOURCE_TYPE_VIRTUAL_CAPTURE:
1351 case SOURCE_TYPE_VOICE_MESSAGE:
1352 default:
1353 return (AudioStreamType)sourceType;
1354 }
1355 }
1356
SetLowPowerVolume(int32_t streamId,float volume)1357 int32_t AudioStreamCollector::SetLowPowerVolume(int32_t streamId, float volume)
1358 {
1359 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1360 CHECK_AND_RETURN_RET_LOG(!(clientTracker_.count(streamId) == 0),
1361 ERR_INVALID_PARAM, "SetLowPowerVolume streamId invalid.");
1362 std::shared_ptr<AudioClientTracker> callback = clientTracker_[streamId];
1363 CHECK_AND_RETURN_RET_LOG(callback != nullptr,
1364 ERR_INVALID_PARAM, "SetLowPowerVolume callback failed");
1365 callback->SetLowPowerVolumeImpl(volume);
1366 return SUCCESS;
1367 }
1368
GetLowPowerVolume(int32_t streamId)1369 float AudioStreamCollector::GetLowPowerVolume(int32_t streamId)
1370 {
1371 std::unique_lock<std::mutex> lock(streamsInfoMutex_);
1372 float ret = 1.0; // invalue volume
1373 CHECK_AND_RETURN_RET_LOG(!(clientTracker_.count(streamId) == 0),
1374 ret, "GetLowPowerVolume streamId invalid.");
1375 float volume;
1376 std::shared_ptr<AudioClientTracker> callback = clientTracker_[streamId];
1377 CHECK_AND_RETURN_RET_LOG(callback != nullptr,
1378 ret, "GetLowPowerVolume callback failed");
1379 lock.unlock();
1380 callback->GetLowPowerVolumeImpl(volume);
1381 return volume;
1382 }
1383
SetOffloadMode(int32_t streamId,int32_t state,bool isAppBack)1384 int32_t AudioStreamCollector::SetOffloadMode(int32_t streamId, int32_t state, bool isAppBack)
1385 {
1386 std::shared_ptr<AudioClientTracker> callback;
1387 {
1388 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1389 CHECK_AND_RETURN_RET_LOG(!(clientTracker_.count(streamId) == 0),
1390 ERR_INVALID_PARAM, "streamId (%{public}d) invalid.", streamId);
1391 callback = clientTracker_[streamId];
1392 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM, "callback failed");
1393 }
1394 callback->SetOffloadModeImpl(state, isAppBack);
1395 return SUCCESS;
1396 }
1397
UnsetOffloadMode(int32_t streamId)1398 int32_t AudioStreamCollector::UnsetOffloadMode(int32_t streamId)
1399 {
1400 std::shared_ptr<AudioClientTracker> callback;
1401 {
1402 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1403 CHECK_AND_RETURN_RET_LOG(!(clientTracker_.count(streamId) == 0),
1404 ERR_INVALID_PARAM, "streamId (%{public}d) invalid.", streamId);
1405 callback = clientTracker_[streamId];
1406 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM, "callback failed");
1407 }
1408 callback->UnsetOffloadModeImpl();
1409 return SUCCESS;
1410 }
1411
GetSingleStreamVolume(int32_t streamId)1412 float AudioStreamCollector::GetSingleStreamVolume(int32_t streamId)
1413 {
1414 std::shared_ptr<AudioClientTracker> callback;
1415 {
1416 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1417 float ret = 1.0; // invalue volume
1418 CHECK_AND_RETURN_RET_LOG(!(clientTracker_.count(streamId) == 0),
1419 ret, "GetSingleStreamVolume streamId invalid.");
1420 callback = clientTracker_[streamId];
1421 CHECK_AND_RETURN_RET_LOG(callback != nullptr,
1422 ret, "GetSingleStreamVolume callback failed");
1423 }
1424 float volume;
1425 callback->GetSingleStreamVolumeImpl(volume);
1426 return volume;
1427 }
1428
UpdateCapturerInfoMuteStatus(int32_t uid,bool muteStatus)1429 int32_t AudioStreamCollector::UpdateCapturerInfoMuteStatus(int32_t uid, bool muteStatus)
1430 {
1431 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1432 bool capturerInfoUpdated = false;
1433 for (auto it = audioCapturerChangeInfos_.begin(); it != audioCapturerChangeInfos_.end(); it++) {
1434 if ((*it)->clientUID == uid || uid == 0) {
1435 (*it)->muted = muteStatus;
1436 capturerInfoUpdated = true;
1437 std::shared_ptr<Media::MediaMonitor::EventBean> bean = std::make_shared<Media::MediaMonitor::EventBean>(
1438 Media::MediaMonitor::ModuleId::AUDIO, Media::MediaMonitor::EventId::CAPTURE_MUTE_STATUS_CHANGE,
1439 Media::MediaMonitor::EventType::BEHAVIOR_EVENT);
1440 bean->Add("ISOUTPUT", 0);
1441 bean->Add("STREAMID", (*it)->sessionId);
1442 bean->Add("STREAM_TYPE", (*it)->capturerInfo.sourceType);
1443 bean->Add("DEVICETYPE", (*it)->inputDeviceInfo.deviceType_);
1444 bean->Add("MUTED", (*it)->muted);
1445 Media::MediaMonitor::MediaMonitorManager::GetInstance().WriteLogMsg(bean);
1446 }
1447 }
1448
1449 if (capturerInfoUpdated && audioPolicyServerHandler_ != nullptr) {
1450 SendCapturerInfoEvent(audioCapturerChangeInfos_);
1451 }
1452
1453 return SUCCESS;
1454 }
1455
GetConcurrencyMap()1456 std::map<std::pair<AudioPipeType, AudioPipeType>, ConcurrencyAction>& AudioStreamCollector::GetConcurrencyMap()
1457 {
1458 return audioConcurrencyService_->GetConcurrencyMap();
1459 }
1460
WriterStreamChangeSysEvent(AudioMode & mode,AudioStreamChangeInfo & streamChangeInfo)1461 void AudioStreamCollector::WriterStreamChangeSysEvent(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo)
1462 {
1463 if (mode == AUDIO_MODE_PLAYBACK) {
1464 WriterRenderStreamChangeSysEvent(streamChangeInfo);
1465 } else {
1466 WriterCaptureStreamChangeSysEvent(streamChangeInfo);
1467 }
1468 }
1469
WriterRenderStreamChangeSysEvent(AudioStreamChangeInfo & streamChangeInfo)1470 void AudioStreamCollector::WriterRenderStreamChangeSysEvent(AudioStreamChangeInfo &streamChangeInfo)
1471 {
1472 bool isOutput = true;
1473 AudioStreamType streamType = GetVolumeTypeFromContentUsage(
1474 streamChangeInfo.audioRendererChangeInfo.rendererInfo.contentType,
1475 streamChangeInfo.audioRendererChangeInfo.rendererInfo.streamUsage);
1476 uint64_t transactionId = audioAbilityMgr_->GetTransactionId(
1477 streamChangeInfo.audioRendererChangeInfo.outputDeviceInfo.deviceType_, OUTPUT_DEVICE);
1478
1479 uint8_t effectChainType = EFFECT_CHAIN_TYPE_MAP.count(
1480 streamChangeInfo.audioRendererChangeInfo.rendererInfo.sceneType) ?
1481 EFFECT_CHAIN_TYPE_MAP.at(streamChangeInfo.audioRendererChangeInfo.rendererInfo.sceneType) :
1482 EFFECT_CHAIN_TYPE_MAP.at("UNKNOWN");
1483
1484 std::shared_ptr<Media::MediaMonitor::EventBean> bean = std::make_shared<Media::MediaMonitor::EventBean>(
1485 Media::MediaMonitor::AUDIO, Media::MediaMonitor::STREAM_CHANGE,
1486 Media::MediaMonitor::BEHAVIOR_EVENT);
1487 bean->Add("ISOUTPUT", isOutput ? 1 : 0);
1488 bean->Add("STREAMID", streamChangeInfo.audioRendererChangeInfo.sessionId);
1489 bean->Add("UID", streamChangeInfo.audioRendererChangeInfo.clientUID);
1490 bean->Add("PID", streamChangeInfo.audioRendererChangeInfo.clientPid);
1491 bean->Add("TRANSACTIONID", transactionId);
1492 bean->Add("STREAMTYPE", streamType);
1493 bean->Add("STATE", streamChangeInfo.audioRendererChangeInfo.rendererState);
1494 bean->Add("DEVICETYPE", streamChangeInfo.audioRendererChangeInfo.outputDeviceInfo.deviceType_);
1495 bean->Add("BT_TYPE", streamChangeInfo.audioRendererChangeInfo.outputDeviceInfo.deviceCategory_);
1496 bean->Add("PIPE_TYPE", streamChangeInfo.audioRendererChangeInfo.rendererInfo.pipeType);
1497 bean->Add("STREAM_TYPE", streamChangeInfo.audioRendererChangeInfo.rendererInfo.streamUsage);
1498 bean->Add("SAMPLE_RATE", streamChangeInfo.audioRendererChangeInfo.rendererInfo.samplingRate);
1499 bean->Add("NETWORKID", ConvertNetworkId(streamChangeInfo.audioRendererChangeInfo.outputDeviceInfo.networkId_));
1500 bean->Add("ENCODING_TYPE", streamChangeInfo.audioRendererChangeInfo.rendererInfo.encodingType);
1501 bean->Add("CHANNEL_LAYOUT", streamChangeInfo.audioRendererChangeInfo.rendererInfo.channelLayout);
1502 bean->Add("EFFECT_CHAIN", effectChainType);
1503 Media::MediaMonitor::MediaMonitorManager::GetInstance().WriteLogMsg(bean);
1504 }
1505
WriterCaptureStreamChangeSysEvent(AudioStreamChangeInfo & streamChangeInfo)1506 void AudioStreamCollector::WriterCaptureStreamChangeSysEvent(AudioStreamChangeInfo &streamChangeInfo)
1507 {
1508 bool isOutput = false;
1509 AudioStreamType streamType = GetStreamTypeFromSourceType(
1510 streamChangeInfo.audioCapturerChangeInfo.capturerInfo.sourceType);
1511 uint64_t transactionId = audioAbilityMgr_->GetTransactionId(
1512 streamChangeInfo.audioCapturerChangeInfo.inputDeviceInfo.deviceType_, INPUT_DEVICE);
1513
1514 uint8_t effectChainType = EFFECT_CHAIN_TYPE_MAP.count(
1515 streamChangeInfo.audioCapturerChangeInfo.capturerInfo.sceneType) ?
1516 EFFECT_CHAIN_TYPE_MAP.at(streamChangeInfo.audioCapturerChangeInfo.capturerInfo.sceneType) :
1517 EFFECT_CHAIN_TYPE_MAP.at("UNKNOWN");
1518
1519 std::shared_ptr<Media::MediaMonitor::EventBean> bean = std::make_shared<Media::MediaMonitor::EventBean>(
1520 Media::MediaMonitor::AUDIO, Media::MediaMonitor::STREAM_CHANGE,
1521 Media::MediaMonitor::BEHAVIOR_EVENT);
1522 bean->Add("ISOUTPUT", isOutput ? 1 : 0);
1523 bean->Add("STREAMID", streamChangeInfo.audioCapturerChangeInfo.sessionId);
1524 bean->Add("UID", streamChangeInfo.audioCapturerChangeInfo.clientUID);
1525 bean->Add("PID", streamChangeInfo.audioCapturerChangeInfo.clientPid);
1526 bean->Add("TRANSACTIONID", transactionId);
1527 bean->Add("STREAMTYPE", streamType);
1528 bean->Add("STATE", streamChangeInfo.audioCapturerChangeInfo.capturerState);
1529 bean->Add("DEVICETYPE", streamChangeInfo.audioCapturerChangeInfo.inputDeviceInfo.deviceType_);
1530 bean->Add("BT_TYPE", streamChangeInfo.audioCapturerChangeInfo.inputDeviceInfo.deviceCategory_);
1531 bean->Add("PIPE_TYPE", streamChangeInfo.audioCapturerChangeInfo.capturerInfo.pipeType);
1532 bean->Add("STREAM_TYPE", streamChangeInfo.audioCapturerChangeInfo.capturerInfo.sourceType);
1533 bean->Add("SAMPLE_RATE", streamChangeInfo.audioCapturerChangeInfo.capturerInfo.samplingRate);
1534 bean->Add("MUTED", streamChangeInfo.audioCapturerChangeInfo.muted);
1535 bean->Add("NETWORKID", ConvertNetworkId(streamChangeInfo.audioCapturerChangeInfo.inputDeviceInfo.networkId_));
1536 bean->Add("ENCODING_TYPE", streamChangeInfo.audioCapturerChangeInfo.capturerInfo.encodingType);
1537 bean->Add("CHANNEL_LAYOUT", streamChangeInfo.audioCapturerChangeInfo.capturerInfo.channelLayout);
1538 bean->Add("EFFECT_CHAIN", effectChainType);
1539 Media::MediaMonitor::MediaMonitorManager::GetInstance().WriteLogMsg(bean);
1540 }
1541
1542
WriteRenderStreamReleaseSysEvent(const std::shared_ptr<AudioRendererChangeInfo> & audioRendererChangeInfo)1543 void AudioStreamCollector::WriteRenderStreamReleaseSysEvent(
1544 const std::shared_ptr<AudioRendererChangeInfo> &audioRendererChangeInfo)
1545 {
1546 AudioStreamType streamType = GetVolumeTypeFromContentUsage(audioRendererChangeInfo->rendererInfo.contentType,
1547 audioRendererChangeInfo->rendererInfo.streamUsage);
1548 uint64_t transactionId = audioAbilityMgr_->GetTransactionId(
1549 audioRendererChangeInfo->outputDeviceInfo.deviceType_, OUTPUT_DEVICE);
1550
1551 uint8_t effectChainType = EFFECT_CHAIN_TYPE_MAP.count(
1552 audioRendererChangeInfo->rendererInfo.sceneType) ?
1553 EFFECT_CHAIN_TYPE_MAP.at(audioRendererChangeInfo->rendererInfo.sceneType) :
1554 EFFECT_CHAIN_TYPE_MAP.at("UNKNOWN");
1555
1556 std::shared_ptr<Media::MediaMonitor::EventBean> bean = std::make_shared<Media::MediaMonitor::EventBean>(
1557 Media::MediaMonitor::AUDIO, Media::MediaMonitor::STREAM_CHANGE,
1558 Media::MediaMonitor::BEHAVIOR_EVENT);
1559 bean->Add("ISOUTPUT", 1);
1560 bean->Add("STREAMID", audioRendererChangeInfo->sessionId);
1561 bean->Add("UID", audioRendererChangeInfo->clientUID);
1562 bean->Add("PID", audioRendererChangeInfo->clientPid);
1563 bean->Add("TRANSACTIONID", transactionId);
1564 bean->Add("STREAMTYPE", streamType);
1565 bean->Add("STATE", audioRendererChangeInfo->rendererState);
1566 bean->Add("DEVICETYPE", audioRendererChangeInfo->outputDeviceInfo.deviceType_);
1567 bean->Add("BT_TYPE", audioRendererChangeInfo->outputDeviceInfo.deviceCategory_);
1568 bean->Add("PIPE_TYPE", audioRendererChangeInfo->rendererInfo.pipeType);
1569 bean->Add("STREAM_TYPE", audioRendererChangeInfo->rendererInfo.streamUsage);
1570 bean->Add("SAMPLE_RATE", audioRendererChangeInfo->rendererInfo.samplingRate);
1571 bean->Add("NETWORKID", ConvertNetworkId(audioRendererChangeInfo->outputDeviceInfo.networkId_));
1572 bean->Add("ENCODING_TYPE", audioRendererChangeInfo->rendererInfo.encodingType);
1573 bean->Add("CHANNEL_LAYOUT", audioRendererChangeInfo->rendererInfo.channelLayout);
1574 bean->Add("EFFECT_CHAIN", effectChainType);
1575 Media::MediaMonitor::MediaMonitorManager::GetInstance().WriteLogMsg(bean);
1576 }
1577
WriteCaptureStreamReleaseSysEvent(const std::shared_ptr<AudioCapturerChangeInfo> & audioCapturerChangeInfo)1578 void AudioStreamCollector::WriteCaptureStreamReleaseSysEvent(
1579 const std::shared_ptr<AudioCapturerChangeInfo> &audioCapturerChangeInfo)
1580 {
1581 AudioStreamType streamType = GetStreamTypeFromSourceType(audioCapturerChangeInfo->capturerInfo.sourceType);
1582 uint64_t transactionId = audioAbilityMgr_->GetTransactionId(
1583 audioCapturerChangeInfo->inputDeviceInfo.deviceType_, INPUT_DEVICE);
1584
1585 uint8_t effectChainType = EFFECT_CHAIN_TYPE_MAP.count(
1586 audioCapturerChangeInfo->capturerInfo.sceneType) ?
1587 EFFECT_CHAIN_TYPE_MAP.at(audioCapturerChangeInfo->capturerInfo.sceneType) :
1588 EFFECT_CHAIN_TYPE_MAP.at("UNKNOWN");
1589
1590 std::shared_ptr<Media::MediaMonitor::EventBean> bean = std::make_shared<Media::MediaMonitor::EventBean>(
1591 Media::MediaMonitor::AUDIO, Media::MediaMonitor::STREAM_CHANGE,
1592 Media::MediaMonitor::BEHAVIOR_EVENT);
1593 bean->Add("ISOUTPUT", 1);
1594 bean->Add("STREAMID", audioCapturerChangeInfo->sessionId);
1595 bean->Add("UID", audioCapturerChangeInfo->clientUID);
1596 bean->Add("PID", audioCapturerChangeInfo->clientPid);
1597 bean->Add("TRANSACTIONID", transactionId);
1598 bean->Add("STREAMTYPE", streamType);
1599 bean->Add("STATE", audioCapturerChangeInfo->capturerState);
1600 bean->Add("DEVICETYPE", audioCapturerChangeInfo->inputDeviceInfo.deviceType_);
1601 bean->Add("BT_TYPE", audioCapturerChangeInfo->inputDeviceInfo.deviceCategory_);
1602 bean->Add("PIPE_TYPE", audioCapturerChangeInfo->capturerInfo.pipeType);
1603 bean->Add("STREAM_TYPE", audioCapturerChangeInfo->capturerInfo.sourceType);
1604 bean->Add("SAMPLE_RATE", audioCapturerChangeInfo->capturerInfo.samplingRate);
1605 bean->Add("MUTED", audioCapturerChangeInfo->muted);
1606 bean->Add("NETWORKID", ConvertNetworkId(audioCapturerChangeInfo->inputDeviceInfo.networkId_));
1607 bean->Add("ENCODING_TYPE", audioCapturerChangeInfo->capturerInfo.encodingType);
1608 bean->Add("CHANNEL_LAYOUT", audioCapturerChangeInfo->capturerInfo.channelLayout);
1609 bean->Add("EFFECT_CHAIN", effectChainType);
1610 Media::MediaMonitor::MediaMonitorManager::GetInstance().WriteLogMsg(bean);
1611 }
1612
IsCallStreamUsage(StreamUsage usage)1613 bool AudioStreamCollector::IsCallStreamUsage(StreamUsage usage)
1614 {
1615 if (usage == STREAM_USAGE_VOICE_COMMUNICATION || usage == STREAM_USAGE_VIDEO_COMMUNICATION ||
1616 usage == STREAM_USAGE_VOICE_MODEM_COMMUNICATION) {
1617 return true;
1618 }
1619 return false;
1620 }
1621
GetRunningStreamUsageNoUltrasonic()1622 StreamUsage AudioStreamCollector::GetRunningStreamUsageNoUltrasonic()
1623 {
1624 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1625 for (const auto &changeInfo : audioRendererChangeInfos_) {
1626 if (changeInfo->rendererState == RENDERER_RUNNING &&
1627 changeInfo->rendererInfo.streamUsage != STREAM_USAGE_ULTRASONIC) {
1628 return changeInfo->rendererInfo.streamUsage;
1629 }
1630 }
1631 return STREAM_USAGE_INVALID;
1632 }
1633
GetRunningSourceTypeNoUltrasonic()1634 SourceType AudioStreamCollector::GetRunningSourceTypeNoUltrasonic()
1635 {
1636 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1637 for (const auto &changeInfo : audioCapturerChangeInfos_) {
1638 if (changeInfo->capturerState == CAPTURER_RUNNING &&
1639 changeInfo->capturerInfo.sourceType != SOURCE_TYPE_ULTRASONIC) {
1640 return changeInfo->capturerInfo.sourceType;
1641 }
1642 }
1643 return SOURCE_TYPE_INVALID;
1644 }
1645
GetLastestRunningCallStreamUsage()1646 StreamUsage AudioStreamCollector::GetLastestRunningCallStreamUsage()
1647 {
1648 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1649 for (const auto &changeInfo : audioRendererChangeInfos_) {
1650 StreamUsage usage = changeInfo->rendererInfo.streamUsage;
1651 RendererState state = changeInfo->rendererState;
1652 if ((IsCallStreamUsage(usage) && state == RENDERER_RUNNING) ||
1653 (usage == STREAM_USAGE_VOICE_MODEM_COMMUNICATION && state == RENDERER_PREPARED)) {
1654 return usage;
1655 }
1656 }
1657 return STREAM_USAGE_UNKNOWN;
1658 }
1659
GetAllRendererSessionIDForUID(int32_t uid)1660 std::vector<uint32_t> AudioStreamCollector::GetAllRendererSessionIDForUID(int32_t uid)
1661 {
1662 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1663 std::vector<uint32_t> sessionIDSet;
1664 for (const auto &changeInfo : audioRendererChangeInfos_) {
1665 if (changeInfo->clientUID == uid) {
1666 sessionIDSet.push_back(changeInfo->sessionId);
1667 }
1668 }
1669 return sessionIDSet;
1670 }
1671
GetAllCapturerSessionIDForUID(int32_t uid)1672 std::vector<uint32_t> AudioStreamCollector::GetAllCapturerSessionIDForUID(int32_t uid)
1673 {
1674 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1675 std::vector<uint32_t> sessionIDSet;
1676 for (const auto &changeInfo : audioCapturerChangeInfos_) {
1677 if (changeInfo->clientUID == uid) {
1678 sessionIDSet.push_back(changeInfo->sessionId);
1679 }
1680 }
1681 return sessionIDSet;
1682 }
1683
ChangeVoipCapturerStreamToNormal()1684 bool AudioStreamCollector::ChangeVoipCapturerStreamToNormal()
1685 {
1686 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1687 int count = std::count_if(audioCapturerChangeInfos_.begin(), audioCapturerChangeInfos_.end(),
1688 [](const auto &changeInfo) {
1689 const auto &sourceType = changeInfo->capturerInfo.sourceType;
1690 return sourceType == SOURCE_TYPE_VOICE_COMMUNICATION || sourceType == SOURCE_TYPE_MIC ||
1691 sourceType == SOURCE_TYPE_VOICE_MESSAGE || sourceType == SOURCE_TYPE_VOICE_TRANSCRIPTION;
1692 });
1693
1694 AUDIO_INFO_LOG("Has capture stream count: %{public}d", count);
1695 // becasue self has been added
1696 return count > 1;
1697 }
1698
HasVoipRendererStream(bool isFirstCreate)1699 bool AudioStreamCollector::HasVoipRendererStream(bool isFirstCreate)
1700 {
1701 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1702 // judge stream original flage is AUDIO_FLAG_VOIP_FAST
1703 int count = std::count_if(audioRendererChangeInfos_.begin(), audioRendererChangeInfos_.end(),
1704 [](const auto &changeInfo) {
1705 return changeInfo->rendererInfo.originalFlag == AUDIO_FLAG_VOIP_FAST;
1706 });
1707
1708 AUDIO_INFO_LOG("Has Fast Voip stream count : %{public}d", count);
1709 return isFirstCreate ? count > 0 : count > 1;
1710 }
1711
HasRunningRendererStream()1712 bool AudioStreamCollector::HasRunningRendererStream()
1713 {
1714 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1715 // judge stream state is running
1716 bool hasRunningRendererStream = std::any_of(audioRendererChangeInfos_.begin(), audioRendererChangeInfos_.end(),
1717 [](const auto &changeInfo) {
1718 return ((changeInfo->rendererState == RENDERER_RUNNING) || (changeInfo->rendererInfo.streamUsage ==
1719 STREAM_USAGE_VOICE_MODEM_COMMUNICATION && changeInfo->rendererState == RENDERER_PREPARED));
1720 });
1721 AUDIO_INFO_LOG("Has Running Renderer stream : %{public}d", hasRunningRendererStream);
1722 return hasRunningRendererStream;
1723 }
1724
HasRunningRecognitionCapturerStream()1725 bool AudioStreamCollector::HasRunningRecognitionCapturerStream()
1726 {
1727 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1728 // judge stream state is running
1729 bool hasRunningRecognitionCapturerStream = std::any_of(audioCapturerChangeInfos_.begin(),
1730 audioCapturerChangeInfos_.end(),
1731 [](const auto &changeInfo) {
1732 return ((changeInfo->capturerState == CAPTURER_RUNNING) &&
1733 (changeInfo->capturerInfo.sourceType == SOURCE_TYPE_VOICE_RECOGNITION ||
1734 changeInfo->capturerInfo.sourceType == SOURCE_TYPE_VOICE_TRANSCRIPTION));
1735 });
1736
1737 AUDIO_INFO_LOG("Has Running Recognition stream : %{public}d", hasRunningRecognitionCapturerStream);
1738 return hasRunningRecognitionCapturerStream;
1739 }
1740
HasRunningNormalCapturerStream(DeviceType type)1741 bool AudioStreamCollector::HasRunningNormalCapturerStream(DeviceType type)
1742 {
1743 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1744 // judge stream state is running
1745 bool hasStream = std::any_of(audioCapturerChangeInfos_.begin(), audioCapturerChangeInfos_.end(),
1746 [type](const auto &changeInfo) {
1747 if ((changeInfo->capturerState == CAPTURER_RUNNING) &&
1748 ((changeInfo->capturerInfo.sourceType == SOURCE_TYPE_MIC) ||
1749 (changeInfo->capturerInfo.sourceType == SOURCE_TYPE_WAKEUP) ||
1750 (changeInfo->capturerInfo.sourceType == SOURCE_TYPE_VOICE_MESSAGE) ||
1751 (changeInfo->capturerInfo.sourceType == SOURCE_TYPE_CAMCORDER) ||
1752 (changeInfo->capturerInfo.sourceType == SOURCE_TYPE_UNPROCESSED)) &&
1753 ((type == DEVICE_TYPE_NONE) || (changeInfo->inputDeviceInfo.deviceType_ == type))) {
1754 AUDIO_INFO_LOG("Running Normal Capturer stream : %{public}d with device %{public}d",
1755 changeInfo->sessionId, type);
1756 return true;
1757 }
1758 return false;
1759 });
1760
1761 return hasStream;
1762 }
1763
1764 // Check if media is currently playing
IsMediaPlaying()1765 bool AudioStreamCollector::IsMediaPlaying()
1766 {
1767 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1768 for (auto &changeInfo: audioRendererChangeInfos_) {
1769 if (changeInfo->rendererState != RENDERER_RUNNING) {
1770 continue;
1771 }
1772 AudioStreamType streamType = GetStreamType((changeInfo->rendererInfo).contentType,
1773 (changeInfo->rendererInfo).streamUsage);
1774 switch (streamType) {
1775 case STREAM_MUSIC:
1776 case STREAM_MEDIA:
1777 case STREAM_MOVIE:
1778 case STREAM_GAME:
1779 case STREAM_SPEECH:
1780 case STREAM_NAVIGATION:
1781 case STREAM_CAMCORDER:
1782 case STREAM_VOICE_MESSAGE:
1783 return true;
1784 default:
1785 break;
1786 }
1787 }
1788 return false;
1789 }
1790
IsVoipStreamActive()1791 bool AudioStreamCollector::IsVoipStreamActive()
1792 {
1793 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1794 for (auto &changeInfo: audioRendererChangeInfos_) {
1795 if (changeInfo != nullptr &&
1796 ((changeInfo->rendererInfo).streamUsage == STREAM_USAGE_VOICE_COMMUNICATION ||
1797 (changeInfo->rendererInfo).streamUsage == STREAM_USAGE_VIDEO_COMMUNICATION) &&
1798 changeInfo->rendererState == RENDERER_RUNNING) {
1799 return true;
1800 }
1801 }
1802 return false;
1803 }
1804 } // namespace AudioStandard
1805 } // namespace OHOS
1806