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