1 /*
2 * Copyright (c) 2021-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 "AudioCapturer"
17 #endif
18
19 #include "audio_capturer.h"
20
21 #include <cinttypes>
22
23 #include "audio_capturer_private.h"
24 #include "audio_errors.h"
25 #include "audio_utils.h"
26 #include "audio_capturer_log.h"
27 #include "audio_policy_manager.h"
28
29 #include "media_monitor_manager.h"
30
31 namespace OHOS {
32 namespace AudioStandard {
33 static constexpr uid_t UID_MSDP_SA = 6699;
34 static constexpr int32_t WRITE_OVERFLOW_NUM = 100;
35 static constexpr int32_t AUDIO_SOURCE_TYPE_INVALID_5 = 5;
36
37 std::map<AudioStreamType, SourceType> AudioCapturerPrivate::streamToSource_ = {
38 {AudioStreamType::STREAM_MUSIC, SourceType::SOURCE_TYPE_MIC},
39 {AudioStreamType::STREAM_MEDIA, SourceType::SOURCE_TYPE_MIC},
40 {AudioStreamType::STREAM_MUSIC, SourceType::SOURCE_TYPE_UNPROCESSED},
41 {AudioStreamType::STREAM_CAMCORDER, SourceType::SOURCE_TYPE_CAMCORDER},
42 {AudioStreamType::STREAM_VOICE_CALL, SourceType::SOURCE_TYPE_VOICE_COMMUNICATION},
43 {AudioStreamType::STREAM_ULTRASONIC, SourceType::SOURCE_TYPE_ULTRASONIC},
44 {AudioStreamType::STREAM_WAKEUP, SourceType::SOURCE_TYPE_WAKEUP},
45 {AudioStreamType::STREAM_SOURCE_VOICE_CALL, SourceType::SOURCE_TYPE_VOICE_CALL},
46 };
47
48 AudioCapturer::~AudioCapturer() = default;
49
~AudioCapturerPrivate()50 AudioCapturerPrivate::~AudioCapturerPrivate()
51 {
52 AUDIO_INFO_LOG("~AudioCapturerPrivate");
53 std::shared_ptr<InputDeviceChangeWithInfoCallbackImpl> inputDeviceChangeCallback = inputDeviceChangeCallback_;
54 if (inputDeviceChangeCallback != nullptr) {
55 inputDeviceChangeCallback->UnsetAudioCapturerObj();
56 }
57 AudioPolicyManager::GetInstance().UnregisterDeviceChangeWithInfoCallback(sessionID_);
58 if (audioStream_ != nullptr) {
59 audioStream_->ReleaseAudioStream(true);
60 audioStream_ = nullptr;
61 }
62 if (audioStateChangeCallback_ != nullptr) {
63 audioStateChangeCallback_->HandleCapturerDestructor();
64 }
65 DumpFileUtil::CloseDumpFile(&dumpFile_);
66 }
67
Create(AudioStreamType audioStreamType)68 std::unique_ptr<AudioCapturer> AudioCapturer::Create(AudioStreamType audioStreamType)
69 {
70 AppInfo appInfo = {};
71 return Create(audioStreamType, appInfo);
72 }
73
Create(AudioStreamType audioStreamType,const AppInfo & appInfo)74 std::unique_ptr<AudioCapturer> AudioCapturer::Create(AudioStreamType audioStreamType, const AppInfo &appInfo)
75 {
76 return std::make_unique<AudioCapturerPrivate>(audioStreamType, appInfo, true);
77 }
78
Create(const AudioCapturerOptions & options)79 std::unique_ptr<AudioCapturer> AudioCapturer::Create(const AudioCapturerOptions &options)
80 {
81 AppInfo appInfo = {};
82 return Create(options, "", appInfo);
83 }
84
Create(const AudioCapturerOptions & options,const AppInfo & appInfo)85 std::unique_ptr<AudioCapturer> AudioCapturer::Create(const AudioCapturerOptions &options, const AppInfo &appInfo)
86 {
87 return Create(options, "", appInfo);
88 }
89
Create(const AudioCapturerOptions & options,const std::string cachePath)90 std::unique_ptr<AudioCapturer> AudioCapturer::Create(const AudioCapturerOptions &options, const std::string cachePath)
91 {
92 AppInfo appInfo = {};
93 return Create(options, cachePath, appInfo);
94 }
95
Create(const AudioCapturerOptions & capturerOptions,const std::string cachePath,const AppInfo & appInfo)96 std::unique_ptr<AudioCapturer> AudioCapturer::Create(const AudioCapturerOptions &capturerOptions,
97 const std::string cachePath, const AppInfo &appInfo)
98 {
99 Trace trace("AudioCapturer::Create");
100 auto sourceType = capturerOptions.capturerInfo.sourceType;
101 if (sourceType < SOURCE_TYPE_MIC || sourceType > SOURCE_TYPE_MAX || sourceType == AUDIO_SOURCE_TYPE_INVALID_5) {
102 AudioCapturer::SendCapturerCreateError(sourceType, ERR_INVALID_PARAM);
103 AUDIO_ERR_LOG("Invalid source type %{public}d!", sourceType);
104 return nullptr;
105 }
106 if (sourceType == SOURCE_TYPE_ULTRASONIC && getuid() != UID_MSDP_SA) {
107 AudioCapturer::SendCapturerCreateError(sourceType, ERR_INVALID_PARAM);
108 }
109 CHECK_AND_RETURN_RET_LOG(sourceType != SOURCE_TYPE_ULTRASONIC || getuid() == UID_MSDP_SA, nullptr,
110 "Create failed: SOURCE_TYPE_ULTRASONIC can only be used by MSDP");
111 AudioStreamType audioStreamType = FindStreamTypeBySourceType(sourceType);
112 AudioCapturerParams params;
113 params.audioSampleFormat = capturerOptions.streamInfo.format;
114 params.samplingRate = capturerOptions.streamInfo.samplingRate;
115 bool isChange = false;
116 if (AudioChannel::CHANNEL_3 == capturerOptions.streamInfo.channels) {
117 params.audioChannel = AudioChannel::STEREO;
118 isChange = true;
119 } else {
120 params.audioChannel = capturerOptions.streamInfo.channels;
121 }
122 params.audioEncoding = capturerOptions.streamInfo.encoding;
123 params.channelLayout = capturerOptions.streamInfo.channelLayout;
124 auto capturer = std::make_unique<AudioCapturerPrivate>(audioStreamType, appInfo, false);
125 if (capturer == nullptr) {
126 AudioCapturer::SendCapturerCreateError(sourceType, ERR_OPERATION_FAILED);
127 AUDIO_ERR_LOG("Failed to create capturer object");
128 return capturer;
129 }
130 if (!cachePath.empty()) {
131 capturer->cachePath_ = cachePath;
132 }
133 AUDIO_INFO_LOG("Capturer::Create sourceType: %{public}d, uid: %{public}d", sourceType, appInfo.appUid);
134 // InitPlaybackCapturer will be replaced by UpdatePlaybackCaptureConfig.
135 capturer->capturerInfo_.sourceType = sourceType;
136 capturer->capturerInfo_.capturerFlags = capturerOptions.capturerInfo.capturerFlags;
137 capturer->capturerInfo_.originalFlag = capturerOptions.capturerInfo.capturerFlags;
138 capturer->capturerInfo_.samplingRate = capturerOptions.streamInfo.samplingRate;
139 capturer->filterConfig_ = capturerOptions.playbackCaptureConfig;
140 capturer->strategy_ = capturerOptions.strategy;
141 if (capturer->SetParams(params) != SUCCESS) {
142 AudioCapturer::SendCapturerCreateError(sourceType, ERR_OPERATION_FAILED);
143 capturer = nullptr;
144 }
145 if (capturer != nullptr && isChange) {
146 capturer->isChannelChange_ = true;
147 }
148 return capturer;
149 }
150
151 // This will be called in Create and after Create.
UpdatePlaybackCaptureConfig(const AudioPlaybackCaptureConfig & config)152 int32_t AudioCapturerPrivate::UpdatePlaybackCaptureConfig(const AudioPlaybackCaptureConfig &config)
153 {
154 // UpdatePlaybackCaptureConfig will only work for InnerCap streams.
155 if (capturerInfo_.sourceType != SOURCE_TYPE_PLAYBACK_CAPTURE) {
156 AUDIO_WARNING_LOG("This is not a PLAYBACK_CAPTURE stream.");
157 return ERR_INVALID_OPERATION;
158 }
159
160 if (config.filterOptions.usages.size() == 0 && config.filterOptions.pids.size() == 0) {
161 AUDIO_WARNING_LOG("Both usages and pids are empty!");
162 }
163
164 CHECK_AND_RETURN_RET_LOG(audioStream_ != nullptr, ERR_OPERATION_FAILED, "Failed with null audioStream_");
165
166 return audioStream_->UpdatePlaybackCaptureConfig(config);
167 }
168
SendCapturerCreateError(const SourceType & sourceType,const int32_t & errorCode)169 void AudioCapturer::SendCapturerCreateError(const SourceType &sourceType,
170 const int32_t &errorCode)
171 {
172 std::shared_ptr<Media::MediaMonitor::EventBean> bean = std::make_shared<Media::MediaMonitor::EventBean>(
173 Media::MediaMonitor::ModuleId::AUDIO, Media::MediaMonitor::EventId::AUDIO_STREAM_CREATE_ERROR_STATS,
174 Media::MediaMonitor::EventType::FREQUENCY_AGGREGATION_EVENT);
175 bean->Add("IS_PLAYBACK", 0);
176 bean->Add("CLIENT_UID", static_cast<int32_t>(getuid()));
177 bean->Add("STREAM_TYPE", sourceType);
178 bean->Add("ERROR_CODE", errorCode);
179 Media::MediaMonitor::MediaMonitorManager::GetInstance().WriteLogMsg(bean);
180 }
181
AudioCapturerPrivate(AudioStreamType audioStreamType,const AppInfo & appInfo,bool createStream)182 AudioCapturerPrivate::AudioCapturerPrivate(AudioStreamType audioStreamType, const AppInfo &appInfo, bool createStream)
183 {
184 if (audioStreamType < STREAM_VOICE_CALL || audioStreamType > STREAM_ALL) {
185 AUDIO_WARNING_LOG("audioStreamType is invalid!");
186 }
187 audioStreamType_ = audioStreamType;
188 auto iter = streamToSource_.find(audioStreamType);
189 if (iter != streamToSource_.end()) {
190 capturerInfo_.sourceType = iter->second;
191 }
192 appInfo_ = appInfo;
193 if (!(appInfo_.appPid)) {
194 appInfo_.appPid = getpid();
195 }
196
197 if (appInfo_.appUid < 0) {
198 appInfo_.appUid = static_cast<int32_t>(getuid());
199 }
200 if (createStream) {
201 AudioStreamParams tempParams = {};
202 audioStream_ = IAudioStream::GetRecordStream(IAudioStream::PA_STREAM, tempParams, audioStreamType_,
203 appInfo_.appUid);
204 AUDIO_INFO_LOG("create normal stream for old mode.");
205 }
206
207 capturerProxyObj_ = std::make_shared<AudioCapturerProxyObj>();
208 if (!capturerProxyObj_) {
209 AUDIO_WARNING_LOG("AudioCapturerProxyObj Memory Allocation Failed !!");
210 }
211 }
212
InitPlaybackCapturer(int32_t type,const AudioPlaybackCaptureConfig & config)213 int32_t AudioCapturerPrivate::InitPlaybackCapturer(int32_t type, const AudioPlaybackCaptureConfig &config)
214 {
215 if (type != SOURCE_TYPE_PLAYBACK_CAPTURE) {
216 return SUCCESS;
217 }
218 return AudioPolicyManager::GetInstance().SetPlaybackCapturerFilterInfos(config, appInfo_.appTokenId);
219 }
220
SetCaptureSilentState(bool state)221 int32_t AudioCapturerPrivate::SetCaptureSilentState(bool state)
222 {
223 return AudioPolicyManager::GetInstance().SetCaptureSilentState(state);
224 }
225
GetFrameCount(uint32_t & frameCount) const226 int32_t AudioCapturerPrivate::GetFrameCount(uint32_t &frameCount) const
227 {
228 return audioStream_->GetFrameCount(frameCount);
229 }
230
GetPreferredStreamClass(AudioStreamParams audioStreamParams)231 IAudioStream::StreamClass AudioCapturerPrivate::GetPreferredStreamClass(AudioStreamParams audioStreamParams)
232 {
233 int32_t flag = AudioPolicyManager::GetInstance().GetPreferredInputStreamType(capturerInfo_);
234 AUDIO_INFO_LOG("Preferred capturer flag: %{public}d", flag);
235 if (flag == AUDIO_FLAG_MMAP && IAudioStream::IsStreamSupported(capturerInfo_.originalFlag, audioStreamParams)) {
236 capturerInfo_.capturerFlags = AUDIO_FLAG_MMAP;
237 return IAudioStream::FAST_STREAM;
238 }
239 if (flag == AUDIO_FLAG_VOIP_FAST) {
240 // It is not possible to directly create a fast VoIP stream
241 isFastVoipSupported_ = true;
242 }
243
244 capturerInfo_.capturerFlags = AUDIO_FLAG_NORMAL;
245 return IAudioStream::PA_STREAM;
246 }
247
SetParams(const AudioCapturerParams params)248 int32_t AudioCapturerPrivate::SetParams(const AudioCapturerParams params)
249 {
250 Trace trace("AudioCapturer::SetParams");
251 AUDIO_INFO_LOG("StreamClientState for Capturer::SetParams.");
252
253 std::shared_lock<std::shared_mutex> lockShared(switchStreamMutex_);
254 std::lock_guard<std::mutex> lock(setParamsMutex_);
255
256 AudioStreamParams audioStreamParams = ConvertToAudioStreamParams(params);
257
258 IAudioStream::StreamClass streamClass = IAudioStream::PA_STREAM;
259 if (capturerInfo_.sourceType != SOURCE_TYPE_PLAYBACK_CAPTURE) {
260 streamClass = GetPreferredStreamClass(audioStreamParams);
261 }
262 ActivateAudioConcurrency(streamClass);
263
264 // check AudioStreamParams for fast stream
265 if (audioStream_ == nullptr) {
266 audioStream_ = IAudioStream::GetRecordStream(streamClass, audioStreamParams, audioStreamType_,
267 appInfo_.appUid);
268 CHECK_AND_RETURN_RET_LOG(audioStream_ != nullptr, ERR_INVALID_PARAM, "SetParams GetRecordStream faied.");
269 AUDIO_INFO_LOG("IAudioStream::GetStream success");
270 audioStream_->SetApplicationCachePath(cachePath_);
271 }
272 int32_t ret = InitAudioStream(audioStreamParams);
273 // When the fast stream creation fails, a normal stream is created
274 if (ret != SUCCESS && streamClass == IAudioStream::FAST_STREAM) {
275 AUDIO_INFO_LOG("Create fast Stream fail, record by normal stream");
276 streamClass = IAudioStream::PA_STREAM;
277 audioStream_ = IAudioStream::GetRecordStream(streamClass, audioStreamParams, audioStreamType_, appInfo_.appUid);
278 CHECK_AND_RETURN_RET_LOG(audioStream_ != nullptr, ERR_INVALID_PARAM, "Get normal record stream failed");
279 ret = InitAudioStream(audioStreamParams);
280 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Init normal audio stream failed");
281 audioStream_->SetCaptureMode(CAPTURE_MODE_CALLBACK);
282 }
283 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "InitAudioStream failed");
284
285 RegisterCapturerPolicyServiceDiedCallback();
286
287 if (audioStream_->GetAudioSessionID(sessionID_) != 0) {
288 AUDIO_ERR_LOG("GetAudioSessionID failed!");
289 return ERR_INVALID_INDEX;
290 }
291 // eg: 100009_44100_2_1_cap_client_out.pcm
292 std::string dumpFileName = std::to_string(sessionID_) + "_" + std::to_string(params.samplingRate) + "_" +
293 std::to_string(params.audioChannel) + "_" + std::to_string(params.audioSampleFormat) + "_cap_client_out.pcm";
294 DumpFileUtil::OpenDumpFile(DUMP_CLIENT_PARA, dumpFileName, &dumpFile_);
295
296 ret = InitInputDeviceChangeCallback();
297 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Init input device change callback failed");
298
299 return InitAudioInterruptCallback();
300 }
301
InitInputDeviceChangeCallback()302 int32_t AudioCapturerPrivate::InitInputDeviceChangeCallback()
303 {
304 CHECK_AND_RETURN_RET_LOG(GetCurrentInputDevices(currentDeviceInfo_) == SUCCESS, ERROR,
305 "Get current device info failed");
306
307 if (!inputDeviceChangeCallback_) {
308 inputDeviceChangeCallback_ = std::make_shared<InputDeviceChangeWithInfoCallbackImpl>();
309 CHECK_AND_RETURN_RET_LOG(inputDeviceChangeCallback_ != nullptr, ERROR, "Memory allocation failed");
310 }
311
312 inputDeviceChangeCallback_->SetAudioCapturerObj(this);
313
314 uint32_t sessionId;
315 int32_t ret = GetAudioStreamId(sessionId);
316 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Get sessionId failed");
317
318 ret = AudioPolicyManager::GetInstance().RegisterDeviceChangeWithInfoCallback(sessionId,
319 inputDeviceChangeCallback_);
320 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Register failed");
321
322 return SUCCESS;
323 }
324
InitAudioStream(const AudioStreamParams & audioStreamParams)325 int32_t AudioCapturerPrivate::InitAudioStream(const AudioStreamParams &audioStreamParams)
326 {
327 Trace trace("AudioCapturer::InitAudioStream");
328 const AudioCapturer *capturer = this;
329 capturerProxyObj_->SaveCapturerObj(capturer);
330
331 audioStream_->SetCapturerInfo(capturerInfo_);
332
333 audioStream_->SetClientID(appInfo_.appPid, appInfo_.appUid, appInfo_.appTokenId, appInfo_.appFullTokenId);
334
335 if (capturerInfo_.sourceType == SOURCE_TYPE_PLAYBACK_CAPTURE) {
336 audioStream_->SetInnerCapturerState(true);
337 } else if (capturerInfo_.sourceType == SourceType::SOURCE_TYPE_WAKEUP) {
338 audioStream_->SetWakeupCapturerState(true);
339 }
340
341 audioStream_->SetCapturerSource(capturerInfo_.sourceType);
342
343 int32_t ret = audioStream_->SetAudioStreamInfo(audioStreamParams, capturerProxyObj_);
344 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "SetAudioStreamInfo failed");
345 // for inner-capturer
346 if (capturerInfo_.sourceType == SOURCE_TYPE_PLAYBACK_CAPTURE) {
347 ret = UpdatePlaybackCaptureConfig(filterConfig_);
348 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "UpdatePlaybackCaptureConfig Failed");
349 }
350 InitLatencyMeasurement(audioStreamParams);
351 InitAudioConcurrencyCallback();
352 return ret;
353 }
354
CheckSignalData(uint8_t * buffer,size_t bufferSize) const355 void AudioCapturerPrivate::CheckSignalData(uint8_t *buffer, size_t bufferSize) const
356 {
357 std::lock_guard lock(signalDetectAgentMutex_);
358 if (!latencyMeasEnabled_) {
359 return;
360 }
361 CHECK_AND_RETURN_LOG(signalDetectAgent_ != nullptr, "LatencyMeas signalDetectAgent_ is nullptr");
362 bool detected = signalDetectAgent_->CheckAudioData(buffer, bufferSize);
363 if (detected) {
364 if (capturerInfo_.capturerFlags == IAudioStream::FAST_STREAM) {
365 AUDIO_INFO_LOG("LatencyMeas fast capturer signal detected");
366 } else {
367 AUDIO_INFO_LOG("LatencyMeas normal capturer signal detected");
368 }
369 audioStream_->UpdateLatencyTimestamp(signalDetectAgent_->lastPeakBufferTime_, false);
370 }
371 }
372
InitLatencyMeasurement(const AudioStreamParams & audioStreamParams)373 void AudioCapturerPrivate::InitLatencyMeasurement(const AudioStreamParams &audioStreamParams)
374 {
375 std::lock_guard lock(signalDetectAgentMutex_);
376 latencyMeasEnabled_ = AudioLatencyMeasurement::CheckIfEnabled();
377 AUDIO_INFO_LOG("LatencyMeas enabled in capturer:%{public}d", latencyMeasEnabled_);
378 if (!latencyMeasEnabled_) {
379 return;
380 }
381 signalDetectAgent_ = std::make_shared<SignalDetectAgent>();
382 CHECK_AND_RETURN_LOG(signalDetectAgent_ != nullptr, "LatencyMeas signalDetectAgent_ is nullptr");
383 signalDetectAgent_->sampleFormat_ = audioStreamParams.format;
384 signalDetectAgent_->formatByteSize_ = GetFormatByteSize(audioStreamParams.format);
385 }
386
InitAudioInterruptCallback()387 int32_t AudioCapturerPrivate::InitAudioInterruptCallback()
388 {
389 if (audioInterrupt_.sessionId != 0) {
390 AUDIO_INFO_LOG("old session already has interrupt, need to reset");
391 (void)AudioPolicyManager::GetInstance().DeactivateAudioInterrupt(audioInterrupt_);
392 (void)AudioPolicyManager::GetInstance().UnsetAudioInterruptCallback(audioInterrupt_.sessionId);
393 }
394
395 if (audioStream_->GetAudioSessionID(sessionID_) != 0) {
396 AUDIO_ERR_LOG("GetAudioSessionID failed for INDEPENDENT_MODE");
397 return ERR_INVALID_INDEX;
398 }
399 audioInterrupt_.sessionId = sessionID_;
400 audioInterrupt_.pid = appInfo_.appPid;
401 audioInterrupt_.audioFocusType.sourceType = capturerInfo_.sourceType;
402 audioInterrupt_.sessionStrategy = strategy_;
403 if (audioInterrupt_.audioFocusType.sourceType == SOURCE_TYPE_VIRTUAL_CAPTURE) {
404 isVoiceCallCapturer_ = true;
405 audioInterrupt_.audioFocusType.sourceType = SOURCE_TYPE_VOICE_COMMUNICATION;
406 }
407 if (audioInterruptCallback_ == nullptr) {
408 audioInterruptCallback_ = std::make_shared<AudioCapturerInterruptCallbackImpl>(audioStream_);
409 CHECK_AND_RETURN_RET_LOG(audioInterruptCallback_ != nullptr, ERROR,
410 "Failed to allocate memory for audioInterruptCallback_");
411 }
412 return AudioPolicyManager::GetInstance().SetAudioInterruptCallback(sessionID_, audioInterruptCallback_,
413 appInfo_.appUid);
414 }
415
SetCapturerCallback(const std::shared_ptr<AudioCapturerCallback> & callback)416 int32_t AudioCapturerPrivate::SetCapturerCallback(const std::shared_ptr<AudioCapturerCallback> &callback)
417 {
418 std::lock_guard<std::mutex> lock(setCapturerCbMutex_);
419 // If the client is using the deprecated SetParams API. SetCapturerCallback must be invoked, after SetParams.
420 // In general, callbacks can only be set after the capturer state is PREPARED.
421 CapturerState state = GetStatus();
422 CHECK_AND_RETURN_RET_LOG(state != CAPTURER_NEW && state != CAPTURER_RELEASED, ERR_ILLEGAL_STATE,
423 "SetCapturerCallback ncorrect state:%{public}d to register cb", state);
424 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM,
425 "SetCapturerCallback callback param is null");
426
427 // Save reference for interrupt callback
428 CHECK_AND_RETURN_RET_LOG(audioInterruptCallback_ != nullptr, ERROR,
429 "SetCapturerCallback audioInterruptCallback_ == nullptr");
430 std::shared_ptr<AudioCapturerInterruptCallbackImpl> cbInterrupt =
431 std::static_pointer_cast<AudioCapturerInterruptCallbackImpl>(audioInterruptCallback_);
432 cbInterrupt->SaveCallback(callback);
433
434 // Save and Set reference for stream callback. Order is important here.
435 if (audioStreamCallback_ == nullptr) {
436 audioStreamCallback_ = std::make_shared<AudioStreamCallbackCapturer>();
437 CHECK_AND_RETURN_RET_LOG(audioStreamCallback_ != nullptr, ERROR,
438 "Failed to allocate memory for audioStreamCallback_");
439 }
440 std::shared_ptr<AudioStreamCallbackCapturer> cbStream =
441 std::static_pointer_cast<AudioStreamCallbackCapturer>(audioStreamCallback_);
442 cbStream->SaveCallback(callback);
443 (void)audioStream_->SetStreamCallback(audioStreamCallback_);
444
445 return SUCCESS;
446 }
447
GetParams(AudioCapturerParams & params) const448 int32_t AudioCapturerPrivate::GetParams(AudioCapturerParams ¶ms) const
449 {
450 AudioStreamParams audioStreamParams;
451 int32_t result = audioStream_->GetAudioStreamInfo(audioStreamParams);
452 if (SUCCESS == result) {
453 params.audioSampleFormat = static_cast<AudioSampleFormat>(audioStreamParams.format);
454 params.samplingRate = static_cast<AudioSamplingRate>(audioStreamParams.samplingRate);
455 params.audioChannel = static_cast<AudioChannel>(audioStreamParams.channels);
456 params.audioEncoding = static_cast<AudioEncodingType>(audioStreamParams.encoding);
457 }
458
459 return result;
460 }
461
GetCapturerInfo(AudioCapturerInfo & capturerInfo) const462 int32_t AudioCapturerPrivate::GetCapturerInfo(AudioCapturerInfo &capturerInfo) const
463 {
464 capturerInfo = capturerInfo_;
465
466 return SUCCESS;
467 }
468
GetStreamInfo(AudioStreamInfo & streamInfo) const469 int32_t AudioCapturerPrivate::GetStreamInfo(AudioStreamInfo &streamInfo) const
470 {
471 AudioStreamParams audioStreamParams;
472 int32_t result = audioStream_->GetAudioStreamInfo(audioStreamParams);
473 if (SUCCESS == result) {
474 streamInfo.format = static_cast<AudioSampleFormat>(audioStreamParams.format);
475 streamInfo.samplingRate = static_cast<AudioSamplingRate>(audioStreamParams.samplingRate);
476 if (this->isChannelChange_) {
477 streamInfo.channels = AudioChannel::CHANNEL_3;
478 } else {
479 streamInfo.channels = static_cast<AudioChannel>(audioStreamParams.channels);
480 }
481 streamInfo.encoding = static_cast<AudioEncodingType>(audioStreamParams.encoding);
482 }
483
484 return result;
485 }
486
SetCapturerPositionCallback(int64_t markPosition,const std::shared_ptr<CapturerPositionCallback> & callback)487 int32_t AudioCapturerPrivate::SetCapturerPositionCallback(int64_t markPosition,
488 const std::shared_ptr<CapturerPositionCallback> &callback)
489 {
490 CHECK_AND_RETURN_RET_LOG((callback != nullptr) && (markPosition > 0), ERR_INVALID_PARAM,
491 "input param is invalid");
492
493 audioStream_->SetCapturerPositionCallback(markPosition, callback);
494
495 return SUCCESS;
496 }
497
UnsetCapturerPositionCallback()498 void AudioCapturerPrivate::UnsetCapturerPositionCallback()
499 {
500 audioStream_->UnsetCapturerPositionCallback();
501 }
502
SetCapturerPeriodPositionCallback(int64_t frameNumber,const std::shared_ptr<CapturerPeriodPositionCallback> & callback)503 int32_t AudioCapturerPrivate::SetCapturerPeriodPositionCallback(int64_t frameNumber,
504 const std::shared_ptr<CapturerPeriodPositionCallback> &callback)
505 {
506 CHECK_AND_RETURN_RET_LOG((callback != nullptr) && (frameNumber > 0), ERR_INVALID_PARAM,
507 "input param is invalid");
508
509 audioStream_->SetCapturerPeriodPositionCallback(frameNumber, callback);
510
511 return SUCCESS;
512 }
513
UnsetCapturerPeriodPositionCallback()514 void AudioCapturerPrivate::UnsetCapturerPeriodPositionCallback()
515 {
516 audioStream_->UnsetCapturerPeriodPositionCallback();
517 }
518
Start() const519 bool AudioCapturerPrivate::Start() const
520 {
521 Trace trace("AudioCapturer::Start" + std::to_string(sessionID_));
522 std::lock_guard lock(switchStreamMutex_);
523 AUDIO_INFO_LOG("StreamClientState for Capturer::Start. id %{public}u, sourceType: %{public}d",
524 sessionID_, audioInterrupt_.audioFocusType.sourceType);
525
526 CapturerState state = GetStatus();
527 CHECK_AND_RETURN_RET_LOG((state == CAPTURER_PREPARED) || (state == CAPTURER_STOPPED) || (state == CAPTURER_PAUSED),
528 false, "Start failed. Illegal state %{public}u.", state);
529
530 CHECK_AND_RETURN_RET_LOG(!isSwitching_, false, "Operation failed, in switching");
531
532 CHECK_AND_RETURN_RET(audioInterrupt_.audioFocusType.sourceType != SOURCE_TYPE_INVALID &&
533 audioInterrupt_.sessionId != INVALID_SESSION_ID, false);
534
535 int32_t ret = AudioPolicyManager::GetInstance().ActivateAudioInterrupt(audioInterrupt_);
536 CHECK_AND_RETURN_RET_LOG(ret == 0, false, "ActivateAudioInterrupt Failed");
537
538 // When the cellular call stream is starting, only need to activate audio interrupt.
539 CHECK_AND_RETURN_RET(!isVoiceCallCapturer_, true);
540
541 bool result = audioStream_->StartAudioStream();
542 if (!result) {
543 AUDIO_ERR_LOG("Start audio stream failed");
544 ret = AudioPolicyManager::GetInstance().DeactivateAudioInterrupt(audioInterrupt_);
545 if (ret != 0) {
546 AUDIO_WARNING_LOG("DeactivateAudioInterrupt Failed");
547 }
548 }
549
550 return result;
551 }
552
Read(uint8_t & buffer,size_t userSize,bool isBlockingRead) const553 int32_t AudioCapturerPrivate::Read(uint8_t &buffer, size_t userSize, bool isBlockingRead) const
554 {
555 Trace trace("AudioCapturer::Read");
556 CheckSignalData(&buffer, userSize);
557 int size = audioStream_->Read(buffer, userSize, isBlockingRead);
558 if (size > 0) {
559 DumpFileUtil::WriteDumpFile(dumpFile_, static_cast<void *>(&buffer), size);
560 }
561 return size;
562 }
563
GetStatus() const564 CapturerState AudioCapturerPrivate::GetStatus() const
565 {
566 return (CapturerState)audioStream_->GetState();
567 }
568
GetAudioTime(Timestamp & timestamp,Timestamp::Timestampbase base) const569 bool AudioCapturerPrivate::GetAudioTime(Timestamp ×tamp, Timestamp::Timestampbase base) const
570 {
571 return audioStream_->GetAudioTime(timestamp, base);
572 }
573
Pause() const574 bool AudioCapturerPrivate::Pause() const
575 {
576 Trace trace("AudioCapturer::Pause" + std::to_string(sessionID_));
577 std::lock_guard lock(switchStreamMutex_);
578 AUDIO_INFO_LOG("StreamClientState for Capturer::Pause. id %{public}u", sessionID_);
579 CHECK_AND_RETURN_RET_LOG(!isSwitching_, false, "Operation failed, in switching");
580
581 // When user is intentionally pausing , Deactivate to remove from audio focus info list
582 int32_t ret = AudioPolicyManager::GetInstance().DeactivateAudioInterrupt(audioInterrupt_);
583 if (ret != 0) {
584 AUDIO_WARNING_LOG("AudioRenderer: DeactivateAudioInterrupt Failed");
585 }
586
587 // When the cellular call stream is pausing, only need to deactivate audio interrupt.
588 CHECK_AND_RETURN_RET(!isVoiceCallCapturer_, true);
589 return audioStream_->PauseAudioStream();
590 }
591
Stop() const592 bool AudioCapturerPrivate::Stop() const
593 {
594 Trace trace("AudioCapturer::Stop" + std::to_string(sessionID_));
595 std::lock_guard lock(switchStreamMutex_);
596 AUDIO_INFO_LOG("StreamClientState for Capturer::Stop. id %{public}u", sessionID_);
597 CHECK_AND_RETURN_RET_LOG(!isSwitching_, false, "Operation failed, in switching");
598
599 WriteOverflowEvent();
600 int32_t ret = AudioPolicyManager::GetInstance().DeactivateAudioInterrupt(audioInterrupt_);
601 if (ret != 0) {
602 AUDIO_WARNING_LOG("AudioCapturer: DeactivateAudioInterrupt Failed");
603 }
604
605 CHECK_AND_RETURN_RET(isVoiceCallCapturer_ != true, true);
606
607 return audioStream_->StopAudioStream();
608 }
609
Flush() const610 bool AudioCapturerPrivate::Flush() const
611 {
612 Trace trace("AudioCapturer::Flush");
613 AUDIO_INFO_LOG("StreamClientState for Capturer::Flush. id %{public}u", sessionID_);
614 return audioStream_->FlushAudioStream();
615 }
616
Release()617 bool AudioCapturerPrivate::Release()
618 {
619 AUDIO_INFO_LOG("StreamClientState for Capturer::Release. id %{public}u", sessionID_);
620
621 abortRestore_ = true;
622 std::lock_guard<std::mutex> lock(lock_);
623 CHECK_AND_RETURN_RET_LOG(isValid_, false, "Release when capturer invalid");
624
625 (void)AudioPolicyManager::GetInstance().DeactivateAudioInterrupt(audioInterrupt_);
626
627 // Unregister the callaback in policy server
628 (void)AudioPolicyManager::GetInstance().UnsetAudioInterruptCallback(sessionID_);
629
630 std::shared_ptr<AudioCapturerConcurrencyCallbackImpl> cb = audioConcurrencyCallback_;
631 if (cb != nullptr) {
632 cb->UnsetAudioCapturerObj();
633 AudioPolicyManager::GetInstance().UnsetAudioConcurrencyCallback(sessionID_);
634 }
635
636 RemoveCapturerPolicyServiceDiedCallback();
637
638 return audioStream_->ReleaseAudioStream();
639 }
640
GetBufferSize(size_t & bufferSize) const641 int32_t AudioCapturerPrivate::GetBufferSize(size_t &bufferSize) const
642 {
643 Trace trace("AudioCapturer::GetBufferSize");
644 return audioStream_->GetBufferSize(bufferSize);
645 }
646
GetAudioStreamId(uint32_t & sessionID) const647 int32_t AudioCapturerPrivate::GetAudioStreamId(uint32_t &sessionID) const
648 {
649 CHECK_AND_RETURN_RET_LOG(audioStream_ != nullptr, ERR_INVALID_HANDLE, "GetAudioStreamId faied.");
650 return audioStream_->GetAudioSessionID(sessionID);
651 }
652
SetBufferDuration(uint64_t bufferDuration) const653 int32_t AudioCapturerPrivate::SetBufferDuration(uint64_t bufferDuration) const
654 {
655 CHECK_AND_RETURN_RET_LOG(bufferDuration >= MINIMUM_BUFFER_SIZE_MSEC && bufferDuration <= MAXIMUM_BUFFER_SIZE_MSEC,
656 ERR_INVALID_PARAM, "Error: Please set the buffer duration between 5ms ~ 20ms");
657 return audioStream_->SetBufferSizeInMsec(bufferDuration);
658 }
659
SetApplicationCachePath(const std::string cachePath)660 void AudioCapturerPrivate::SetApplicationCachePath(const std::string cachePath)
661 {
662 cachePath_ = cachePath;
663 if (audioStream_ != nullptr) {
664 audioStream_->SetApplicationCachePath(cachePath_);
665 } else {
666 AUDIO_WARNING_LOG("AudioCapturer SetApplicationCachePath while stream is null");
667 }
668 }
669
AudioCapturerInterruptCallbackImpl(const std::shared_ptr<IAudioStream> & audioStream)670 AudioCapturerInterruptCallbackImpl::AudioCapturerInterruptCallbackImpl(const std::shared_ptr<IAudioStream> &audioStream)
671 : audioStream_(audioStream)
672 {
673 AUDIO_DEBUG_LOG("AudioCapturerInterruptCallbackImpl constructor");
674 }
675
~AudioCapturerInterruptCallbackImpl()676 AudioCapturerInterruptCallbackImpl::~AudioCapturerInterruptCallbackImpl()
677 {
678 AUDIO_DEBUG_LOG("AudioCapturerInterruptCallbackImpl: instance destroy");
679 }
680
SaveCallback(const std::weak_ptr<AudioCapturerCallback> & callback)681 void AudioCapturerInterruptCallbackImpl::SaveCallback(const std::weak_ptr<AudioCapturerCallback> &callback)
682 {
683 callback_ = callback;
684 }
685
UpdateAudioStream(const std::shared_ptr<IAudioStream> & audioStream)686 void AudioCapturerInterruptCallbackImpl::UpdateAudioStream(const std::shared_ptr<IAudioStream> &audioStream)
687 {
688 std::lock_guard<std::mutex> lock(mutex_);
689 audioStream_ = audioStream;
690 }
691
NotifyEvent(const InterruptEvent & interruptEvent)692 void AudioCapturerInterruptCallbackImpl::NotifyEvent(const InterruptEvent &interruptEvent)
693 {
694 AUDIO_INFO_LOG("NotifyEvent: Hint: %{public}d, eventType: %{public}d",
695 interruptEvent.hintType, interruptEvent.eventType);
696
697 if (cb_ != nullptr) {
698 cb_->OnInterrupt(interruptEvent);
699 AUDIO_DEBUG_LOG("OnInterrupt : NotifyEvent to app complete");
700 } else {
701 AUDIO_DEBUG_LOG("cb_ == nullptr cannont NotifyEvent to app");
702 }
703 }
704
NotifyForcePausedToResume(const InterruptEventInternal & interruptEvent)705 void AudioCapturerInterruptCallbackImpl::NotifyForcePausedToResume(const InterruptEventInternal &interruptEvent)
706 {
707 // Change InterruptForceType to Share, Since app will take care of resuming
708 InterruptEvent interruptEventResume {interruptEvent.eventType, INTERRUPT_SHARE,
709 interruptEvent.hintType};
710 NotifyEvent(interruptEventResume);
711 }
712
HandleAndNotifyForcedEvent(const InterruptEventInternal & interruptEvent)713 void AudioCapturerInterruptCallbackImpl::HandleAndNotifyForcedEvent(const InterruptEventInternal &interruptEvent)
714 {
715 State currentState = audioStream_->GetState();
716 switch (interruptEvent.hintType) {
717 case INTERRUPT_HINT_RESUME:
718 CHECK_AND_RETURN_LOG((currentState == PAUSED || currentState == PREPARED) && isForcePaused_ == true,
719 "OnInterrupt state %{public}d or not forced pause %{public}d before", currentState, isForcePaused_);
720 AUDIO_INFO_LOG("set force pause false");
721 isForcePaused_ = false;
722 NotifyForcePausedToResume(interruptEvent);
723 return;
724 case INTERRUPT_HINT_PAUSE:
725 CHECK_AND_RETURN_LOG(currentState == RUNNING || currentState == PREPARED,
726 "OnInterrupt state %{public}d, no need to pause", currentState);
727 (void)audioStream_->PauseAudioStream(); // Just Pause, do not deactivate here
728 AUDIO_INFO_LOG("set force pause true");
729 isForcePaused_ = true;
730 break;
731 case INTERRUPT_HINT_STOP:
732 (void)audioStream_->StopAudioStream();
733 break;
734 default:
735 break;
736 }
737 // Notify valid forced event callbacks to app
738 InterruptEvent interruptEventForced {interruptEvent.eventType, interruptEvent.forceType, interruptEvent.hintType};
739 NotifyEvent(interruptEventForced);
740 }
741
OnInterrupt(const InterruptEventInternal & interruptEvent)742 void AudioCapturerInterruptCallbackImpl::OnInterrupt(const InterruptEventInternal &interruptEvent)
743 {
744 std::lock_guard<std::mutex> lock(mutex_);
745
746 cb_ = callback_.lock();
747 InterruptForceType forceType = interruptEvent.forceType;
748 AUDIO_INFO_LOG("InterruptForceType: %{public}d", forceType);
749
750 if (forceType != INTERRUPT_FORCE) { // INTERRUPT_SHARE
751 AUDIO_DEBUG_LOG("AudioCapturerPrivate ForceType: INTERRUPT_SHARE. Let app handle the event");
752 InterruptEvent interruptEventShared {interruptEvent.eventType, interruptEvent.forceType,
753 interruptEvent.hintType};
754 NotifyEvent(interruptEventShared);
755 return;
756 }
757
758 CHECK_AND_RETURN_LOG(audioStream_ != nullptr,
759 "Stream is not alive. No need to take forced action");
760
761 HandleAndNotifyForcedEvent(interruptEvent);
762 }
763
SaveCallback(const std::weak_ptr<AudioCapturerCallback> & callback)764 void AudioStreamCallbackCapturer::SaveCallback(const std::weak_ptr<AudioCapturerCallback> &callback)
765 {
766 callback_ = callback;
767 }
768
OnStateChange(const State state,const StateChangeCmdType cmdType)769 void AudioStreamCallbackCapturer::OnStateChange(const State state,
770 const StateChangeCmdType __attribute__((unused)) cmdType)
771 {
772 std::shared_ptr<AudioCapturerCallback> cb = callback_.lock();
773
774 CHECK_AND_RETURN_LOG(cb != nullptr, "AudioStreamCallbackCapturer::OnStateChange cb == nullptr.");
775
776 cb->OnStateChange(static_cast<CapturerState>(state));
777 }
778
GetSupportedFormats()779 std::vector<AudioSampleFormat> AudioCapturer::GetSupportedFormats()
780 {
781 return AUDIO_SUPPORTED_FORMATS;
782 }
783
GetSupportedChannels()784 std::vector<AudioChannel> AudioCapturer::GetSupportedChannels()
785 {
786 return CAPTURER_SUPPORTED_CHANNELS;
787 }
788
GetSupportedEncodingTypes()789 std::vector<AudioEncodingType> AudioCapturer::GetSupportedEncodingTypes()
790 {
791 return AUDIO_SUPPORTED_ENCODING_TYPES;
792 }
793
GetSupportedSamplingRates()794 std::vector<AudioSamplingRate> AudioCapturer::GetSupportedSamplingRates()
795 {
796 return AUDIO_SUPPORTED_SAMPLING_RATES;
797 }
798
FindStreamTypeBySourceType(SourceType sourceType)799 AudioStreamType AudioCapturer::FindStreamTypeBySourceType(SourceType sourceType)
800 {
801 switch (sourceType) {
802 case SOURCE_TYPE_VOICE_COMMUNICATION:
803 case SOURCE_TYPE_VIRTUAL_CAPTURE:
804 return STREAM_VOICE_CALL;
805 case SOURCE_TYPE_WAKEUP:
806 return STREAM_WAKEUP;
807 case SOURCE_TYPE_VOICE_CALL:
808 return STREAM_SOURCE_VOICE_CALL;
809 case SOURCE_TYPE_CAMCORDER:
810 return STREAM_CAMCORDER;
811 default:
812 return STREAM_MUSIC;
813 }
814 }
815
SetAudioSourceConcurrency(const std::vector<SourceType> & targetSources)816 int32_t AudioCapturerPrivate::SetAudioSourceConcurrency(const std::vector<SourceType> &targetSources)
817 {
818 if (targetSources.size() <= 0) {
819 AUDIO_ERR_LOG("TargetSources size is 0, set audio source concurrency failed.");
820 return ERR_INVALID_PARAM;
821 }
822 AUDIO_INFO_LOG("Set audio source concurrency success.");
823 audioInterrupt_.currencySources.sourcesTypes = targetSources;
824 return SUCCESS;
825 }
826
SetCaptureMode(AudioCaptureMode captureMode)827 int32_t AudioCapturerPrivate::SetCaptureMode(AudioCaptureMode captureMode)
828 {
829 AUDIO_INFO_LOG("Capture mode: %{public}d", captureMode);
830 audioCaptureMode_ = captureMode;
831
832 if (capturerInfo_.sourceType == SOURCE_TYPE_VOICE_COMMUNICATION && captureMode == CAPTURE_MODE_CALLBACK &&
833 AudioPolicyManager::GetInstance().GetPreferredInputStreamType(capturerInfo_) == AUDIO_FLAG_VOIP_FAST) {
834 AUDIO_INFO_LOG("Switch to fast voip stream");
835 uint32_t sessionId = 0;
836 int32_t ret = audioStream_->GetAudioSessionID(sessionId);
837 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Get audio session Id failed");
838 uint32_t newSessionId = 0;
839 if (!SwitchToTargetStream(IAudioStream::VOIP_STREAM, newSessionId)) {
840 AUDIO_ERR_LOG("Switch to target stream failed");
841 return ERROR;
842 }
843 ret = AudioPolicyManager::GetInstance().RegisterDeviceChangeWithInfoCallback(newSessionId,
844 inputDeviceChangeCallback_);
845 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Register device change callback for new session failed");
846 ret = AudioPolicyManager::GetInstance().UnregisterDeviceChangeWithInfoCallback(sessionId);
847 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Unregister device change callback for old session failed");
848 }
849
850 return audioStream_->SetCaptureMode(captureMode);
851 }
852
GetCaptureMode() const853 AudioCaptureMode AudioCapturerPrivate::GetCaptureMode() const
854 {
855 return audioStream_->GetCaptureMode();
856 }
857
SetCapturerReadCallback(const std::shared_ptr<AudioCapturerReadCallback> & callback)858 int32_t AudioCapturerPrivate::SetCapturerReadCallback(const std::shared_ptr<AudioCapturerReadCallback> &callback)
859 {
860 return audioStream_->SetCapturerReadCallback(callback);
861 }
862
GetBufferDesc(BufferDesc & bufDesc) const863 int32_t AudioCapturerPrivate::GetBufferDesc(BufferDesc &bufDesc) const
864 {
865 int32_t ret = audioStream_->GetBufferDesc(bufDesc);
866 DumpFileUtil::WriteDumpFile(dumpFile_, static_cast<void *>(bufDesc.buffer), bufDesc.bufLength);
867 return ret;
868 }
869
Enqueue(const BufferDesc & bufDesc) const870 int32_t AudioCapturerPrivate::Enqueue(const BufferDesc &bufDesc) const
871 {
872 CheckSignalData(bufDesc.buffer, bufDesc.bufLength);
873 return audioStream_->Enqueue(bufDesc);
874 }
875
Clear() const876 int32_t AudioCapturerPrivate::Clear() const
877 {
878 return audioStream_->Clear();
879 }
880
GetBufQueueState(BufferQueueState & bufState) const881 int32_t AudioCapturerPrivate::GetBufQueueState(BufferQueueState &bufState) const
882 {
883 return audioStream_->GetBufQueueState(bufState);
884 }
885
SetValid(bool valid)886 void AudioCapturerPrivate::SetValid(bool valid)
887 {
888 std::lock_guard<std::mutex> lock(lock_);
889 isValid_ = valid;
890 }
891
GetFramesRead() const892 int64_t AudioCapturerPrivate::GetFramesRead() const
893 {
894 return audioStream_->GetFramesRead();
895 }
896
GetCurrentInputDevices(DeviceInfo & deviceInfo) const897 int32_t AudioCapturerPrivate::GetCurrentInputDevices(DeviceInfo &deviceInfo) const
898 {
899 std::vector<std::unique_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
900 uint32_t sessionId = static_cast<uint32_t>(-1);
901 int32_t ret = GetAudioStreamId(sessionId);
902 CHECK_AND_RETURN_RET_LOG(!ret, ret, "Get sessionId failed");
903
904 ret = AudioPolicyManager::GetInstance().GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
905 CHECK_AND_RETURN_RET_LOG(!ret, ret, "Get current capturer devices failed");
906
907 for (auto it = audioCapturerChangeInfos.begin(); it != audioCapturerChangeInfos.end(); it++) {
908 if ((*it)->sessionId == static_cast<int32_t>(sessionId)) {
909 deviceInfo = (*it)->inputDeviceInfo;
910 }
911 }
912 return SUCCESS;
913 }
914
GetCurrentCapturerChangeInfo(AudioCapturerChangeInfo & changeInfo) const915 int32_t AudioCapturerPrivate::GetCurrentCapturerChangeInfo(AudioCapturerChangeInfo &changeInfo) const
916 {
917 std::vector<std::unique_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
918 uint32_t sessionId = static_cast<uint32_t>(-1);
919 int32_t ret = GetAudioStreamId(sessionId);
920 CHECK_AND_RETURN_RET_LOG(!ret, ret, "Get sessionId failed");
921
922 ret = AudioPolicyManager::GetInstance().GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
923 CHECK_AND_RETURN_RET_LOG(!ret, ret, "Get current capturer devices failed");
924
925 for (auto it = audioCapturerChangeInfos.begin(); it != audioCapturerChangeInfos.end(); it++) {
926 if ((*it)->sessionId == static_cast<int32_t>(sessionId)) {
927 changeInfo = *(*it);
928 }
929 }
930 return SUCCESS;
931 }
932
GetCurrentMicrophones() const933 std::vector<sptr<MicrophoneDescriptor>> AudioCapturerPrivate::GetCurrentMicrophones() const
934 {
935 uint32_t sessionId = static_cast<uint32_t>(-1);
936 GetAudioStreamId(sessionId);
937 return AudioPolicyManager::GetInstance().GetAudioCapturerMicrophoneDescriptors(sessionId);
938 }
939
SetAudioCapturerDeviceChangeCallback(const std::shared_ptr<AudioCapturerDeviceChangeCallback> & callback)940 int32_t AudioCapturerPrivate::SetAudioCapturerDeviceChangeCallback(
941 const std::shared_ptr<AudioCapturerDeviceChangeCallback> &callback)
942 {
943 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERROR, "Callback is null");
944
945 if (RegisterAudioCapturerEventListener() != SUCCESS) {
946 return ERROR;
947 }
948
949 CHECK_AND_RETURN_RET_LOG(audioStateChangeCallback_ != nullptr, ERROR, "audioStateChangeCallback_ is null");
950 audioStateChangeCallback_->SaveDeviceChangeCallback(callback);
951 return SUCCESS;
952 }
953
RemoveAudioCapturerDeviceChangeCallback(const std::shared_ptr<AudioCapturerDeviceChangeCallback> & callback)954 int32_t AudioCapturerPrivate::RemoveAudioCapturerDeviceChangeCallback(
955 const std::shared_ptr<AudioCapturerDeviceChangeCallback> &callback)
956 {
957 CHECK_AND_RETURN_RET_LOG(audioStateChangeCallback_ != nullptr, ERROR, "audioStateChangeCallback_ is null");
958
959 audioStateChangeCallback_->RemoveDeviceChangeCallback(callback);
960 if (UnregisterAudioCapturerEventListener() != SUCCESS) {
961 return ERROR;
962 }
963 return SUCCESS;
964 }
965
IsDeviceChanged(DeviceInfo & newDeviceInfo)966 bool AudioCapturerPrivate::IsDeviceChanged(DeviceInfo &newDeviceInfo)
967 {
968 bool deviceUpdated = false;
969 DeviceInfo deviceInfo = {};
970
971 CHECK_AND_RETURN_RET_LOG(GetCurrentInputDevices(deviceInfo) == SUCCESS, deviceUpdated,
972 "GetCurrentInputDevices failed");
973
974 if (currentDeviceInfo_.deviceType != deviceInfo.deviceType) {
975 currentDeviceInfo_ = deviceInfo;
976 newDeviceInfo = currentDeviceInfo_;
977 deviceUpdated = true;
978 }
979 return deviceUpdated;
980 }
981
GetAudioInterrupt(AudioInterrupt & audioInterrupt)982 void AudioCapturerPrivate::GetAudioInterrupt(AudioInterrupt &audioInterrupt)
983 {
984 audioInterrupt = audioInterrupt_;
985 }
986
WriteOverflowEvent() const987 void AudioCapturerPrivate::WriteOverflowEvent() const
988 {
989 AUDIO_INFO_LOG("Write overflowEvent to media monitor");
990 if (GetOverflowCount() < WRITE_OVERFLOW_NUM) {
991 return;
992 }
993 AudioPipeType pipeType = PIPE_TYPE_NORMAL_IN;
994 IAudioStream::StreamClass streamClass = audioStream_->GetStreamClass();
995 if (streamClass == IAudioStream::FAST_STREAM) {
996 pipeType = PIPE_TYPE_LOWLATENCY_IN;
997 }
998 std::shared_ptr<Media::MediaMonitor::EventBean> bean = std::make_shared<Media::MediaMonitor::EventBean>(
999 Media::MediaMonitor::ModuleId::AUDIO, Media::MediaMonitor::EventId::PERFORMANCE_UNDER_OVERRUN_STATS,
1000 Media::MediaMonitor::EventType::FREQUENCY_AGGREGATION_EVENT);
1001 bean->Add("IS_PLAYBACK", 0);
1002 bean->Add("CLIENT_UID", appInfo_.appUid);
1003 bean->Add("PIPE_TYPE", pipeType);
1004 bean->Add("STREAM_TYPE", capturerInfo_.sourceType);
1005 Media::MediaMonitor::MediaMonitorManager::GetInstance().WriteLogMsg(bean);
1006 }
1007
RegisterAudioCapturerEventListener()1008 int32_t AudioCapturerPrivate::RegisterAudioCapturerEventListener()
1009 {
1010 if (!audioStateChangeCallback_) {
1011 audioStateChangeCallback_ = std::make_shared<AudioCapturerStateChangeCallbackImpl>();
1012 CHECK_AND_RETURN_RET_LOG(audioStateChangeCallback_, ERROR, "Memory allocation failed!!");
1013
1014 int32_t ret =
1015 AudioPolicyManager::GetInstance().RegisterAudioCapturerEventListener(getpid(), audioStateChangeCallback_);
1016 CHECK_AND_RETURN_RET_LOG(ret == 0, ERROR, "RegisterAudioCapturerEventListener failed");
1017 audioStateChangeCallback_->setAudioCapturerObj(this);
1018 }
1019 return SUCCESS;
1020 }
1021
UnregisterAudioCapturerEventListener()1022 int32_t AudioCapturerPrivate::UnregisterAudioCapturerEventListener()
1023 {
1024 CHECK_AND_RETURN_RET_LOG(audioStateChangeCallback_ != nullptr, ERROR, "audioStateChangeCallback_ is null");
1025 if (audioStateChangeCallback_->DeviceChangeCallbackArraySize() == 0 &&
1026 audioStateChangeCallback_->GetCapturerInfoChangeCallbackArraySize() == 0) {
1027 int32_t ret =
1028 AudioPolicyManager::GetInstance().UnregisterAudioCapturerEventListener(getpid());
1029 CHECK_AND_RETURN_RET_LOG(ret == 0, ERROR, "failed");
1030 audioStateChangeCallback_->HandleCapturerDestructor();
1031 audioStateChangeCallback_ = nullptr;
1032 }
1033 return SUCCESS;
1034 }
1035
SetAudioCapturerInfoChangeCallback(const std::shared_ptr<AudioCapturerInfoChangeCallback> & callback)1036 int32_t AudioCapturerPrivate::SetAudioCapturerInfoChangeCallback(
1037 const std::shared_ptr<AudioCapturerInfoChangeCallback> &callback)
1038 {
1039 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM, "Callback is null");
1040
1041 CHECK_AND_RETURN_RET(RegisterAudioCapturerEventListener() == SUCCESS, ERROR);
1042
1043 CHECK_AND_RETURN_RET_LOG(audioStateChangeCallback_ != nullptr, ERROR, "audioStateChangeCallback_ is null");
1044 audioStateChangeCallback_->SaveCapturerInfoChangeCallback(callback);
1045 return SUCCESS;
1046 }
1047
RemoveAudioCapturerInfoChangeCallback(const std::shared_ptr<AudioCapturerInfoChangeCallback> & callback)1048 int32_t AudioCapturerPrivate::RemoveAudioCapturerInfoChangeCallback(
1049 const std::shared_ptr<AudioCapturerInfoChangeCallback> &callback)
1050 {
1051 CHECK_AND_RETURN_RET_LOG(audioStateChangeCallback_ != nullptr, ERROR, "audioStateChangeCallback_ is null");
1052 audioStateChangeCallback_->RemoveCapturerInfoChangeCallback(callback);
1053 CHECK_AND_RETURN_RET(UnregisterAudioCapturerEventListener() == SUCCESS, ERROR);
1054 return SUCCESS;
1055 }
1056
RegisterCapturerPolicyServiceDiedCallback()1057 int32_t AudioCapturerPrivate::RegisterCapturerPolicyServiceDiedCallback()
1058 {
1059 AUDIO_DEBUG_LOG("AudioCapturerPrivate::SetCapturerPolicyServiceDiedCallback");
1060 if (!audioPolicyServiceDiedCallback_) {
1061 audioPolicyServiceDiedCallback_ = std::make_shared<CapturerPolicyServiceDiedCallback>();
1062 if (!audioPolicyServiceDiedCallback_) {
1063 AUDIO_ERR_LOG("Memory allocation failed!!");
1064 return ERROR;
1065 }
1066 AudioPolicyManager::GetInstance().RegisterAudioStreamPolicyServerDiedCb(audioPolicyServiceDiedCallback_);
1067 audioPolicyServiceDiedCallback_->SetAudioCapturerObj(this);
1068 audioPolicyServiceDiedCallback_->SetAudioInterrupt(audioInterrupt_);
1069 }
1070 return SUCCESS;
1071 }
1072
RemoveCapturerPolicyServiceDiedCallback()1073 int32_t AudioCapturerPrivate::RemoveCapturerPolicyServiceDiedCallback()
1074 {
1075 AUDIO_DEBUG_LOG("AudioCapturerPrivate::RemoveCapturerPolicyServiceDiedCallback");
1076 if (audioPolicyServiceDiedCallback_) {
1077 int32_t ret = AudioPolicyManager::GetInstance().UnregisterAudioStreamPolicyServerDiedCb(
1078 audioPolicyServiceDiedCallback_);
1079 if (ret != 0) {
1080 AUDIO_ERR_LOG("RemoveCapturerPolicyServiceDiedCallback failed");
1081 audioPolicyServiceDiedCallback_ = nullptr;
1082 return ERROR;
1083 }
1084 }
1085 audioPolicyServiceDiedCallback_ = nullptr;
1086 return SUCCESS;
1087 }
1088
GetOverflowCount() const1089 uint32_t AudioCapturerPrivate::GetOverflowCount() const
1090 {
1091 return audioStream_->GetOverflowCount();
1092 }
1093
SetSwitchInfo(IAudioStream::SwitchInfo info,std::shared_ptr<IAudioStream> audioStream)1094 void AudioCapturerPrivate::SetSwitchInfo(IAudioStream::SwitchInfo info, std::shared_ptr<IAudioStream> audioStream)
1095 {
1096 CHECK_AND_RETURN_LOG(audioStream, "stream is nullptr");
1097
1098 audioStream->SetStreamTrackerState(false);
1099 audioStream->SetApplicationCachePath(info.cachePath);
1100 audioStream->SetClientID(info.clientPid, info.clientUid, appInfo_.appTokenId, appInfo_.appFullTokenId);
1101 audioStream->SetCapturerInfo(info.capturerInfo);
1102 audioStream->SetAudioStreamInfo(info.params, capturerProxyObj_);
1103 audioStream->SetCaptureMode(info.captureMode);
1104
1105 // set callback
1106 if ((info.renderPositionCb != nullptr) && (info.frameMarkPosition > 0)) {
1107 audioStream->SetRendererPositionCallback(info.frameMarkPosition, info.renderPositionCb);
1108 }
1109
1110 if ((info.capturePositionCb != nullptr) && (info.frameMarkPosition > 0)) {
1111 audioStream->SetCapturerPositionCallback(info.frameMarkPosition, info.capturePositionCb);
1112 }
1113
1114 if ((info.renderPeriodPositionCb != nullptr) && (info.framePeriodNumber > 0)) {
1115 audioStream->SetRendererPeriodPositionCallback(info.framePeriodNumber, info.renderPeriodPositionCb);
1116 }
1117
1118 if ((info.capturePeriodPositionCb != nullptr) && (info.framePeriodNumber > 0)) {
1119 audioStream->SetCapturerPeriodPositionCallback(info.framePeriodNumber, info.capturePeriodPositionCb);
1120 }
1121
1122 audioStream->SetCapturerReadCallback(info.capturerReadCallback);
1123
1124 audioStream->SetStreamCallback(info.audioStreamCallback);
1125 }
1126
SwitchToTargetStream(IAudioStream::StreamClass targetClass,uint32_t & newSessionId)1127 bool AudioCapturerPrivate::SwitchToTargetStream(IAudioStream::StreamClass targetClass, uint32_t &newSessionId)
1128 {
1129 bool switchResult = false;
1130 if (audioStream_) {
1131 Trace trace("SwitchToTargetStream");
1132 isSwitching_ = true;
1133 CapturerState previousState = GetStatus();
1134 AUDIO_INFO_LOG("Previous stream state: %{public}d, original sessionId: %{public}u", previousState, sessionID_);
1135 if (previousState == CAPTURER_RUNNING) {
1136 // stop old stream
1137 switchResult = audioStream_->StopAudioStream();
1138 CHECK_AND_RETURN_RET_LOG(switchResult, false, "StopAudioStream failed.");
1139 }
1140 std::lock_guard lock(switchStreamMutex_);
1141 // switch new stream
1142 IAudioStream::SwitchInfo info;
1143 audioStream_->GetSwitchInfo(info);
1144 info.params.originalSessionId = sessionID_;
1145
1146 // release old stream and restart audio stream
1147 switchResult = audioStream_->ReleaseAudioStream();
1148 CHECK_AND_RETURN_RET_LOG(switchResult, false, "release old stream failed.");
1149
1150 if (targetClass == IAudioStream::VOIP_STREAM) {
1151 info.capturerInfo.originalFlag = AUDIO_FLAG_VOIP_FAST;
1152 }
1153 std::shared_ptr<IAudioStream> newAudioStream = IAudioStream::GetRecordStream(targetClass, info.params,
1154 info.eStreamType, appInfo_.appPid);
1155 CHECK_AND_RETURN_RET_LOG(newAudioStream != nullptr, false, "GetRecordStream failed.");
1156 AUDIO_INFO_LOG("Get new stream success!");
1157
1158 // set new stream info
1159 SetSwitchInfo(info, newAudioStream);
1160
1161 if (previousState == CAPTURER_RUNNING) {
1162 // restart audio stream
1163 switchResult = newAudioStream->StartAudioStream();
1164 CHECK_AND_RETURN_RET_LOG(switchResult, false, "start new stream failed.");
1165 }
1166 audioStream_ = newAudioStream;
1167 if (audioInterruptCallback_ != nullptr) {
1168 std::shared_ptr<AudioCapturerInterruptCallbackImpl> interruptCbImpl =
1169 std::static_pointer_cast<AudioCapturerInterruptCallbackImpl>(audioInterruptCallback_);
1170 interruptCbImpl->UpdateAudioStream(audioStream_);
1171 }
1172 isSwitching_ = false;
1173 audioStream_->GetAudioSessionID(newSessionId);
1174 switchResult = true;
1175 }
1176 return switchResult;
1177 }
1178
SwitchStream(const uint32_t sessionId,const int32_t streamFlag,const AudioStreamDeviceChangeReasonExt reason)1179 void AudioCapturerPrivate::SwitchStream(const uint32_t sessionId, const int32_t streamFlag,
1180 const AudioStreamDeviceChangeReasonExt reason)
1181 {
1182 IAudioStream::StreamClass targetClass = IAudioStream::PA_STREAM;
1183 switch (streamFlag) {
1184 case AUDIO_FLAG_NORMAL:
1185 capturerInfo_.capturerFlags = AUDIO_FLAG_NORMAL;
1186 targetClass = IAudioStream::PA_STREAM;
1187 break;
1188 case AUDIO_FLAG_MMAP:
1189 capturerInfo_.capturerFlags = AUDIO_FLAG_MMAP;
1190 targetClass = IAudioStream::FAST_STREAM;
1191 break;
1192 case AUDIO_FLAG_VOIP_FAST:
1193 capturerInfo_.capturerFlags = AUDIO_FLAG_VOIP_FAST;
1194 targetClass = IAudioStream::VOIP_STREAM;
1195 break;
1196 }
1197
1198 uint32_t newSessionId = 0;
1199 if (!SwitchToTargetStream(targetClass, newSessionId)) {
1200 int32_t ret = AudioPolicyManager::GetInstance().DeactivateAudioInterrupt(audioInterrupt_);
1201 CHECK_AND_RETURN_LOG(ret == 0, "DeactivateAudioInterrupt Failed");
1202 AUDIO_ERR_LOG("Switch to target stream failed");
1203 }
1204 int32_t ret = AudioPolicyManager::GetInstance().RegisterDeviceChangeWithInfoCallback(newSessionId,
1205 inputDeviceChangeCallback_);
1206 CHECK_AND_RETURN_LOG(ret == SUCCESS, "Register device change callback for new session failed");
1207 ret = AudioPolicyManager::GetInstance().UnregisterDeviceChangeWithInfoCallback(sessionId);
1208 CHECK_AND_RETURN_LOG(ret == SUCCESS, "Unregister device change callback for old session failed");
1209 }
1210
ActivateAudioConcurrency(IAudioStream::StreamClass & streamClass)1211 void AudioCapturerPrivate::ActivateAudioConcurrency(IAudioStream::StreamClass &streamClass)
1212 {
1213 capturerInfo_.pipeType = PIPE_TYPE_NORMAL_IN;
1214 if (capturerInfo_.sourceType == SOURCE_TYPE_VOICE_COMMUNICATION) {
1215 capturerInfo_.pipeType = PIPE_TYPE_CALL_IN;
1216 } else if (streamClass == IAudioStream::FAST_STREAM) {
1217 capturerInfo_.pipeType = PIPE_TYPE_LOWLATENCY_IN;
1218 }
1219 int32_t ret = AudioPolicyManager::GetInstance().ActivateAudioConcurrency(capturerInfo_.pipeType);
1220 if (ret != SUCCESS && streamClass == IAudioStream::FAST_STREAM) {
1221 streamClass = IAudioStream::PA_STREAM;
1222 capturerInfo_.pipeType = PIPE_TYPE_NORMAL_IN;
1223 }
1224 return;
1225 }
1226
InitAudioConcurrencyCallback()1227 int32_t AudioCapturerPrivate::InitAudioConcurrencyCallback()
1228 {
1229 if (audioConcurrencyCallback_ == nullptr) {
1230 audioConcurrencyCallback_ = std::make_shared<AudioCapturerConcurrencyCallbackImpl>();
1231 CHECK_AND_RETURN_RET_LOG(audioConcurrencyCallback_ != nullptr, ERROR, "Memory Allocation Failed !!");
1232 }
1233 CHECK_AND_RETURN_RET_LOG(audioStream_->GetAudioSessionID(sessionID_) == SUCCESS, ERR_INVALID_INDEX,
1234 "Get session id failed!");
1235 audioConcurrencyCallback_->SetAudioCapturerObj(this);
1236 return AudioPolicyManager::GetInstance().SetAudioConcurrencyCallback(sessionID_, audioConcurrencyCallback_);
1237 }
1238
ConcedeStream()1239 void AudioCapturerPrivate::ConcedeStream()
1240 {
1241 AUDIO_INFO_LOG("session %{public}u concede from pipeType %{public}d", sessionID_, capturerInfo_.pipeType);
1242 AudioPipeType pipeType = PIPE_TYPE_NORMAL_IN;
1243 audioStream_->GetAudioPipeType(pipeType);
1244 if (pipeType == PIPE_TYPE_LOWLATENCY_IN || pipeType == PIPE_TYPE_CALL_IN) {
1245 SwitchStream(sessionID_, IAudioStream::PA_STREAM, AudioStreamDeviceChangeReasonExt::ExtEnum::UNKNOWN);
1246 }
1247 }
1248
AudioCapturerConcurrencyCallbackImpl()1249 AudioCapturerConcurrencyCallbackImpl::AudioCapturerConcurrencyCallbackImpl()
1250 {
1251 AUDIO_INFO_LOG("AudioCapturerConcurrencyCallbackImpl ctor");
1252 }
1253
~AudioCapturerConcurrencyCallbackImpl()1254 AudioCapturerConcurrencyCallbackImpl::~AudioCapturerConcurrencyCallbackImpl()
1255 {
1256 AUDIO_INFO_LOG("AudioCapturerConcurrencyCallbackImpl dtor");
1257 }
1258
OnConcedeStream()1259 void AudioCapturerConcurrencyCallbackImpl::OnConcedeStream()
1260 {
1261 std::lock_guard<std::mutex> lock(mutex_);
1262 CHECK_AND_RETURN_LOG(capturer_ != nullptr, "capturer is nullptr");
1263 capturer_->ConcedeStream();
1264 }
1265
AudioCapturerStateChangeCallbackImpl()1266 AudioCapturerStateChangeCallbackImpl::AudioCapturerStateChangeCallbackImpl()
1267 {
1268 AUDIO_DEBUG_LOG("AudioCapturerStateChangeCallbackImpl instance create");
1269 }
1270
~AudioCapturerStateChangeCallbackImpl()1271 AudioCapturerStateChangeCallbackImpl::~AudioCapturerStateChangeCallbackImpl()
1272 {
1273 AUDIO_DEBUG_LOG("AudioCapturerStateChangeCallbackImpl instance destory");
1274 }
1275
SaveCapturerInfoChangeCallback(const std::shared_ptr<AudioCapturerInfoChangeCallback> & callback)1276 void AudioCapturerStateChangeCallbackImpl::SaveCapturerInfoChangeCallback(
1277 const std::shared_ptr<AudioCapturerInfoChangeCallback> &callback)
1278 {
1279 std::lock_guard<std::mutex> lock(capturerMutex_);
1280 auto iter = find(capturerInfoChangeCallbacklist_.begin(), capturerInfoChangeCallbacklist_.end(), callback);
1281 if (iter == capturerInfoChangeCallbacklist_.end()) {
1282 capturerInfoChangeCallbacklist_.emplace_back(callback);
1283 }
1284 }
1285
RemoveCapturerInfoChangeCallback(const std::shared_ptr<AudioCapturerInfoChangeCallback> & callback)1286 void AudioCapturerStateChangeCallbackImpl::RemoveCapturerInfoChangeCallback(
1287 const std::shared_ptr<AudioCapturerInfoChangeCallback> &callback)
1288 {
1289 std::lock_guard<std::mutex> lock(capturerMutex_);
1290 if (callback == nullptr) {
1291 capturerInfoChangeCallbacklist_.clear();
1292 return;
1293 }
1294
1295 auto iter = find(capturerInfoChangeCallbacklist_.begin(), capturerInfoChangeCallbacklist_.end(), callback);
1296 if (iter != capturerInfoChangeCallbacklist_.end()) {
1297 capturerInfoChangeCallbacklist_.erase(iter);
1298 }
1299 }
1300
GetCapturerInfoChangeCallbackArraySize()1301 int32_t AudioCapturerStateChangeCallbackImpl::GetCapturerInfoChangeCallbackArraySize()
1302 {
1303 std::lock_guard<std::mutex> lock(capturerMutex_);
1304 return capturerInfoChangeCallbacklist_.size();
1305 }
1306
SaveDeviceChangeCallback(const std::shared_ptr<AudioCapturerDeviceChangeCallback> & callback)1307 void AudioCapturerStateChangeCallbackImpl::SaveDeviceChangeCallback(
1308 const std::shared_ptr<AudioCapturerDeviceChangeCallback> &callback)
1309 {
1310 auto iter = find(deviceChangeCallbacklist_.begin(), deviceChangeCallbacklist_.end(), callback);
1311 if (iter == deviceChangeCallbacklist_.end()) {
1312 deviceChangeCallbacklist_.emplace_back(callback);
1313 }
1314 }
1315
RemoveDeviceChangeCallback(const std::shared_ptr<AudioCapturerDeviceChangeCallback> & callback)1316 void AudioCapturerStateChangeCallbackImpl::RemoveDeviceChangeCallback(
1317 const std::shared_ptr<AudioCapturerDeviceChangeCallback> &callback)
1318 {
1319 if (callback == nullptr) {
1320 deviceChangeCallbacklist_.clear();
1321 return;
1322 }
1323
1324 auto iter = find(deviceChangeCallbacklist_.begin(), deviceChangeCallbacklist_.end(), callback);
1325 if (iter != deviceChangeCallbacklist_.end()) {
1326 deviceChangeCallbacklist_.erase(iter);
1327 }
1328 }
1329
DeviceChangeCallbackArraySize()1330 int32_t AudioCapturerStateChangeCallbackImpl::DeviceChangeCallbackArraySize()
1331 {
1332 return deviceChangeCallbacklist_.size();
1333 }
1334
setAudioCapturerObj(AudioCapturerPrivate * capturerObj)1335 void AudioCapturerStateChangeCallbackImpl::setAudioCapturerObj(AudioCapturerPrivate *capturerObj)
1336 {
1337 std::lock_guard<std::mutex> lock(capturerMutex_);
1338 capturer_ = capturerObj;
1339 }
1340
NotifyAudioCapturerInfoChange(const std::vector<std::unique_ptr<AudioCapturerChangeInfo>> & audioCapturerChangeInfos)1341 void AudioCapturerStateChangeCallbackImpl::NotifyAudioCapturerInfoChange(
1342 const std::vector<std::unique_ptr<AudioCapturerChangeInfo>> &audioCapturerChangeInfos)
1343 {
1344 uint32_t sessionId = static_cast<uint32_t>(-1);
1345 bool found = false;
1346 AudioCapturerChangeInfo capturerChangeInfo;
1347 std::vector<std::shared_ptr<AudioCapturerInfoChangeCallback>> capturerInfoChangeCallbacklist;
1348
1349 {
1350 std::lock_guard<std::mutex> lock(capturerMutex_);
1351 CHECK_AND_RETURN_LOG(capturer_ != nullptr, "Bare pointer capturer_ is nullptr");
1352 int32_t ret = capturer_->GetAudioStreamId(sessionId);
1353 CHECK_AND_RETURN_LOG(!ret, "Get sessionId failed");
1354 }
1355
1356 for (auto it = audioCapturerChangeInfos.begin(); it != audioCapturerChangeInfos.end(); it++) {
1357 if ((*it)->sessionId == static_cast<int32_t>(sessionId)) {
1358 capturerChangeInfo = *(*it);
1359 found = true;
1360 }
1361 }
1362
1363 {
1364 std::lock_guard<std::mutex> lock(capturerMutex_);
1365 capturerInfoChangeCallbacklist = capturerInfoChangeCallbacklist_;
1366 }
1367 if (found) {
1368 for (auto it = capturerInfoChangeCallbacklist.begin(); it != capturerInfoChangeCallbacklist.end(); ++it) {
1369 if (*it != nullptr) {
1370 (*it)->OnStateChange(capturerChangeInfo);
1371 }
1372 }
1373 }
1374 }
1375
NotifyAudioCapturerDeviceChange(const std::vector<std::unique_ptr<AudioCapturerChangeInfo>> & audioCapturerChangeInfos)1376 void AudioCapturerStateChangeCallbackImpl::NotifyAudioCapturerDeviceChange(
1377 const std::vector<std::unique_ptr<AudioCapturerChangeInfo>> &audioCapturerChangeInfos)
1378 {
1379 DeviceInfo deviceInfo = {};
1380 {
1381 std::lock_guard<std::mutex> lock(capturerMutex_);
1382 CHECK_AND_RETURN_LOG(capturer_ != nullptr, "Bare pointer capturer_ is nullptr");
1383 CHECK_AND_RETURN_LOG(capturer_->IsDeviceChanged(deviceInfo), "Device not change, no need callback.");
1384 }
1385
1386 for (auto it = deviceChangeCallbacklist_.begin(); it != deviceChangeCallbacklist_.end(); ++it) {
1387 if (*it != nullptr) {
1388 (*it)->OnStateChange(deviceInfo);
1389 }
1390 }
1391 }
1392
OnCapturerStateChange(const std::vector<std::unique_ptr<AudioCapturerChangeInfo>> & audioCapturerChangeInfos)1393 void AudioCapturerStateChangeCallbackImpl::OnCapturerStateChange(
1394 const std::vector<std::unique_ptr<AudioCapturerChangeInfo>> &audioCapturerChangeInfos)
1395 {
1396 if (deviceChangeCallbacklist_.size() != 0) {
1397 NotifyAudioCapturerDeviceChange(audioCapturerChangeInfos);
1398 }
1399
1400 if (capturerInfoChangeCallbacklist_.size() != 0) {
1401 NotifyAudioCapturerInfoChange(audioCapturerChangeInfos);
1402 }
1403 }
1404
HandleCapturerDestructor()1405 void AudioCapturerStateChangeCallbackImpl::HandleCapturerDestructor()
1406 {
1407 std::lock_guard<std::mutex> lock(capturerMutex_);
1408 capturer_ = nullptr;
1409 }
1410
OnDeviceChangeWithInfo(const uint32_t sessionId,const DeviceInfo & deviceInfo,const AudioStreamDeviceChangeReasonExt reason)1411 void InputDeviceChangeWithInfoCallbackImpl::OnDeviceChangeWithInfo(
1412 const uint32_t sessionId, const DeviceInfo &deviceInfo, const AudioStreamDeviceChangeReasonExt reason)
1413 {
1414 AUDIO_INFO_LOG("For capturer, OnDeviceChangeWithInfo callback is not support");
1415 }
1416
OnRecreateStreamEvent(const uint32_t sessionId,const int32_t streamFlag,const AudioStreamDeviceChangeReasonExt reason)1417 void InputDeviceChangeWithInfoCallbackImpl::OnRecreateStreamEvent(const uint32_t sessionId, const int32_t streamFlag,
1418 const AudioStreamDeviceChangeReasonExt reason)
1419 {
1420 AUDIO_INFO_LOG("Enter");
1421 capturer_->SwitchStream(sessionId, streamFlag, reason);
1422 }
1423
CapturerPolicyServiceDiedCallback()1424 CapturerPolicyServiceDiedCallback::CapturerPolicyServiceDiedCallback()
1425 {
1426 AUDIO_DEBUG_LOG("CapturerPolicyServiceDiedCallback create");
1427 }
1428
~CapturerPolicyServiceDiedCallback()1429 CapturerPolicyServiceDiedCallback::~CapturerPolicyServiceDiedCallback()
1430 {
1431 AUDIO_DEBUG_LOG("CapturerPolicyServiceDiedCallback destroy");
1432 if (restoreThread_ != nullptr && restoreThread_->joinable()) {
1433 restoreThread_->join();
1434 restoreThread_.reset();
1435 restoreThread_ = nullptr;
1436 }
1437 }
1438
SetAudioCapturerObj(AudioCapturerPrivate * capturerObj)1439 void CapturerPolicyServiceDiedCallback::SetAudioCapturerObj(AudioCapturerPrivate *capturerObj)
1440 {
1441 capturer_ = capturerObj;
1442 }
1443
SetAudioInterrupt(AudioInterrupt & audioInterrupt)1444 void CapturerPolicyServiceDiedCallback::SetAudioInterrupt(AudioInterrupt &audioInterrupt)
1445 {
1446 audioInterrupt_ = audioInterrupt;
1447 }
1448
OnAudioPolicyServiceDied()1449 void CapturerPolicyServiceDiedCallback::OnAudioPolicyServiceDied()
1450 {
1451 AUDIO_INFO_LOG("CapturerPolicyServiceDiedCallback OnAudioPolicyServiceDied");
1452 if (restoreThread_ != nullptr) {
1453 restoreThread_->detach();
1454 }
1455 restoreThread_ = std::make_unique<std::thread>([this] { this->RestoreTheadLoop(); });
1456 pthread_setname_np(restoreThread_->native_handle(), "OS_ACPSRestore");
1457 }
1458
RestoreTheadLoop()1459 void CapturerPolicyServiceDiedCallback::RestoreTheadLoop()
1460 {
1461 int32_t tryCounter = 5;
1462 uint32_t sleepTime = 500000;
1463 bool result = false;
1464 int32_t ret = -1;
1465 while (!result && tryCounter > 0) {
1466 tryCounter--;
1467 usleep(sleepTime);
1468 if (capturer_== nullptr || capturer_->audioStream_== nullptr ||
1469 capturer_->abortRestore_) {
1470 AUDIO_INFO_LOG("CapturerPolicyServiceDiedCallback RestoreTheadLoop abort restore");
1471 break;
1472 }
1473 result = capturer_->audioStream_->RestoreAudioStream();
1474 if (!result) {
1475 AUDIO_ERR_LOG("RestoreAudioStream Failed, %{public}d attempts remaining", tryCounter);
1476 continue;
1477 } else {
1478 capturer_->abortRestore_ = false;
1479 }
1480
1481 if (capturer_->GetStatus() == CAPTURER_RUNNING) {
1482 capturer_->GetAudioInterrupt(audioInterrupt_);
1483 ret = AudioPolicyManager::GetInstance().ActivateAudioInterrupt(audioInterrupt_);
1484 if (ret != SUCCESS) {
1485 AUDIO_ERR_LOG("RestoreTheadLoop ActivateAudioInterrupt Failed");
1486 }
1487 }
1488 }
1489 }
1490 } // namespace AudioStandard
1491 } // namespace OHOS
1492