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 <cstdlib>
19 #include <hdf_base.h>
20 #include "hdf_device_object.h"
21 #include "iservice_registry.h"
22 #include "iproxy_broker.h"
23 #include "iservmgr_hdi.h"
24 #include <sstream>
25
26 #include "daudio_constants.h"
27 #include "daudio_errcode.h"
28 #include "daudio_events.h"
29 #include "daudio_log.h"
30 #include "daudio_utils.h"
31
32 #undef DH_LOG_TAG
33 #define DH_LOG_TAG "AudioManagerInterfaceImpl"
34
35 using namespace OHOS::DistributedHardware;
36 namespace OHOS {
37 namespace HDI {
38 namespace DistributedAudio {
39 namespace Audio {
40 namespace V1_0 {
41 AudioManagerInterfaceImpl *AudioManagerInterfaceImpl::audioManager_ = nullptr;
42 std::mutex AudioManagerInterfaceImpl::audioManagerMtx_;
AudioManagerImplGetInstance(void)43 extern "C" IAudioManager *AudioManagerImplGetInstance(void)
44 {
45 return AudioManagerInterfaceImpl::GetAudioManager();
46 }
47
AudioManagerInterfaceImpl()48 AudioManagerInterfaceImpl::AudioManagerInterfaceImpl()
49 {
50 DHLOGD("Distributed audio manager constructed.");
51 audioManagerRecipient_ = new AudioManagerRecipient();
52 }
53
~AudioManagerInterfaceImpl()54 AudioManagerInterfaceImpl::~AudioManagerInterfaceImpl()
55 {
56 DHLOGD("Distributed audio manager destructed.");
57 }
58
GetAllAdapters(std::vector<AudioAdapterDescriptor> & descs)59 int32_t AudioManagerInterfaceImpl::GetAllAdapters(std::vector<AudioAdapterDescriptor> &descs)
60 {
61 DHLOGI("Get all distributed audio adapters.");
62 std::lock_guard<std::mutex> adpLck(adapterMapMtx_);
63
64 std::transform(mapAudioAdapter_.begin(), mapAudioAdapter_.end(), std::back_inserter(descs),
65 [](auto& adp) { return adp.second->GetAdapterDesc(); });
66
67 DHLOGI("Get adapters success, total is (%zu). ", mapAudioAdapter_.size());
68 return HDF_SUCCESS;
69 }
70
LoadAdapter(const AudioAdapterDescriptor & desc,sptr<IAudioAdapter> & adapter)71 int32_t AudioManagerInterfaceImpl::LoadAdapter(const AudioAdapterDescriptor &desc, sptr<IAudioAdapter> &adapter)
72 {
73 DHLOGI("Load distributed audio adapter: %s.", GetAnonyString(desc.adapterName).c_str());
74 std::lock_guard<std::mutex> adpLck(adapterMapMtx_);
75 auto adp = mapAudioAdapter_.find(desc.adapterName);
76 if (adp == mapAudioAdapter_.end()) {
77 DHLOGE("Load audio adapter failed, can not find adapter.");
78 adapter = nullptr;
79 return HDF_FAILURE;
80 }
81
82 int32_t ret = adp->second->AdapterLoad();
83 if (ret != DH_SUCCESS) {
84 DHLOGE("Load audio adapter failed, adapter return: %d.", ret);
85 adapter = nullptr;
86 return HDF_FAILURE;
87 }
88
89 adapter = adp->second;
90 DHLOGI("Load adapter success.");
91 return HDF_SUCCESS;
92 }
93
UnloadAdapter(const std::string & adapterName)94 int32_t AudioManagerInterfaceImpl::UnloadAdapter(const std::string &adapterName)
95 {
96 DHLOGI("Unload distributed audio adapter: %s.", GetAnonyString(adapterName).c_str());
97 std::lock_guard<std::mutex> adpLck(adapterMapMtx_);
98 auto adp = mapAudioAdapter_.find(adapterName);
99 if (adp == mapAudioAdapter_.end()) {
100 DHLOGE("Unload audio adapter failed, can not find adapter.");
101 return HDF_SUCCESS;
102 }
103
104 int32_t ret = adp->second->AdapterUnload();
105 if (ret != DH_SUCCESS) {
106 DHLOGE("Unload audio adapter failed, adapter return: %d.", ret);
107 return ret;
108 }
109 DHLOGI("Unload adapter success.");
110 return HDF_SUCCESS;
111 }
112
ReleaseAudioManagerObject()113 int32_t AudioManagerInterfaceImpl::ReleaseAudioManagerObject()
114 {
115 DHLOGD("Release distributed audio manager object.");
116 return HDF_SUCCESS;
117 }
118
AddAudioDevice(const std::string & adpName,const uint32_t dhId,const std::string & caps,const sptr<IDAudioCallback> & callback)119 int32_t AudioManagerInterfaceImpl::AddAudioDevice(const std::string &adpName, const uint32_t dhId,
120 const std::string &caps, const sptr<IDAudioCallback> &callback)
121 {
122 DHLOGI("Add audio device name: %s, device: %d.", GetAnonyString(adpName).c_str(), dhId);
123 std::lock_guard<std::mutex> adpLck(adapterMapMtx_);
124 auto adp = mapAudioAdapter_.find(adpName);
125 if (adp == mapAudioAdapter_.end()) {
126 int32_t ret = CreateAdapter(adpName, dhId, callback);
127 if (ret != DH_SUCCESS) {
128 DHLOGE("Create audio adapter failed.");
129 return ERR_DH_AUDIO_HDF_FAIL;
130 }
131 }
132 adp = mapAudioAdapter_.find(adpName);
133 if (adp == mapAudioAdapter_.end() || adp->second == nullptr) {
134 DHLOGE("Audio device has not been created or is null ptr.");
135 return ERR_DH_AUDIO_HDF_INVALID_OPERATION;
136 }
137 switch (GetDevTypeByDHId(dhId)) {
138 case AUDIO_DEVICE_TYPE_SPEAKER:
139 adp->second->SetSpeakerCallback(dhId, callback);
140 break;
141 case AUDIO_DEVICE_TYPE_MIC:
142 adp->second->SetMicCallback(dhId, callback);
143 break;
144 default:
145 DHLOGE("DhId is illegal, devType is unknow.");
146 return ERR_DH_AUDIO_HDF_FAIL;
147 }
148 int32_t ret = adp->second->AddAudioDevice(dhId, caps);
149 if (ret != DH_SUCCESS) {
150 DHLOGE("Add audio device failed, adapter return: %d.", ret);
151 return ERR_DH_AUDIO_HDF_FAIL;
152 }
153
154 DAudioDevEvent event = { adpName, dhId, HDF_AUDIO_DEVICE_ADD,
155 0, adp->second->GetVolumeGroup(dhId),
156 adp->second->GetInterruptGroup(dhId) };
157 ret = NotifyFwk(event);
158 if (ret != DH_SUCCESS) {
159 DHLOGE("Notify audio fwk failed, ret = %d.", ret);
160 return ret;
161 }
162 sptr<IRemoteObject> remote = GetRemote(adpName);
163 if (remote != nullptr) {
164 remote->AddDeathRecipient(audioManagerRecipient_);
165 }
166 DHLOGI("Add audio device success.");
167 return DH_SUCCESS;
168 }
169
RemoveAudioDevice(const std::string & adpName,const uint32_t dhId)170 int32_t AudioManagerInterfaceImpl::RemoveAudioDevice(const std::string &adpName, const uint32_t dhId)
171 {
172 DHLOGI("Remove audio device name: %s, device: %d.", GetAnonyString(adpName).c_str(), dhId);
173 std::lock_guard<std::mutex> adpLck(adapterMapMtx_);
174 auto adp = mapAudioAdapter_.find(adpName);
175 if (adp == mapAudioAdapter_.end() || adp->second == nullptr) {
176 DHLOGE("Audio device has not been created or is null ptr.");
177 return ERR_DH_AUDIO_HDF_INVALID_OPERATION;
178 }
179
180 int32_t ret = adp->second->RemoveAudioDevice(dhId);
181 if (ret != DH_SUCCESS) {
182 DHLOGE("Remove audio device failed, adapter return: %d.", ret);
183 return ret;
184 }
185 DAudioDevEvent event = { adpName, dhId, HDF_AUDIO_DEVICE_REMOVE, 0, 0, 0 };
186 ret = NotifyFwk(event);
187 if (ret != DH_SUCCESS) {
188 DHLOGE("Notify audio fwk failed, ret = %d.", ret);
189 }
190 if (adp->second->IsPortsNoReg()) {
191 mapAudioAdapter_.erase(adpName);
192 sptr<IRemoteObject> remote = GetRemote(adpName);
193 if (remote != nullptr) {
194 remote->RemoveDeathRecipient(audioManagerRecipient_);
195 }
196 mapAudioCallback_.erase(adpName);
197 }
198 DHLOGI("Remove audio device success, mapAudioAdapter size() is : %d .", mapAudioAdapter_.size());
199 return DH_SUCCESS;
200 }
201
Notify(const std::string & adpName,const uint32_t devId,const DAudioEvent & event)202 int32_t AudioManagerInterfaceImpl::Notify(const std::string &adpName, const uint32_t devId, const DAudioEvent &event)
203 {
204 DHLOGI("Notify event, adapter name: %s. event type: %d", GetAnonyString(adpName).c_str(),
205 event.type);
206 auto adp = mapAudioAdapter_.find(adpName);
207 if (adp == mapAudioAdapter_.end()) {
208 DHLOGE("Notify failed, can not find adapter.");
209 return ERR_DH_AUDIO_HDF_INVALID_OPERATION;
210 }
211
212 int32_t ret = adp->second->Notify(devId, event);
213 if (ret != DH_SUCCESS) {
214 DHLOGE("Notify failed, adapter return: %d.", ret);
215 return ERR_DH_AUDIO_HDF_FAIL;
216 }
217 return DH_SUCCESS;
218 }
219
NotifyFwk(const DAudioDevEvent & event)220 int32_t AudioManagerInterfaceImpl::NotifyFwk(const DAudioDevEvent &event)
221 {
222 DHLOGD("Notify audio fwk event(type:%d, adapter:%s, pin:%d).", event.eventType,
223 GetAnonyString(event.adapterName).c_str(), event.dhId);
224 std::stringstream ss;
225 ss << "EVENT_TYPE=" << event.eventType << ";NID=" << event.adapterName << ";PIN=" << event.dhId << ";VID=" <<
226 event.volGroupId << ";IID=" << event.iptGroupId;
227 std::string eventInfo = ss.str();
228 int ret = HdfDeviceObjectSetServInfo(deviceObject_, eventInfo.c_str());
229 if (ret != HDF_SUCCESS) {
230 DHLOGE("Set service info failed, ret = %d.", ret);
231 return ERR_DH_AUDIO_HDF_FAIL;
232 }
233 ret = HdfDeviceObjectUpdate(deviceObject_);
234 if (ret != HDF_SUCCESS) {
235 DHLOGE("Update service info failed, ret = %d.", ret);
236 return ERR_DH_AUDIO_HDF_FAIL;
237 }
238
239 DHLOGI("Notify audio fwk success.");
240 return DH_SUCCESS;
241 }
242
CreateAdapter(const std::string & adpName,const uint32_t devId,const sptr<IDAudioCallback> & callback)243 int32_t AudioManagerInterfaceImpl::CreateAdapter(const std::string &adpName, const uint32_t devId,
244 const sptr<IDAudioCallback> &callback)
245 {
246 DHLOGI("Create adapter, pin id: %d.", devId);
247 if (callback == nullptr) {
248 DHLOGE("Adapter callback is null.");
249 return ERR_DH_AUDIO_HDF_NULLPTR;
250 }
251 if (devId != DEFAULT_RENDER_ID && devId != DEFAULT_CAPTURE_ID && devId != LOW_LATENCY_RENDER_ID) {
252 DHLOGE("Pin is not default, can not create audio adapter.");
253 return ERR_DH_AUDIO_HDF_FAIL;
254 }
255
256 AudioAdapterDescriptor desc = { adpName };
257 sptr<AudioAdapterInterfaceImpl> adapter(new AudioAdapterInterfaceImpl(desc));
258 if (adapter == nullptr) {
259 DHLOGE("Create new audio adapter failed.");
260 return ERR_DH_AUDIO_HDF_NULLPTR;
261 }
262 mapAudioAdapter_.insert(std::make_pair(adpName, adapter));
263 mapAudioCallback_.insert(std::make_pair(adpName, callback));
264 return DH_SUCCESS;
265 }
266
SetDeviceObject(struct HdfDeviceObject * deviceObject)267 void AudioManagerInterfaceImpl::SetDeviceObject(struct HdfDeviceObject *deviceObject)
268 {
269 deviceObject_ = deviceObject;
270 }
271
OnRemoteDied(const wptr<IRemoteObject> & remote)272 void AudioManagerInterfaceImpl::AudioManagerRecipient::OnRemoteDied(const wptr<IRemoteObject> &remote)
273 {
274 DHLOGE("Exit the current process.");
275 _Exit(0);
276 }
277
GetRemote(const std::string & adpName)278 sptr<IRemoteObject> AudioManagerInterfaceImpl::GetRemote(const std::string &adpName)
279 {
280 auto call = mapAudioCallback_.find(adpName);
281 if (call == mapAudioCallback_.end() || call->second == nullptr) {
282 DHLOGE("Audio callback has not been created or is null ptr.");
283 return nullptr;
284 }
285 sptr<IRemoteObject> remote = OHOS::HDI::hdi_objcast<IDAudioCallback>(call->second);
286 if (remote == nullptr) {
287 DHLOGE("Remote callback is nullptr.");
288 return nullptr;
289 }
290 return remote;
291 }
292 } // V1_0
293 } // Audio
294 } // Distributedaudio
295 } // HDI
296 } // OHOSf
297