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