• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2022-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 
16 #include "audio_adapter_interface_impl.h"
17 
18 #include <algorithm>
19 #include <dlfcn.h>
20 #include <hdf_base.h>
21 #include <sstream>
22 
23 #include "cJSON.h"
24 
25 #include "daudio_constants.h"
26 #include "daudio_errcode.h"
27 #include "daudio_events.h"
28 #include "daudio_log.h"
29 #include "daudio_utils.h"
30 
31 #undef DH_LOG_TAG
32 #define DH_LOG_TAG "AudioAdapterInterfaceImpl"
33 
34 using namespace OHOS::DistributedHardware;
35 namespace OHOS {
36 namespace HDI {
37 namespace DistributedAudio {
38 namespace Audio {
39 namespace V1_0 {
40 static constexpr uint32_t MAX_AUDIO_STREAM_NUM = 10;
41 
AudioAdapterInterfaceImpl(const AudioAdapterDescriptor & desc)42 AudioAdapterInterfaceImpl::AudioAdapterInterfaceImpl(const AudioAdapterDescriptor &desc)
43     : adpDescriptor_(desc)
44 {
45     renderDevs_ = std::vector<std::pair<int32_t, sptr<AudioRenderInterfaceImplBase>>>(
46         MAX_AUDIO_STREAM_NUM, std::make_pair(0, sptr<AudioRenderInterfaceImplBase>(nullptr)));
47     captureDevs_ = std::vector<std::pair<int32_t, sptr<AudioCaptureInterfaceImplBase>>>(
48         MAX_AUDIO_STREAM_NUM, std::make_pair(0, sptr<AudioCaptureInterfaceImplBase>(nullptr)));
49     spkStatus_ = std::vector<bool>(MAX_AUDIO_STREAM_NUM, false);
50     renderParam_ = { 0, 0, 0, 0, 0, 0 };
51     captureParam_ = { 0, 0, 0, 0, 0, 0 };
52 
53     DHLOGD("Distributed audio adapter constructed, name(%{public}s).", GetAnonyString(desc.adapterName).c_str());
54 }
55 
~AudioAdapterInterfaceImpl()56 AudioAdapterInterfaceImpl::~AudioAdapterInterfaceImpl()
57 {
58     DHLOGD("Distributed audio adapter destructed, name(%{public}s).",
59         GetAnonyString(adpDescriptor_.adapterName).c_str());
60 }
61 
SetSpeakerCallback(const int32_t dhId,const sptr<IDAudioCallback> & spkCallback)62 void AudioAdapterInterfaceImpl::SetSpeakerCallback(const int32_t dhId, const sptr<IDAudioCallback> &spkCallback)
63 {
64     if (spkCallback == nullptr) {
65         DHLOGE("Callback is nullptr.");
66         return;
67     }
68     std::lock_guard<std::mutex> callbackLck(extCallbackMtx_);
69     if (extCallbackMap_.find(dhId) != extCallbackMap_.end()) {
70         DHLOGI("The callback of daudio is already set.");
71         return;
72     }
73     extCallbackMap_[dhId] = spkCallback;
74 }
75 
SetMicCallback(const int32_t dhId,const sptr<IDAudioCallback> & micCallback)76 void AudioAdapterInterfaceImpl::SetMicCallback(const int32_t dhId, const sptr<IDAudioCallback> &micCallback)
77 {
78     if (micCallback == nullptr) {
79         DHLOGE("Callback is nullptr.");
80         return;
81     }
82     std::lock_guard<std::mutex> callbackLck(extCallbackMtx_);
83     if (extCallbackMap_.find(dhId) != extCallbackMap_.end()) {
84         DHLOGI("The callback of daudio is already set.");
85         return;
86     }
87     extCallbackMap_[dhId] = micCallback;
88 }
89 
InitAllPorts()90 int32_t AudioAdapterInterfaceImpl::InitAllPorts()
91 {
92     DHLOGI("Init (%{public}zu) distributed audio ports.", mapAudioDevice_.size());
93     return HDF_SUCCESS;
94 }
95 
CreateRenderImpl(const AudioDeviceDescriptor & desc,const AudioSampleAttributes & attrs,int32_t renderId)96 sptr<AudioRenderInterfaceImplBase> AudioAdapterInterfaceImpl::CreateRenderImpl(const AudioDeviceDescriptor &desc,
97     const AudioSampleAttributes &attrs, int32_t renderId)
98 {
99     sptr<AudioRenderInterfaceImplBase> audioRender = nullptr;
100     int renderPinId = 0;
101     auto extSpkCallback = MatchStreamCallback(attrs, desc, renderPinId);
102     if (extSpkCallback == nullptr) {
103         DHLOGE("Matched callback is null.");
104         return audioRender;
105     }
106 #ifdef DAUDIO_SUPPORT_EXTENSION
107     if (attrs.type == AUDIO_MMAP_NOIRQ || attrs.type == AUDIO_MMAP_VOIP) {
108         DHLOGI("Try to mmap mode.");
109         renderFlags_ = Audioext::V2_1::MMAP_MODE;
110         audioRender = sptr<AudioRenderInterfaceImplBase>(new AudioRenderExtImpl());
111         if (audioRender == nullptr) {
112             DHLOGE("audioRender is null.");
113             return audioRender;
114         }
115         audioRender->SetAttrs(adpDescriptor_.adapterName, desc, attrs, extSpkCallback, renderPinId);
116     } else {
117         DHLOGI("Try to normal mode.");
118         renderFlags_ = Audioext::V2_1::NORMAL_MODE;
119         audioRender = sptr<AudioRenderInterfaceImplBase>(new AudioRenderInterfaceImpl(adpDescriptor_.adapterName,
120             desc, attrs, extSpkCallback, renderId));
121     }
122 #else
123     renderFlags_ = Audioext::V2_1::NORMAL_MODE;
124     audioRender = sptr<AudioRenderInterfaceImplBase>(new AudioRenderInterfaceImpl(adpDescriptor_.adapterName,
125         desc, attrs, extSpkCallback, renderId));
126 #endif
127     return audioRender;
128 }
129 
CreateRender(const AudioDeviceDescriptor & desc,const AudioSampleAttributes & attrs,sptr<IAudioRender> & render,uint32_t & renderId)130 int32_t AudioAdapterInterfaceImpl::CreateRender(const AudioDeviceDescriptor &desc,
131     const AudioSampleAttributes &attrs, sptr<IAudioRender> &render, uint32_t &renderId)
132 {
133     DHLOGI("Create distributed audio render, {pin: %{public}d, sampleRate: %{public}d, channel: %{public}d,"
134         "formats: %{public}d, type: %{public}d}.", desc.pins, attrs.sampleRate, attrs.channelCount,
135         attrs.format, static_cast<int32_t>(attrs.type));
136     render = nullptr;
137     sptr<AudioRenderInterfaceImplBase> audioRender = nullptr;
138     if (!CheckDevCapability(desc)) {
139         DHLOGE("Can not find device, create render failed.");
140         return HDF_FAILURE;
141     }
142     int renderPinId = 0;
143     auto extSpkCallback = MatchStreamCallback(attrs, desc, renderPinId);
144     if (extSpkCallback == nullptr) {
145         DHLOGE("Matched callback is null.");
146         return HDF_FAILURE;
147     }
148     if (InsertRenderImpl(desc, attrs, audioRender, renderPinId, renderId) != HDF_SUCCESS) {
149         DHLOGE("Create and insert render implement failed.");
150         return HDF_FAILURE;
151     }
152 
153     int32_t ret = OpenRenderDevice(desc, attrs, extSpkCallback, renderPinId, renderId);
154     if (ret != DH_SUCCESS) {
155         DHLOGE("Open render device failed.");
156         DeleteRenderImpl(renderId);
157         renderId = MAX_AUDIO_STREAM_NUM;
158         audioRender = nullptr;
159         return ret == ERR_DH_AUDIO_HDF_WAIT_TIMEOUT ? HDF_ERR_TIMEOUT : HDF_FAILURE;
160     }
161     renderCallbacks_[renderId] = audioRender;
162     render = audioRender;
163     DHLOGI("Create render success, render ID is %{public}u.", renderId);
164     return HDF_SUCCESS;
165 }
166 
MatchStreamCallback(const AudioSampleAttributes & attrs,const AudioDeviceDescriptor & desc,int32_t & dhId)167 sptr<IDAudioCallback> AudioAdapterInterfaceImpl::MatchStreamCallback(const AudioSampleAttributes &attrs,
168     const AudioDeviceDescriptor &desc, int32_t &dhId)
169 {
170     dhId = static_cast<int32_t>(desc.pins);
171     if (desc.pins == DEFAULT_RENDER_ID && (attrs.type == AUDIO_MMAP_NOIRQ || attrs.type == AUDIO_MMAP_VOIP)) {
172         dhId = LOW_LATENCY_RENDER_ID;
173     }
174 
175     std::lock_guard<std::mutex> callbackLck(extCallbackMtx_);
176     auto iter = extCallbackMap_.find(dhId);
177     if (iter == extCallbackMap_.end()) {
178         DHLOGE("Can't find matched callback");
179         return nullptr;
180     }
181     return iter->second;
182 }
183 
InsertRenderImpl(const AudioDeviceDescriptor & desc,const AudioSampleAttributes & attrs,sptr<AudioRenderInterfaceImplBase> & audioRender,const int32_t dhId,uint32_t & renderId)184 int32_t AudioAdapterInterfaceImpl::InsertRenderImpl(const AudioDeviceDescriptor &desc,
185     const AudioSampleAttributes &attrs, sptr<AudioRenderInterfaceImplBase> &audioRender,
186     const int32_t dhId, uint32_t &renderId)
187 {
188     std::lock_guard<std::mutex> devLck(renderDevMtx_);
189     if (renderDevs_.size() != MAX_AUDIO_STREAM_NUM) {
190         DHLOGE("Render device contain check error.");
191         return HDF_FAILURE;
192     }
193     renderId = MAX_AUDIO_STREAM_NUM;
194     for (uint32_t i = 0; i < MAX_AUDIO_STREAM_NUM; i++) {
195         if (renderDevs_[i].second == nullptr) {
196             renderId = i;
197             audioRender = CreateRenderImpl(desc, attrs, renderId);
198             CHECK_NULL_RETURN(audioRender, HDF_FAILURE);
199             renderDevs_[renderId] = std::make_pair(dhId, audioRender);
200             return HDF_SUCCESS;
201         }
202     }
203     DHLOGE("The device is busy, can't create render anymore.");
204     return HDF_FAILURE;
205 }
206 
DeleteRenderImpl(uint32_t renderId)207 void AudioAdapterInterfaceImpl::DeleteRenderImpl(uint32_t renderId)
208 {
209     if (renderId >= MAX_AUDIO_STREAM_NUM) {
210         DHLOGE("Invalid render ID.");
211         return;
212     }
213     std::lock_guard<std::mutex> devLck(renderDevMtx_);
214     renderDevs_[renderId] = std::make_pair(0, sptr<AudioRenderInterfaceImplBase>(nullptr));
215     DeleteRenderCallback(renderId);
216     DHLOGE("Delete render success.");
217     return;
218 }
219 
DestroyRender(uint32_t renderId)220 int32_t AudioAdapterInterfaceImpl::DestroyRender(uint32_t renderId)
221 {
222     DHLOGI("Destroy distributed audio render, ID: %{public}u.", renderId);
223     if (!IsIdValid(renderId)) {
224         DHLOGE("The input render ID is invalid.");
225         return HDF_FAILURE;
226     }
227     sptr<AudioRenderInterfaceImplBase> audioRender(nullptr);
228     int32_t dhId = 0;
229     {
230         std::lock_guard<std::mutex> devLck(renderDevMtx_);
231         audioRender = renderDevs_[renderId].second;
232         dhId = renderDevs_[renderId].first;
233     }
234     std::lock_guard<std::mutex> callbackLck(extCallbackMtx_);
235     sptr<IDAudioCallback> extSpkCallback(extCallbackMap_[dhId]);
236     if (audioRender == nullptr) {
237         DHLOGD("Render has not been created, do not need destroy.");
238         return HDF_SUCCESS;
239     }
240     if (audioRender->GetRenderStatus() == AudioRenderStatus::RENDER_STATUS_CLOSE) {
241         DHLOGI("Render has been closed before.");
242         std::lock_guard<std::mutex> devLck(renderDevMtx_);
243         renderDevs_[renderId] = std::make_pair(0, sptr<AudioRenderInterfaceImplBase>(nullptr));
244         DeleteRenderCallback(renderId);
245         return HDF_SUCCESS;
246     }
247     audioRender->SetRenderStatus(AudioRenderStatus::RENDER_STATUS_CLOSE);
248     int32_t ret = CloseRenderDevice(audioRender->GetRenderDesc(), extSpkCallback, dhId, renderId);
249     if (ret != DH_SUCCESS) {
250         DHLOGE("Close render device failed.");
251         return HDF_FAILURE;
252     }
253     {
254         std::lock_guard<std::mutex> devLck(renderDevMtx_);
255         renderDevs_[renderId] = std::make_pair(0, sptr<AudioRenderInterfaceImplBase>(nullptr));
256         DeleteRenderCallback(renderId);
257     }
258     DHLOGI("Destroy render: %{public}u done", renderId);
259     return HDF_SUCCESS;
260 }
261 
CheckDevCapability(const AudioDeviceDescriptor & desc)262 bool AudioAdapterInterfaceImpl::CheckDevCapability(const AudioDeviceDescriptor &desc)
263 {
264     std::lock_guard<std::mutex> devLck(devMapMtx_);
265     if (mapAudioDevice_.find(desc.pins) == mapAudioDevice_.end()) {
266         DHLOGE("Can not find device, create render failed.");
267         return false;
268     }
269     return true;
270 }
271 
CreateCapture(const AudioDeviceDescriptor & desc,const AudioSampleAttributes & attrs,sptr<IAudioCapture> & capture,uint32_t & captureId)272 int32_t AudioAdapterInterfaceImpl::CreateCapture(const AudioDeviceDescriptor &desc,
273     const AudioSampleAttributes &attrs, sptr<IAudioCapture> &capture, uint32_t &captureId)
274 {
275     DHLOGI("Create daudio capture, {pin: %{public}d, sampleRate: %{public}" PRIu32", channel: %{public}" PRIu32
276         ", formats: %{public}d}.", desc.pins, attrs.sampleRate, attrs.channelCount, attrs.format);
277     capture = nullptr;
278     sptr<AudioCaptureInterfaceImplBase> audioCapture(nullptr);
279     if (!CheckDevCapability(desc)) {
280         DHLOGE("Can not find device, create capture failed.");
281         return HDF_FAILURE;
282     }
283     int32_t capPinId = 0;
284     auto extMicCallback = MatchStreamCallback(attrs, desc, capPinId);
285     if (extMicCallback == nullptr) {
286         DHLOGE("Matched callback is null.");
287         return HDF_FAILURE;
288     }
289 #ifdef DAUDIO_SUPPORT_EXTENSION
290     if (attrs.type == AUDIO_MMAP_NOIRQ || attrs.type == AUDIO_MMAP_VOIP) {
291         DHLOGI("Try to mmap mode.");
292         capturerFlags_ = Audioext::V2_1::MMAP_MODE;
293         audioCapture = sptr<AudioCaptureInterfaceImplBase>(new AudioCaptureExtImpl());
294         if (audioCapture == nullptr) {
295             DHLOGE("audioCapture is null.");
296             return HDF_FAILURE;
297         }
298         audioCapture->SetAttrs(adpDescriptor_.adapterName, desc, attrs, extMicCallback, desc.pins);
299     } else {
300         DHLOGI("Try to normal mode.");
301         capturerFlags_ = Audioext::V2_1::NORMAL_MODE;
302         audioCapture = sptr<AudioCaptureInterfaceImplBase>(new AudioCaptureInterfaceImpl(adpDescriptor_.adapterName,
303             desc, attrs, extMicCallback));
304     }
305 #else
306     capturerFlags_ = Audioext::V2_1::NORMAL_MODE;
307     audioCapture = sptr<AudioCaptureInterfaceImplBase>(new AudioCaptureInterfaceImpl(adpDescriptor_.adapterName,
308         desc, attrs, extMicCallback));
309 #endif
310     int32_t ret = OpenCaptureDevice(desc, attrs, extMicCallback, capPinId);
311     if (ret != DH_SUCCESS) {
312         DHLOGE("Open capture device failed.");
313         audioCapture = nullptr;
314         return ret == ERR_DH_AUDIO_HDF_WAIT_TIMEOUT ? HDF_ERR_TIMEOUT : HDF_FAILURE;
315     }
316     capture = audioCapture;
317     if (InsertCapImpl(audioCapture, capPinId, captureId) != HDF_SUCCESS) {
318         DHLOGE("Generrate capture ID and insert capture failed.");
319         return HDF_FAILURE;
320     }
321     DHLOGI("Create capture success, capture ID is %{public}u.", captureId);
322     return HDF_SUCCESS;
323 }
324 
InsertCapImpl(const sptr<AudioCaptureInterfaceImplBase> & audioCapture,const int32_t dhId,uint32_t & captureId)325 int32_t AudioAdapterInterfaceImpl::InsertCapImpl(const sptr<AudioCaptureInterfaceImplBase> &audioCapture,
326     const int32_t dhId, uint32_t &captureId)
327 {
328     std::lock_guard<std::mutex> devLck(capDevMtx_);
329     if (captureDevs_.size() != MAX_AUDIO_STREAM_NUM) {
330         DHLOGE("Capture device's size check error.");
331         return HDF_FAILURE;
332     }
333     captureId = MAX_AUDIO_STREAM_NUM;
334     for (uint32_t i = 0; i < MAX_AUDIO_STREAM_NUM; i++) {
335         if (captureDevs_[i].second == nullptr) {
336             captureId = i;
337             captureDevs_[captureId] = std::make_pair(dhId, audioCapture);
338             return HDF_SUCCESS;
339         }
340     }
341     DHLOGE("The device is busy, can't create capture anymore.");
342     return HDF_FAILURE;
343 }
344 
DestroyCapture(uint32_t captureId)345 int32_t AudioAdapterInterfaceImpl::DestroyCapture(uint32_t captureId)
346 {
347     DHLOGI("Destroy distributed audio capture, ID: %{public}u.", captureId);
348     if (!IsIdValid(captureId)) {
349         DHLOGE("The input capture ID is invalid.");
350         return HDF_FAILURE;
351     }
352     sptr<AudioCaptureInterfaceImplBase> audioCapture(nullptr);
353     int32_t dhId = 0;
354     {
355         std::lock_guard<std::mutex> devLck(capDevMtx_);
356         audioCapture = captureDevs_[captureId].second;
357         dhId = captureDevs_[captureId].first;
358     }
359     std::lock_guard<std::mutex> callbackLck(extCallbackMtx_);
360     sptr<IDAudioCallback> extMicCallback(extCallbackMap_[dhId]);
361     if (audioCapture == nullptr) {
362         DHLOGD("Capture has not been created, do not need destroy.");
363         return HDF_SUCCESS;
364     }
365     if (audioCapture->GetCaptureStatus() == AudioCaptureStatus::CAPTURE_STATUS_CLOSE) {
366         DHLOGI("Capture has been closed before.");
367         std::lock_guard<std::mutex> devLck(capDevMtx_);
368         captureDevs_[captureId] = std::make_pair(0, sptr<AudioCaptureInterfaceImplBase>(nullptr));
369         return HDF_SUCCESS;
370     }
371     audioCapture->SetCaptureStatus(AudioCaptureStatus::CAPTURE_STATUS_CLOSE);
372     int32_t ret = CloseCaptureDevice(audioCapture->GetCaptureDesc(), extMicCallback, dhId);
373     if (ret != DH_SUCCESS) {
374         DHLOGE("Close capture device failed.");
375         return HDF_FAILURE;
376     }
377     {
378         std::lock_guard<std::mutex> devLck(capDevMtx_);
379         captureDevs_[captureId].first = 0;
380         captureDevs_[captureId].second = nullptr;
381     }
382     return HDF_SUCCESS;
383 }
384 
GetPortCapability(const AudioPort & port,AudioPortCapability & capability)385 int32_t AudioAdapterInterfaceImpl::GetPortCapability(const AudioPort &port, AudioPortCapability &capability)
386 {
387     DHLOGD("Get audio port capability.");
388     (void)port;
389     capability.sampleRateMasks = AUDIO_SAMPLE_RATE_DEFAULT;
390     capability.channelCount = AUDIO_CHANNEL_COUNT_DEFAULT;
391 
392     return HDF_SUCCESS;
393 }
394 
SetPassthroughMode(const AudioPort & port,AudioPortPassthroughMode mode)395 int32_t AudioAdapterInterfaceImpl::SetPassthroughMode(const AudioPort &port, AudioPortPassthroughMode mode)
396 {
397     (void)port;
398     (void)mode;
399     return HDF_SUCCESS;
400 }
401 
GetPassthroughMode(const AudioPort & port,AudioPortPassthroughMode & mode)402 int32_t AudioAdapterInterfaceImpl::GetPassthroughMode(const AudioPort &port, AudioPortPassthroughMode &mode)
403 {
404     (void)port;
405     (void)mode;
406     return HDF_SUCCESS;
407 }
408 
GetDeviceStatus(AudioDeviceStatus & status)409 int32_t AudioAdapterInterfaceImpl::GetDeviceStatus(AudioDeviceStatus& status)
410 {
411     (void) status;
412     return HDF_SUCCESS;
413 }
414 
UpdateAudioRoute(const AudioRoute & route,int32_t & routeHandle)415 int32_t AudioAdapterInterfaceImpl::UpdateAudioRoute(const AudioRoute &route, int32_t &routeHandle)
416 {
417     (void) route;
418     (void) routeHandle;
419     return HDF_SUCCESS;
420 }
421 
ReleaseAudioRoute(int32_t routeHandle)422 int32_t AudioAdapterInterfaceImpl::ReleaseAudioRoute(int32_t routeHandle)
423 {
424     (void) routeHandle;
425     return HDF_SUCCESS;
426 }
427 
SetMicMute(bool mute)428 int32_t AudioAdapterInterfaceImpl::SetMicMute(bool mute)
429 {
430     (void) mute;
431     return HDF_SUCCESS;
432 }
433 
GetMicMute(bool & mute)434 int32_t AudioAdapterInterfaceImpl::GetMicMute(bool& mute)
435 {
436     (void) mute;
437     return HDF_SUCCESS;
438 }
439 
SetVoiceVolume(float volume)440 int32_t AudioAdapterInterfaceImpl::SetVoiceVolume(float volume)
441 {
442     (void) volume;
443     return HDF_SUCCESS;
444 }
445 
SetExtraParams(AudioExtParamKey key,const std::string & condition,const std::string & value)446 int32_t AudioAdapterInterfaceImpl::SetExtraParams(AudioExtParamKey key, const std::string &condition,
447     const std::string &value)
448 {
449     DHLOGD("Set audio parameters, key = %{public}d, condition: %{public}s value: %{public}s.", key,
450         condition.c_str(), value.c_str());
451     int32_t ret = ERR_DH_AUDIO_HDF_FAIL;
452     switch (key) {
453         case AudioExtParamKey::AUDIO_EXT_PARAM_KEY_VOLUME:
454             ret = SetAudioVolume(condition, value);
455             if (ret != DH_SUCCESS) {
456                 DHLOGE("Set audio parameters failed.");
457                 return HDF_FAILURE;
458             }
459             break;
460         default:
461             DHLOGE("Parameter is invalid.");
462             return HDF_ERR_INVALID_PARAM;
463     }
464     DHLOGI("Set audio parameters success.");
465     return HDF_SUCCESS;
466 }
467 
GetExtraParams(AudioExtParamKey key,const std::string & condition,std::string & value)468 int32_t AudioAdapterInterfaceImpl::GetExtraParams(AudioExtParamKey key, const std::string &condition,
469     std::string &value)
470 {
471     DHLOGI("Get audio parameters, key: %{public}d, condition: %{public}s.", key, condition.c_str());
472     int32_t ret = ERR_DH_AUDIO_HDF_FAIL;
473     switch (key) {
474         case AudioExtParamKey::AUDIO_EXT_PARAM_KEY_VOLUME:
475             ret = GetAudioVolume(condition, value);
476             if (ret != DH_SUCCESS) {
477                 DHLOGE("Get audio parameters failed.");
478                 return HDF_FAILURE;
479             }
480             break;
481         default:
482             DHLOGE("Parameter is invalid.");
483             return HDF_ERR_INVALID_PARAM;
484     }
485     DHLOGI("Get audio parameters success.");
486     return HDF_SUCCESS;
487 }
488 
RegExtraParamObserver(const sptr<IAudioCallback> & audioCallback,int8_t cookie)489 int32_t AudioAdapterInterfaceImpl::RegExtraParamObserver(const sptr<IAudioCallback> &audioCallback, int8_t cookie)
490 {
491     DHLOGD("Register audio param observer.");
492     paramCallback_ = audioCallback;
493     (void) cookie;
494     return HDF_SUCCESS;
495 }
496 
GetAdapterDesc()497 AudioAdapterDescriptor AudioAdapterInterfaceImpl::GetAdapterDesc()
498 {
499     adpDescriptor_.ports.clear();
500     std::lock_guard<std::mutex> devLck(devMapMtx_);
501     for (auto pin = mapAudioDevice_.begin(); pin != mapAudioDevice_.end(); pin++) {
502         AudioPort port = {PORT_OUT_IN, pin->first, ""};
503         adpDescriptor_.ports.emplace_back(port);
504     }
505     return adpDescriptor_;
506 }
507 
GetDeviceCapabilitys(const uint32_t devId)508 std::string AudioAdapterInterfaceImpl::GetDeviceCapabilitys(const uint32_t devId)
509 {
510     std::lock_guard<std::mutex> devLck(devMapMtx_);
511     auto dev = mapAudioDevice_.find(devId);
512     if (dev == mapAudioDevice_.end()) {
513         DHLOGE("Device not found.");
514         return "";
515     }
516     return dev->second;
517 }
518 
AdapterLoad()519 int32_t AudioAdapterInterfaceImpl::AdapterLoad()
520 {
521     status_ = AudioAdapterStatus::STATUS_LOAD;
522     return HDF_SUCCESS;
523 }
524 
AdapterUnload()525 int32_t AudioAdapterInterfaceImpl::AdapterUnload()
526 {
527     if (CheckRendersValid() || CheckCapsValid()) {
528         DHLOGE("Adapter is busy, audio render or capture is not null.");
529         return HDF_ERR_DEVICE_BUSY;
530     }
531     status_ = AudioAdapterStatus::STATUS_UNLOAD;
532     return HDF_SUCCESS;
533 }
534 
Notify(const uint32_t devId,const uint32_t streamId,const DAudioEvent & event)535 int32_t AudioAdapterInterfaceImpl::Notify(const uint32_t devId, const uint32_t streamId, const DAudioEvent &event)
536 {
537     switch (static_cast<AudioExtParamEvent>(event.type)) {
538         case HDF_AUDIO_EVENT_VOLUME_CHANGE:
539             DHLOGI("Notify event: VOLUME_CHANGE, event content: %{public}s.", event.content.c_str());
540             return HandleVolumeChangeEvent(event);
541         case HDF_AUDIO_EVENT_FOCUS_CHANGE:
542             DHLOGI("Notify event: FOCUS_CHANGE, event content: %{public}s.", event.content.c_str());
543             return HandleFocusChangeEvent(event);
544         case HDF_AUDIO_EVENT_RENDER_STATE_CHANGE:
545             DHLOGI("Notify event: RENDER_STATE_CHANGE, event content: %{public}s.", event.content.c_str());
546             return HandleRenderStateChangeEvent(event);
547         case HDF_AUDIO_EVENT_OPEN_SPK_RESULT:
548         case HDF_AUDIO_EVENT_CLOSE_SPK_RESULT:
549         case HDF_AUDIO_EVENT_OPEN_MIC_RESULT:
550         case HDF_AUDIO_EVENT_CLOSE_MIC_RESULT:
551         case HDF_AUDIO_EVENT_SPK_DUMP:
552         case HDF_AUDIO_EVENT_MIC_DUMP:
553             return HandleSANotifyEvent(streamId, event);
554         case HDF_AUDIO_EVENT_SPK_CLOSED:
555         case HDF_AUDIO_EVENT_MIC_CLOSED:
556             return HandleDeviceClosed(streamId, event);
557         case HDF_AUDIO_EVENT_FULL:
558         case HDF_AUDIO_EVENT_NEED_DATA:
559             return HandleRenderCallback(streamId, event);
560         default:
561             DHLOGE("Audio event: %{public}d is undefined.", event.type);
562             return ERR_DH_AUDIO_HDF_INVALID_OPERATION;
563     }
564 }
565 
AddAudioDevice(const uint32_t devId,const std::string & caps)566 int32_t AudioAdapterInterfaceImpl::AddAudioDevice(const uint32_t devId, const std::string &caps)
567 {
568     DHLOGI("Add distributed audio device %{public}s.", GetChangeDevIdMap(static_cast<int32_t>(devId)).c_str());
569     std::lock_guard<std::mutex> devLck(devMapMtx_);
570     auto dev = mapAudioDevice_.find(devId);
571     if (dev != mapAudioDevice_.end()) {
572         mapAudioDevice_[devId] = caps;
573         DHLOGI("Device has been add, refresh caps.");
574         return DH_SUCCESS;
575     }
576     mapAudioDevice_.insert(std::make_pair(devId, caps));
577 
578     DHLOGI("Add audio device success.");
579     return DH_SUCCESS;
580 }
581 
RemoveAudioDevice(const uint32_t devId)582 int32_t AudioAdapterInterfaceImpl::RemoveAudioDevice(const uint32_t devId)
583 {
584     DHLOGI("Remove distributed audio device %{public}s.", GetChangeDevIdMap(static_cast<int32_t>(devId)).c_str());
585     {
586         std::lock_guard<std::mutex> devLck(devMapMtx_);
587         if (mapAudioDevice_.find(devId) == mapAudioDevice_.end()) {
588             DHLOGE("Device has not been add, remove device failed.");
589             return ERR_DH_AUDIO_HDF_INVALID_OPERATION;
590         }
591         mapAudioDevice_.erase(devId);
592     }
593     if (devId == spkPinInUse_) {
594         for (uint32_t i = 0; i < MAX_AUDIO_STREAM_NUM; i++) {
595             DestroyRender(i);
596         }
597     }
598     if (devId == micPinInUse_) {
599         for (uint32_t capId = 0; capId < MAX_AUDIO_STREAM_NUM; capId++) {
600             DestroyCapture(capId);
601         }
602     }
603 
604     DHLOGI("Remove audio device success.");
605     return DH_SUCCESS;
606 }
607 
OpenRenderDevice(const AudioDeviceDescriptor & desc,const AudioSampleAttributes & attrs,const sptr<IDAudioCallback> extSpkCallback,const int32_t dhId,const int32_t renderId)608 int32_t AudioAdapterInterfaceImpl::OpenRenderDevice(const AudioDeviceDescriptor &desc,
609     const AudioSampleAttributes &attrs, const sptr<IDAudioCallback> extSpkCallback,
610     const int32_t dhId, const int32_t renderId)
611 {
612     DHLOGI("Open render device, pin: %{public}d.", dhId);
613     if (extSpkCallback == nullptr) {
614         DHLOGE("Callback is null.");
615         return ERR_DH_AUDIO_HDF_NULLPTR;
616     }
617     std::lock_guard<std::mutex> devLck(renderOptMtx_);
618     renderParam_.format = attrs.format;
619     renderParam_.channelCount = attrs.channelCount;
620     renderParam_.sampleRate = attrs.sampleRate;
621     renderParam_.streamUsage = attrs.type;
622     if (attrs.type == AUDIO_MMAP_NOIRQ) {
623         renderParam_.period = AUDIO_MMAP_NOIRQ_INTERVAL;
624     } else if (attrs.type == AUDIO_MMAP_VOIP) {
625         renderParam_.period = AUDIO_MMAP_VOIP_INTERVAL;
626     } else {
627         renderParam_.period = AUDIO_NORMAL_INTERVAL;
628     }
629     renderParam_.frameSize = CalculateFrameSize(attrs.sampleRate, attrs.channelCount, attrs.format,
630         renderParam_.period, renderFlags_ == Audioext::V2_1::MMAP_MODE);
631     renderParam_.renderFlags = renderFlags_;
632 
633     int32_t ret = extSpkCallback->SetParameters(renderId, renderParam_);
634     if (ret != HDF_SUCCESS) {
635         DHLOGE("Set render parameters failed.");
636         return ERR_DH_AUDIO_HDF_SET_PARAM_FAIL;
637     }
638     ret = extSpkCallback->CreateStream(renderId);
639     if (ret != HDF_SUCCESS) {
640         DHLOGE("Open render device failed.");
641         return ERR_DH_AUDIO_HDF_OPEN_DEVICE_FAIL;
642     }
643 
644     ret = WaitForSANotify(renderId, EVENT_OPEN_SPK);
645     if (ret != DH_SUCCESS) {
646         DHLOGE("Wait SA notify failed. ret: %{public}d", ret);
647         extSpkCallback->DestroyStream(renderId);
648         return ret;
649     }
650     spkPinInUse_ = static_cast<uint32_t>(dhId);
651     DHLOGI("Open render device success.");
652     return DH_SUCCESS;
653 }
654 
CloseRenderDevice(const AudioDeviceDescriptor & desc,sptr<IDAudioCallback> extSpkCallback,const int32_t dhId,const int32_t renderId)655 int32_t AudioAdapterInterfaceImpl::CloseRenderDevice(const AudioDeviceDescriptor &desc,
656     sptr<IDAudioCallback> extSpkCallback, const int32_t dhId, const int32_t renderId)
657 {
658     DHLOGI("Close render device, pin: %{public}d.", dhId);
659     std::lock_guard<std::mutex> devLck(renderOptMtx_);
660     if (spkPinInUse_ == 0) {
661         DHLOGI("No need close render device.");
662         return DH_SUCCESS;
663     }
664     renderParam_ = {};
665     if (extSpkCallback == nullptr) {
666         DHLOGE("Callback is null.");
667         return ERR_DH_AUDIO_HDF_NULLPTR;
668     }
669     DHLOGI("DestroyStream start");
670     int32_t ret = extSpkCallback->DestroyStream(renderId);
671     if (ret != HDF_SUCCESS) {
672         DHLOGE("Close audio device failed.");
673         return ERR_DH_AUDIO_HDF_CLOSE_DEVICE_FAIL;
674     }
675     DHLOGI("DestroyStream  %{public}u done", renderId);
676     ret = WaitForSANotify(renderId, EVENT_CLOSE_SPK);
677     if (ret != DH_SUCCESS) {
678         DHLOGE("Wait SA notify failed. ret: %{public}d.", ret);
679         return ret;
680     }
681     spkPinInUse_ = 0;
682     DHLOGI("Close render device success.");
683     return DH_SUCCESS;
684 }
685 
OpenCaptureDevice(const AudioDeviceDescriptor & desc,const AudioSampleAttributes & attrs,const sptr<IDAudioCallback> extMicCallback,const int32_t dhId,const int32_t captureId)686 int32_t AudioAdapterInterfaceImpl::OpenCaptureDevice(const AudioDeviceDescriptor &desc,
687     const AudioSampleAttributes &attrs, const sptr<IDAudioCallback> extMicCallback,
688     const int32_t dhId, const int32_t captureId)
689 {
690     DHLOGI("Open capture device, pin: %{public}d.", dhId);
691     if (isMicOpened_) {
692         DHLOGI("Capture already opened.");
693         return DH_SUCCESS;
694     }
695     std::lock_guard<std::mutex> devLck(captureOptMtx_);
696     micPinInUse_ = dhId;
697     captureParam_.format = attrs.format;
698     captureParam_.channelCount = attrs.channelCount;
699     captureParam_.sampleRate = attrs.sampleRate;
700     captureParam_.streamUsage = attrs.type;
701     if (attrs.type == AUDIO_MMAP_NOIRQ) {
702         captureParam_.period = AUDIO_MMAP_NOIRQ_INTERVAL;
703     } else if (attrs.type == AUDIO_MMAP_VOIP) {
704         captureParam_.period = AUDIO_MMAP_VOIP_INTERVAL;
705     } else {
706         captureParam_.period = AUDIO_NORMAL_INTERVAL;
707     }
708     captureParam_.frameSize = CalculateFrameSize(attrs.sampleRate, attrs.channelCount,
709         attrs.format, captureParam_.period, capturerFlags_ == Audioext::V2_1::MMAP_MODE);
710     captureParam_.capturerFlags = capturerFlags_;
711 
712     if (extMicCallback == nullptr) {
713         DHLOGE("Callback is null.");
714         return ERR_DH_AUDIO_HDF_NULLPTR;
715     }
716     int32_t ret = extMicCallback->SetParameters(captureId, captureParam_);
717     if (ret != HDF_SUCCESS) {
718         DHLOGE("Set audio parameters failed.");
719         return ERR_DH_AUDIO_HDF_SET_PARAM_FAIL;
720     }
721     ret = extMicCallback->CreateStream(captureId);
722     if (ret != HDF_SUCCESS) {
723         DHLOGE("Open audio device failed.");
724         return ERR_DH_AUDIO_HDF_OPEN_DEVICE_FAIL;
725     }
726 
727     ret = WaitForSANotify(captureId, EVENT_OPEN_MIC);
728     if (ret != DH_SUCCESS) {
729         DHLOGE("Wait SA notify failed. ret: %{public}d.", ret);
730         return ret;
731     }
732     DHLOGI("Open capture device success.");
733     return DH_SUCCESS;
734 }
735 
CloseCaptureDevice(const AudioDeviceDescriptor & desc,const sptr<IDAudioCallback> extMicCallback,const int32_t dhId,const int32_t captureId)736 int32_t AudioAdapterInterfaceImpl::CloseCaptureDevice(const AudioDeviceDescriptor &desc,
737     const sptr<IDAudioCallback> extMicCallback, const int32_t dhId, const int32_t captureId)
738 {
739     DHLOGI("Close capture device, pin: %{public}d.", dhId);
740     std::lock_guard<std::mutex> devLck(captureOptMtx_);
741     if (micPinInUse_ == 0) {
742         DHLOGI("No need close capture device.");
743         return DH_SUCCESS;
744     }
745     captureParam_ = {};
746     if (extMicCallback == nullptr) {
747         DHLOGE("Callback is null.");
748         return ERR_DH_AUDIO_HDF_NULLPTR;
749     }
750     int32_t ret = extMicCallback->DestroyStream(captureId);
751     if (ret != HDF_SUCCESS) {
752         DHLOGE("Close audio device failed.");
753         return ERR_DH_AUDIO_HDF_CLOSE_DEVICE_FAIL;
754     }
755 
756     ret = WaitForSANotify(captureId, EVENT_CLOSE_MIC);
757     if (ret != DH_SUCCESS) {
758         DHLOGE("Wait SA notify failed. ret:%{public}d.", ret);
759         return ret;
760     }
761     micPinInUse_ = 0;
762     DHLOGI("Close capture device success.");
763     return DH_SUCCESS;
764 }
765 
GetVolumeGroup(const uint32_t devId)766 uint32_t AudioAdapterInterfaceImpl::GetVolumeGroup(const uint32_t devId)
767 {
768     uint32_t volGroup = VOLUME_GROUP_ID_DEFAULT;
769     std::lock_guard<std::mutex> devLck(devMapMtx_);
770     auto caps = mapAudioDevice_.find(devId);
771     if (caps == mapAudioDevice_.end()) {
772         DHLOGE("Can not find caps of dev:%{public}s.", GetChangeDevIdMap(static_cast<int32_t>(devId)).c_str());
773         return volGroup;
774     }
775 
776     int32_t ret = GetAudioParamUInt(caps->second, VOLUME_GROUP_ID, volGroup);
777     if (ret != DH_SUCCESS) {
778         DHLOGE("Get volume group param failed, use default value, ret = %{public}d.", ret);
779     }
780     return volGroup;
781 }
782 
GetInterruptGroup(const uint32_t devId)783 uint32_t AudioAdapterInterfaceImpl::GetInterruptGroup(const uint32_t devId)
784 {
785     uint32_t iptGroup = INTERRUPT_GROUP_ID_DEFAULT;
786     std::lock_guard<std::mutex> devLck(devMapMtx_);
787     auto caps = mapAudioDevice_.find(devId);
788     if (caps == mapAudioDevice_.end()) {
789         DHLOGE("Can not find caps of devType: %{public}s.", GetChangeDevIdMap(static_cast<int32_t>(devId)).c_str());
790         return iptGroup;
791     }
792 
793     int32_t ret = GetAudioParamUInt(caps->second, INTERRUPT_GROUP_ID, iptGroup);
794     if (ret != DH_SUCCESS) {
795         DHLOGE("Get interrupt group param failed, use default value, ret = %{public}d.", ret);
796     }
797     return iptGroup;
798 }
799 
SetAudioVolume(const std::string & condition,const std::string & param)800 int32_t AudioAdapterInterfaceImpl::SetAudioVolume(const std::string& condition, const std::string &param)
801 {
802     std::string content = condition;
803     int32_t type = getEventTypeFromCondition(content);
804     EXT_PARAM_EVENT eventType;
805 
806     if (type == VolumeEventType::EVENT_IS_STREAM_MUTE) {
807         if (param == IS_MUTE_STATUS) {
808             streamMuteStatus_ = 1;
809         } else if (param == NOT_MUTE_STATUS) {
810             streamMuteStatus_ = 0;
811         } else {
812             DHLOGE("Mute param is error.");
813             return ERR_DH_AUDIO_HDF_FAIL;
814         }
815         eventType = HDF_AUDIO_EVNET_MUTE_SET;
816         SetAudioParamStr(content, STREAM_MUTE_STATUS, param);
817     } else {
818         eventType = HDF_AUDIO_EVENT_VOLUME_SET;
819         streamMuteStatus_ = 0;
820         SetAudioParamStr(content, VOLUME_LEVEL, param);
821     }
822     DAudioEvent event = { eventType, content };
823 
824     {
825         std::lock_guard<std::mutex> devLck(renderDevMtx_);
826         for (uint32_t id = 0; id < MAX_AUDIO_STREAM_NUM; id++) {
827             const auto &item = renderDevs_[id];
828             std::lock_guard<std::mutex> callbackLck(extCallbackMtx_);
829             sptr<IDAudioCallback> extSpkCallback(extCallbackMap_[item.first]);
830             SetAudioParamStr(event.content, "dhId", std::to_string(item.first));
831             auto render = item.second;
832             if (render == nullptr || extSpkCallback == nullptr) {
833                 continue;
834             }
835             if (extSpkCallback->NotifyEvent(id, event) != HDF_SUCCESS) {
836                 DHLOGE("NotifyEvent failed.");
837                 return ERR_DH_AUDIO_HDF_FAIL;
838             }
839         }
840     }
841     return DH_SUCCESS;
842 }
843 
GetAudioVolume(const std::string & condition,std::string & param)844 int32_t AudioAdapterInterfaceImpl::GetAudioVolume(const std::string& condition, std::string &param)
845 {
846     sptr<AudioRenderInterfaceImplBase> audioRender(nullptr);
847     {
848         std::lock_guard<std::mutex> devLck(renderDevMtx_);
849         audioRender = renderDevs_[0].second; // from audioframwork
850     }
851     if (audioRender == nullptr) {
852         DHLOGE("Render has not been created.");
853         return ERR_DH_AUDIO_HDF_NULLPTR;
854     }
855     int32_t type = getEventTypeFromCondition(condition);
856     uint32_t vol;
857     switch (type) {
858         case VolumeEventType::EVENT_GET_VOLUME:
859             vol = audioRender->GetVolumeInner();
860             break;
861         case VolumeEventType::EVENT_GET_MAX_VOLUME:
862             vol = audioRender->GetMaxVolumeInner();
863             break;
864         case VolumeEventType::EVENT_GET_MIN_VOLUME:
865             vol = audioRender->GetMinVolumeInner();
866             break;
867         case VolumeEventType::EVENT_IS_STREAM_MUTE:
868             vol = streamMuteStatus_;
869             break;
870         default:
871             vol = 0;
872             DHLOGE("Get volume failed.");
873     }
874     DHLOGI("Get volume : %{public}" PRIu32" type : %{public}d", vol, type);
875     param = std::to_string(vol);
876     return DH_SUCCESS;
877 }
878 
getEventTypeFromCondition(const std::string & condition)879 int32_t AudioAdapterInterfaceImpl::getEventTypeFromCondition(const std::string &condition)
880 {
881     std::string::size_type position = condition.find_first_of(";");
882     int32_t len = static_cast<int32_t>(position) - TYPE_CONDITION;
883     if (len < 0 || len > MAX_EVENT_DIGITS || position == std::string::npos) {
884         DHLOGE("Position is illegal or not find split word");
885         return ERR_DH_AUDIO_HDF_FAIL;
886     }
887     std::string val = condition.substr(TYPE_CONDITION, len);
888     if (!CheckIsNum(val)) {
889         DHLOGE("String is not number. str:%{public}s.", val.c_str());
890         return ERR_DH_AUDIO_HDF_FAIL;
891     }
892     int32_t type = std::atoi(val.c_str());
893     return static_cast<VolumeEventType>(type);
894 }
895 
ParseDhIdFromJson(const std::string & args)896 int32_t AudioAdapterInterfaceImpl::ParseDhIdFromJson(const std::string &args)
897 {
898     DHLOGI("Parse distributed hardward Id from args : %{public}s", args.c_str());
899     cJSON *jParam = cJSON_Parse(args.c_str());
900     if (jParam == nullptr) {
901         DHLOGE("Failed to parse JSON: %{public}s", cJSON_GetErrorPtr());
902         return -1;
903     }
904     if (!CJsonParamCheck(jParam, { KEY_DH_ID })) {
905         DHLOGE("Not found the keys of dhId.");
906         cJSON_Delete(jParam);
907         return -1;
908     }
909     cJSON *dhIdItem = cJSON_GetObjectItem(jParam, KEY_DH_ID);
910     if (dhIdItem == NULL || !cJSON_IsString(dhIdItem)) {
911         DHLOGE("Not found the keys of dhId.");
912         cJSON_Delete(jParam);
913         return ERR_DH_AUDIO_HDF_FAIL;
914     }
915     int32_t dhId = ConvertString2Int(std::string(dhIdItem->valuestring));
916     cJSON_Delete(jParam);
917     DHLOGI("Parsed dhId is: %{public}d.", dhId);
918     return dhId;
919 }
920 
ConvertString2Int(std::string val)921 int32_t AudioAdapterInterfaceImpl::ConvertString2Int(std::string val)
922 {
923     if (!CheckIsNum(val)) {
924         DHLOGE("String is not number. str:%{public}s.", val.c_str());
925         return -1;
926     }
927     return std::atoi(val.c_str());
928 }
929 
GetRenderImpl(const std::string & content)930 sptr<AudioRenderInterfaceImplBase> AudioAdapterInterfaceImpl::GetRenderImpl(const std::string &content)
931 {
932     int32_t dhId = ParseDhIdFromJson(content);
933     if (dhId < 0) {
934         DHLOGE("Failed to parse dhardware id.");
935         return nullptr;
936     }
937     {
938         std::lock_guard<std::mutex> devLck(renderDevMtx_);
939         auto renderDev = find_if(renderDevs_.begin(), renderDevs_.end(),
940             [dhId](std::pair<int32_t, sptr<AudioRenderInterfaceImplBase>> item) { return item.first == dhId; });
941         if (renderDev != renderDevs_.end()) {
942             return renderDev->second;
943         }
944     }
945     DHLOGE("Render has not been created.");
946     return nullptr;
947 }
948 
HandleVolumeChangeEvent(const DAudioEvent & event)949 int32_t AudioAdapterInterfaceImpl::HandleVolumeChangeEvent(const DAudioEvent &event)
950 {
951     DHLOGI("Vol change (%{public}s).", event.content.c_str());
952     sptr<AudioRenderInterfaceImplBase> audioRender = GetRenderImpl(event.content);
953     if (audioRender == nullptr) {
954         DHLOGE("Render is null.");
955         return ERR_DH_AUDIO_HDF_NULLPTR;
956     }
957     int32_t vol = AUDIO_DEFAULT_MIN_VOLUME_LEVEL;
958     int32_t ret = GetVolFromEvent(event.content, VOLUME_LEVEL, vol);
959     if (ret != DH_SUCCESS) {
960         DHLOGE("Get volume value failed.");
961         return ERR_DH_AUDIO_HDF_FAIL;
962     }
963 
964     if (event.content.find(FIRST_VOLUME_CHANAGE) != event.content.npos) {
965         int32_t maxVol = AUDIO_DEFAULT_MAX_VOLUME_LEVEL;
966         ret = GetVolFromEvent(event.content, MAX_VOLUME_LEVEL, maxVol);
967         if (ret != DH_SUCCESS) {
968             DHLOGE("Get max volume value failed, use defult max volume.");
969         }
970         int32_t minVol = AUDIO_DEFAULT_MIN_VOLUME_LEVEL;
971         ret = GetVolFromEvent(event.content, MIN_VOLUME_LEVEL, minVol);
972         if (ret != DH_SUCCESS) {
973             DHLOGE("Get min volume value failed, use defult min volume.");
974         }
975         audioRender->SetVolumeInner(vol);
976         audioRender->SetVolumeRangeInner(maxVol, minVol);
977         return DH_SUCCESS;
978     }
979 
980     audioRender->SetVolumeInner(vol);
981     if (paramCallback_ == nullptr) {
982         DHLOGE("Audio param observer is null.");
983         return ERR_DH_AUDIO_HDF_NULLPTR;
984     }
985     std::string volumeChange = GetVolumeChangeString(event.content);
986     int8_t reserved = 0;
987     int8_t cookie = 0;
988     ret = paramCallback_->ParamCallback(AUDIO_EXT_PARAM_KEY_VOLUME, volumeChange, std::to_string(vol),
989         reserved, cookie);
990     if (ret != DH_SUCCESS) {
991         DHLOGE("Notify vol failed.");
992         return ERR_DH_AUDIO_HDF_FAIL;
993     }
994     return DH_SUCCESS;
995 }
996 
GetVolumeChangeString(const std::string & args)997 std::string AudioAdapterInterfaceImpl::GetVolumeChangeString(const std::string &args)
998 {
999     DHLOGI("Vol change (%{public}s).", args.c_str());
1000     std::stringstream ss;
1001     ss << VOLUME_CHANAGE << ";"
1002         << AUDIO_STREAM_TYPE << "=" << ParseStringFromArgs(args, AUDIO_STREAM_TYPE) << ";"
1003         << VOLUME_LEVEL << "=" << ParseStringFromArgs(args, VOLUME_LEVEL.c_str()) << ";"
1004         << IS_UPDATEUI << "=" << ParseStringFromArgs(args, IS_UPDATEUI) << ";"
1005         << VOLUME_GROUP_ID << "=" << ParseStringFromArgs(args, VOLUME_GROUP_ID.c_str()) << ";"
1006         << KEY_DH_ID << "=" << ParseStringFromArgs(args, KEY_DH_ID) << ";";
1007     std::string res = ss.str();
1008     DHLOGI("get ss : %{public}s", res.c_str());
1009     return res;
1010 }
1011 
GetVolFromEvent(const std::string & content,const std::string & key,int32_t & vol)1012 int32_t AudioAdapterInterfaceImpl::GetVolFromEvent(const std::string &content, const std::string &key, int32_t &vol)
1013 {
1014     cJSON *jParam = cJSON_Parse(content.c_str());
1015     if (jParam == nullptr) {
1016         DHLOGE("Failed to parse JSON: %{public}s", cJSON_GetErrorPtr());
1017         cJSON_Delete(jParam);
1018         return ERR_DH_AUDIO_HDF_FAIL;
1019     }
1020     cJSON *dhIdItem = cJSON_GetObjectItem(jParam, key.c_str());
1021     if (dhIdItem == NULL || !cJSON_IsString(dhIdItem)) {
1022         DHLOGE("Not found the keys of dhId.");
1023         cJSON_Delete(jParam);
1024         return ERR_DH_AUDIO_HDF_FAIL;
1025     }
1026     std::string val(dhIdItem->valuestring);
1027     if (!CheckIsNum(val)) {
1028         DHLOGE("String is not number. str:%{public}s.", val.c_str());
1029         cJSON_Delete(jParam);
1030         return ERR_DH_AUDIO_HDF_FAIL;
1031     }
1032     vol = std::atoi(val.c_str());
1033     cJSON_Delete(jParam);
1034     return DH_SUCCESS;
1035 }
1036 
HandleFocusChangeEvent(const DAudioEvent & event)1037 int32_t AudioAdapterInterfaceImpl::HandleFocusChangeEvent(const DAudioEvent &event)
1038 {
1039     DHLOGI("Focus change (%{public}s).", event.content.c_str());
1040     if (paramCallback_ == nullptr) {
1041         DHLOGE("Audio param observer is null.");
1042         return ERR_DH_AUDIO_HDF_NULLPTR;
1043     }
1044     std::stringstream ss;
1045     ss << INTERRUPT_EVENT << ";"
1046         << VOLUME_EVENT_TYPE << "=" << ParseStringFromArgs(event.content, VOLUME_EVENT_TYPE.c_str()) << ";"
1047         << FORCE_TYPE << "=" << ParseStringFromArgs(event.content, FORCE_TYPE) << ";"
1048         << HINT_TYPE << "=" << ParseStringFromArgs(event.content, HINT_TYPE) << ";"
1049         << KEY_DH_ID << "=" << ParseStringFromArgs(event.content, KEY_DH_ID) << ";"
1050         << AUDIOCATEGORY << "=" << ParseStringFromArgs(event.content, AUDIOCATEGORY) << ";";
1051     DHLOGI("get ss : %{public}s", ss.str().c_str());
1052     int8_t reserved = 0;
1053     int8_t cookie = 0;
1054     int32_t ret = paramCallback_->ParamCallback(AUDIO_EXT_PARAM_KEY_FOCUS, ss.str(), "", reserved, cookie);
1055     if (ret != DH_SUCCESS) {
1056         DHLOGE("Notify Focus failed.");
1057         return ERR_DH_AUDIO_HDF_FAIL;
1058     }
1059     return DH_SUCCESS;
1060 }
1061 
HandleRenderStateChangeEvent(const DAudioEvent & event)1062 int32_t AudioAdapterInterfaceImpl::HandleRenderStateChangeEvent(const DAudioEvent &event)
1063 {
1064     DHLOGI("Render state change (%{public}s).", event.content.c_str());
1065     if (paramCallback_ == nullptr) {
1066         DHLOGE("Audio param observer is null.");
1067         return ERR_DH_AUDIO_HDF_NULLPTR;
1068     }
1069     std::stringstream ss;
1070     ss << RENDER_STATE_CHANGE_EVENT << ";"
1071         << KEY_STATE << "=" << ParseStringFromArgs(event.content, KEY_STATE) << ";"
1072         << KEY_DH_ID << "=" << ParseStringFromArgs(event.content, KEY_DH_ID) << ";";
1073     DHLOGI("get ss : %{public}s", ss.str().c_str());
1074     int8_t reserved = 0;
1075     int8_t cookie = 0;
1076     int32_t ret = paramCallback_->ParamCallback(AUDIO_EXT_PARAM_KEY_STATUS, ss.str(), "", reserved, cookie);
1077     if (ret != DH_SUCCESS) {
1078         DHLOGE("Notify render state failed.");
1079         return ERR_DH_AUDIO_HDF_FAIL;
1080     }
1081     return DH_SUCCESS;
1082 }
1083 
ConvertMsg2Code(const std::string & msg)1084 int32_t AudioAdapterInterfaceImpl::ConvertMsg2Code(const std::string &msg)
1085 {
1086     if (msg == HDF_EVENT_RESULT_SUCCESS) {
1087         return DH_SUCCESS;
1088     } else if (msg == HDF_EVENT_INIT_ENGINE_FAILED) {
1089         return ERR_DH_AUDIO_HDF_INIT_ENGINE_FAILED;
1090     } else if (msg == HDF_EVENT_NOTIFY_SINK_FAILED) {
1091         return ERR_DH_AUDIO_HDF_NOTIFY_SINK_FAILED;
1092     } else if (msg == HDF_EVENT_TRANS_SETUP_FAILED) {
1093         return ERR_DH_AUDIO_HDF_TRANS_SETUP_FAILED;
1094     } else if (msg == HDF_EVENT_TRANS_START_FAILED) {
1095         return ERR_DH_AUDIO_HDF_TRANS_START_FAILED;
1096     } else {
1097         return ERR_DH_AUDIO_HDF_FAIL;
1098     }
1099 }
1100 
HandleSANotifyEvent(const uint32_t streamId,const DAudioEvent & event)1101 int32_t AudioAdapterInterfaceImpl::HandleSANotifyEvent(const uint32_t streamId, const DAudioEvent &event)
1102 {
1103     DHLOGD("Notify event type %{public}d, event content: %{public}s.", event.type, event.content.c_str());
1104     switch (event.type) {
1105         case HDF_AUDIO_EVENT_OPEN_SPK_RESULT:
1106             if (event.content == HDF_EVENT_RESULT_SUCCESS) {
1107                 SetSpkStatus(streamId, true);
1108             }
1109             errCode_ = ConvertMsg2Code(event.content);
1110             spkNotifyFlag_ = true;
1111             spkWaitCond_.notify_all();
1112             break;
1113         case HDF_AUDIO_EVENT_CLOSE_SPK_RESULT:
1114             if (event.content == HDF_EVENT_RESULT_SUCCESS) {
1115                 SetSpkStatus(streamId, false);
1116             }
1117             errCode_ = ConvertMsg2Code(event.content);
1118             spkNotifyFlag_ = true;
1119             spkWaitCond_.notify_all();
1120             break;
1121         case HDF_AUDIO_EVENT_OPEN_MIC_RESULT:
1122             if (event.content == HDF_EVENT_RESULT_SUCCESS) {
1123                 isMicOpened_ = true;
1124             }
1125             errCode_ = ConvertMsg2Code(event.content);
1126             micNotifyFlag_ = true;
1127             micWaitCond_.notify_all();
1128             break;
1129         case HDF_AUDIO_EVENT_CLOSE_MIC_RESULT:
1130             if (event.content == HDF_EVENT_RESULT_SUCCESS) {
1131                 isMicOpened_ = false;
1132             }
1133             errCode_ = ConvertMsg2Code(event.content);
1134             micNotifyFlag_ = true;
1135             micWaitCond_.notify_all();
1136             break;
1137         case HDF_AUDIO_EVENT_SPK_DUMP:
1138             SetDumpFlag(true);
1139             break;
1140         case HDF_AUDIO_EVENT_MIC_DUMP:
1141             SetDumpFlag(false);
1142             break;
1143         default:
1144             DHLOGE("Notify not support event type %{public}d, event content: %{public}s.",
1145                 event.type, event.content.c_str());
1146             return ERR_DH_AUDIO_HDF_FAIL;
1147     }
1148     return DH_SUCCESS;
1149 }
1150 
WaitForSANotify(const uint32_t streamId,const AudioDeviceEvent & event)1151 int32_t AudioAdapterInterfaceImpl::WaitForSANotify(const uint32_t streamId, const AudioDeviceEvent &event)
1152 {
1153     if (event == EVENT_OPEN_SPK || event == EVENT_CLOSE_SPK) {
1154         spkNotifyFlag_ = false;
1155         std::unique_lock<std::mutex> lck(spkWaitMutex_);
1156         DHLOGI("spkWaitCond wait start");
1157         auto status = spkWaitCond_.wait_for(lck, std::chrono::milliseconds(WAIT_MILLISECONDS),
1158             [this, streamId, event]() {
1159                 auto isSpkOpened = GetSpkStatus(streamId);
1160                 return spkNotifyFlag_ ||
1161                     (event == EVENT_OPEN_SPK && isSpkOpened) || (event == EVENT_CLOSE_SPK && !isSpkOpened);
1162         });
1163         if (!status) {
1164             DHLOGE("Wait spk event: %{public}d timeout(%{public}d)ms.", event, WAIT_MILLISECONDS);
1165             return ERR_DH_AUDIO_HDF_WAIT_TIMEOUT;
1166         }
1167         if (event == EVENT_OPEN_SPK && !GetSpkStatus(streamId)) {
1168             DHLOGE("Wait open render device failed.");
1169             return errCode_;
1170         } else if (event == EVENT_CLOSE_SPK && GetSpkStatus(streamId)) {
1171             DHLOGE("Wait close render device failed.");
1172             return errCode_;
1173         }
1174         DHLOGI("spkWaitCond wait end");
1175         return DH_SUCCESS;
1176     }
1177 
1178     if (event == EVENT_OPEN_MIC || event == EVENT_CLOSE_MIC) {
1179         micNotifyFlag_ = false;
1180         std::unique_lock<std::mutex> lck(micWaitMutex_);
1181         DHLOGI("micWaitCond wait start");
1182         auto status = micWaitCond_.wait_for(lck, std::chrono::milliseconds(WAIT_MILLISECONDS), [this, event]() {
1183             return micNotifyFlag_ ||
1184                 (event == EVENT_OPEN_MIC && isMicOpened_) || (event == EVENT_CLOSE_MIC && !isMicOpened_);
1185         });
1186         if (!status) {
1187             DHLOGE("Wait mic event: %{public}d timeout(%{public}d)ms.", event, WAIT_MILLISECONDS);
1188             return ERR_DH_AUDIO_HDF_WAIT_TIMEOUT;
1189         }
1190         if (event == EVENT_OPEN_MIC && !isMicOpened_) {
1191             DHLOGE("Wait open capture device failed.");
1192             return errCode_;
1193         } else if (event == EVENT_CLOSE_MIC && isMicOpened_) {
1194             DHLOGE("Wait close capture device failed.");
1195             return errCode_;
1196         }
1197         DHLOGI("micWaitCond wait end");
1198         return DH_SUCCESS;
1199     }
1200     return DH_SUCCESS;
1201 }
1202 
HandleDeviceClosed(const uint32_t streamId,const DAudioEvent & event)1203 int32_t AudioAdapterInterfaceImpl::HandleDeviceClosed(const uint32_t streamId, const DAudioEvent &event)
1204 {
1205     DHLOGI("Handle device closed, event type: %{public}d.", event.type);
1206     if (paramCallback_ != nullptr) {
1207         std::stringstream ss;
1208         ss << "ERR_EVENT;DEVICE_TYPE=" <<
1209             (event.type == HDF_AUDIO_EVENT_SPK_CLOSED ? AUDIO_DEVICE_TYPE_SPEAKER : AUDIO_DEVICE_TYPE_MIC) << ";"
1210             << KEY_DH_ID << "=" << ParseStringFromArgs(event.content, KEY_DH_ID) << ";";
1211         DHLOGI("get ss : %{public}s", ss.str().c_str());
1212         int8_t reserved = 0;
1213         int8_t cookie = 0;
1214         int32_t ret = paramCallback_->ParamCallback(AUDIO_EXT_PARAM_KEY_STATUS, ss.str(),
1215             std::to_string(EVENT_DEV_CLOSED), reserved, cookie);
1216         if (ret != DH_SUCCESS) {
1217             DHLOGE("Notify fwk failed.");
1218         }
1219     }
1220 
1221     if (GetSpkStatus(streamId) && event.type == HDF_AUDIO_EVENT_SPK_CLOSED) {
1222         DHLOGE("Render device status error, close render.");
1223         bool destroyStatus = true;
1224         for (uint32_t i = 0; i < MAX_AUDIO_STREAM_NUM; i++) {
1225             if (DestroyRender(i) != DH_SUCCESS) {
1226                 destroyStatus = false;
1227             }
1228         }
1229         return destroyStatus ? DH_SUCCESS : ERR_DH_AUDIO_HDF_FAIL;
1230     } else if (isMicOpened_ && event.type == HDF_AUDIO_EVENT_MIC_CLOSED) {
1231         DHLOGE("Capture device status error, close capture.");
1232         bool capCloseStatus = true;
1233         for (uint32_t i = 0; i < MAX_AUDIO_STREAM_NUM; i++) {
1234             if (DestroyCapture(i) != DH_SUCCESS) {
1235                 capCloseStatus = false;
1236             }
1237         }
1238         return capCloseStatus ? DH_SUCCESS : ERR_DH_AUDIO_HDF_FAIL;
1239     }
1240     DHLOGI("Handle device closed success.");
1241     return DH_SUCCESS;
1242 }
1243 
HandleRenderCallback(const uint32_t renderId,const DAudioEvent & event)1244 int32_t AudioAdapterInterfaceImpl::HandleRenderCallback(const uint32_t renderId, const DAudioEvent &event)
1245 {
1246     DHLOGI("Handle render callback, event type: %{public}d.", event.type);
1247     AudioCallbackType type = AUDIO_ERROR_OCCUR;
1248     if (static_cast<AudioExtParamEvent>(event.type) == HDF_AUDIO_EVENT_FULL) {
1249         type = AUDIO_RENDER_FULL;
1250     } else {
1251         type = AUDIO_NONBLOCK_WRITE_COMPLETED;
1252     }
1253     int8_t reserved = 0;
1254     int8_t cookie = 0;
1255 
1256     auto renderCallback = GetRenderCallback(renderId);
1257     if (renderCallback == nullptr) {
1258         DHLOGE("renderCallback is null.");
1259         return ERR_DH_AUDIO_HDF_NULLPTR;
1260     }
1261     int32_t ret = renderCallback->RenderCallback(type, reserved, cookie);
1262     if (ret != DH_SUCCESS) {
1263         DHLOGE("HandleRenderCallback failed.");
1264         return ERR_DH_AUDIO_HDF_FAIL;
1265     }
1266     DHLOGI("HandleRenderCallback success.");
1267     return DH_SUCCESS;
1268 }
1269 
GetRenderCallback(const uint32_t renderId)1270 sptr<IAudioCallback> AudioAdapterInterfaceImpl::GetRenderCallback(const uint32_t renderId)
1271 {
1272     DHLOGI("GetRenderCallback enter, render Id:%{public}d", renderId);
1273     auto iter = renderCallbacks_.find(renderId);
1274     if (iter == renderCallbacks_.end()) {
1275         DHLOGE("Not find renderId:%{public}d", renderId);
1276         return nullptr;
1277     }
1278     if (iter->second == nullptr) {
1279         DHLOGE("Render is null.");
1280         return nullptr;
1281     }
1282     return iter->second->GetAudioCallback();
1283 }
1284 
DeleteRenderCallback(const uint32_t renderId)1285 void AudioAdapterInterfaceImpl::DeleteRenderCallback(const uint32_t renderId)
1286 {
1287     DHLOGI("DeleteRenderCallback enter, render Id:%{public}d", renderId);
1288     auto iter = renderCallbacks_.find(renderId);
1289     if (iter == renderCallbacks_.end()) {
1290         DHLOGE("Not find renderId:%{public}d", renderId);
1291         return;
1292     }
1293     renderCallbacks_.erase(iter);
1294 }
1295 
IsPortsNoReg()1296 bool AudioAdapterInterfaceImpl::IsPortsNoReg()
1297 {
1298     std::lock_guard<std::mutex> devLck(devMapMtx_);
1299     return mapAudioDevice_.empty();
1300 }
1301 
IsIdValid(const uint32_t id)1302 inline bool AudioAdapterInterfaceImpl::IsIdValid(const uint32_t id)
1303 {
1304     if (id >= MAX_AUDIO_STREAM_NUM) {
1305         DHLOGE("Current id:%{public}u is not supported.", id);
1306         return false;
1307     }
1308     return true;
1309 }
1310 
CheckRendersValid()1311 bool AudioAdapterInterfaceImpl::CheckRendersValid()
1312 {
1313     {
1314         std::lock_guard<std::mutex> devLck(renderDevMtx_);
1315         for (uint32_t i = 0; i < MAX_AUDIO_STREAM_NUM; i++) {
1316             if (renderDevs_[i].second != nullptr) {
1317                 DHLOGI("Containing active render.");
1318                 return true;
1319             }
1320         }
1321     }
1322     return false;
1323 }
1324 
CheckCapsValid()1325 bool AudioAdapterInterfaceImpl::CheckCapsValid()
1326 {
1327     {
1328         std::lock_guard<std::mutex> devLck(capDevMtx_);
1329         for (uint32_t i = 0; i < MAX_AUDIO_STREAM_NUM; i++) {
1330             if (captureDevs_[i].second != nullptr) {
1331                 DHLOGI("Containing active capture.");
1332                 return true;
1333             }
1334         }
1335     }
1336     return false;
1337 }
1338 
SetDumpFlag(bool isRender)1339 void AudioAdapterInterfaceImpl::SetDumpFlag(bool isRender)
1340 {
1341     if (isRender) {
1342         std::lock_guard<std::mutex> renderLck(renderDevMtx_);
1343         for (auto item : renderDevs_) {
1344             auto render = item.second;
1345             if (render == nullptr) {
1346                 continue;
1347             }
1348             render->SetDumpFlagInner();
1349         }
1350     } else {
1351         std::lock_guard<std::mutex> capLck(capDevMtx_);
1352         for (auto item : captureDevs_) {
1353             auto capture = item.second;
1354             if (capture == nullptr) {
1355                 continue;
1356             }
1357             capture->SetDumpFlagInner();
1358         }
1359     }
1360 }
1361 
SetSpkStatus(const uint32_t streamId,bool status)1362 void AudioAdapterInterfaceImpl::SetSpkStatus(const uint32_t streamId, bool status)
1363 {
1364     if (streamId >= MAX_AUDIO_STREAM_NUM) {
1365         DHLOGE("Stream ID is out of range.");
1366         return;
1367     }
1368     std::lock_guard<std::mutex> devLck(spkStatusMutex_);
1369     spkStatus_[streamId] = status;
1370 }
1371 
GetSpkStatus(const uint32_t streamId)1372 bool AudioAdapterInterfaceImpl::GetSpkStatus(const uint32_t streamId)
1373 {
1374     if (streamId >= MAX_AUDIO_STREAM_NUM) {
1375         DHLOGE("Stream ID is out of range.");
1376         return false;
1377     }
1378     std::lock_guard<std::mutex> devLck(spkStatusMutex_);
1379     return spkStatus_[streamId];
1380 }
1381 
1382 } // V1_0
1383 } // Audio
1384 } // Distributedaudio
1385 } // HDI
1386 } // OHOS