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