1 /*
2 * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "audio_manager_interface_impl.h"
17
18 #include <hdf_base.h>
19 #include "hdf_device_object.h"
20 #include <sstream>
21
22 #include "daudio_constants.h"
23 #include "daudio_errcode.h"
24 #include "daudio_events.h"
25 #include "daudio_log.h"
26 #include "daudio_utils.h"
27
28 #undef DH_LOG_TAG
29 #define DH_LOG_TAG "AudioManagerInterfaceImpl"
30
31 using namespace OHOS::DistributedHardware;
32 namespace OHOS {
33 namespace HDI {
34 namespace DistributedAudio {
35 namespace Audio {
36 namespace V1_0 {
37 AudioManagerInterfaceImpl *AudioManagerInterfaceImpl::audioManager_ = nullptr;
38 std::mutex AudioManagerInterfaceImpl::audioManagerMtx_;
AudioManagerImplGetInstance(void)39 extern "C" IAudioManager *AudioManagerImplGetInstance(void)
40 {
41 return AudioManagerInterfaceImpl::GetAudioManager();
42 }
43
AudioManagerInterfaceImpl()44 AudioManagerInterfaceImpl::AudioManagerInterfaceImpl()
45 {
46 DHLOGD("Distributed audio manager constructed.");
47 }
48
~AudioManagerInterfaceImpl()49 AudioManagerInterfaceImpl::~AudioManagerInterfaceImpl()
50 {
51 DHLOGD("Distributed audio manager destructed.");
52 }
53
GetAllAdapters(std::vector<AudioAdapterDescriptor> & descs)54 int32_t AudioManagerInterfaceImpl::GetAllAdapters(std::vector<AudioAdapterDescriptor> &descs)
55 {
56 DHLOGI("Get all distributed audio adapters.");
57 std::lock_guard<std::mutex> adpLck(adapterMapMtx_);
58
59 std::transform(mapAudioAdapter_.begin(), mapAudioAdapter_.end(), std::back_inserter(descs),
60 [](auto& adp) { return adp.second->GetAdapterDesc(); });
61
62 DHLOGI("Get adapters success, total is (%zu). ", mapAudioAdapter_.size());
63 return HDF_SUCCESS;
64 }
65
LoadAdapter(const AudioAdapterDescriptor & desc,sptr<IAudioAdapter> & adapter)66 int32_t AudioManagerInterfaceImpl::LoadAdapter(const AudioAdapterDescriptor &desc, sptr<IAudioAdapter> &adapter)
67 {
68 DHLOGI("Load distributed audio adapter: %s.", GetAnonyString(desc.adapterName).c_str());
69 std::lock_guard<std::mutex> adpLck(adapterMapMtx_);
70 auto adp = mapAudioAdapter_.find(desc.adapterName);
71 if (adp == mapAudioAdapter_.end()) {
72 DHLOGE("Load audio adapter failed, can not find adapter.");
73 adapter = nullptr;
74 return HDF_FAILURE;
75 }
76
77 int32_t ret = adp->second->AdapterLoad();
78 if (ret != DH_SUCCESS) {
79 DHLOGE("Load audio adapter failed, adapter return: %d.", ret);
80 adapter = nullptr;
81 return HDF_FAILURE;
82 }
83
84 adapter = adp->second;
85 DHLOGI("Load adapter success.");
86 return HDF_SUCCESS;
87 }
88
UnloadAdapter(const std::string & adapterName)89 int32_t AudioManagerInterfaceImpl::UnloadAdapter(const std::string &adapterName)
90 {
91 DHLOGI("Unload distributed audio adapter: %s.", GetAnonyString(adapterName).c_str());
92 std::lock_guard<std::mutex> adpLck(adapterMapMtx_);
93 auto adp = mapAudioAdapter_.find(adapterName);
94 if (adp == mapAudioAdapter_.end()) {
95 DHLOGE("Unload audio adapter failed, can not find adapter.");
96 return HDF_SUCCESS;
97 }
98
99 int32_t ret = adp->second->AdapterUnload();
100 if (ret != DH_SUCCESS) {
101 DHLOGE("Unload audio adapter failed, adapter return: %d.", ret);
102 return ret;
103 }
104 DHLOGI("Unload adapter success.");
105 return HDF_SUCCESS;
106 }
107
ReleaseAudioManagerObject()108 int32_t AudioManagerInterfaceImpl::ReleaseAudioManagerObject()
109 {
110 DHLOGD("Release distributed audio manager object.");
111 return HDF_SUCCESS;
112 }
113
AddAudioDevice(const std::string & adpName,const uint32_t dhId,const std::string & caps,const sptr<IDAudioCallback> & callback)114 int32_t AudioManagerInterfaceImpl::AddAudioDevice(const std::string &adpName, const uint32_t dhId,
115 const std::string &caps, const sptr<IDAudioCallback> &callback)
116 {
117 DHLOGI("Add audio device name: %s, device: %d.", GetAnonyString(adpName).c_str(), dhId);
118 std::lock_guard<std::mutex> adpLck(adapterMapMtx_);
119 auto adp = mapAudioAdapter_.find(adpName);
120 if (adp == mapAudioAdapter_.end()) {
121 int32_t ret = CreateAdapter(adpName, dhId, callback);
122 if (ret != DH_SUCCESS) {
123 DHLOGE("Create audio adapter failed.");
124 return ERR_DH_AUDIO_HDF_FAIL;
125 }
126 }
127 adp = mapAudioAdapter_.find(adpName);
128 if (adp == mapAudioAdapter_.end() || adp->second == nullptr) {
129 DHLOGE("Audio device has not been created or is null ptr.");
130 return ERR_DH_AUDIO_HDF_INVALID_OPERATION;
131 }
132 switch (GetDevTypeByDHId(dhId)) {
133 case AUDIO_DEVICE_TYPE_SPEAKER:
134 adp->second->SetSpeakerCallback(callback);
135 break;
136 case AUDIO_DEVICE_TYPE_MIC:
137 adp->second->SetMicCallback(callback);
138 break;
139 case AUDIO_DEVICE_TYPE_UNKNOWN:
140 default:
141 DHLOGE("DhId is illegal, devType is unknow.");
142 return ERR_DH_AUDIO_HDF_FAIL;
143 }
144 int32_t ret = adp->second->AddAudioDevice(dhId, caps);
145 if (ret != DH_SUCCESS) {
146 DHLOGE("Add audio device failed, adapter return: %d.", ret);
147 return ERR_DH_AUDIO_HDF_FAIL;
148 }
149
150 DAudioDevEvent event = { adpName,
151 dhId,
152 HDF_AUDIO_DEVICE_ADD,
153 0,
154 adp->second->GetVolumeGroup(dhId),
155 adp->second->GetInterruptGroup(dhId) };
156 ret = NotifyFwk(event);
157 if (ret != DH_SUCCESS) {
158 DHLOGE("Notify audio fwk failed, ret = %d.", ret);
159 return ret;
160 }
161 DHLOGI("Add audio device success.");
162 return DH_SUCCESS;
163 }
164
RemoveAudioDevice(const std::string & adpName,const uint32_t dhId)165 int32_t AudioManagerInterfaceImpl::RemoveAudioDevice(const std::string &adpName, const uint32_t dhId)
166 {
167 DHLOGI("Remove audio device name: %s, device: %d.", GetAnonyString(adpName).c_str(), dhId);
168 std::lock_guard<std::mutex> adpLck(adapterMapMtx_);
169 auto adp = mapAudioAdapter_.find(adpName);
170 if (adp == mapAudioAdapter_.end() || adp->second == nullptr) {
171 DHLOGE("Audio device has not been created or is null ptr.");
172 return ERR_DH_AUDIO_HDF_INVALID_OPERATION;
173 }
174
175 int32_t ret = adp->second->RemoveAudioDevice(dhId);
176 if (ret != DH_SUCCESS) {
177 DHLOGE("Remove audio device failed, adapter return: %d.", ret);
178 return ret;
179 }
180
181 DAudioDevEvent event = { adpName, dhId, HDF_AUDIO_DEVICE_REMOVE, 0, 0, 0 };
182 ret = NotifyFwk(event);
183 if (ret != DH_SUCCESS) {
184 DHLOGE("Notify audio fwk failed, ret = %d.", ret);
185 }
186 if (adp->second->IsPortsNoReg()) {
187 mapAudioAdapter_.erase(adpName);
188 }
189 DHLOGI("Remove audio device success, mapAudioAdapter size() is : %d .", mapAudioAdapter_.size());
190 return DH_SUCCESS;
191 }
192
Notify(const std::string & adpName,const uint32_t devId,const DAudioEvent & event)193 int32_t AudioManagerInterfaceImpl::Notify(const std::string &adpName, const uint32_t devId, const DAudioEvent &event)
194 {
195 DHLOGI("Notify event, adapter name: %s. event type: %d", GetAnonyString(adpName).c_str(),
196 event.type);
197 auto adp = mapAudioAdapter_.find(adpName);
198 if (adp == mapAudioAdapter_.end()) {
199 DHLOGE("Notify failed, can not find adapter.");
200 return ERR_DH_AUDIO_HDF_INVALID_OPERATION;
201 }
202
203 int32_t ret = adp->second->Notify(devId, event);
204 if (ret != DH_SUCCESS) {
205 DHLOGE("Notify failed, adapter return: %d.", ret);
206 return ERR_DH_AUDIO_HDF_FAIL;
207 }
208 return DH_SUCCESS;
209 }
210
NotifyFwk(const DAudioDevEvent & event)211 int32_t AudioManagerInterfaceImpl::NotifyFwk(const DAudioDevEvent &event)
212 {
213 DHLOGD("Notify audio fwk event(type:%d, adapter:%s, pin:%d).", event.eventType,
214 GetAnonyString(event.adapterName).c_str(), event.dhId);
215 std::stringstream ss;
216 ss << "EVENT_TYPE=" << event.eventType << ";NID=" << event.adapterName << ";PIN=" << event.dhId << ";VID=" <<
217 event.volGroupId << ";IID=" << event.iptGroupId;
218 std::string eventInfo = ss.str();
219 int ret = HdfDeviceObjectSetServInfo(deviceObject_, eventInfo.c_str());
220 if (ret != HDF_SUCCESS) {
221 DHLOGE("Set service info failed, ret = %d.", ret);
222 return ERR_DH_AUDIO_HDF_FAIL;
223 }
224 ret = HdfDeviceObjectUpdate(deviceObject_);
225 if (ret != HDF_SUCCESS) {
226 DHLOGE("Update service info failed, ret = %d.", ret);
227 return ERR_DH_AUDIO_HDF_FAIL;
228 }
229
230 DHLOGI("Notify audio fwk success.");
231 return DH_SUCCESS;
232 }
233
CreateAdapter(const std::string & adpName,const uint32_t devId,const sptr<IDAudioCallback> & callback)234 int32_t AudioManagerInterfaceImpl::CreateAdapter(const std::string &adpName, const uint32_t devId,
235 const sptr<IDAudioCallback> &callback)
236 {
237 if (callback == nullptr) {
238 DHLOGE("Adapter callback is null.");
239 return ERR_DH_AUDIO_HDF_NULLPTR;
240 }
241 if (devId != PIN_OUT_DAUDIO_DEFAULT && devId != PIN_IN_DAUDIO_DEFAULT) {
242 DHLOGE("Pin is not default, can not create audio adapter.");
243 return ERR_DH_AUDIO_HDF_FAIL;
244 }
245
246 AudioAdapterDescriptor desc = { adpName };
247 sptr<AudioAdapterInterfaceImpl> adapter(new AudioAdapterInterfaceImpl(desc));
248 if (adapter == nullptr) {
249 DHLOGE("Create new audio adapter failed.");
250 return ERR_DH_AUDIO_HDF_NULLPTR;
251 }
252 mapAudioAdapter_.insert(std::make_pair(adpName, adapter));
253 return DH_SUCCESS;
254 }
255
SetDeviceObject(struct HdfDeviceObject * deviceObject)256 void AudioManagerInterfaceImpl::SetDeviceObject(struct HdfDeviceObject *deviceObject)
257 {
258 deviceObject_ = deviceObject;
259 }
260 } // V1_0
261 } // Audio
262 } // Distributedaudio
263 } // HDI
264 } // OHOSf
265