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