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_proxy.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
39 const map<pair<ContentType, StreamUsage>, AudioStreamType> AudioStreamCollector::streamTypeMap_ =
40 AudioStreamCollector::CreateStreamMap();
41 const std::unordered_map<std::string, uint8_t> EFFECT_CHAIN_TYPE_MAP {
42 {"UNKNOWN", 0},
43 {"NONE", 1},
44 {"SCENE_OTHERS", 2},
45 {"SCENE_MUSIC", 3},
46 {"SCENE_MOVIE", 4},
47 {"SCENE_GAME", 5},
48 {"SCENE_SPEECH", 6},
49 {"SCENE_RING", 7},
50 {"SCENE_VOIP_DOWN", 8}
51 };
52
CreateStreamMap()53 map<pair<ContentType, StreamUsage>, AudioStreamType> AudioStreamCollector::CreateStreamMap()
54 {
55 map<pair<ContentType, StreamUsage>, AudioStreamType> streamMap;
56 // Mapping relationships from content and usage to stream type in design
57 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_UNKNOWN)] = STREAM_MUSIC;
58 streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_VOICE_COMMUNICATION)] = STREAM_VOICE_COMMUNICATION;
59 streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_VIDEO_COMMUNICATION)] = STREAM_VOICE_COMMUNICATION;
60 streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_VOICE_MODEM_COMMUNICATION)] = STREAM_VOICE_CALL;
61 streamMap[make_pair(CONTENT_TYPE_PROMPT, STREAM_USAGE_SYSTEM)] = STREAM_SYSTEM;
62 streamMap[make_pair(CONTENT_TYPE_MUSIC, STREAM_USAGE_NOTIFICATION_RINGTONE)] = STREAM_RING;
63 streamMap[make_pair(CONTENT_TYPE_MUSIC, STREAM_USAGE_MEDIA)] = STREAM_MUSIC;
64 streamMap[make_pair(CONTENT_TYPE_MOVIE, STREAM_USAGE_MEDIA)] = STREAM_MOVIE;
65 streamMap[make_pair(CONTENT_TYPE_GAME, STREAM_USAGE_MEDIA)] = STREAM_GAME;
66 streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_MEDIA)] = STREAM_SPEECH;
67 streamMap[make_pair(CONTENT_TYPE_MUSIC, STREAM_USAGE_ALARM)] = STREAM_ALARM;
68 streamMap[make_pair(CONTENT_TYPE_PROMPT, STREAM_USAGE_NOTIFICATION)] = STREAM_NOTIFICATION;
69 streamMap[make_pair(CONTENT_TYPE_PROMPT, STREAM_USAGE_ENFORCED_TONE)] = STREAM_SYSTEM_ENFORCED;
70 streamMap[make_pair(CONTENT_TYPE_DTMF, STREAM_USAGE_VOICE_COMMUNICATION)] = STREAM_DTMF;
71 streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_VOICE_ASSISTANT)] = STREAM_VOICE_ASSISTANT;
72 streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_ACCESSIBILITY)] = STREAM_ACCESSIBILITY;
73 streamMap[make_pair(CONTENT_TYPE_ULTRASONIC, STREAM_USAGE_SYSTEM)] = STREAM_ULTRASONIC;
74
75 // Old mapping relationships from content and usage to stream type
76 streamMap[make_pair(CONTENT_TYPE_MUSIC, STREAM_USAGE_VOICE_ASSISTANT)] = STREAM_VOICE_ASSISTANT;
77 streamMap[make_pair(CONTENT_TYPE_SONIFICATION, STREAM_USAGE_UNKNOWN)] = STREAM_NOTIFICATION;
78 streamMap[make_pair(CONTENT_TYPE_SONIFICATION, STREAM_USAGE_MEDIA)] = STREAM_NOTIFICATION;
79 streamMap[make_pair(CONTENT_TYPE_SONIFICATION, STREAM_USAGE_NOTIFICATION_RINGTONE)] = STREAM_RING;
80 streamMap[make_pair(CONTENT_TYPE_RINGTONE, STREAM_USAGE_UNKNOWN)] = STREAM_RING;
81 streamMap[make_pair(CONTENT_TYPE_RINGTONE, STREAM_USAGE_MEDIA)] = STREAM_RING;
82 streamMap[make_pair(CONTENT_TYPE_RINGTONE, STREAM_USAGE_NOTIFICATION_RINGTONE)] = STREAM_RING;
83
84 // Only use stream usage to choose stream type
85 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_MEDIA)] = STREAM_MUSIC;
86 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_MUSIC)] = STREAM_MUSIC;
87 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VOICE_COMMUNICATION)] = STREAM_VOICE_COMMUNICATION;
88 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VIDEO_COMMUNICATION)] = STREAM_VOICE_COMMUNICATION;
89 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VOICE_MODEM_COMMUNICATION)] = STREAM_VOICE_CALL;
90 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VOICE_ASSISTANT)] = STREAM_VOICE_ASSISTANT;
91 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_ALARM)] = STREAM_ALARM;
92 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VOICE_MESSAGE)] = STREAM_VOICE_MESSAGE;
93 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_NOTIFICATION_RINGTONE)] = STREAM_RING;
94 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_RINGTONE)] = STREAM_RING;
95 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_NOTIFICATION)] = STREAM_NOTIFICATION;
96 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_ACCESSIBILITY)] = STREAM_ACCESSIBILITY;
97 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_SYSTEM)] = STREAM_SYSTEM;
98 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_MOVIE)] = STREAM_MOVIE;
99 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_GAME)] = STREAM_GAME;
100 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_AUDIOBOOK)] = STREAM_SPEECH;
101 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_NAVIGATION)] = STREAM_NAVIGATION;
102 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_DTMF)] = STREAM_DTMF;
103 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_ENFORCED_TONE)] = STREAM_SYSTEM_ENFORCED;
104 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_ULTRASONIC)] = STREAM_ULTRASONIC;
105 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VOICE_RINGTONE)] = STREAM_VOICE_RING;
106 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VOICE_CALL_ASSISTANT)] = STREAM_VOICE_CALL_ASSISTANT;
107
108 return streamMap;
109 }
110
AudioStreamCollector()111 AudioStreamCollector::AudioStreamCollector() : audioAbilityMgr_
112 (AudioAbilityManager::GetInstance())
113 {
114 audioPolicyServerHandler_ = DelayedSingleton<AudioPolicyServerHandler>::GetInstance();
115 audioConcurrencyService_ = std::make_shared<AudioConcurrencyService>();
116 audioPolicyServerHandler_->AddConcurrencyEventDispatcher(audioConcurrencyService_);
117 audioConcurrencyService_->Init();
118 audioConcurrencyService_->SetCallbackHandler(audioPolicyServerHandler_);
119 AUDIO_INFO_LOG("AudioStreamCollector()");
120 }
121
~AudioStreamCollector()122 AudioStreamCollector::~AudioStreamCollector()
123 {
124 AUDIO_INFO_LOG("~AudioStreamCollector()");
125 }
126
AddRendererStream(AudioStreamChangeInfo & streamChangeInfo)127 int32_t AudioStreamCollector::AddRendererStream(AudioStreamChangeInfo &streamChangeInfo)
128 {
129 AUDIO_INFO_LOG("Add playback client uid %{public}d sessionId %{public}d",
130 streamChangeInfo.audioRendererChangeInfo.clientUID, streamChangeInfo.audioRendererChangeInfo.sessionId);
131
132 rendererStatequeue_.insert({{streamChangeInfo.audioRendererChangeInfo.clientUID,
133 streamChangeInfo.audioRendererChangeInfo.sessionId},
134 streamChangeInfo.audioRendererChangeInfo.rendererState});
135
136 shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
137 if (!rendererChangeInfo) {
138 AUDIO_ERR_LOG("AddRendererStream Memory Allocation Failed");
139 return ERR_MEMORY_ALLOC_FAILED;
140 }
141 rendererChangeInfo->createrUID = streamChangeInfo.audioRendererChangeInfo.createrUID;
142 rendererChangeInfo->clientUID = streamChangeInfo.audioRendererChangeInfo.clientUID;
143 rendererChangeInfo->sessionId = streamChangeInfo.audioRendererChangeInfo.sessionId;
144 rendererChangeInfo->callerPid = streamChangeInfo.audioRendererChangeInfo.callerPid;
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
UpdateCapturerStream(AudioStreamChangeInfo & streamChangeInfo)506 int32_t AudioStreamCollector::UpdateCapturerStream(AudioStreamChangeInfo &streamChangeInfo)
507 {
508 AUDIO_INFO_LOG("UpdateCapturerStream client %{public}d state %{public}d session %{public}d",
509 streamChangeInfo.audioCapturerChangeInfo.clientUID, streamChangeInfo.audioCapturerChangeInfo.capturerState,
510 streamChangeInfo.audioCapturerChangeInfo.sessionId);
511
512 if (capturerStatequeue_.find(make_pair(streamChangeInfo.audioCapturerChangeInfo.clientUID,
513 streamChangeInfo.audioCapturerChangeInfo.sessionId)) != capturerStatequeue_.end()) {
514 if (streamChangeInfo.audioCapturerChangeInfo.capturerState ==
515 capturerStatequeue_[make_pair(streamChangeInfo.audioCapturerChangeInfo.clientUID,
516 streamChangeInfo.audioCapturerChangeInfo.sessionId)]) {
517 // Capturer state not changed
518 return SUCCESS;
519 }
520 }
521
522 // Update the capturer info in audioCapturerChangeInfos_
523 for (auto it = audioCapturerChangeInfos_.begin(); it != audioCapturerChangeInfos_.end(); it++) {
524 AudioCapturerChangeInfo audioCapturerChangeInfo = **it;
525 if (audioCapturerChangeInfo.clientUID == streamChangeInfo.audioCapturerChangeInfo.clientUID &&
526 audioCapturerChangeInfo.sessionId == streamChangeInfo.audioCapturerChangeInfo.sessionId) {
527 capturerStatequeue_[make_pair(audioCapturerChangeInfo.clientUID, audioCapturerChangeInfo.sessionId)] =
528 streamChangeInfo.audioCapturerChangeInfo.capturerState;
529
530 AUDIO_DEBUG_LOG("Session is updated for client %{public}d session %{public}d",
531 streamChangeInfo.audioCapturerChangeInfo.clientUID,
532 streamChangeInfo.audioCapturerChangeInfo.sessionId);
533
534 shared_ptr<AudioCapturerChangeInfo> capturerChangeInfo = make_shared<AudioCapturerChangeInfo>();
535 CHECK_AND_RETURN_RET_LOG(capturerChangeInfo != nullptr,
536 ERR_MEMORY_ALLOC_FAILED, "CapturerChangeInfo Memory Allocation Failed");
537 SetCapturerStreamParam(streamChangeInfo, capturerChangeInfo);
538 if (capturerChangeInfo->inputDeviceInfo.deviceType_ == DEVICE_TYPE_INVALID) {
539 streamChangeInfo.audioCapturerChangeInfo.inputDeviceInfo = (*it)->inputDeviceInfo;
540 capturerChangeInfo->inputDeviceInfo = (*it)->inputDeviceInfo;
541 }
542 capturerChangeInfo->appTokenId = (*it)->appTokenId;
543 *it = move(capturerChangeInfo);
544 if (audioPolicyServerHandler_ != nullptr) {
545 SendCapturerInfoEvent(audioCapturerChangeInfos_);
546 }
547 if (streamChangeInfo.audioCapturerChangeInfo.capturerState == CAPTURER_RELEASED) {
548 audioCapturerChangeInfos_.erase(it);
549 capturerStatequeue_.erase(make_pair(audioCapturerChangeInfo.clientUID,
550 audioCapturerChangeInfo.sessionId));
551 clientTracker_.erase(audioCapturerChangeInfo.sessionId);
552 }
553 return SUCCESS;
554 }
555 }
556 AUDIO_DEBUG_LOG("UpdateCapturerStream: clientUI not in audioCapturerChangeInfos_::%{public}d",
557 streamChangeInfo.audioCapturerChangeInfo.clientUID);
558 return SUCCESS;
559 }
560
UpdateRendererDeviceInfo(AudioDeviceDescriptor & outputDeviceInfo)561 int32_t AudioStreamCollector::UpdateRendererDeviceInfo(AudioDeviceDescriptor &outputDeviceInfo)
562 {
563 bool deviceInfoUpdated = false;
564
565 for (auto it = audioRendererChangeInfos_.begin(); it != audioRendererChangeInfos_.end(); it++) {
566 if (!(*it)->outputDeviceInfo.IsSameDeviceInfo(outputDeviceInfo)) {
567 AUDIO_DEBUG_LOG("UpdateRendererDeviceInfo: old device: %{public}d new device: %{public}d",
568 (*it)->outputDeviceInfo.deviceType_, outputDeviceInfo.deviceType_);
569 (*it)->outputDeviceInfo = outputDeviceInfo;
570 deviceInfoUpdated = true;
571 }
572 }
573
574 if (deviceInfoUpdated && audioPolicyServerHandler_ != nullptr) {
575 audioPolicyServerHandler_->SendRendererInfoEvent(audioRendererChangeInfos_);
576 }
577 if (deviceInfoUpdated) {
578 AudioSpatializationService::GetAudioSpatializationService().UpdateRendererInfo(audioRendererChangeInfos_);
579 }
580
581 return SUCCESS;
582 }
583
UpdateCapturerDeviceInfo(AudioDeviceDescriptor & inputDeviceInfo)584 int32_t AudioStreamCollector::UpdateCapturerDeviceInfo(AudioDeviceDescriptor &inputDeviceInfo)
585 {
586 bool deviceInfoUpdated = false;
587
588 for (auto it = audioCapturerChangeInfos_.begin(); it != audioCapturerChangeInfos_.end(); it++) {
589 if (!(*it)->inputDeviceInfo.IsSameDeviceInfo(inputDeviceInfo)) {
590 AUDIO_DEBUG_LOG("UpdateCapturerDeviceInfo: old device: %{public}d new device: %{public}d",
591 (*it)->inputDeviceInfo.deviceType_, inputDeviceInfo.deviceType_);
592 (*it)->inputDeviceInfo = inputDeviceInfo;
593 deviceInfoUpdated = true;
594 }
595 }
596
597 if (deviceInfoUpdated && audioPolicyServerHandler_ != nullptr) {
598 SendCapturerInfoEvent(audioCapturerChangeInfos_);
599 }
600
601 return SUCCESS;
602 }
603
UpdateRendererDeviceInfo(int32_t clientUID,int32_t sessionId,AudioDeviceDescriptor & outputDeviceInfo)604 int32_t AudioStreamCollector::UpdateRendererDeviceInfo(int32_t clientUID, int32_t sessionId,
605 AudioDeviceDescriptor &outputDeviceInfo)
606 {
607 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
608 bool deviceInfoUpdated = false;
609
610 for (auto it = audioRendererChangeInfos_.begin(); it != audioRendererChangeInfos_.end(); it++) {
611 if ((*it)->clientUID == clientUID && (*it)->sessionId == sessionId &&
612 !(*it)->outputDeviceInfo.IsSameDeviceInfo(outputDeviceInfo)) {
613 AUDIO_DEBUG_LOG("uid %{public}d sessionId %{public}d update device: old %{public}d, new %{public}d",
614 clientUID, sessionId, (*it)->outputDeviceInfo.deviceType_, outputDeviceInfo.deviceType_);
615 (*it)->outputDeviceInfo = outputDeviceInfo;
616 deviceInfoUpdated = true;
617 }
618 }
619
620 if (deviceInfoUpdated && audioPolicyServerHandler_ != nullptr) {
621 audioPolicyServerHandler_->SendRendererInfoEvent(audioRendererChangeInfos_);
622 }
623 if (deviceInfoUpdated) {
624 AudioSpatializationService::GetAudioSpatializationService().UpdateRendererInfo(audioRendererChangeInfos_);
625 }
626 return SUCCESS;
627 }
628
UpdateRendererPipeInfo(const int32_t sessionId,const AudioPipeType pipeType)629 int32_t AudioStreamCollector::UpdateRendererPipeInfo(const int32_t sessionId, const AudioPipeType pipeType)
630 {
631 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
632 bool pipeTypeUpdated = false;
633
634 for (auto it = audioRendererChangeInfos_.begin(); it != audioRendererChangeInfos_.end(); it++) {
635 if ((*it)->sessionId == sessionId && (*it)->rendererInfo.pipeType != pipeType) {
636 AUDIO_INFO_LOG("sessionId %{public}d update pipeType: old %{public}d, new %{public}d",
637 sessionId, (*it)->rendererInfo.pipeType, pipeType);
638 (*it)->rendererInfo.pipeType = pipeType;
639 pipeTypeUpdated = true;
640 }
641 }
642
643 if (pipeTypeUpdated && audioPolicyServerHandler_ != nullptr) {
644 audioPolicyServerHandler_->SendRendererInfoEvent(audioRendererChangeInfos_);
645 }
646 if (pipeTypeUpdated) {
647 AudioSpatializationService::GetAudioSpatializationService().UpdateRendererInfo(audioRendererChangeInfos_);
648 }
649 return SUCCESS;
650 }
651
UpdateCapturerDeviceInfo(int32_t clientUID,int32_t sessionId,AudioDeviceDescriptor & inputDeviceInfo)652 int32_t AudioStreamCollector::UpdateCapturerDeviceInfo(int32_t clientUID, int32_t sessionId,
653 AudioDeviceDescriptor &inputDeviceInfo)
654 {
655 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
656 bool deviceInfoUpdated = false;
657
658 for (auto it = audioCapturerChangeInfos_.begin(); it != audioCapturerChangeInfos_.end(); it++) {
659 if ((*it)->clientUID == clientUID && (*it)->sessionId == sessionId &&
660 !(*it)->inputDeviceInfo.IsSameDeviceInfo(inputDeviceInfo)) {
661 AUDIO_DEBUG_LOG("uid %{public}d sessionId %{public}d update device: old %{public}d, new %{public}d",
662 (*it)->clientUID, (*it)->sessionId, (*it)->inputDeviceInfo.deviceType_, inputDeviceInfo.deviceType_);
663 (*it)->inputDeviceInfo = inputDeviceInfo;
664 deviceInfoUpdated = true;
665 }
666 }
667
668 if (deviceInfoUpdated && audioPolicyServerHandler_ != nullptr) {
669 SendCapturerInfoEvent(audioCapturerChangeInfos_);
670 }
671
672 return SUCCESS;
673 }
674
UpdateTracker(const AudioMode & mode,AudioDeviceDescriptor & deviceInfo)675 int32_t AudioStreamCollector::UpdateTracker(const AudioMode &mode, AudioDeviceDescriptor &deviceInfo)
676 {
677 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
678 if (mode == AUDIO_MODE_PLAYBACK) {
679 UpdateRendererDeviceInfo(deviceInfo);
680 } else {
681 UpdateCapturerDeviceInfo(deviceInfo);
682 }
683
684 return SUCCESS;
685 }
686
UpdateAppVolume(int32_t appUid,int32_t volume)687 void AudioStreamCollector::UpdateAppVolume(int32_t appUid, int32_t volume)
688 {
689 for (auto itemInfo : audioRendererChangeInfos_) {
690 if (itemInfo->clientUID != appUid) {
691 continue;
692 }
693 itemInfo->appVolume = volume;
694 AUDIO_INFO_LOG("UpdateAppVolume success, appuid = %{public}d, volume = %{public}d", appUid, volume);
695 }
696 }
697
UpdateTracker(AudioMode & mode,AudioStreamChangeInfo & streamChangeInfo)698 int32_t AudioStreamCollector::UpdateTracker(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo)
699 {
700 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
701 // update the stream change info
702 if (mode == AUDIO_MODE_PLAYBACK) {
703 UpdateRendererStream(streamChangeInfo);
704 } else {
705 // mode = AUDIO_MODE_RECORD
706 UpdateCapturerStream(streamChangeInfo);
707 }
708 WriterStreamChangeSysEvent(mode, streamChangeInfo);
709 return SUCCESS;
710 }
711
UpdateTrackerInternal(AudioMode & mode,AudioStreamChangeInfo & streamChangeInfo)712 int32_t AudioStreamCollector::UpdateTrackerInternal(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo)
713 {
714 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
715 // update the stream change internal info
716 if (mode == AUDIO_MODE_PLAYBACK) {
717 return UpdateRendererStreamInternal(streamChangeInfo);
718 }
719 return SUCCESS;
720 }
721
GetStreamType(ContentType contentType,StreamUsage streamUsage)722 AudioStreamType AudioStreamCollector::GetStreamType(ContentType contentType, StreamUsage streamUsage)
723 {
724 AudioStreamType streamType = STREAM_MUSIC;
725 auto pos = streamTypeMap_.find(std::make_pair(contentType, streamUsage));
726 if (pos != streamTypeMap_.end()) {
727 streamType = pos->second;
728 }
729
730 if (streamType == STREAM_MEDIA) {
731 streamType = STREAM_MUSIC;
732 }
733
734 return streamType;
735 }
736
GetStreamType(int32_t sessionId)737 AudioStreamType AudioStreamCollector::GetStreamType(int32_t sessionId)
738 {
739 AudioStreamType streamType = STREAM_MUSIC;
740 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
741 for (const auto &changeInfo : audioRendererChangeInfos_) {
742 if (changeInfo->sessionId == sessionId) {
743 streamType = GetStreamType(changeInfo->rendererInfo.contentType, changeInfo->rendererInfo.streamUsage);
744 }
745 }
746 return streamType;
747 }
748
GetSessionIdsOnRemoteDeviceByStreamUsage(StreamUsage streamUsage)749 std::set<int32_t> AudioStreamCollector::GetSessionIdsOnRemoteDeviceByStreamUsage(StreamUsage streamUsage)
750 {
751 std::set<int32_t> sessionIdSet;
752 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
753 for (const auto &changeInfo : audioRendererChangeInfos_) {
754 if (changeInfo->rendererInfo.streamUsage == streamUsage &&
755 changeInfo->outputDeviceInfo.deviceType_ == DEVICE_TYPE_SPEAKER &&
756 changeInfo->outputDeviceInfo.networkId_ != LOCAL_NETWORK_ID) {
757 sessionIdSet.insert(changeInfo->sessionId);
758 }
759 }
760 return sessionIdSet;
761 }
762
GetSessionIdsOnRemoteDeviceBySourceType(SourceType sourceType)763 std::set<int32_t> AudioStreamCollector::GetSessionIdsOnRemoteDeviceBySourceType(SourceType sourceType)
764 {
765 std::set<int32_t> sessionIdSet;
766 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
767 for (const auto &changeInfo : audioCapturerChangeInfos_) {
768 if (changeInfo->capturerInfo.sourceType == sourceType &&
769 changeInfo->inputDeviceInfo.deviceType_ == DEVICE_TYPE_MIC &&
770 changeInfo->inputDeviceInfo.networkId_ != LOCAL_NETWORK_ID) {
771 sessionIdSet.insert(changeInfo->sessionId);
772 }
773 }
774 return sessionIdSet;
775 }
776
GetSessionIdsOnRemoteDeviceByDeviceType(DeviceType deviceType)777 std::set<int32_t> AudioStreamCollector::GetSessionIdsOnRemoteDeviceByDeviceType(DeviceType deviceType)
778 {
779 std::set<int32_t> sessionIdSet;
780 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
781 for (const auto &changeInfo : audioRendererChangeInfos_) {
782 if (changeInfo->outputDeviceInfo.deviceType_ == deviceType) {
783 sessionIdSet.insert(changeInfo->sessionId);
784 }
785 }
786 return sessionIdSet;
787 }
788
GetSessionIdsPauseOnRemoteDeviceByRemote(InterruptHint hintType)789 int32_t AudioStreamCollector::GetSessionIdsPauseOnRemoteDeviceByRemote(InterruptHint hintType)
790 {
791 int32_t sessionIdVec = -1;
792 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
793 for (const auto &changeInfo : audioRendererChangeInfos_) {
794 if (changeInfo->outputDeviceInfo.deviceType_ == DEVICE_TYPE_REMOTE_CAST &&
795 changeInfo->rendererState == RendererState::RENDERER_RUNNING) {
796 return changeInfo->sessionId;
797 }
798 }
799 return sessionIdVec;
800 }
801
IsOffloadAllowed(const int32_t sessionId)802 bool AudioStreamCollector::IsOffloadAllowed(const int32_t sessionId)
803 {
804 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
805 const auto &it = std::find_if(audioRendererChangeInfos_.begin(), audioRendererChangeInfos_.end(),
806 [&sessionId](const std::shared_ptr<AudioRendererChangeInfo> &changeInfo) {
807 return changeInfo->sessionId == sessionId;
808 });
809 if (it == audioRendererChangeInfos_.end()) {
810 AUDIO_WARNING_LOG("invalid session id: %{public}d", sessionId);
811 return false;
812 }
813 return (*it)->rendererInfo.isOffloadAllowed;
814 }
815
GetChannelCount(int32_t sessionId)816 int32_t AudioStreamCollector::GetChannelCount(int32_t sessionId)
817 {
818 int32_t channelCount = 0;
819 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
820 const auto &it = std::find_if(audioRendererChangeInfos_.begin(), audioRendererChangeInfos_.end(),
821 [&sessionId](const std::shared_ptr<AudioRendererChangeInfo> &changeInfo) {
822 return changeInfo->sessionId == sessionId;
823 });
824 if (it != audioRendererChangeInfos_.end()) {
825 channelCount = (*it)->channelCount;
826 }
827 return channelCount;
828 }
829
GetCurrentRendererChangeInfos(std::vector<shared_ptr<AudioRendererChangeInfo>> & rendererChangeInfos)830 int32_t AudioStreamCollector::GetCurrentRendererChangeInfos(
831 std::vector<shared_ptr<AudioRendererChangeInfo>> &rendererChangeInfos)
832 {
833 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
834 for (const auto &changeInfo : audioRendererChangeInfos_) {
835 rendererChangeInfos.push_back(make_shared<AudioRendererChangeInfo>(*changeInfo));
836 }
837 AUDIO_DEBUG_LOG("GetCurrentRendererChangeInfos returned");
838
839 return SUCCESS;
840 }
841
GetCurrentCapturerChangeInfos(std::vector<shared_ptr<AudioCapturerChangeInfo>> & capturerChangeInfos)842 int32_t AudioStreamCollector::GetCurrentCapturerChangeInfos(
843 std::vector<shared_ptr<AudioCapturerChangeInfo>> &capturerChangeInfos)
844 {
845 AUDIO_DEBUG_LOG("GetCurrentCapturerChangeInfos");
846 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
847 for (const auto &changeInfo : audioCapturerChangeInfos_) {
848 if (!IsTransparentCapture(changeInfo->clientUID)) {
849 capturerChangeInfos.push_back(make_shared<AudioCapturerChangeInfo>(*changeInfo));
850 } else {
851 AUDIO_INFO_LOG("GetCurrentCapturerChangeInfos remove uid:%{public}d", changeInfo->clientUID);
852 }
853 AUDIO_DEBUG_LOG("GetCurrentCapturerChangeInfos returned");
854 }
855
856 return SUCCESS;
857 }
858
RegisteredRendererTrackerClientDied(const int32_t uid)859 void AudioStreamCollector::RegisteredRendererTrackerClientDied(const int32_t uid)
860 {
861 int32_t sessionID = -1;
862 auto audioRendererBegin = audioRendererChangeInfos_.begin();
863 while (audioRendererBegin != audioRendererChangeInfos_.end()) {
864 const auto &audioRendererChangeInfo = *audioRendererBegin;
865 if (audioRendererChangeInfo == nullptr ||
866 (audioRendererChangeInfo->clientUID != uid && audioRendererChangeInfo->createrUID != uid)) {
867 audioRendererBegin++;
868 continue;
869 }
870 sessionID = audioRendererChangeInfo->sessionId;
871 audioRendererChangeInfo->rendererState = RENDERER_RELEASED;
872 WriteRenderStreamReleaseSysEvent(audioRendererChangeInfo);
873 if (audioPolicyServerHandler_ != nullptr) {
874 audioPolicyServerHandler_->SendRendererInfoEvent(audioRendererChangeInfos_);
875 }
876 AudioSpatializationService::GetAudioSpatializationService().UpdateRendererInfo(audioRendererChangeInfos_);
877 rendererStatequeue_.erase(make_pair(audioRendererChangeInfo->clientUID,
878 audioRendererChangeInfo->sessionId));
879
880 auto temp = audioRendererBegin;
881 audioRendererBegin = audioRendererChangeInfos_.erase(temp);
882 if ((sessionID != -1) && clientTracker_.erase(sessionID)) {
883 AUDIO_INFO_LOG("TrackerClientDied:client %{public}d cleared", sessionID);
884 }
885 }
886 }
887
RegisteredCapturerTrackerClientDied(const int32_t uid)888 void AudioStreamCollector::RegisteredCapturerTrackerClientDied(const int32_t uid)
889 {
890 int32_t sessionID = -1;
891 auto audioCapturerBegin = audioCapturerChangeInfos_.begin();
892 while (audioCapturerBegin != audioCapturerChangeInfos_.end()) {
893 const auto &audioCapturerChangeInfo = *audioCapturerBegin;
894 if (audioCapturerChangeInfo == nullptr ||
895 (audioCapturerChangeInfo->clientUID != uid && audioCapturerChangeInfo->createrUID != uid)) {
896 audioCapturerBegin++;
897 continue;
898 }
899 sessionID = audioCapturerChangeInfo->sessionId;
900 audioCapturerChangeInfo->capturerState = CAPTURER_RELEASED;
901 WriteCaptureStreamReleaseSysEvent(audioCapturerChangeInfo);
902 if (audioPolicyServerHandler_ != nullptr) {
903 SendCapturerInfoEvent(audioCapturerChangeInfos_);
904 }
905 capturerStatequeue_.erase(make_pair(audioCapturerChangeInfo->clientUID,
906 audioCapturerChangeInfo->sessionId));
907 auto temp = audioCapturerBegin;
908 audioCapturerBegin = audioCapturerChangeInfos_.erase(temp);
909 if ((sessionID != -1) && clientTracker_.erase(sessionID)) {
910 AUDIO_INFO_LOG("TrackerClientDied:client %{public}d cleared", sessionID);
911 }
912 }
913 }
914
RegisteredTrackerClientDied(int32_t uid)915 void AudioStreamCollector::RegisteredTrackerClientDied(int32_t uid)
916 {
917 AUDIO_INFO_LOG("TrackerClientDied:client:%{public}d Died", uid);
918
919 // Send the release state event notification for all streams of died client to registered app
920 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
921 RegisteredRendererTrackerClientDied(uid);
922 RegisteredCapturerTrackerClientDied(uid);
923 }
924
GetAndCompareStreamType(StreamUsage targetUsage,AudioRendererInfo rendererInfo)925 bool AudioStreamCollector::GetAndCompareStreamType(StreamUsage targetUsage, AudioRendererInfo rendererInfo)
926 {
927 AudioStreamType requiredType = GetStreamType(CONTENT_TYPE_UNKNOWN, targetUsage);
928 AUDIO_INFO_LOG("GetAndCompareStreamType:requiredType:%{public}d ", requiredType);
929 AudioStreamType defaultStreamType = STREAM_MUSIC;
930 auto pos = streamTypeMap_.find(make_pair(rendererInfo.contentType, rendererInfo.streamUsage));
931 if (pos != streamTypeMap_.end()) {
932 defaultStreamType = pos->second;
933 }
934 return defaultStreamType == requiredType;
935 }
936
GetUid(int32_t sessionId)937 int32_t AudioStreamCollector::GetUid(int32_t sessionId)
938 {
939 int32_t defaultUid = -1;
940 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
941 const auto &it = std::find_if(audioRendererChangeInfos_.begin(), audioRendererChangeInfos_.end(),
942 [&sessionId](const std::shared_ptr<AudioRendererChangeInfo> &changeInfo) {
943 return changeInfo->sessionId == sessionId;
944 });
945 if (it != audioRendererChangeInfos_.end()) {
946 defaultUid = (*it)->createrUID;
947 }
948 return defaultUid;
949 }
950
ResumeStreamState()951 int32_t AudioStreamCollector::ResumeStreamState()
952 {
953 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
954 for (const auto &changeInfo : audioRendererChangeInfos_) {
955 std::shared_ptr<AudioClientTracker> callback = clientTracker_[changeInfo->sessionId];
956 if (callback == nullptr) {
957 AUDIO_ERR_LOG("AVSession is not alive,UpdateStreamState callback failed sId:%{public}d",
958 changeInfo->sessionId);
959 continue;
960 }
961 StreamSetStateEventInternal setStateEvent = {};
962 setStateEvent.streamSetState = StreamSetState::STREAM_UNMUTE;
963 setStateEvent.streamUsage = changeInfo->rendererInfo.streamUsage;
964 callback->UnmuteStreamImpl(setStateEvent);
965 }
966
967 return SUCCESS;
968 }
969
UpdateStreamState(int32_t clientUid,StreamSetStateEventInternal & streamSetStateEventInternal)970 int32_t AudioStreamCollector::UpdateStreamState(int32_t clientUid,
971 StreamSetStateEventInternal &streamSetStateEventInternal)
972 {
973 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
974 for (const auto &changeInfo : audioRendererChangeInfos_) {
975 if (changeInfo->clientUID == clientUid &&
976 streamSetStateEventInternal.streamUsage == changeInfo->rendererInfo.streamUsage) {
977 AUDIO_INFO_LOG("UpdateStreamState Found matching uid=%{public}d and usage=%{public}d",
978 clientUid, streamSetStateEventInternal.streamUsage);
979 if (std::count(BACKGROUND_MUTE_STREAM_USAGE.begin(), BACKGROUND_MUTE_STREAM_USAGE.end(),
980 streamSetStateEventInternal.streamUsage) == 0) {
981 continue;
982 }
983 std::shared_ptr<AudioClientTracker> callback = clientTracker_[changeInfo->sessionId];
984 if (callback == nullptr) {
985 AUDIO_ERR_LOG("UpdateStreamState callback failed sId:%{public}d",
986 changeInfo->sessionId);
987 continue;
988 }
989 if (streamSetStateEventInternal.streamSetState == StreamSetState::STREAM_PAUSE) {
990 callback->PausedStreamImpl(streamSetStateEventInternal);
991 } else if (streamSetStateEventInternal.streamSetState == StreamSetState::STREAM_RESUME) {
992 callback->ResumeStreamImpl(streamSetStateEventInternal);
993 } else if (streamSetStateEventInternal.streamSetState == StreamSetState::STREAM_MUTE &&
994 !changeInfo->backMute) {
995 callback->MuteStreamImpl(streamSetStateEventInternal);
996 changeInfo->backMute = true;
997 } else if (streamSetStateEventInternal.streamSetState == StreamSetState::STREAM_UNMUTE &&
998 changeInfo->backMute) {
999 callback->UnmuteStreamImpl(streamSetStateEventInternal);
1000 changeInfo->backMute = false;
1001 }
1002 }
1003 }
1004
1005 return SUCCESS;
1006 }
1007
IsStreamActive(AudioStreamType volumeType)1008 bool AudioStreamCollector::IsStreamActive(AudioStreamType volumeType)
1009 {
1010 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1011 bool result = false;
1012 for (auto &changeInfo: audioRendererChangeInfos_) {
1013 if (changeInfo->rendererState != RENDERER_RUNNING) {
1014 continue;
1015 }
1016 AudioVolumeType rendererVolumeType = GetVolumeTypeFromContentUsage((changeInfo->rendererInfo).contentType,
1017 (changeInfo->rendererInfo).streamUsage);
1018 if (rendererVolumeType == volumeType) {
1019 // An active stream has been found, return true directly.
1020 AUDIO_INFO_LOG("matched clientUid: %{public}d id: %{public}d",
1021 changeInfo->clientUID, changeInfo->sessionId);
1022 return true;
1023 }
1024 }
1025 return result;
1026 }
1027
GetRunningStream(AudioStreamType certainType,int32_t certainChannelCount)1028 int32_t AudioStreamCollector::GetRunningStream(AudioStreamType certainType, int32_t certainChannelCount)
1029 {
1030 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1031 int32_t runningStream = -1;
1032 if ((certainType == STREAM_DEFAULT) && (certainChannelCount == 0)) {
1033 for (auto &changeInfo : audioRendererChangeInfos_) {
1034 if (changeInfo->rendererState == RENDERER_RUNNING) {
1035 runningStream = changeInfo->sessionId;
1036 break;
1037 }
1038 }
1039 } else if (certainChannelCount == 0) {
1040 for (auto &changeInfo : audioRendererChangeInfos_) {
1041 if ((changeInfo->rendererState == RENDERER_RUNNING) &&
1042 (certainType == GetStreamType(changeInfo->rendererInfo.contentType,
1043 changeInfo->rendererInfo.streamUsage))) {
1044 runningStream = changeInfo->sessionId;
1045 break;
1046 }
1047 }
1048 } else {
1049 for (auto &changeInfo : audioRendererChangeInfos_) {
1050 if ((changeInfo->rendererState == RENDERER_RUNNING) &&
1051 (certainType == GetStreamType(changeInfo->rendererInfo.contentType,
1052 changeInfo->rendererInfo.streamUsage)) && (certainChannelCount == changeInfo->channelCount)) {
1053 runningStream = changeInfo->sessionId;
1054 break;
1055 }
1056 }
1057 }
1058 return runningStream;
1059 }
1060
GetVolumeTypeFromContentUsage(ContentType contentType,StreamUsage streamUsage)1061 AudioStreamType AudioStreamCollector::GetVolumeTypeFromContentUsage(ContentType contentType, StreamUsage streamUsage)
1062 {
1063 AudioStreamType streamType = STREAM_MUSIC;
1064 auto pos = streamTypeMap_.find(make_pair(contentType, streamUsage));
1065 if (pos != streamTypeMap_.end()) {
1066 streamType = pos->second;
1067 }
1068 return VolumeUtils::GetVolumeTypeFromStreamType(streamType);
1069 }
1070
GetStreamTypeFromSourceType(SourceType sourceType)1071 AudioStreamType AudioStreamCollector::GetStreamTypeFromSourceType(SourceType sourceType)
1072 {
1073 switch (sourceType) {
1074 case SOURCE_TYPE_MIC:
1075 case SOURCE_TYPE_UNPROCESSED:
1076 return STREAM_MUSIC;
1077 case SOURCE_TYPE_VOICE_COMMUNICATION:
1078 case SOURCE_TYPE_VOICE_CALL:
1079 return STREAM_VOICE_CALL;
1080 case SOURCE_TYPE_ULTRASONIC:
1081 return STREAM_ULTRASONIC;
1082 case SOURCE_TYPE_WAKEUP:
1083 return STREAM_WAKEUP;
1084 case SOURCE_TYPE_CAMCORDER:
1085 return STREAM_CAMCORDER;
1086 case SOURCE_TYPE_VOICE_RECOGNITION:
1087 case SOURCE_TYPE_PLAYBACK_CAPTURE:
1088 case SOURCE_TYPE_REMOTE_CAST:
1089 case SOURCE_TYPE_VIRTUAL_CAPTURE:
1090 case SOURCE_TYPE_VOICE_MESSAGE:
1091 default:
1092 return (AudioStreamType)sourceType;
1093 }
1094 }
1095
SetLowPowerVolume(int32_t streamId,float volume)1096 int32_t AudioStreamCollector::SetLowPowerVolume(int32_t streamId, float volume)
1097 {
1098 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1099 CHECK_AND_RETURN_RET_LOG(!(clientTracker_.count(streamId) == 0),
1100 ERR_INVALID_PARAM, "SetLowPowerVolume streamId invalid.");
1101 std::shared_ptr<AudioClientTracker> callback = clientTracker_[streamId];
1102 CHECK_AND_RETURN_RET_LOG(callback != nullptr,
1103 ERR_INVALID_PARAM, "SetLowPowerVolume callback failed");
1104 callback->SetLowPowerVolumeImpl(volume);
1105 return SUCCESS;
1106 }
1107
GetLowPowerVolume(int32_t streamId)1108 float AudioStreamCollector::GetLowPowerVolume(int32_t streamId)
1109 {
1110 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1111 float ret = 1.0; // invalue volume
1112 CHECK_AND_RETURN_RET_LOG(!(clientTracker_.count(streamId) == 0),
1113 ret, "GetLowPowerVolume streamId invalid.");
1114 float volume;
1115 std::shared_ptr<AudioClientTracker> callback = clientTracker_[streamId];
1116 CHECK_AND_RETURN_RET_LOG(callback != nullptr,
1117 ret, "GetLowPowerVolume callback failed");
1118 callback->GetLowPowerVolumeImpl(volume);
1119 return volume;
1120 }
1121
SetOffloadMode(int32_t streamId,int32_t state,bool isAppBack)1122 int32_t AudioStreamCollector::SetOffloadMode(int32_t streamId, int32_t state, bool isAppBack)
1123 {
1124 std::shared_ptr<AudioClientTracker> callback;
1125 {
1126 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1127 CHECK_AND_RETURN_RET_LOG(!(clientTracker_.count(streamId) == 0),
1128 ERR_INVALID_PARAM, "streamId (%{public}d) invalid.", streamId);
1129 callback = clientTracker_[streamId];
1130 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM, "callback failed");
1131 }
1132 callback->SetOffloadModeImpl(state, isAppBack);
1133 return SUCCESS;
1134 }
1135
UnsetOffloadMode(int32_t streamId)1136 int32_t AudioStreamCollector::UnsetOffloadMode(int32_t streamId)
1137 {
1138 std::shared_ptr<AudioClientTracker> callback;
1139 {
1140 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1141 CHECK_AND_RETURN_RET_LOG(!(clientTracker_.count(streamId) == 0),
1142 ERR_INVALID_PARAM, "streamId (%{public}d) invalid.", streamId);
1143 callback = clientTracker_[streamId];
1144 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM, "callback failed");
1145 }
1146 callback->UnsetOffloadModeImpl();
1147 return SUCCESS;
1148 }
1149
GetSingleStreamVolume(int32_t streamId)1150 float AudioStreamCollector::GetSingleStreamVolume(int32_t streamId)
1151 {
1152 std::shared_ptr<AudioClientTracker> callback;
1153 {
1154 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1155 float ret = 1.0; // invalue volume
1156 CHECK_AND_RETURN_RET_LOG(!(clientTracker_.count(streamId) == 0),
1157 ret, "GetSingleStreamVolume streamId invalid.");
1158 callback = clientTracker_[streamId];
1159 CHECK_AND_RETURN_RET_LOG(callback != nullptr,
1160 ret, "GetSingleStreamVolume callback failed");
1161 }
1162 float volume;
1163 callback->GetSingleStreamVolumeImpl(volume);
1164 return volume;
1165 }
1166
UpdateCapturerInfoMuteStatus(int32_t uid,bool muteStatus)1167 int32_t AudioStreamCollector::UpdateCapturerInfoMuteStatus(int32_t uid, bool muteStatus)
1168 {
1169 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1170 bool capturerInfoUpdated = false;
1171 for (auto it = audioCapturerChangeInfos_.begin(); it != audioCapturerChangeInfos_.end(); it++) {
1172 if ((*it)->clientUID == uid || uid == 0) {
1173 (*it)->muted = muteStatus;
1174 capturerInfoUpdated = true;
1175 std::shared_ptr<Media::MediaMonitor::EventBean> bean = std::make_shared<Media::MediaMonitor::EventBean>(
1176 Media::MediaMonitor::ModuleId::AUDIO, Media::MediaMonitor::EventId::CAPTURE_MUTE_STATUS_CHANGE,
1177 Media::MediaMonitor::EventType::BEHAVIOR_EVENT);
1178 bean->Add("ISOUTPUT", 0);
1179 bean->Add("STREAMID", (*it)->sessionId);
1180 bean->Add("STREAM_TYPE", (*it)->capturerInfo.sourceType);
1181 bean->Add("DEVICETYPE", (*it)->inputDeviceInfo.deviceType_);
1182 bean->Add("MUTED", (*it)->muted);
1183 Media::MediaMonitor::MediaMonitorManager::GetInstance().WriteLogMsg(bean);
1184 }
1185 }
1186
1187 if (capturerInfoUpdated && audioPolicyServerHandler_ != nullptr) {
1188 SendCapturerInfoEvent(audioCapturerChangeInfos_);
1189 }
1190
1191 return SUCCESS;
1192 }
1193
SetAudioConcurrencyCallback(const uint32_t sessionID,const sptr<IRemoteObject> & object)1194 int32_t AudioStreamCollector::SetAudioConcurrencyCallback(const uint32_t sessionID, const sptr<IRemoteObject> &object)
1195 {
1196 return audioConcurrencyService_->SetAudioConcurrencyCallback(sessionID, object);
1197 }
1198
UnsetAudioConcurrencyCallback(const uint32_t sessionID)1199 int32_t AudioStreamCollector::UnsetAudioConcurrencyCallback(const uint32_t sessionID)
1200 {
1201 return audioConcurrencyService_->UnsetAudioConcurrencyCallback(sessionID);
1202 }
1203
ActivateAudioConcurrency(const AudioPipeType & pipeType)1204 int32_t AudioStreamCollector::ActivateAudioConcurrency(const AudioPipeType &pipeType)
1205 {
1206 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1207 return audioConcurrencyService_->ActivateAudioConcurrency(pipeType,
1208 audioRendererChangeInfos_, audioCapturerChangeInfos_);
1209 }
1210
WriterStreamChangeSysEvent(AudioMode & mode,AudioStreamChangeInfo & streamChangeInfo)1211 void AudioStreamCollector::WriterStreamChangeSysEvent(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo)
1212 {
1213 if (mode == AUDIO_MODE_PLAYBACK) {
1214 WriterRenderStreamChangeSysEvent(streamChangeInfo);
1215 } else {
1216 WriterCaptureStreamChangeSysEvent(streamChangeInfo);
1217 }
1218 }
1219
WriterRenderStreamChangeSysEvent(AudioStreamChangeInfo & streamChangeInfo)1220 void AudioStreamCollector::WriterRenderStreamChangeSysEvent(AudioStreamChangeInfo &streamChangeInfo)
1221 {
1222 bool isOutput = true;
1223 AudioStreamType streamType = GetVolumeTypeFromContentUsage(
1224 streamChangeInfo.audioRendererChangeInfo.rendererInfo.contentType,
1225 streamChangeInfo.audioRendererChangeInfo.rendererInfo.streamUsage);
1226 uint64_t transactionId = audioAbilityMgr_->GetTransactionId(
1227 streamChangeInfo.audioRendererChangeInfo.outputDeviceInfo.deviceType_, OUTPUT_DEVICE);
1228
1229 uint8_t effectChainType = EFFECT_CHAIN_TYPE_MAP.count(
1230 streamChangeInfo.audioRendererChangeInfo.rendererInfo.sceneType) ?
1231 EFFECT_CHAIN_TYPE_MAP.at(streamChangeInfo.audioRendererChangeInfo.rendererInfo.sceneType) :
1232 EFFECT_CHAIN_TYPE_MAP.at("UNKNOWN");
1233
1234 std::shared_ptr<Media::MediaMonitor::EventBean> bean = std::make_shared<Media::MediaMonitor::EventBean>(
1235 Media::MediaMonitor::AUDIO, Media::MediaMonitor::STREAM_CHANGE,
1236 Media::MediaMonitor::BEHAVIOR_EVENT);
1237 bean->Add("ISOUTPUT", isOutput ? 1 : 0);
1238 bean->Add("STREAMID", streamChangeInfo.audioRendererChangeInfo.sessionId);
1239 bean->Add("UID", streamChangeInfo.audioRendererChangeInfo.clientUID);
1240 bean->Add("PID", streamChangeInfo.audioRendererChangeInfo.clientPid);
1241 bean->Add("TRANSACTIONID", transactionId);
1242 bean->Add("STREAMTYPE", streamType);
1243 bean->Add("STATE", streamChangeInfo.audioRendererChangeInfo.rendererState);
1244 bean->Add("DEVICETYPE", streamChangeInfo.audioRendererChangeInfo.outputDeviceInfo.deviceType_);
1245 bean->Add("BT_TYPE", streamChangeInfo.audioRendererChangeInfo.outputDeviceInfo.deviceCategory_);
1246 bean->Add("PIPE_TYPE", streamChangeInfo.audioRendererChangeInfo.rendererInfo.pipeType);
1247 bean->Add("STREAM_TYPE", streamChangeInfo.audioRendererChangeInfo.rendererInfo.streamUsage);
1248 bean->Add("SAMPLE_RATE", streamChangeInfo.audioRendererChangeInfo.rendererInfo.samplingRate);
1249 bean->Add("NETWORKID", ConvertNetworkId(streamChangeInfo.audioRendererChangeInfo.outputDeviceInfo.networkId_));
1250 bean->Add("ENCODING_TYPE", streamChangeInfo.audioRendererChangeInfo.rendererInfo.encodingType);
1251 bean->Add("CHANNEL_LAYOUT", streamChangeInfo.audioRendererChangeInfo.rendererInfo.channelLayout);
1252 bean->Add("EFFECT_CHAIN", effectChainType);
1253 Media::MediaMonitor::MediaMonitorManager::GetInstance().WriteLogMsg(bean);
1254 }
1255
WriterCaptureStreamChangeSysEvent(AudioStreamChangeInfo & streamChangeInfo)1256 void AudioStreamCollector::WriterCaptureStreamChangeSysEvent(AudioStreamChangeInfo &streamChangeInfo)
1257 {
1258 bool isOutput = false;
1259 AudioStreamType streamType = GetStreamTypeFromSourceType(
1260 streamChangeInfo.audioCapturerChangeInfo.capturerInfo.sourceType);
1261 uint64_t transactionId = audioAbilityMgr_->GetTransactionId(
1262 streamChangeInfo.audioCapturerChangeInfo.inputDeviceInfo.deviceType_, INPUT_DEVICE);
1263
1264 uint8_t effectChainType = EFFECT_CHAIN_TYPE_MAP.count(
1265 streamChangeInfo.audioCapturerChangeInfo.capturerInfo.sceneType) ?
1266 EFFECT_CHAIN_TYPE_MAP.at(streamChangeInfo.audioCapturerChangeInfo.capturerInfo.sceneType) :
1267 EFFECT_CHAIN_TYPE_MAP.at("UNKNOWN");
1268
1269 std::shared_ptr<Media::MediaMonitor::EventBean> bean = std::make_shared<Media::MediaMonitor::EventBean>(
1270 Media::MediaMonitor::AUDIO, Media::MediaMonitor::STREAM_CHANGE,
1271 Media::MediaMonitor::BEHAVIOR_EVENT);
1272 bean->Add("ISOUTPUT", isOutput ? 1 : 0);
1273 bean->Add("STREAMID", streamChangeInfo.audioCapturerChangeInfo.sessionId);
1274 bean->Add("UID", streamChangeInfo.audioCapturerChangeInfo.clientUID);
1275 bean->Add("PID", streamChangeInfo.audioCapturerChangeInfo.clientPid);
1276 bean->Add("TRANSACTIONID", transactionId);
1277 bean->Add("STREAMTYPE", streamType);
1278 bean->Add("STATE", streamChangeInfo.audioCapturerChangeInfo.capturerState);
1279 bean->Add("DEVICETYPE", streamChangeInfo.audioCapturerChangeInfo.inputDeviceInfo.deviceType_);
1280 bean->Add("BT_TYPE", streamChangeInfo.audioCapturerChangeInfo.inputDeviceInfo.deviceCategory_);
1281 bean->Add("PIPE_TYPE", streamChangeInfo.audioCapturerChangeInfo.capturerInfo.pipeType);
1282 bean->Add("STREAM_TYPE", streamChangeInfo.audioCapturerChangeInfo.capturerInfo.sourceType);
1283 bean->Add("SAMPLE_RATE", streamChangeInfo.audioCapturerChangeInfo.capturerInfo.samplingRate);
1284 bean->Add("MUTED", streamChangeInfo.audioCapturerChangeInfo.muted);
1285 bean->Add("NETWORKID", ConvertNetworkId(streamChangeInfo.audioCapturerChangeInfo.inputDeviceInfo.networkId_));
1286 bean->Add("ENCODING_TYPE", streamChangeInfo.audioCapturerChangeInfo.capturerInfo.encodingType);
1287 bean->Add("CHANNEL_LAYOUT", streamChangeInfo.audioCapturerChangeInfo.capturerInfo.channelLayout);
1288 bean->Add("EFFECT_CHAIN", effectChainType);
1289 Media::MediaMonitor::MediaMonitorManager::GetInstance().WriteLogMsg(bean);
1290 }
1291
1292
WriteRenderStreamReleaseSysEvent(const std::shared_ptr<AudioRendererChangeInfo> & audioRendererChangeInfo)1293 void AudioStreamCollector::WriteRenderStreamReleaseSysEvent(
1294 const std::shared_ptr<AudioRendererChangeInfo> &audioRendererChangeInfo)
1295 {
1296 AudioStreamType streamType = GetVolumeTypeFromContentUsage(audioRendererChangeInfo->rendererInfo.contentType,
1297 audioRendererChangeInfo->rendererInfo.streamUsage);
1298 uint64_t transactionId = audioAbilityMgr_->GetTransactionId(
1299 audioRendererChangeInfo->outputDeviceInfo.deviceType_, OUTPUT_DEVICE);
1300
1301 uint8_t effectChainType = EFFECT_CHAIN_TYPE_MAP.count(
1302 audioRendererChangeInfo->rendererInfo.sceneType) ?
1303 EFFECT_CHAIN_TYPE_MAP.at(audioRendererChangeInfo->rendererInfo.sceneType) :
1304 EFFECT_CHAIN_TYPE_MAP.at("UNKNOWN");
1305
1306 std::shared_ptr<Media::MediaMonitor::EventBean> bean = std::make_shared<Media::MediaMonitor::EventBean>(
1307 Media::MediaMonitor::AUDIO, Media::MediaMonitor::STREAM_CHANGE,
1308 Media::MediaMonitor::BEHAVIOR_EVENT);
1309 bean->Add("ISOUTPUT", 1);
1310 bean->Add("STREAMID", audioRendererChangeInfo->sessionId);
1311 bean->Add("UID", audioRendererChangeInfo->clientUID);
1312 bean->Add("PID", audioRendererChangeInfo->clientPid);
1313 bean->Add("TRANSACTIONID", transactionId);
1314 bean->Add("STREAMTYPE", streamType);
1315 bean->Add("STATE", audioRendererChangeInfo->rendererState);
1316 bean->Add("DEVICETYPE", audioRendererChangeInfo->outputDeviceInfo.deviceType_);
1317 bean->Add("BT_TYPE", audioRendererChangeInfo->outputDeviceInfo.deviceCategory_);
1318 bean->Add("PIPE_TYPE", audioRendererChangeInfo->rendererInfo.pipeType);
1319 bean->Add("STREAM_TYPE", audioRendererChangeInfo->rendererInfo.streamUsage);
1320 bean->Add("SAMPLE_RATE", audioRendererChangeInfo->rendererInfo.samplingRate);
1321 bean->Add("NETWORKID", ConvertNetworkId(audioRendererChangeInfo->outputDeviceInfo.networkId_));
1322 bean->Add("ENCODING_TYPE", audioRendererChangeInfo->rendererInfo.encodingType);
1323 bean->Add("CHANNEL_LAYOUT", audioRendererChangeInfo->rendererInfo.channelLayout);
1324 bean->Add("EFFECT_CHAIN", effectChainType);
1325 Media::MediaMonitor::MediaMonitorManager::GetInstance().WriteLogMsg(bean);
1326 }
1327
WriteCaptureStreamReleaseSysEvent(const std::shared_ptr<AudioCapturerChangeInfo> & audioCapturerChangeInfo)1328 void AudioStreamCollector::WriteCaptureStreamReleaseSysEvent(
1329 const std::shared_ptr<AudioCapturerChangeInfo> &audioCapturerChangeInfo)
1330 {
1331 AudioStreamType streamType = GetStreamTypeFromSourceType(audioCapturerChangeInfo->capturerInfo.sourceType);
1332 uint64_t transactionId = audioAbilityMgr_->GetTransactionId(
1333 audioCapturerChangeInfo->inputDeviceInfo.deviceType_, INPUT_DEVICE);
1334
1335 uint8_t effectChainType = EFFECT_CHAIN_TYPE_MAP.count(
1336 audioCapturerChangeInfo->capturerInfo.sceneType) ?
1337 EFFECT_CHAIN_TYPE_MAP.at(audioCapturerChangeInfo->capturerInfo.sceneType) :
1338 EFFECT_CHAIN_TYPE_MAP.at("UNKNOWN");
1339
1340 std::shared_ptr<Media::MediaMonitor::EventBean> bean = std::make_shared<Media::MediaMonitor::EventBean>(
1341 Media::MediaMonitor::AUDIO, Media::MediaMonitor::STREAM_CHANGE,
1342 Media::MediaMonitor::BEHAVIOR_EVENT);
1343 bean->Add("ISOUTPUT", 1);
1344 bean->Add("STREAMID", audioCapturerChangeInfo->sessionId);
1345 bean->Add("UID", audioCapturerChangeInfo->clientUID);
1346 bean->Add("PID", audioCapturerChangeInfo->clientPid);
1347 bean->Add("TRANSACTIONID", transactionId);
1348 bean->Add("STREAMTYPE", streamType);
1349 bean->Add("STATE", audioCapturerChangeInfo->capturerState);
1350 bean->Add("DEVICETYPE", audioCapturerChangeInfo->inputDeviceInfo.deviceType_);
1351 bean->Add("BT_TYPE", audioCapturerChangeInfo->inputDeviceInfo.deviceCategory_);
1352 bean->Add("PIPE_TYPE", audioCapturerChangeInfo->capturerInfo.pipeType);
1353 bean->Add("STREAM_TYPE", audioCapturerChangeInfo->capturerInfo.sourceType);
1354 bean->Add("SAMPLE_RATE", audioCapturerChangeInfo->capturerInfo.samplingRate);
1355 bean->Add("MUTED", audioCapturerChangeInfo->muted);
1356 bean->Add("NETWORKID", ConvertNetworkId(audioCapturerChangeInfo->inputDeviceInfo.networkId_));
1357 bean->Add("ENCODING_TYPE", audioCapturerChangeInfo->capturerInfo.encodingType);
1358 bean->Add("CHANNEL_LAYOUT", audioCapturerChangeInfo->capturerInfo.channelLayout);
1359 bean->Add("EFFECT_CHAIN", effectChainType);
1360 Media::MediaMonitor::MediaMonitorManager::GetInstance().WriteLogMsg(bean);
1361 }
1362
IsCallStreamUsage(StreamUsage usage)1363 bool AudioStreamCollector::IsCallStreamUsage(StreamUsage usage)
1364 {
1365 if (usage == STREAM_USAGE_VOICE_COMMUNICATION || usage == STREAM_USAGE_VIDEO_COMMUNICATION ||
1366 usage == STREAM_USAGE_VOICE_MODEM_COMMUNICATION) {
1367 return true;
1368 }
1369 return false;
1370 }
1371
GetRunningStreamUsageNoUltrasonic()1372 StreamUsage AudioStreamCollector::GetRunningStreamUsageNoUltrasonic()
1373 {
1374 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1375 for (const auto &changeInfo : audioRendererChangeInfos_) {
1376 if (changeInfo->rendererState == RENDERER_RUNNING &&
1377 changeInfo->rendererInfo.streamUsage != STREAM_USAGE_ULTRASONIC) {
1378 return changeInfo->rendererInfo.streamUsage;
1379 }
1380 }
1381 return STREAM_USAGE_INVALID;
1382 }
1383
GetRunningSourceTypeNoUltrasonic()1384 SourceType AudioStreamCollector::GetRunningSourceTypeNoUltrasonic()
1385 {
1386 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1387 for (const auto &changeInfo : audioCapturerChangeInfos_) {
1388 if (changeInfo->capturerState == CAPTURER_RUNNING &&
1389 changeInfo->capturerInfo.sourceType != SOURCE_TYPE_ULTRASONIC) {
1390 return changeInfo->capturerInfo.sourceType;
1391 }
1392 }
1393 return SOURCE_TYPE_INVALID;
1394 }
1395
GetLastestRunningCallStreamUsage()1396 StreamUsage AudioStreamCollector::GetLastestRunningCallStreamUsage()
1397 {
1398 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1399 for (const auto &changeInfo : audioRendererChangeInfos_) {
1400 StreamUsage usage = changeInfo->rendererInfo.streamUsage;
1401 RendererState state = changeInfo->rendererState;
1402 if ((IsCallStreamUsage(usage) && state == RENDERER_RUNNING) ||
1403 (usage == STREAM_USAGE_VOICE_MODEM_COMMUNICATION && state == RENDERER_PREPARED)) {
1404 return usage;
1405 }
1406 }
1407 return STREAM_USAGE_UNKNOWN;
1408 }
1409
GetAllRendererSessionIDForUID(int32_t uid)1410 std::vector<uint32_t> AudioStreamCollector::GetAllRendererSessionIDForUID(int32_t uid)
1411 {
1412 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1413 std::vector<uint32_t> sessionIDSet;
1414 for (const auto &changeInfo : audioRendererChangeInfos_) {
1415 if (changeInfo->clientUID == uid) {
1416 sessionIDSet.push_back(changeInfo->sessionId);
1417 }
1418 }
1419 return sessionIDSet;
1420 }
1421
ChangeVoipCapturerStreamToNormal()1422 bool AudioStreamCollector::ChangeVoipCapturerStreamToNormal()
1423 {
1424 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1425 int count = std::count_if(audioCapturerChangeInfos_.begin(), audioCapturerChangeInfos_.end(),
1426 [](const auto &changeInfo) {
1427 const auto &sourceType = changeInfo->capturerInfo.sourceType;
1428 return sourceType == SOURCE_TYPE_VOICE_COMMUNICATION || sourceType == SOURCE_TYPE_MIC ||
1429 sourceType == SOURCE_TYPE_VOICE_MESSAGE || sourceType == SOURCE_TYPE_VOICE_TRANSCRIPTION;
1430 });
1431
1432 AUDIO_INFO_LOG("Has capture stream count: %{public}d", count);
1433 // becasue self has been added
1434 return count > 1;
1435 }
1436
HasVoipRendererStream()1437 bool AudioStreamCollector::HasVoipRendererStream()
1438 {
1439 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1440 // judge stream original flage is AUDIO_FLAG_VOIP_FAST
1441 bool hasVoip = std::any_of(audioRendererChangeInfos_.begin(), audioRendererChangeInfos_.end(),
1442 [](const auto &changeInfo) {
1443 return changeInfo->rendererInfo.originalFlag == AUDIO_FLAG_VOIP_FAST;
1444 });
1445
1446 AUDIO_INFO_LOG("Has Fast Voip stream : %{public}d", hasVoip);
1447 return hasVoip;
1448 }
1449
HasRunningRendererStream()1450 bool AudioStreamCollector::HasRunningRendererStream()
1451 {
1452 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1453 // judge stream state is running
1454 bool hasRunningRendererStream = std::any_of(audioRendererChangeInfos_.begin(), audioRendererChangeInfos_.end(),
1455 [](const auto &changeInfo) {
1456 return ((changeInfo->rendererState == RENDERER_RUNNING) || (changeInfo->rendererInfo.streamUsage ==
1457 STREAM_USAGE_VOICE_MODEM_COMMUNICATION && changeInfo->rendererState == RENDERER_PREPARED));
1458 });
1459 AUDIO_INFO_LOG("Has Running Renderer stream : %{public}d", hasRunningRendererStream);
1460 return hasRunningRendererStream;
1461 }
1462
HasRunningRecognitionCapturerStream()1463 bool AudioStreamCollector::HasRunningRecognitionCapturerStream()
1464 {
1465 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1466 // judge stream state is running
1467 bool hasRunningRecognitionCapturerStream = std::any_of(audioCapturerChangeInfos_.begin(),
1468 audioCapturerChangeInfos_.end(),
1469 [](const auto &changeInfo) {
1470 return ((changeInfo->capturerState == CAPTURER_RUNNING) && (changeInfo->capturerInfo.sourceType ==
1471 SOURCE_TYPE_VOICE_RECOGNITION));
1472 });
1473
1474 AUDIO_INFO_LOG("Has Running Recognition stream : %{public}d", hasRunningRecognitionCapturerStream);
1475 return hasRunningRecognitionCapturerStream;
1476 }
1477
1478 // Check if media is currently playing
IsMediaPlaying()1479 bool AudioStreamCollector::IsMediaPlaying()
1480 {
1481 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
1482 for (auto &changeInfo: audioRendererChangeInfos_) {
1483 if (changeInfo->rendererState != RENDERER_RUNNING) {
1484 continue;
1485 }
1486 AudioStreamType streamType = GetStreamType((changeInfo->rendererInfo).contentType,
1487 (changeInfo->rendererInfo).streamUsage);
1488 switch (streamType) {
1489 case STREAM_MUSIC:
1490 case STREAM_MEDIA:
1491 case STREAM_MOVIE:
1492 case STREAM_GAME:
1493 case STREAM_SPEECH:
1494 case STREAM_NAVIGATION:
1495 case STREAM_CAMCORDER:
1496 case STREAM_VOICE_MESSAGE:
1497 return true;
1498 default:
1499 break;
1500 }
1501 }
1502 return false;
1503 }
1504 } // namespace AudioStandard
1505 } // namespace OHOS
1506