1 /*
2 * Copyright (c) 2022 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 #include "audio_stream_collector.h"
16
17 #include "audio_capturer_state_change_listener_proxy.h"
18 #include "audio_errors.h"
19 #include "audio_renderer_state_change_listener_proxy.h"
20 #include "audio_client_tracker_callback_proxy.h"
21
22 #include "i_standard_renderer_state_change_listener.h"
23 #include "i_standard_capturer_state_change_listener.h"
24 #include "i_standard_client_tracker.h"
25
26 namespace OHOS {
27 namespace AudioStandard {
28 using namespace std;
29
30 const map<pair<ContentType, StreamUsage>, AudioStreamType> AudioStreamCollector::streamTypeMap_ =
31 AudioStreamCollector::CreateStreamMap();
32
CreateStreamMap()33 map<pair<ContentType, StreamUsage>, AudioStreamType> AudioStreamCollector::CreateStreamMap()
34 {
35 map<pair<ContentType, StreamUsage>, AudioStreamType> streamMap;
36
37 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_UNKNOWN)] = STREAM_MUSIC;
38 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_MEDIA)] = STREAM_MUSIC;
39 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VOICE_COMMUNICATION)] = STREAM_MUSIC;
40 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_VOICE_ASSISTANT)] = STREAM_MUSIC;
41 streamMap[make_pair(CONTENT_TYPE_UNKNOWN, STREAM_USAGE_NOTIFICATION_RINGTONE)] = STREAM_MUSIC;
42
43 streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_UNKNOWN)] = STREAM_MUSIC;
44 streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_MEDIA)] = STREAM_VOICE_ASSISTANT;
45 streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_VOICE_COMMUNICATION)] = STREAM_VOICE_CALL;
46 streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_VOICE_ASSISTANT)] = STREAM_VOICE_ASSISTANT;
47 streamMap[make_pair(CONTENT_TYPE_SPEECH, STREAM_USAGE_NOTIFICATION_RINGTONE)] = STREAM_MUSIC;
48
49 streamMap[make_pair(CONTENT_TYPE_MUSIC, STREAM_USAGE_UNKNOWN)] = STREAM_MUSIC;
50 streamMap[make_pair(CONTENT_TYPE_MUSIC, STREAM_USAGE_MEDIA)] = STREAM_MUSIC;
51 streamMap[make_pair(CONTENT_TYPE_MUSIC, STREAM_USAGE_VOICE_COMMUNICATION)] = STREAM_MUSIC;
52 streamMap[make_pair(CONTENT_TYPE_MUSIC, STREAM_USAGE_VOICE_ASSISTANT)] = STREAM_VOICE_ASSISTANT;
53 streamMap[make_pair(CONTENT_TYPE_MUSIC, STREAM_USAGE_NOTIFICATION_RINGTONE)] = STREAM_RING;
54
55 streamMap[make_pair(CONTENT_TYPE_MOVIE, STREAM_USAGE_UNKNOWN)] = STREAM_MEDIA;
56 streamMap[make_pair(CONTENT_TYPE_MOVIE, STREAM_USAGE_MEDIA)] = STREAM_MEDIA;
57 streamMap[make_pair(CONTENT_TYPE_MOVIE, STREAM_USAGE_VOICE_COMMUNICATION)] = STREAM_MUSIC;
58 streamMap[make_pair(CONTENT_TYPE_MOVIE, STREAM_USAGE_VOICE_ASSISTANT)] = STREAM_MUSIC;
59 streamMap[make_pair(CONTENT_TYPE_MOVIE, STREAM_USAGE_NOTIFICATION_RINGTONE)] = STREAM_MUSIC;
60
61 streamMap[make_pair(CONTENT_TYPE_SONIFICATION, STREAM_USAGE_UNKNOWN)] = STREAM_NOTIFICATION;
62 streamMap[make_pair(CONTENT_TYPE_SONIFICATION, STREAM_USAGE_MEDIA)] = STREAM_NOTIFICATION;
63 streamMap[make_pair(CONTENT_TYPE_SONIFICATION, STREAM_USAGE_VOICE_COMMUNICATION)] = STREAM_MUSIC;
64 streamMap[make_pair(CONTENT_TYPE_SONIFICATION, STREAM_USAGE_VOICE_ASSISTANT)] = STREAM_MUSIC;
65 streamMap[make_pair(CONTENT_TYPE_SONIFICATION, STREAM_USAGE_NOTIFICATION_RINGTONE)] = STREAM_MUSIC;
66
67 streamMap[make_pair(CONTENT_TYPE_RINGTONE, STREAM_USAGE_UNKNOWN)] = STREAM_RING;
68 streamMap[make_pair(CONTENT_TYPE_RINGTONE, STREAM_USAGE_MEDIA)] = STREAM_RING;
69 streamMap[make_pair(CONTENT_TYPE_RINGTONE, STREAM_USAGE_VOICE_COMMUNICATION)] = STREAM_MUSIC;
70 streamMap[make_pair(CONTENT_TYPE_RINGTONE, STREAM_USAGE_VOICE_ASSISTANT)] = STREAM_MUSIC;
71 streamMap[make_pair(CONTENT_TYPE_RINGTONE, STREAM_USAGE_NOTIFICATION_RINGTONE)] = STREAM_RING;
72
73 return streamMap;
74 }
75
AudioStreamCollector()76 AudioStreamCollector::AudioStreamCollector() : mDispatcherService
77 (AudioStreamEventDispatcher::GetAudioStreamEventDispatcher())
78 {
79 AUDIO_INFO_LOG("AudioStreamCollector::AudioStreamCollector()");
80 }
81
~AudioStreamCollector()82 AudioStreamCollector::~AudioStreamCollector()
83 {
84 AUDIO_INFO_LOG("AudioStreamCollector::~AudioStreamCollector()");
85 }
86
RegisterAudioRendererEventListener(int32_t clientUID,const sptr<IRemoteObject> & object,bool hasBTPermission)87 int32_t AudioStreamCollector::RegisterAudioRendererEventListener(int32_t clientUID, const sptr<IRemoteObject> &object,
88 bool hasBTPermission)
89 {
90 AUDIO_INFO_LOG("AudioStreamCollector: RegisterAudioRendererEventListener client id %{public}d done", clientUID);
91
92 CHECK_AND_RETURN_RET_LOG(object != nullptr, ERR_INVALID_PARAM,
93 "AudioStreamCollector:set renderer state change event listener object is nullptr");
94
95 sptr<IStandardRendererStateChangeListener> listener = iface_cast<IStandardRendererStateChangeListener>(object);
96 CHECK_AND_RETURN_RET_LOG(listener != nullptr, ERR_INVALID_PARAM,
97 "AudioStreamCollector: renderer listener obj cast failed");
98
99 std::shared_ptr<AudioRendererStateChangeCallback> callback =
100 std::make_shared<AudioRendererStateChangeListenerCallback>(listener, hasBTPermission);
101 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM, "AudioStreamCollector: failed to create cb obj");
102
103 mDispatcherService.addRendererListener(clientUID, callback);
104 return SUCCESS;
105 }
106
UnregisterAudioRendererEventListener(int32_t clientUID)107 int32_t AudioStreamCollector::UnregisterAudioRendererEventListener(int32_t clientUID)
108 {
109 AUDIO_INFO_LOG("AudioStreamCollector::UnregisterAudioRendererEventListener()");
110 mDispatcherService.removeRendererListener(clientUID);
111 return SUCCESS;
112 }
113
RegisterAudioCapturerEventListener(int32_t clientUID,const sptr<IRemoteObject> & object,bool hasBTPermission)114 int32_t AudioStreamCollector::RegisterAudioCapturerEventListener(int32_t clientUID, const sptr<IRemoteObject> &object,
115 bool hasBTPermission)
116 {
117 AUDIO_INFO_LOG("AudioStreamCollector: RegisterAudioCapturerEventListener for client id %{public}d done", clientUID);
118
119 CHECK_AND_RETURN_RET_LOG(object != nullptr, ERR_INVALID_PARAM,
120 "AudioStreamCollector:set capturer event listener object is nullptr");
121
122 sptr<IStandardCapturerStateChangeListener> listener = iface_cast<IStandardCapturerStateChangeListener>(object);
123 CHECK_AND_RETURN_RET_LOG(listener != nullptr, ERR_INVALID_PARAM, "AudioStreamCollector: capturer obj cast failed");
124
125 std::shared_ptr<AudioCapturerStateChangeCallback> callback =
126 std::make_shared<AudioCapturerStateChangeListenerCallback>(listener, hasBTPermission);
127 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM,
128 "AudioStreamCollector: failed to create capturer cb obj");
129
130 mDispatcherService.addCapturerListener(clientUID, callback);
131 return SUCCESS;
132 }
133
UnregisterAudioCapturerEventListener(int32_t clientUID)134 int32_t AudioStreamCollector::UnregisterAudioCapturerEventListener(int32_t clientUID)
135 {
136 AUDIO_INFO_LOG("AudioStreamCollector: UnregisterAudioCapturerEventListener client id %{public}d done", clientUID);
137 mDispatcherService.removeCapturerListener(clientUID);
138 return SUCCESS;
139 }
140
AddRendererStream(AudioStreamChangeInfo & streamChangeInfo)141 int32_t AudioStreamCollector::AddRendererStream(AudioStreamChangeInfo &streamChangeInfo)
142 {
143 AUDIO_INFO_LOG("AudioStreamCollector: AddRendererStream playback client id %{public}d session %{public}d",
144 streamChangeInfo.audioRendererChangeInfo.clientUID, streamChangeInfo.audioRendererChangeInfo.sessionId);
145
146 rendererStatequeue_.insert({{streamChangeInfo.audioRendererChangeInfo.clientUID,
147 streamChangeInfo.audioRendererChangeInfo.sessionId},
148 streamChangeInfo.audioRendererChangeInfo.rendererState});
149
150 unique_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_unique<AudioRendererChangeInfo>();
151 if (!rendererChangeInfo) {
152 AUDIO_ERR_LOG("AudioStreamCollector::AddRendererStream Memory Allocation Failed");
153 return ERR_MEMORY_ALLOC_FAILED;
154 }
155 rendererChangeInfo->clientUID = streamChangeInfo.audioRendererChangeInfo.clientUID;
156 rendererChangeInfo->sessionId = streamChangeInfo.audioRendererChangeInfo.sessionId;
157 rendererChangeInfo->rendererState = streamChangeInfo.audioRendererChangeInfo.rendererState;
158 rendererChangeInfo->rendererInfo = streamChangeInfo.audioRendererChangeInfo.rendererInfo;
159 rendererChangeInfo->outputDeviceInfo = streamChangeInfo.audioRendererChangeInfo.outputDeviceInfo;
160 audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
161
162 AUDIO_DEBUG_LOG("AudioStreamCollector: audioRendererChangeInfos_: Added for client %{public}d session %{public}d",
163 streamChangeInfo.audioRendererChangeInfo.clientUID, streamChangeInfo.audioRendererChangeInfo.sessionId);
164
165 mDispatcherService.SendRendererInfoEventToDispatcher(AudioMode::AUDIO_MODE_PLAYBACK, audioRendererChangeInfos_);
166 return SUCCESS;
167 }
168
AddCapturerStream(AudioStreamChangeInfo & streamChangeInfo)169 int32_t AudioStreamCollector::AddCapturerStream(AudioStreamChangeInfo &streamChangeInfo)
170 {
171 AUDIO_INFO_LOG("AudioStreamCollector: AddCapturerStream recording client id %{public}d session %{public}d",
172 streamChangeInfo.audioCapturerChangeInfo.clientUID, streamChangeInfo.audioCapturerChangeInfo.sessionId);
173
174 capturerStatequeue_.insert({{streamChangeInfo.audioCapturerChangeInfo.clientUID,
175 streamChangeInfo.audioCapturerChangeInfo.sessionId},
176 streamChangeInfo.audioCapturerChangeInfo.capturerState});
177
178 unique_ptr<AudioCapturerChangeInfo> capturerChangeInfo = make_unique<AudioCapturerChangeInfo>();
179 if (!capturerChangeInfo) {
180 AUDIO_ERR_LOG("AudioStreamCollector::AddCapturerStream Memory Allocation Failed");
181 return ERR_MEMORY_ALLOC_FAILED;
182 }
183 capturerChangeInfo->clientUID = streamChangeInfo.audioCapturerChangeInfo.clientUID;
184 capturerChangeInfo->sessionId = streamChangeInfo.audioCapturerChangeInfo.sessionId;
185 capturerChangeInfo->capturerState = streamChangeInfo.audioCapturerChangeInfo.capturerState;
186 capturerChangeInfo->capturerInfo = streamChangeInfo.audioCapturerChangeInfo.capturerInfo;
187 capturerChangeInfo->inputDeviceInfo = streamChangeInfo.audioCapturerChangeInfo.inputDeviceInfo;
188 audioCapturerChangeInfos_.push_back(move(capturerChangeInfo));
189
190 AUDIO_DEBUG_LOG("AudioStreamCollector: audioCapturerChangeInfos_: Added for client %{public}d session %{public}d",
191 streamChangeInfo.audioCapturerChangeInfo.clientUID, streamChangeInfo.audioCapturerChangeInfo.sessionId);
192
193 mDispatcherService.SendCapturerInfoEventToDispatcher(AudioMode::AUDIO_MODE_RECORD, audioCapturerChangeInfos_);
194 return SUCCESS;
195 }
196
RegisterTracker(AudioMode & mode,AudioStreamChangeInfo & streamChangeInfo,const sptr<IRemoteObject> & object)197 int32_t AudioStreamCollector::RegisterTracker(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo,
198 const sptr<IRemoteObject> &object)
199 {
200 AUDIO_INFO_LOG("AudioStreamCollector: RegisterTracker mode %{public}d", mode);
201
202 int32_t clientID;
203 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
204 if (mode == AUDIO_MODE_PLAYBACK) {
205 AddRendererStream(streamChangeInfo);
206 clientID = streamChangeInfo.audioRendererChangeInfo.sessionId;
207 } else {
208 // mode = AUDIO_MODE_RECORD
209 AddCapturerStream(streamChangeInfo);
210 clientID = streamChangeInfo.audioCapturerChangeInfo.sessionId;
211 }
212
213 sptr<IStandardClientTracker> listener = iface_cast<IStandardClientTracker>(object);
214 CHECK_AND_RETURN_RET_LOG(listener != nullptr,
215 ERR_INVALID_PARAM, "AudioStreamCollector: client tracker obj cast failed");
216 std::shared_ptr<AudioClientTracker> callback = std::make_shared<ClientTrackerCallbackListener>(listener);
217 CHECK_AND_RETURN_RET_LOG(callback != nullptr,
218 ERR_INVALID_PARAM, "AudioStreamCollector: failed to create tracker cb obj");
219 clientTracker_[clientID] = callback;
220
221 return SUCCESS;
222 }
223
UpdateRendererStream(AudioStreamChangeInfo & streamChangeInfo)224 int32_t AudioStreamCollector::UpdateRendererStream(AudioStreamChangeInfo &streamChangeInfo)
225 {
226 AUDIO_INFO_LOG("AudioStreamCollector: UpdateRendererStream client %{public}d state %{public}d session %{public}d",
227 streamChangeInfo.audioRendererChangeInfo.clientUID, streamChangeInfo.audioRendererChangeInfo.rendererState,
228 streamChangeInfo.audioRendererChangeInfo.sessionId);
229
230 if (rendererStatequeue_.find(make_pair(streamChangeInfo.audioRendererChangeInfo.clientUID,
231 streamChangeInfo.audioRendererChangeInfo.sessionId)) != rendererStatequeue_.end()) {
232 if (streamChangeInfo.audioRendererChangeInfo.rendererState ==
233 rendererStatequeue_[make_pair(streamChangeInfo.audioRendererChangeInfo.clientUID,
234 streamChangeInfo.audioRendererChangeInfo.sessionId)]) {
235 // Renderer state not changed
236 return SUCCESS;
237 }
238 } else {
239 AUDIO_INFO_LOG("UpdateRendererStream client %{public}d not found in rendererStatequeue_",
240 streamChangeInfo.audioRendererChangeInfo.clientUID);
241 }
242
243 // Update the renderer info in audioRendererChangeInfos_
244 for (auto it = audioRendererChangeInfos_.begin(); it != audioRendererChangeInfos_.end(); it++) {
245 AudioRendererChangeInfo audioRendererChangeInfo = **it;
246 if (audioRendererChangeInfo.clientUID == streamChangeInfo.audioRendererChangeInfo.clientUID &&
247 audioRendererChangeInfo.sessionId == streamChangeInfo.audioRendererChangeInfo.sessionId) {
248 rendererStatequeue_[make_pair(audioRendererChangeInfo.clientUID, audioRendererChangeInfo.sessionId)] =
249 streamChangeInfo.audioRendererChangeInfo.rendererState;
250 AUDIO_DEBUG_LOG("AudioStreamCollector: UpdateRendererStream: update client %{public}d session %{public}d",
251 audioRendererChangeInfo.clientUID, audioRendererChangeInfo.sessionId);
252
253 unique_ptr<AudioRendererChangeInfo> RendererChangeInfo = make_unique<AudioRendererChangeInfo>();
254 CHECK_AND_RETURN_RET_LOG(RendererChangeInfo != nullptr,
255 ERR_MEMORY_ALLOC_FAILED, "AudioStreamCollector::RendererChangeInfo Memory Allocation Failed");
256 RendererChangeInfo->clientUID = streamChangeInfo.audioRendererChangeInfo.clientUID;
257 RendererChangeInfo->sessionId = streamChangeInfo.audioRendererChangeInfo.sessionId;
258 RendererChangeInfo->rendererState = streamChangeInfo.audioRendererChangeInfo.rendererState;
259 RendererChangeInfo->rendererInfo = streamChangeInfo.audioRendererChangeInfo.rendererInfo;
260 RendererChangeInfo->outputDeviceInfo = streamChangeInfo.audioRendererChangeInfo.outputDeviceInfo;
261 *it = move(RendererChangeInfo);
262 AUDIO_DEBUG_LOG("AudioStreamCollector: Playback details updated, to be dispatched");
263
264 mDispatcherService.SendRendererInfoEventToDispatcher(AudioMode::AUDIO_MODE_PLAYBACK,
265 audioRendererChangeInfos_);
266
267 if (streamChangeInfo.audioRendererChangeInfo.rendererState == RENDERER_RELEASED) {
268 audioRendererChangeInfos_.erase(it);
269 AUDIO_DEBUG_LOG("AudioStreamCollector: Session removed for client %{public}d session %{public}d",
270 streamChangeInfo.audioRendererChangeInfo.clientUID,
271 streamChangeInfo.audioRendererChangeInfo.sessionId);
272 rendererStatequeue_.erase(make_pair(audioRendererChangeInfo.clientUID,
273 audioRendererChangeInfo.sessionId));
274 clientTracker_.erase(audioRendererChangeInfo.sessionId);
275 }
276 return SUCCESS;
277 }
278 }
279 AUDIO_INFO_LOG("UpdateRendererStream: Not found clientUid:%{public}d sessionId:%{public}d",
280 streamChangeInfo.audioRendererChangeInfo.clientUID, streamChangeInfo.audioRendererChangeInfo.clientUID);
281 return SUCCESS;
282 }
283
UpdateCapturerStream(AudioStreamChangeInfo & streamChangeInfo)284 int32_t AudioStreamCollector::UpdateCapturerStream(AudioStreamChangeInfo &streamChangeInfo)
285 {
286 AUDIO_INFO_LOG("AudioStreamCollector: UpdateCapturerStream client %{public}d state %{public}d session %{public}d",
287 streamChangeInfo.audioCapturerChangeInfo.clientUID, streamChangeInfo.audioCapturerChangeInfo.capturerState,
288 streamChangeInfo.audioCapturerChangeInfo.sessionId);
289
290 if (capturerStatequeue_.find(make_pair(streamChangeInfo.audioCapturerChangeInfo.clientUID,
291 streamChangeInfo.audioCapturerChangeInfo.sessionId)) != capturerStatequeue_.end()) {
292 if (streamChangeInfo.audioCapturerChangeInfo.capturerState ==
293 capturerStatequeue_[make_pair(streamChangeInfo.audioCapturerChangeInfo.clientUID,
294 streamChangeInfo.audioCapturerChangeInfo.sessionId)]) {
295 // Capturer state not changed
296 return SUCCESS;
297 }
298 } else {
299 AUDIO_INFO_LOG("AudioStreamCollector: UpdateCapturerStream client %{public}d not found in capturerStatequeue_",
300 streamChangeInfo.audioCapturerChangeInfo.clientUID);
301 }
302
303 // Update the capturer info in audioCapturerChangeInfos_
304 for (auto it = audioCapturerChangeInfos_.begin(); it != audioCapturerChangeInfos_.end(); it++) {
305 AudioCapturerChangeInfo audioCapturerChangeInfo = **it;
306 if (audioCapturerChangeInfo.clientUID == streamChangeInfo.audioCapturerChangeInfo.clientUID &&
307 audioCapturerChangeInfo.sessionId == streamChangeInfo.audioCapturerChangeInfo.sessionId) {
308 capturerStatequeue_[make_pair(audioCapturerChangeInfo.clientUID, audioCapturerChangeInfo.sessionId)] =
309 streamChangeInfo.audioCapturerChangeInfo.capturerState;
310
311 AUDIO_DEBUG_LOG("AudioStreamCollector: Session is updated for client %{public}d session %{public}d",
312 streamChangeInfo.audioCapturerChangeInfo.clientUID,
313 streamChangeInfo.audioCapturerChangeInfo.sessionId);
314
315 unique_ptr<AudioCapturerChangeInfo> CapturerChangeInfo = make_unique<AudioCapturerChangeInfo>();
316 CHECK_AND_RETURN_RET_LOG(CapturerChangeInfo != nullptr,
317 ERR_MEMORY_ALLOC_FAILED, "AudioStreamCollector::CapturerChangeInfo Memory Allocation Failed");
318 CapturerChangeInfo->clientUID = streamChangeInfo.audioCapturerChangeInfo.clientUID;
319 CapturerChangeInfo->sessionId = streamChangeInfo.audioCapturerChangeInfo.sessionId;
320 CapturerChangeInfo->capturerState = streamChangeInfo.audioCapturerChangeInfo.capturerState;
321 CapturerChangeInfo->capturerInfo = streamChangeInfo.audioCapturerChangeInfo.capturerInfo;
322 CapturerChangeInfo->inputDeviceInfo = streamChangeInfo.audioCapturerChangeInfo.inputDeviceInfo;
323 *it = move(CapturerChangeInfo);
324
325 mDispatcherService.SendCapturerInfoEventToDispatcher(AudioMode::AUDIO_MODE_RECORD,
326 audioCapturerChangeInfos_);
327 if (streamChangeInfo.audioCapturerChangeInfo.capturerState == CAPTURER_RELEASED) {
328 audioCapturerChangeInfos_.erase(it);
329 AUDIO_DEBUG_LOG("UpdateCapturerStream::Session is removed for client %{public}d session %{public}d",
330 streamChangeInfo.audioCapturerChangeInfo.clientUID,
331 streamChangeInfo.audioCapturerChangeInfo.sessionId);
332 capturerStatequeue_.erase(make_pair(audioCapturerChangeInfo.clientUID,
333 audioCapturerChangeInfo.sessionId));
334 clientTracker_.erase(audioCapturerChangeInfo.sessionId);
335 }
336 return SUCCESS;
337 }
338 }
339 AUDIO_INFO_LOG("AudioStreamCollector:UpdateCapturerStream: clientUI not in audioCapturerChangeInfos_::%{public}d",
340 streamChangeInfo.audioCapturerChangeInfo.clientUID);
341 return SUCCESS;
342 }
343
UpdateRendererDeviceInfo(DeviceInfo & outputDeviceInfo)344 int32_t AudioStreamCollector::UpdateRendererDeviceInfo(DeviceInfo &outputDeviceInfo)
345 {
346 bool deviceInfoUpdated = false;
347
348 for (auto it = audioRendererChangeInfos_.begin(); it != audioRendererChangeInfos_.end(); it++) {
349 if ((*it)->outputDeviceInfo.deviceType != outputDeviceInfo.deviceType) {
350 AUDIO_DEBUG_LOG("UpdateRendererDeviceInfo: old device: %{public}d new device: %{public}d",
351 (*it)->outputDeviceInfo.deviceType, outputDeviceInfo.deviceType);
352 (*it)->outputDeviceInfo = outputDeviceInfo;
353 deviceInfoUpdated = true;
354 }
355 }
356
357 if (deviceInfoUpdated) {
358 mDispatcherService.SendRendererInfoEventToDispatcher(AudioMode::AUDIO_MODE_PLAYBACK,
359 audioRendererChangeInfos_);
360 }
361
362 return SUCCESS;
363 }
364
UpdateCapturerDeviceInfo(DeviceInfo & inputDeviceInfo)365 int32_t AudioStreamCollector::UpdateCapturerDeviceInfo(DeviceInfo &inputDeviceInfo)
366 {
367 bool deviceInfoUpdated = false;
368
369 for (auto it = audioCapturerChangeInfos_.begin(); it != audioCapturerChangeInfos_.end(); it++) {
370 if ((*it)->inputDeviceInfo.deviceType != inputDeviceInfo.deviceType) {
371 AUDIO_DEBUG_LOG("UpdateCapturerDeviceInfo: old device: %{public}d new device: %{public}d",
372 (*it)->inputDeviceInfo.deviceType, inputDeviceInfo.deviceType);
373 (*it)->inputDeviceInfo = inputDeviceInfo;
374 deviceInfoUpdated = true;
375 }
376 }
377
378 if (deviceInfoUpdated) {
379 mDispatcherService.SendRendererInfoEventToDispatcher(AudioMode::AUDIO_MODE_PLAYBACK,
380 audioRendererChangeInfos_);
381 }
382
383 return SUCCESS;
384 }
385
UpdateTracker(const AudioMode & mode,DeviceInfo & deviceInfo)386 int32_t AudioStreamCollector::UpdateTracker(const AudioMode &mode, DeviceInfo &deviceInfo)
387 {
388 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
389 if (mode == AUDIO_MODE_PLAYBACK) {
390 UpdateRendererDeviceInfo(deviceInfo);
391 } else {
392 UpdateCapturerDeviceInfo(deviceInfo);
393 }
394
395 return SUCCESS;
396 }
397
UpdateTracker(AudioMode & mode,AudioStreamChangeInfo & streamChangeInfo)398 int32_t AudioStreamCollector::UpdateTracker(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo)
399 {
400 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
401 // update the stream change info
402 if (mode == AUDIO_MODE_PLAYBACK) {
403 UpdateRendererStream(streamChangeInfo);
404 } else {
405 // mode = AUDIO_MODE_RECORD
406 UpdateCapturerStream(streamChangeInfo);
407 }
408 return SUCCESS;
409 }
410
GetCurrentRendererChangeInfos(vector<unique_ptr<AudioRendererChangeInfo>> & rendererChangeInfos)411 int32_t AudioStreamCollector::GetCurrentRendererChangeInfos(
412 vector<unique_ptr<AudioRendererChangeInfo>> &rendererChangeInfos)
413 {
414 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
415 for (const auto &changeInfo : audioRendererChangeInfos_) {
416 rendererChangeInfos.push_back(make_unique<AudioRendererChangeInfo>(*changeInfo));
417 }
418 AUDIO_DEBUG_LOG("AudioStreamCollector::GetCurrentRendererChangeInfos returned");
419
420 return SUCCESS;
421 }
422
GetCurrentCapturerChangeInfos(vector<unique_ptr<AudioCapturerChangeInfo>> & capturerChangeInfos)423 int32_t AudioStreamCollector::GetCurrentCapturerChangeInfos(
424 vector<unique_ptr<AudioCapturerChangeInfo>> &capturerChangeInfos)
425 {
426 AUDIO_DEBUG_LOG("AudioStreamCollector::GetCurrentCapturerChangeInfos");
427 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
428 for (const auto &changeInfo : audioCapturerChangeInfos_) {
429 capturerChangeInfos.push_back(make_unique<AudioCapturerChangeInfo>(*changeInfo));
430 AUDIO_DEBUG_LOG("AudioStreamCollector::GetCurrentCapturerChangeInfos returned");
431 }
432
433 return SUCCESS;
434 }
435
RegisteredTrackerClientDied(int32_t uid)436 void AudioStreamCollector::RegisteredTrackerClientDied(int32_t uid)
437 {
438 AUDIO_INFO_LOG("TrackerClientDied:client:%{public}d Died", uid);
439
440 // Send the release state event notification for all streams of died client to registered app
441 int32_t sessionID = -1;
442 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
443 vector<std::unique_ptr<AudioRendererChangeInfo>>::iterator audioRendererBegin = audioRendererChangeInfos_.begin();
444 while (audioRendererBegin != audioRendererChangeInfos_.end()) {
445 const auto &audioRendererChangeInfo = *audioRendererBegin;
446 if (audioRendererChangeInfo == nullptr || audioRendererChangeInfo->clientUID != uid) {
447 audioRendererBegin++;
448 continue;
449 }
450 sessionID = audioRendererChangeInfo->sessionId;
451 audioRendererChangeInfo->rendererState = RENDERER_RELEASED;
452 mDispatcherService.SendRendererInfoEventToDispatcher(AudioMode::AUDIO_MODE_PLAYBACK,
453 audioRendererChangeInfos_);
454 rendererStatequeue_.erase(make_pair(audioRendererChangeInfo->clientUID,
455 audioRendererChangeInfo->sessionId));
456 vector<std::unique_ptr<AudioRendererChangeInfo>>::iterator temp = audioRendererBegin;
457 audioRendererBegin = audioRendererChangeInfos_.erase(temp);
458 if ((sessionID != -1) && clientTracker_.erase(sessionID)) {
459 AUDIO_DEBUG_LOG("AudioStreamCollector::TrackerClientDied:client %{public}d cleared ", sessionID);
460 }
461 }
462
463 sessionID = -1;
464 vector<std::unique_ptr<AudioCapturerChangeInfo>>::iterator audioCapturerBegin = audioCapturerChangeInfos_.begin();
465 while (audioCapturerBegin != audioCapturerChangeInfos_.end()) {
466 const auto &audioCapturerChangeInfo = *audioCapturerBegin;
467 if (audioCapturerChangeInfo == nullptr || audioCapturerChangeInfo->clientUID != uid) {
468 audioCapturerBegin++;
469 continue;
470 }
471 sessionID = audioCapturerChangeInfo->sessionId;
472 audioCapturerChangeInfo->capturerState = CAPTURER_RELEASED;
473 mDispatcherService.SendCapturerInfoEventToDispatcher(AudioMode::AUDIO_MODE_RECORD,
474 audioCapturerChangeInfos_);
475 capturerStatequeue_.erase(make_pair(audioCapturerChangeInfo->clientUID,
476 audioCapturerChangeInfo->sessionId));
477 vector<std::unique_ptr<AudioCapturerChangeInfo>>::iterator temp = audioCapturerBegin;
478 audioCapturerBegin = audioCapturerChangeInfos_.erase(temp);
479 if ((sessionID != -1) && clientTracker_.erase(sessionID)) {
480 AUDIO_DEBUG_LOG("AudioStreamCollector::TrackerClientDied:client %{public}d cleared", sessionID);
481 }
482 }
483 }
484
RegisteredStreamListenerClientDied(int32_t uid)485 void AudioStreamCollector::RegisteredStreamListenerClientDied(int32_t uid)
486 {
487 AUDIO_INFO_LOG("AudioStreamCollector::StreamListenerClientDied:client %{public}d", uid);
488 mDispatcherService.removeRendererListener(uid);
489 mDispatcherService.removeCapturerListener(uid);
490 }
491
GetAndCompareStreamType(AudioStreamType requiredType,AudioRendererInfo rendererInfo)492 bool AudioStreamCollector::GetAndCompareStreamType(AudioStreamType requiredType, AudioRendererInfo rendererInfo)
493 {
494 AudioStreamType defaultStreamType = STREAM_MUSIC;
495 auto pos = streamTypeMap_.find(make_pair(rendererInfo.contentType, rendererInfo.streamUsage));
496 if (pos != streamTypeMap_.end()) {
497 defaultStreamType = pos->second;
498 }
499 return defaultStreamType == requiredType;
500 }
501
UpdateStreamState(int32_t clientUid,StreamSetStateEventInternal & streamSetStateEventInternal)502 int32_t AudioStreamCollector::UpdateStreamState(int32_t clientUid,
503 StreamSetStateEventInternal &streamSetStateEventInternal)
504 {
505 std::lock_guard<std::mutex> lock(streamsInfoMutex_);
506 for (const auto &changeInfo : audioRendererChangeInfos_) {
507 if (changeInfo->clientUID == clientUid &&
508 GetAndCompareStreamType(streamSetStateEventInternal.audioStreamType, changeInfo->rendererInfo)) {
509 AUDIO_INFO_LOG("AudioStreamCollector:UpdateStreamState Found matching uid and type");
510 std::shared_ptr<AudioClientTracker> callback = clientTracker_[changeInfo->sessionId];
511 if (callback == nullptr) {
512 AUDIO_ERR_LOG("AudioStreamCollector:UpdateStreamState callback failed sId:%{public}d",
513 changeInfo->sessionId);
514 continue;
515 }
516 if (streamSetStateEventInternal.streamSetState == StreamSetState::STREAM_PAUSE) {
517 callback->PausedStreamImpl(streamSetStateEventInternal);
518 } else if (streamSetStateEventInternal.streamSetState == StreamSetState::STREAM_RESUME) {
519 callback->ResumeStreamImpl(streamSetStateEventInternal);
520 }
521 }
522 }
523
524 return SUCCESS;
525 }
526
SetLowPowerVolume(int32_t streamId,float volume)527 int32_t AudioStreamCollector::SetLowPowerVolume(int32_t streamId, float volume)
528 {
529 CHECK_AND_RETURN_RET_LOG(!(clientTracker_.count(streamId) == 0),
530 ERR_INVALID_PARAM, "AudioStreamCollector:SetLowPowerVolume streamId invalid.");
531 std::shared_ptr<AudioClientTracker> callback = clientTracker_[streamId];
532 CHECK_AND_RETURN_RET_LOG(callback != nullptr,
533 ERR_INVALID_PARAM, "AudioStreamCollector:SetLowPowerVolume callback failed");
534 callback->SetLowPowerVolumeImpl(volume);
535 return SUCCESS;
536 }
537
GetLowPowerVolume(int32_t streamId)538 float AudioStreamCollector::GetLowPowerVolume(int32_t streamId)
539 {
540 CHECK_AND_RETURN_RET_LOG(!(clientTracker_.count(streamId) == 0),
541 ERR_INVALID_PARAM, "AudioStreamCollector:GetLowPowerVolume streamId invalid.");
542 float volume;
543 std::shared_ptr<AudioClientTracker> callback = clientTracker_[streamId];
544 CHECK_AND_RETURN_RET_LOG(callback != nullptr,
545 ERR_INVALID_PARAM, "AudioStreamCollector:GetLowPowerVolume callback failed");
546 callback->GetLowPowerVolumeImpl(volume);
547 return volume;
548 }
549
GetSingleStreamVolume(int32_t streamId)550 float AudioStreamCollector::GetSingleStreamVolume(int32_t streamId)
551 {
552 CHECK_AND_RETURN_RET_LOG(!(clientTracker_.count(streamId) == 0),
553 ERR_INVALID_PARAM, "AudioStreamCollector:GetSingleStreamVolume streamId invalid.");
554 float volume;
555 std::shared_ptr<AudioClientTracker> callback = clientTracker_[streamId];
556 CHECK_AND_RETURN_RET_LOG(callback != nullptr,
557 ERR_INVALID_PARAM, "AudioStreamCollector:GetSingleStreamVolume callback failed");
558 callback->GetSingleStreamVolumeImpl(volume);
559 return volume;
560 }
561 } // namespace AudioStandard
562 } // namespace OHOS
563