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