1 /*
2  * Copyright (c) 2022-2023 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 "RemoteAudioCapturerSourceInner"
17 #endif
18 
19 #include "remote_audio_capturer_source.h"
20 
21 #include <cstring>
22 #include <dlfcn.h>
23 #include <string>
24 #include <mutex>
25 #include "securec.h"
26 
27 #include "audio_errors.h"
28 #include "audio_hdi_log.h"
29 #include "audio_utils.h"
30 #include "i_audio_device_adapter.h"
31 #include "i_audio_device_manager.h"
32 
33 using namespace std;
34 using OHOS::HDI::DistributedAudio::Audio::V1_0::IAudioAdapter;
35 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioAdapterDescriptor;
36 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioFormat;
37 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioPort;
38 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioPortDirection;
39 using OHOS::HDI::DistributedAudio::Audio::V1_0::IAudioManager;
40 using OHOS::HDI::DistributedAudio::Audio::V1_0::IAudioCapture;
41 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioSampleAttributes;
42 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioDeviceDescriptor;
43 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioCategory;
44 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioRouteNode;
45 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioExtParamKey;
46 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioRoute;
47 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioSceneDescriptor;
48 using OHOS::HDI::DistributedAudio::Audio::V1_0::IAudioCallback;
49 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioPortPin;
50 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioPortType;
51 using OHOS::HDI::DistributedAudio::Audio::V1_0::AudioPortRole;
52 
53 namespace OHOS {
54 namespace AudioStandard {
55 namespace {
56 const uint16_t GET_MAX_AMPLITUDE_FRAMES_THRESHOLD = 10;
57 }
58 
59 class RemoteAudioCapturerSourceInner : public RemoteAudioCapturerSource, public IAudioDeviceAdapterCallback {
60 public:
61     explicit RemoteAudioCapturerSourceInner(const std::string &deviceNetworkId);
62     ~RemoteAudioCapturerSourceInner();
63 
64     int32_t Init(const IAudioSourceAttr &attr) override;
65     bool IsInited(void) override;
66     void DeInit(void) override;
67 
68     int32_t Start(void) override;
69     int32_t Stop(void) override;
70     int32_t Flush(void) override;
71     int32_t Reset(void) override;
72     int32_t Pause(void) override;
73     int32_t Resume(void) override;
74     int32_t CaptureFrame(char *frame, uint64_t requestBytes, uint64_t &replyBytes) override;
75     int32_t SetVolume(float left, float right) override;
76     int32_t GetVolume(float &left, float &right) override;
77     int32_t SetMute(bool isMute) override;
78     int32_t GetMute(bool &isMute) override;
79     int32_t SetAudioScene(AudioScene audioScene, DeviceType activeDevice) override;
80     int32_t SetInputRoute(DeviceType inputDevice) override;
81     uint64_t GetTransactionId() override;
82     int32_t GetPresentationPosition(uint64_t& frames, int64_t& timeSec, int64_t& timeNanoSec) override;
83     std::string GetAudioParameter(const AudioParamKey key, const std::string &condition) override;
84     void RegisterWakeupCloseCallback(IAudioSourceCallback *callback) override;
85     void RegisterAudioCapturerSourceCallback(std::unique_ptr<ICapturerStateCallback> callback) override;
86     void RegisterParameterCallback(IAudioSourceCallback *callback) override;
87 
88     void OnAudioParamChange(const std::string &adapterName, const AudioParamKey key, const std::string &condition,
89         const std::string &value) override;
90 
91     float GetMaxAmplitude() override;
92 
93     int32_t UpdateAppsUid(const int32_t appsUid[PA_MAX_OUTPUTS_PER_SOURCE], const size_t size) final;
94     int32_t UpdateAppsUid(const std::vector<int32_t> &appsUid) final;
95 private:
96     int32_t CreateCapture(const AudioPort &capturePort);
97     int32_t SetInputPortPin(DeviceType inputDevice, AudioRouteNode &source);
98     AudioCategory GetAudioCategory(AudioScene audioScene);
99     void ClearCapture();
100     AudioFormat ConvertToHdiFormat(HdiAdapterFormat format);
101     void CheckUpdateState(char *frame, uint64_t replyBytes);
102 
103 private:
104     static constexpr uint32_t REMOTE_INPUT_STREAM_ID = 30; // 14 + 2 * 8
105     const uint32_t maxInt32 = 0x7fffffff;
106     const uint32_t audioBufferSize = 16 * 1024;
107     const uint32_t deepBufferCapturePeriodSize = 4096;
108     // for get amplitude
109     float maxAmplitude_ = 0;
110     int64_t lastGetMaxAmplitudeTime_ = 0;
111     int64_t last10FrameStartTime_ = 0;
112     bool startUpdate_ = false;
113     int capFrameNum_ = 0;
114 
115     IAudioSourceAttr attr_ = {};
116     std::string deviceNetworkId_ = "";
117     std::atomic<bool> capturerInited_ = false;
118     std::atomic<bool> isCapturerCreated_ = false;
119     std::atomic<bool> started_ = false;
120     std::atomic<bool> paused_ = false;
121 
122     std::shared_ptr<IAudioDeviceManager> audioManager_ = nullptr;
123     std::mutex audioMangerMutex_;
124 
125     std::shared_ptr<IAudioDeviceAdapter> audioAdapter_ = nullptr;
126     std::mutex audioAdapterMutex_;
127 
128     IAudioSourceCallback *paramCb_ = nullptr;
129     sptr<IAudioCapture> audioCapture_ = nullptr;
130     struct AudioPort audioPort_ = {};
131     FILE *dumpFile_ = nullptr;
132     bool muteState_ = false;
133     std::mutex createCaptureMutex_;
134     uint32_t captureId_ = 0;
135 };
136 
137 std::mutex g_capturerRemoteSourcesMutex;
138 std::map<std::string, RemoteAudioCapturerSourceInner *> allRemoteSources;
GetInstance(const std::string & deviceNetworkId)139 RemoteAudioCapturerSource *RemoteAudioCapturerSource::GetInstance(const std::string &deviceNetworkId)
140 {
141     std::lock_guard<std::mutex> lock(g_capturerRemoteSourcesMutex);
142     AUDIO_INFO_LOG("GetInstance.");
143     bool isEmpty = deviceNetworkId.empty();
144     CHECK_AND_RETURN_RET_LOG(!isEmpty, nullptr, "Remote capture device networkId is null.");
145 
146     if (allRemoteSources.count(deviceNetworkId)) {
147         return allRemoteSources[deviceNetworkId];
148     }
149     RemoteAudioCapturerSourceInner *audioCapturer = new(std::nothrow) RemoteAudioCapturerSourceInner(deviceNetworkId);
150     AUDIO_INFO_LOG("New daudio remote capture device [%{public}s].", GetEncryptStr(deviceNetworkId).c_str());
151     allRemoteSources[deviceNetworkId] = audioCapturer;
152     return audioCapturer;
153 }
154 
GetAllInstance(std::vector<IAudioCapturerSource * > & allInstance)155 void RemoteAudioCapturerSource::GetAllInstance(std::vector<IAudioCapturerSource *> &allInstance)
156 {
157     std::lock_guard<std::mutex> lock(g_capturerRemoteSourcesMutex);
158     for (auto it = allRemoteSources.begin(); it != allRemoteSources.end(); it++) {
159         allInstance.push_back((*it).second);
160     }
161 }
162 
RemoteAudioCapturerSourceInner(const std::string & deviceNetworkId)163 RemoteAudioCapturerSourceInner::RemoteAudioCapturerSourceInner(const std::string &deviceNetworkId)
164     : deviceNetworkId_(deviceNetworkId) {}
165 
~RemoteAudioCapturerSourceInner()166 RemoteAudioCapturerSourceInner::~RemoteAudioCapturerSourceInner()
167 {
168     if (capturerInited_.load()) {
169         RemoteAudioCapturerSourceInner::DeInit();
170     } else {
171         AUDIO_DEBUG_LOG("RemoteAudioCapturerSource has already DeInit.");
172     }
173 }
174 
ClearCapture()175 void RemoteAudioCapturerSourceInner::ClearCapture()
176 {
177     AUDIO_INFO_LOG("Clear capture enter.");
178     capturerInited_.store(false);
179     isCapturerCreated_.store(false);
180     started_.store(false);
181     paused_.store(false);
182 
183     std::shared_ptr<IAudioDeviceAdapter> audioAdapter;
184     {
185         std::lock_guard<std::mutex> lock(audioAdapterMutex_);
186         audioAdapter = std::move(audioAdapter_);
187         audioAdapter_ = nullptr;
188     }
189 
190     if (audioAdapter != nullptr) {
191         audioAdapter->DestroyCapture(audioCapture_, captureId_);
192         audioAdapter->Release();
193     }
194     audioCapture_ = nullptr;
195     audioAdapter = nullptr;
196 
197     std::shared_ptr<IAudioDeviceManager> audioManager;
198     {
199         std::lock_guard<std::mutex> lock(audioMangerMutex_);
200         audioManager = std::move(audioManager_);
201         audioManager_ = nullptr;
202     }
203 
204     if (audioManager != nullptr) {
205         audioManager->UnloadAdapter(deviceNetworkId_);
206     }
207     audioManager = nullptr;
208 
209     AudioDeviceManagerFactory::GetInstance().DestoryDeviceManager(REMOTE_DEV_MGR);
210     DumpFileUtil::CloseDumpFile(&dumpFile_);
211     AUDIO_DEBUG_LOG("Clear capture end.");
212 }
213 
DeInit()214 void RemoteAudioCapturerSourceInner::DeInit()
215 {
216     AUDIO_INFO_LOG("RemoteAudioCapturerSourceInner::DeInit");
217     ClearCapture();
218 
219     std::lock_guard<std::mutex> lock(g_capturerRemoteSourcesMutex);
220     // remove map recorder.
221 
222     CHECK_AND_RETURN_LOG(allRemoteSources.count(this->deviceNetworkId_) > 0,
223         "not find %{public}s", this->deviceNetworkId_.c_str());
224 
225     RemoteAudioCapturerSource *temp = allRemoteSources[this->deviceNetworkId_];
226     allRemoteSources.erase(this->deviceNetworkId_);
227     if (temp == nullptr) {
228         AUDIO_ERR_LOG("temp is nullptr");
229     } else {
230         delete temp;
231     }
232 
233     AUDIO_INFO_LOG("end.");
234 }
235 
Init(const IAudioSourceAttr & attr)236 int32_t RemoteAudioCapturerSourceInner::Init(const IAudioSourceAttr &attr)
237 {
238     AUDIO_INFO_LOG("RemoteAudioCapturerSourceInner::Init");
239     attr_ = attr;
240 
241     auto audioManager = AudioDeviceManagerFactory::GetInstance().CreatDeviceManager(REMOTE_DEV_MGR);
242     CHECK_AND_RETURN_RET_LOG(audioManager != nullptr, ERR_NOT_STARTED, "Init audio manager fail.");
243 
244     {
245         std::lock_guard<std::mutex> lock(audioMangerMutex_);
246         audioManager_ = audioManager;
247     }
248 
249     struct AudioAdapterDescriptor *desc = audioManager->GetTargetAdapterDesc(deviceNetworkId_, false);
250     CHECK_AND_RETURN_RET_LOG(desc != nullptr, ERR_NOT_STARTED, "Get target adapters descriptor fail.");
251     for (uint32_t port = 0; port < desc->ports.size(); port++) {
252         if (desc->ports[port].portId == AudioPortPin::PIN_IN_MIC) {
253             audioPort_ = desc->ports[port];
254             break;
255         }
256         CHECK_AND_RETURN_RET_LOG(port != (desc->ports.size() - 1), ERR_INVALID_INDEX,
257             "Not found the audio mic port.");
258     }
259 
260     auto audioAdapter = audioManager->LoadAdapters(deviceNetworkId_, false);
261     CHECK_AND_RETURN_RET_LOG(audioAdapter != nullptr, ERR_NOT_STARTED, "Load audio device adapter failed.");
262 
263     {
264         std::lock_guard<std::mutex> lock(audioAdapterMutex_);
265         audioAdapter_ = audioAdapter;
266     }
267 
268     int32_t ret = audioAdapter->Init();
269     CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Audio adapter init fail, ret %{public}d.", ret);
270 
271     capturerInited_.store(true);
272 
273     SetMute(muteState_);
274 
275     AUDIO_DEBUG_LOG("RemoteAudioCapturerSource: Init end.");
276     return SUCCESS;
277 }
278 
IsInited(void)279 bool RemoteAudioCapturerSourceInner::IsInited(void)
280 {
281     return capturerInited_.load();
282 }
283 
ConvertToHdiFormat(HdiAdapterFormat format)284 AudioFormat RemoteAudioCapturerSourceInner::ConvertToHdiFormat(HdiAdapterFormat format)
285 {
286     AudioFormat hdiFormat;
287     switch (format) {
288         case SAMPLE_U8:
289             hdiFormat = AudioFormat::AUDIO_FORMAT_TYPE_PCM_8_BIT;
290             break;
291         case SAMPLE_S16:
292             hdiFormat = AudioFormat::AUDIO_FORMAT_TYPE_PCM_16_BIT;
293             break;
294         case SAMPLE_S24:
295             hdiFormat = AudioFormat::AUDIO_FORMAT_TYPE_PCM_24_BIT;
296             break;
297         case SAMPLE_S32:
298             hdiFormat = AudioFormat::AUDIO_FORMAT_TYPE_PCM_32_BIT;
299             break;
300         default:
301             hdiFormat = AudioFormat::AUDIO_FORMAT_TYPE_PCM_16_BIT;
302             break;
303     }
304 
305     return hdiFormat;
306 }
307 
CreateCapture(const struct AudioPort & capturePort)308 int32_t RemoteAudioCapturerSourceInner::CreateCapture(const struct AudioPort &capturePort)
309 {
310     struct AudioSampleAttributes param;
311     param.type = AudioCategory::AUDIO_IN_MEDIA;
312     param.period = deepBufferCapturePeriodSize;
313     param.streamId = REMOTE_INPUT_STREAM_ID;
314     param.isSignedData = true;
315     param.stopThreshold = maxInt32;
316     param.silenceThreshold = audioBufferSize;
317     // User needs to set
318     param.sampleRate = attr_.sampleRate;
319     param.format = ConvertToHdiFormat(attr_.format);
320     param.isBigEndian = attr_.isBigEndian;
321     param.channelCount = attr_.channel;
322     param.silenceThreshold = attr_.bufferSize;
323     param.frameSize = param.format * param.channelCount;
324     param.startThreshold = deepBufferCapturePeriodSize / (param.frameSize);
325     param.sourceType = attr_.sourceType;
326 
327     struct AudioDeviceDescriptor deviceDesc;
328     deviceDesc.portId = capturePort.portId;
329     deviceDesc.pins = AudioPortPin::PIN_IN_MIC;
330     deviceDesc.desc = "";
331 
332     std::shared_ptr<IAudioDeviceAdapter> audioAdapter;
333     {
334         std::lock_guard<std::mutex> lock(audioAdapterMutex_);
335         audioAdapter = audioAdapter_;
336     }
337 
338     CHECK_AND_RETURN_RET_LOG(audioAdapter != nullptr, ERR_INVALID_HANDLE, "CreateCapture: Audio adapter is null.");
339     int32_t ret = audioAdapter->CreateCapture(deviceDesc, param, audioCapture_, this, captureId_);
340     CHECK_AND_RETURN_RET_LOG(ret == SUCCESS && audioCapture_ != nullptr, ret,
341         "Create capture failed, ret %{public}d.", ret);
342 
343     isCapturerCreated_.store(true);
344     return SUCCESS;
345 }
346 
CaptureFrame(char * frame,uint64_t requestBytes,uint64_t & replyBytes)347 int32_t RemoteAudioCapturerSourceInner::CaptureFrame(char *frame, uint64_t requestBytes, uint64_t &replyBytes)
348 {
349     CHECK_AND_RETURN_RET_LOG((audioCapture_ != nullptr), ERR_INVALID_HANDLE, "CaptureFrame: Audio capture is null.");
350     if (!started_.load()) {
351         AUDIO_DEBUG_LOG("AudioRendererSinkInner::RenderFrame invalid state not started!");
352     }
353     std::vector<int8_t> frameHal(requestBytes);
354     int32_t ret = audioCapture_->CaptureFrame(frameHal, replyBytes);
355     CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_READ_FAILED, "Capture frame fail, ret %{public}x.", ret);
356 
357     ret = memcpy_s(frame, requestBytes, frameHal.data(), requestBytes);
358     if (ret != EOK) {
359         AUDIO_ERR_LOG("Copy capture frame failed, error code %d.", ret);
360         return ERR_MEMORY_ALLOC_FAILED;
361     }
362     replyBytes = requestBytes;
363 
364     DumpFileUtil::WriteDumpFile(dumpFile_, frame, requestBytes);
365     CheckUpdateState(frame, requestBytes);
366 
367     return SUCCESS;
368 }
369 
CheckUpdateState(char * frame,uint64_t replyBytes)370 void RemoteAudioCapturerSourceInner::CheckUpdateState(char *frame, uint64_t replyBytes)
371 {
372     if (startUpdate_) {
373         if (capFrameNum_ == 0) {
374             last10FrameStartTime_ = ClockTime::GetCurNano();
375         }
376         capFrameNum_++;
377         maxAmplitude_ = UpdateMaxAmplitude(static_cast<ConvertHdiFormat>(attr_.format), frame, replyBytes);
378         if (capFrameNum_ == GET_MAX_AMPLITUDE_FRAMES_THRESHOLD) {
379             capFrameNum_ = 0;
380             if (last10FrameStartTime_ > lastGetMaxAmplitudeTime_) {
381                 startUpdate_ = false;
382                 maxAmplitude_ = 0;
383             }
384         }
385     }
386 }
387 
GetMaxAmplitude()388 float RemoteAudioCapturerSourceInner::GetMaxAmplitude()
389 {
390     lastGetMaxAmplitudeTime_ = ClockTime::GetCurNano();
391     startUpdate_ = true;
392     return maxAmplitude_;
393 }
394 
Start(void)395 int32_t RemoteAudioCapturerSourceInner::Start(void)
396 {
397     AUDIO_INFO_LOG("RemoteAudioCapturerSourceInner::Start");
398     std::lock_guard<std::mutex> lock(createCaptureMutex_);
399     DumpFileUtil::OpenDumpFile(DUMP_SERVER_PARA, DUMP_REMOTE_CAPTURE_SOURCE_FILENAME, &dumpFile_);
400     if (!isCapturerCreated_.load()) {
401         CHECK_AND_RETURN_RET_LOG(CreateCapture(audioPort_) == SUCCESS, ERR_NOT_STARTED,
402             "Create capture fail, audio port %{public}d", audioPort_.portId);
403     }
404 
405     if (started_.load()) {
406         AUDIO_INFO_LOG("Remote capture is already started.");
407         return SUCCESS;
408     }
409 
410     CHECK_AND_RETURN_RET_LOG((audioCapture_ != nullptr), ERR_INVALID_HANDLE, "Audio capture Handle is nullptr!");
411     int32_t ret = audioCapture_->Start();
412     CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_NOT_STARTED, "Start fail, ret %{public}d.", ret);
413     started_.store(true);
414     return SUCCESS;
415 }
416 
Stop(void)417 int32_t RemoteAudioCapturerSourceInner::Stop(void)
418 {
419     AUDIO_INFO_LOG("RemoteAudioCapturerSourceInner::Stop");
420     if (!started_.load()) {
421         AUDIO_INFO_LOG("Remote capture is already stopped.");
422         return SUCCESS;
423     }
424 
425     CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "Stop: Audio capture is null.");
426     int32_t ret = audioCapture_->Stop();
427     CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_OPERATION_FAILED, "Stop fail, ret %{public}d.", ret);
428     started_.store(false);
429     std::shared_ptr<IAudioDeviceAdapter> audioAdapter = nullptr;
430     {
431         std::lock_guard<std::mutex> lock(audioAdapterMutex_);
432         audioAdapter = audioAdapter_;
433     }
434     if (isCapturerCreated_.load() && audioAdapter != nullptr) {
435         audioAdapter->DestroyCapture(audioCapture_, captureId_);
436         AUDIO_INFO_LOG("RemoteAudioCapturerSourceInner::destroy capture end");
437         audioCapture_ = nullptr;
438         captureId_ = 0;
439         isCapturerCreated_.store(false);
440     }
441     return SUCCESS;
442 }
443 
Pause(void)444 int32_t RemoteAudioCapturerSourceInner::Pause(void)
445 {
446     AUDIO_INFO_LOG("RemoteAudioCapturerSourceInner::Pause");
447     CHECK_AND_RETURN_RET_LOG(started_.load(), ERR_ILLEGAL_STATE, "Pause invalid state!");
448 
449     if (paused_.load()) {
450         AUDIO_INFO_LOG("Remote render is already paused.");
451         return SUCCESS;
452     }
453 
454     CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "Pause: Audio capture is null.");
455     int32_t ret = audioCapture_->Pause();
456     CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_OPERATION_FAILED, "Pause fail, ret %{public}d.", ret);
457     paused_.store(true);
458     return SUCCESS;
459 }
460 
Resume(void)461 int32_t RemoteAudioCapturerSourceInner::Resume(void)
462 {
463     AUDIO_INFO_LOG("RemoteAudioCapturerSourceInner::Resume");
464     CHECK_AND_RETURN_RET_LOG(started_.load(), ERR_ILLEGAL_STATE, "Resume invalid state!");
465 
466     if (!paused_.load()) {
467         AUDIO_INFO_LOG("Remote render is already resumed.");
468         return SUCCESS;
469     }
470 
471     CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "Resume: Audio capture is null.");
472     int32_t ret = audioCapture_->Resume();
473     CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_OPERATION_FAILED, "Resume fail, ret %{public}d.", ret);
474     paused_.store(false);
475     return SUCCESS;
476 }
477 
Reset(void)478 int32_t RemoteAudioCapturerSourceInner::Reset(void)
479 {
480     AUDIO_INFO_LOG("RemoteAudioCapturerSourceInner::Reset");
481     CHECK_AND_RETURN_RET_LOG(started_.load(), ERR_ILLEGAL_STATE, "Reset invalid state!");
482 
483     CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "Reset: Audio capture is null.");
484     int32_t ret = audioCapture_->Flush();
485     CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_OPERATION_FAILED, "Reset fail, ret %{public}d.", ret);
486     return SUCCESS;
487 }
488 
Flush(void)489 int32_t RemoteAudioCapturerSourceInner::Flush(void)
490 {
491     AUDIO_INFO_LOG("RemoteAudioCapturerSourceInner::Flush");
492     CHECK_AND_RETURN_RET_LOG(started_.load(), ERR_ILLEGAL_STATE, "Flush invalid state!");
493 
494     CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "Flush: Audio capture is null.");
495     int32_t ret = audioCapture_->Flush();
496     CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_OPERATION_FAILED, "Flush fail, ret %{public}d.", ret);
497     return SUCCESS;
498 }
499 
SetVolume(float left,float right)500 int32_t RemoteAudioCapturerSourceInner::SetVolume(float left, float right)
501 {
502     // remote setvolume may not supported
503     float volume = 0.5;
504     CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "SetVolume: Audio capture is null.");
505 
506     float leftVolume = left;
507     float rightVolume = right;
508     float half = 0.5;
509     if ((leftVolume == 0) && (rightVolume != 0)) {
510         volume = rightVolume;
511     } else if ((leftVolume != 0) && (rightVolume == 0)) {
512         volume = leftVolume;
513     } else {
514         volume = (leftVolume + rightVolume) * half;
515     }
516 
517     int32_t ret = audioCapture_->SetVolume(volume);
518     AUDIO_INFO_LOG("remote setVolume(%{public}f, %{public}f):%{public}d", left, right, ret);
519     return ret;
520 }
521 
GetVolume(float & left,float & right)522 int32_t RemoteAudioCapturerSourceInner::GetVolume(float &left, float &right)
523 {
524     CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "GetVolume: Audio capture is null.");
525     float val = 0.0;
526     audioCapture_->GetVolume(val);
527     left = val;
528     right = val;
529 
530     return SUCCESS;
531 }
532 
SetMute(bool isMute)533 int32_t RemoteAudioCapturerSourceInner::SetMute(bool isMute)
534 {
535     muteState_ = isMute;
536 
537     if (!IsInited()) {
538         AUDIO_INFO_LOG("SetMute before init, only record mute state");
539         return SUCCESS;
540     }
541 
542     CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "SetMute: Audio capture is null.");
543 
544     int32_t ret = audioCapture_->SetMute(isMute);
545     if (ret != 0) {
546         AUDIO_ERR_LOG("SetMute failed from hdi");
547     }
548 
549     return SUCCESS;
550 }
551 
GetMute(bool & isMute)552 int32_t RemoteAudioCapturerSourceInner::GetMute(bool &isMute)
553 {
554     isMute = muteState_;
555 
556     CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "GetMute: Audio capture is null.");
557 
558     bool isHdiMute = false;
559     int32_t ret = audioCapture_->GetMute(isHdiMute);
560     if (ret != 0) {
561         AUDIO_ERR_LOG("AudioCapturerSource::GetMute failed from hdi");
562     }
563 
564     return SUCCESS;
565 }
566 
SetInputPortPin(DeviceType inputDevice,AudioRouteNode & source)567 int32_t RemoteAudioCapturerSourceInner::SetInputPortPin(DeviceType inputDevice, AudioRouteNode &source)
568 {
569     int32_t ret = SUCCESS;
570 
571     switch (inputDevice) {
572         case DEVICE_TYPE_MIC:
573             source.ext.device.type = AudioPortPin::PIN_IN_MIC;
574             source.ext.device.desc = "pin_in_mic";
575             break;
576         case DEVICE_TYPE_WIRED_HEADSET:
577             source.ext.device.type = AudioPortPin::PIN_IN_HS_MIC;
578             source.ext.device.desc = "pin_in_hs_mic";
579             break;
580         case DEVICE_TYPE_USB_HEADSET:
581             source.ext.device.type = AudioPortPin::PIN_IN_USB_EXT;
582             source.ext.device.desc = "pin_in_usb_ext";
583             break;
584         default:
585             ret = ERR_NOT_SUPPORTED;
586             break;
587     }
588 
589     return ret;
590 }
591 
SetInputRoute(DeviceType inputDevice)592 int32_t RemoteAudioCapturerSourceInner::SetInputRoute(DeviceType inputDevice)
593 {
594     AudioRouteNode source = {};
595     AudioRouteNode sink = {};
596 
597     int32_t ret = SetInputPortPin(inputDevice, source);
598     CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Set input port pin fail, ret %{public}d", ret);
599 
600     source.portId = static_cast<int32_t>(audioPort_.portId);
601     source.role = AudioPortRole::AUDIO_PORT_SOURCE_ROLE;
602     source.type = AudioPortType::AUDIO_PORT_DEVICE_TYPE;
603     source.ext.device.moduleId = 0;
604 
605     sink.portId = 0;
606     sink.role = AudioPortRole::AUDIO_PORT_SINK_ROLE;
607     sink.type = AudioPortType::AUDIO_PORT_MIX_TYPE;
608     sink.ext.mix.moduleId = 0;
609     sink.ext.mix.streamId = REMOTE_INPUT_STREAM_ID;
610 
611     AudioRoute route;
612     route.sources.push_back(source);
613     route.sinks.push_back(sink);
614 
615     std::shared_ptr<IAudioDeviceAdapter> audioAdapter;
616     {
617         std::lock_guard<std::mutex> lock(audioAdapterMutex_);
618         audioAdapter = audioAdapter_;
619     }
620 
621     CHECK_AND_RETURN_RET_LOG(audioAdapter != nullptr, ERR_INVALID_HANDLE, "SetInputRoute: Audio adapter is null.");
622     ret = audioAdapter->UpdateAudioRoute(route);
623     CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "Update audio route fail, ret %{public}d", ret);
624     return SUCCESS;
625 }
626 
GetAudioCategory(AudioScene audioScene)627 AudioCategory RemoteAudioCapturerSourceInner::GetAudioCategory(AudioScene audioScene)
628 {
629     AudioCategory audioCategory;
630     switch (audioScene) {
631         case AUDIO_SCENE_DEFAULT:
632             audioCategory = AudioCategory::AUDIO_IN_MEDIA;
633             break;
634         case AUDIO_SCENE_RINGING:
635         case AUDIO_SCENE_VOICE_RINGING:
636             audioCategory = AudioCategory::AUDIO_IN_RINGTONE;
637             break;
638         case AUDIO_SCENE_PHONE_CALL:
639             audioCategory = AudioCategory::AUDIO_IN_CALL;
640             break;
641         case AUDIO_SCENE_PHONE_CHAT:
642             audioCategory = AudioCategory::AUDIO_IN_COMMUNICATION;
643             break;
644         default:
645             audioCategory = AudioCategory::AUDIO_IN_MEDIA;
646             break;
647     }
648     AUDIO_DEBUG_LOG("RemoteAudioCapturerSource: Audio category returned is: %{public}d", audioCategory);
649 
650     return audioCategory;
651 }
652 
SetAudioScene(AudioScene audioScene,DeviceType activeDevice)653 int32_t RemoteAudioCapturerSourceInner::SetAudioScene(AudioScene audioScene, DeviceType activeDevice)
654 {
655     CHECK_AND_RETURN_RET_LOG(audioCapture_ != nullptr, ERR_INVALID_HANDLE, "SetAudioScene: Audio capture is null.");
656     struct AudioSceneDescriptor scene;
657     scene.scene.id = GetAudioCategory(audioScene);
658     scene.desc.pins = AudioPortPin::PIN_IN_MIC;
659     CHECK_AND_RETURN_RET_LOG(audioScene >= AUDIO_SCENE_DEFAULT && audioScene < AUDIO_SCENE_MAX,
660         ERR_INVALID_PARAM, "invalid audioScene");
661 
662     AUDIO_INFO_LOG("AudioCapturerSource::SelectScene start");
663     int32_t ret = audioCapture_->SelectScene(scene);
664     AUDIO_INFO_LOG("AudioCapturerSource::SelectScene over");
665     CHECK_AND_RETURN_RET_LOG(ret >= 0, ERR_OPERATION_FAILED,
666         "AudioCapturerSource: Select scene FAILED: %{public}d", ret);
667     AUDIO_INFO_LOG("AudioCapturerSource::Select audio scene SUCCESS: %{public}d", audioScene);
668     return SUCCESS;
669 }
670 
GetTransactionId()671 uint64_t RemoteAudioCapturerSourceInner::GetTransactionId()
672 {
673     return ERR_NOT_SUPPORTED;
674 }
675 
GetPresentationPosition(uint64_t & frames,int64_t & timeSec,int64_t & timeNanoSec)676 int32_t RemoteAudioCapturerSourceInner::GetPresentationPosition(uint64_t& frames, int64_t& timeSec,
677     int64_t& timeNanoSec)
678 {
679     return ERR_OPERATION_FAILED;
680 }
681 
GetAudioParameter(const AudioParamKey key,const std::string & condition)682 std::string RemoteAudioCapturerSourceInner::GetAudioParameter(const AudioParamKey key,
683                                                               const std::string &condition)
684 {
685     AUDIO_WARNING_LOG("not supported yet");
686     return "";
687 }
688 
RegisterWakeupCloseCallback(IAudioSourceCallback * callback)689 void RemoteAudioCapturerSourceInner::RegisterWakeupCloseCallback(IAudioSourceCallback *callback)
690 {
691     AUDIO_ERR_LOG("RegisterWakeupCloseCallback FAILED");
692 }
693 
RegisterAudioCapturerSourceCallback(std::unique_ptr<ICapturerStateCallback> callback)694 void RemoteAudioCapturerSourceInner::RegisterAudioCapturerSourceCallback(
695     std::unique_ptr<ICapturerStateCallback> callback)
696 {
697     AUDIO_ERR_LOG("RegisterAudioCapturerSourceCallback FAILED");
698 }
699 
RegisterParameterCallback(IAudioSourceCallback * callback)700 void RemoteAudioCapturerSourceInner::RegisterParameterCallback(IAudioSourceCallback *callback)
701 {
702     AUDIO_INFO_LOG("register params callback");
703     paramCb_ = callback;
704 
705 #ifdef FEATURE_DISTRIBUTE_AUDIO
706     std::shared_ptr<IAudioDeviceAdapter> audioAdapter;
707     {
708         std::lock_guard<std::mutex> lock(audioAdapterMutex_);
709         audioAdapter = audioAdapter_;
710     }
711     CHECK_AND_RETURN_LOG(audioAdapter != nullptr, "RegisterParameterCallback: Audio adapter is null.");
712     int32_t ret = audioAdapter->RegExtraParamObserver();
713     CHECK_AND_RETURN_LOG(ret == SUCCESS, "RegisterParameterCallback failed, ret %{public}d.", ret);
714 #endif
715 }
716 
OnAudioParamChange(const std::string & adapterName,const AudioParamKey key,const std::string & condition,const std::string & value)717 void RemoteAudioCapturerSourceInner::OnAudioParamChange(const std::string &adapterName, const AudioParamKey key,
718     const std::string &condition, const std::string &value)
719 {
720     AUDIO_INFO_LOG("Audio param change event, key:%{public}d, condition:%{public}s, value:%{public}s",
721         key, condition.c_str(), value.c_str());
722     if (key == AudioParamKey::PARAM_KEY_STATE) {
723         ClearCapture();
724     }
725 
726     CHECK_AND_RETURN_LOG(paramCb_ != nullptr, "Sink audio param callback is null.");
727     paramCb_->OnAudioSourceParamChange(adapterName, key, condition, value);
728 }
729 
UpdateAppsUid(const int32_t appsUid[PA_MAX_OUTPUTS_PER_SOURCE],const size_t size)730 int32_t RemoteAudioCapturerSourceInner::UpdateAppsUid(const int32_t appsUid[PA_MAX_OUTPUTS_PER_SOURCE],
731     const size_t size)
732 {
733     AUDIO_WARNING_LOG("not supported.");
734     return ERR_NOT_SUPPORTED;
735 }
736 
UpdateAppsUid(const std::vector<int32_t> & appsUid)737 int32_t RemoteAudioCapturerSourceInner::UpdateAppsUid(const std::vector<int32_t> &appsUid)
738 {
739     AUDIO_WARNING_LOG("not supported.");
740     return ERR_NOT_SUPPORTED;
741 }
742 } // namespace AudioStandard
743 } // namesapce OHOS
744 
745