1 /*
2 * Copyright (c) 2021 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 <hdf_device_object.h>
17 #include "hdf_audio_server_common.h"
18 #include "hdf_audio_server_render.h"
19 #include "hdf_audio_server_capture.h"
20 #include "hdf_audio_server.h"
21 namespace OHOS::HDI::Audio_Bluetooth {
22 #define HDF_LOG_TAG hdf_audio_bluetooth_server
23
24 struct AudioAdapterDescriptor *g_descs = NULL;
25 struct AudioManager *g_serverManager = NULL;
26 /**************************public************************/
HdiServiceGetFuncs()27 int32_t HdiServiceGetFuncs()
28 {
29 HDF_LOGE("%{public}s: enter to", __func__);
30 if (g_serverManager != NULL) {
31 return AUDIO_HAL_SUCCESS;
32 }
33 g_serverManager = GetAudioManagerFuncs();
34 if (g_serverManager == NULL) {
35 HDF_LOGE("%{public}s: GetAudioManagerFuncs FAIL!", __func__);
36 return AUDIO_HAL_ERR_INTERNAL;
37 }
38 return AUDIO_HAL_SUCCESS;
39 }
40
HdiServiceGetAllAdapter(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)41 static int32_t HdiServiceGetAllAdapter(const struct HdfDeviceIoClient *client,
42 struct HdfSBuf *data, struct HdfSBuf *reply)
43 {
44 HDF_LOGE("%{public}s: enter to", __func__);
45 if (client == NULL || data == NULL || reply == NULL) {
46 return AUDIO_HAL_ERR_INVALID_PARAM;
47 }
48 static bool getAdaptersFlag = true;
49 struct AudioAdapterDescriptor *descs = NULL;
50 struct AudioManager *manager = g_serverManager;
51 int32_t size = 0;
52
53 if (manager == NULL) {
54 HDF_LOGE("%{public}s: Manager is NULL", __func__);
55 return AUDIO_HAL_ERR_INVALID_PARAM;
56 }
57 int32_t ret = manager->GetAllAdapters(manager, &descs, &size);
58 if (ret < 0) {
59 HDF_LOGE("%{public}s: g_manager->GetAllAdapters error", __func__);
60 return AUDIO_HAL_ERR_INTERNAL;
61 }
62 if (size > MAX_AUDIO_ADAPTER_NUM_SERVER || size == 0 || descs == NULL || ret < 0) {
63 HDF_LOGE("%{public}s: size or g_descs is error", __func__);
64 return AUDIO_HAL_ERR_NOT_SUPPORT;
65 }
66 g_descs = descs;
67 if (getAdaptersFlag) { // Initialize only once
68 ret = AdaptersServerManageInit(descs, size);
69 if (ret != AUDIO_HAL_SUCCESS) {
70 HDF_LOGE("%{public}s: AdapterServerManageInit fail", __func__);
71
72 return ret;
73 }
74 getAdaptersFlag = false;
75 }
76 HDF_LOGE("%{public}s: out", __func__);
77
78 return AUDIO_HAL_SUCCESS;
79 }
80
SwitchAdapter(struct AudioAdapterDescriptor * descs,const char * adapterNameCase,AudioPortDirection portFlag,struct AudioPort * renderPort,const int size)81 int SwitchAdapter(struct AudioAdapterDescriptor *descs, const char *adapterNameCase, AudioPortDirection portFlag,
82 struct AudioPort *renderPort, const int size)
83 {
84 if (descs == NULL || adapterNameCase == NULL || renderPort == NULL) {
85 return HDF_FAILURE;
86 }
87 for (int index = 0; index < size; index++) {
88 struct AudioAdapterDescriptor *desc = &descs[index];
89 if (desc == NULL) {
90 continue;
91 }
92 if (desc->adapterName == NULL) {
93 return HDF_FAILURE;
94 }
95 if (strcmp(desc->adapterName, adapterNameCase)) {
96 continue;
97 }
98 for (uint32_t port = 0; port < desc->portNum; port++) {
99 if (desc->ports[port].dir == portFlag) {
100 *renderPort = desc->ports[port];
101 HDF_LOGE("%{public}s: success!,%{public}d", __func__, portFlag);
102 return index;
103 }
104 }
105 }
106 HDF_LOGE("%{public}s: out!", __func__);
107 return HDF_FAILURE;
108 }
109
110 /* Adapter Check */
111
HdiServiceLoadAdapter(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)112 static int32_t HdiServiceLoadAdapter(const struct HdfDeviceIoClient *client,
113 struct HdfSBuf *data, struct HdfSBuf *reply)
114 {
115 if (client == NULL || data == NULL || reply == NULL) {
116 return AUDIO_HAL_ERR_INVALID_PARAM;
117 }
118 struct AudioAdapter *adapter = NULL;
119 struct AudioPort renderPort;
120 const char *adapterName = NULL;
121 uint32_t tempDir = 0;
122 if ((adapterName = HdfSbufReadString(data)) == NULL) {
123 HDF_LOGE("%{public}s: adapterNameCase Is NULL", __func__);
124 return AUDIO_HAL_ERR_INVALID_PARAM;
125 }
126 int32_t ret = AudioAdapterCheckListExist(adapterName);
127 if (ret == AUDIO_HAL_ERR_INVALID_PARAM) {
128 return AUDIO_HAL_ERR_INTERNAL;
129 }
130 if (ret == AUDIO_HAL_SUCCESS) {
131 HDF_LOGE("%{public}s: adapter already exist !", __func__);
132 return AUDIO_HAL_SUCCESS;
133 }
134 if (!HdfSbufReadUint32(data, &tempDir)) {
135 HDF_LOGE("%{public}s: adapter need Load!", __func__);
136 return AUDIO_HAL_ERR_INTERNAL;
137 }
138 AudioPortDirection port = (AudioPortDirection)tempDir;
139 struct AudioManager *manager = g_serverManager;
140 if (adapterName == NULL || manager == NULL || g_descs == NULL) {
141 HDF_LOGE("%{public}s: Point is NULL!", __func__);
142 return AUDIO_HAL_ERR_INTERNAL;
143 }
144 int index = SwitchAdapter(g_descs, adapterName, port,
145 &renderPort, ServerManageGetAdapterNum());
146 if (index < 0) {
147 return AUDIO_HAL_ERR_NOT_SUPPORT;
148 }
149 struct AudioAdapterDescriptor *desc = &g_descs[index];
150 ret = manager->LoadAdapter(manager, desc, &adapter);
151 if (ret < 0) {
152 return AUDIO_HAL_ERR_NOT_SUPPORT;
153 }
154 if (adapter == NULL) {
155 HDF_LOGE("%{public}s: load audio device failed", __func__);
156 return AUDIO_HAL_ERR_INVALID_PARAM;
157 }
158 if (AudioAdapterListAdd(adapterName, adapter)) {
159 HDF_LOGE("%{public}s: AudioAdapterListAdd error!", __func__);
160 manager->UnloadAdapter(manager, adapter);
161 return AUDIO_HAL_ERR_INTERNAL;
162 }
163 return AUDIO_HAL_SUCCESS;
164 }
165
HdiServiceInitAllPorts(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)166 static int32_t HdiServiceInitAllPorts(const struct HdfDeviceIoClient *client,
167 struct HdfSBuf *data, struct HdfSBuf *reply)
168 {
169 HDF_LOGE("%{public}s: HdiServiceInitAllPorts", __func__);
170 if (client == NULL || data == NULL || reply == NULL) {
171 return AUDIO_HAL_ERR_INVALID_PARAM;
172 }
173 const char *adapterName = NULL;
174 struct AudioAdapter *adapter = NULL;
175 if ((adapterName = HdfSbufReadString(data)) == NULL) {
176 HDF_LOGE("%{public}s: adapterNameCase Is NULL", __func__);
177 return AUDIO_HAL_ERR_INVALID_PARAM;
178 }
179 if (AudioAdapterListGetAdapter(adapterName, &adapter)) {
180 HDF_LOGE("%{public}s: AudioAdapterListGetAdapter fail", __func__);
181 return AUDIO_HAL_ERR_INTERNAL;
182 }
183 if (adapter->InitAllPorts(adapter)) {
184 HDF_LOGE("%{public}s: InitAllPorts fail", __func__);
185 return AUDIO_HAL_ERR_INTERNAL;
186 }
187 return AUDIO_HAL_SUCCESS;
188 }
189
HdiServiceUnloadAdapter(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)190 static int32_t HdiServiceUnloadAdapter(const struct HdfDeviceIoClient *client,
191 struct HdfSBuf *data, struct HdfSBuf *reply)
192 {
193 if (client == NULL || data == NULL || reply == NULL) {
194 return AUDIO_HAL_ERR_INVALID_PARAM;
195 }
196 struct AudioAdapter *adapter = NULL;
197 const char *adapterName = NULL;
198 int ret;
199 struct AudioManager *manager = g_serverManager;
200 if (manager == NULL) {
201 HDF_LOGE("%{public}s: Point is NULL!", __func__);
202 return AUDIO_HAL_ERR_INVALID_PARAM;
203 }
204 if ((adapterName = HdfSbufReadString(data)) == NULL) {
205 HDF_LOGE("%{public}s: adapterNameCase Is NULL", __func__);
206 return AUDIO_HAL_ERR_INVALID_PARAM;
207 }
208 ret = AudioAdapterListDestory(adapterName, &adapter);
209 if (ret == AUDIO_HAL_ERR_INTERNAL) {
210 HDF_LOGE("%{public}s: Other dev Use the adapter", __func__);
211 return AUDIO_HAL_SUCCESS;
212 } else if (ret == AUDIO_HAL_ERR_INVALID_PARAM) {
213 HDF_LOGE("%{public}s: param invalid!", __func__);
214 return AUDIO_HAL_ERR_INTERNAL;
215 } else {
216 HDF_LOGE("%{public}s: Unload the adapter!", __func__);
217 }
218 if (adapter == NULL) {
219 return AUDIO_HAL_ERR_INVALID_PARAM;
220 }
221 manager->UnloadAdapter(manager, adapter);
222 return AUDIO_HAL_SUCCESS;
223 }
224
HdiServiceGetPortCapability(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)225 static int32_t HdiServiceGetPortCapability(const struct HdfDeviceIoClient *client,
226 struct HdfSBuf *data, struct HdfSBuf *reply)
227 {
228 HDF_LOGE("%{public}s: enter", __func__);
229 if (client == NULL || data == NULL || reply == NULL) {
230 return AUDIO_HAL_ERR_INVALID_PARAM;
231 }
232 struct AudioPort port;
233 struct AudioPortCapability capability;
234 struct AudioAdapter *adapter = NULL;
235 const char *adapterName = NULL;
236 uint32_t tempDir;
237 if ((adapterName = HdfSbufReadString(data)) == NULL) {
238 HDF_LOGE("%{public}s: adapterNameCase Is NULL", __func__);
239 return AUDIO_HAL_ERR_INVALID_PARAM;
240 }
241 if (!HdfSbufReadUint32(data, &tempDir)) {
242 return AUDIO_HAL_ERR_INTERNAL;
243 }
244 port.dir = (AudioPortDirection)tempDir;
245 if (!HdfSbufReadUint32(data, &port.portId)) {
246 return AUDIO_HAL_ERR_INTERNAL;
247 }
248 if ((port.portName = HdfSbufReadString(data)) == NULL) {
249 return AUDIO_HAL_ERR_INTERNAL;
250 }
251 HDF_LOGE("port.portName = %{public}s", port.portName);
252 if (AudioAdapterListGetAdapter(adapterName, &adapter)) {
253 HDF_LOGE("%{public}s: AudioAdapterListGetAdapter fail", __func__);
254 return AUDIO_HAL_ERR_INTERNAL;
255 }
256 if (adapter == NULL) {
257 HDF_LOGE("%{public}s: HdiServiceCreatRender adapter is NULL!", __func__);
258 return AUDIO_HAL_ERR_INVALID_PARAM;
259 }
260 int32_t ret = adapter->GetPortCapability(adapter, &port, &capability);
261 if (ret < 0) {
262 HDF_LOGE("%{public}s: ret failed", __func__);
263 return AUDIO_HAL_ERR_INTERNAL;
264 }
265 return AUDIO_HAL_SUCCESS;
266 }
267
HdiServiceSetPassthroughMode(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)268 static int32_t HdiServiceSetPassthroughMode(const struct HdfDeviceIoClient *client,
269 struct HdfSBuf *data, struct HdfSBuf *reply)
270 {
271 HDF_LOGE("%{public}s: enter", __func__);
272 if (client == NULL || data == NULL || reply == NULL) {
273 return AUDIO_HAL_ERR_INVALID_PARAM;
274 }
275 struct AudioPort port;
276 AudioPortPassthroughMode mode;
277 struct AudioAdapter *adapter = NULL;
278 const char *adapterName = NULL;
279 if ((adapterName = HdfSbufReadString(data)) == NULL) {
280 HDF_LOGE("%{public}s: adapterNameCase Is NULL", __func__);
281 return AUDIO_HAL_ERR_INVALID_PARAM;
282 }
283 uint32_t tempDir;
284 if (!HdfSbufReadUint32(data, &tempDir)) {
285 return AUDIO_HAL_ERR_INTERNAL;
286 }
287 port.dir = (AudioPortDirection)tempDir;
288 HDF_LOGE("port.dir = %{public}d", port.dir);
289 if (!HdfSbufReadUint32(data, &port.portId)) {
290 return AUDIO_HAL_ERR_INTERNAL;
291 }
292 if ((port.portName = HdfSbufReadString(data)) == NULL) {
293 HDF_LOGE("port.portName = %{public}s", port.portName);
294 return AUDIO_HAL_ERR_INTERNAL;
295 }
296 HDF_LOGE("port.portName = %{public}s", port.portName);
297 uint32_t tempMode = 0;
298 if (!HdfSbufReadUint32(data, &tempMode)) {
299 return AUDIO_HAL_ERR_INTERNAL;
300 }
301 mode = (AudioPortPassthroughMode)tempMode;
302 HDF_LOGE("%{public}s: ready in,mode = %{public}d", __func__, mode);
303 if (AudioAdapterListGetAdapter(adapterName, &adapter)) {
304 HDF_LOGE("%{public}s: AudioAdapterListGetAdapter fail", __func__);
305 return AUDIO_HAL_ERR_INTERNAL;
306 }
307 if (adapter == NULL) {
308 HDF_LOGE("%{public}s: HdiServiceCreatRender adapter is NULL!", __func__);
309 return AUDIO_HAL_ERR_INVALID_PARAM;
310 }
311 int ret = adapter->SetPassthroughMode(adapter, &port, mode);
312 return ret;
313 }
HdiServiceGetPassthroughMode(const struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)314 static int32_t HdiServiceGetPassthroughMode(const struct HdfDeviceIoClient *client,
315 struct HdfSBuf *data, struct HdfSBuf *reply)
316 {
317 if (client == NULL || data == NULL || reply == NULL) {
318 return AUDIO_HAL_ERR_INVALID_PARAM;
319 }
320 AudioPortPassthroughMode mode = PORT_PASSTHROUGH_AUTO;
321 struct AudioAdapter *adapter = NULL;
322 const char *adapterName = NULL;
323 struct AudioPort port;
324 memset_s(&port, sizeof(struct AudioPort), 0, sizeof(struct AudioPort));
325 if ((adapterName = HdfSbufReadString(data)) == NULL) {
326 HDF_LOGE("%{public}s: adapterNameCase Is NULL", __func__);
327 return AUDIO_HAL_ERR_INVALID_PARAM;
328 }
329 uint32_t tempDir = port.dir;
330 if (!HdfSbufReadUint32(data, &tempDir)) {
331 return AUDIO_HAL_ERR_INTERNAL;
332 }
333 port.dir = (AudioPortDirection)tempDir;
334 if (!HdfSbufReadUint32(data, &port.portId)) {
335 return AUDIO_HAL_ERR_INTERNAL;
336 }
337 if ((port.portName = HdfSbufReadString(data)) == NULL) {
338 HDF_LOGE("port.portName = %{public}s", port.portName);
339 return AUDIO_HAL_ERR_INTERNAL;
340 }
341 if (AudioAdapterListGetAdapter(adapterName, &adapter)) {
342 HDF_LOGE("%{public}s: AudioAdapterListGetAdapter fail", __func__);
343 return AUDIO_HAL_ERR_INTERNAL;
344 }
345 if (adapter == NULL) {
346 HDF_LOGE("%{public}s: adapter is NULL!", __func__);
347 return AUDIO_HAL_ERR_INVALID_PARAM;
348 }
349 int ret = adapter->GetPassthroughMode(adapter, &port, &mode);
350 if (ret < 0) {
351 HDF_LOGE("%{public}s: GetPassthroughMode ret failed", __func__);
352 return AUDIO_HAL_ERR_INTERNAL;
353 }
354 uint32_t tempMode = (uint32_t)mode;
355 if (!HdfSbufWriteUint32(reply, tempMode)) {
356 return AUDIO_HAL_ERR_INTERNAL;
357 }
358 return AUDIO_HAL_SUCCESS;
359 }
360
361 /*****************************end*************************/
362 struct HdiServiceDispatchCmdHandleList g_hdiServiceDispatchCmdHandleList[] = {
363 {AUDIO_HDI_MGR_GET_FUNCS, (AudioAllfunc)HdiServiceGetFuncs},
364 {AUDIO_HDI_MGR_GET_ALL_ADAPTER, HdiServiceGetAllAdapter},
365 {AUDIO_HDI_MGR_LOAD_ADAPTER, HdiServiceLoadAdapter},
366 {AUDIO_HDI_MGR_UNLOAD_ADAPTER, HdiServiceUnloadAdapter},
367 {AUDIO_HDI_ADT_INIT_PORTS, HdiServiceInitAllPorts},
368 {AUDIO_HDI_ADT_GET_PORT_CAPABILITY, HdiServiceGetPortCapability},
369 {AUDIO_HDI_ADT_SET_PASS_MODE, HdiServiceSetPassthroughMode},
370 {AUDIO_HDI_ADT_GET_PASS_MODE, HdiServiceGetPassthroughMode},
371 {AUDIO_HDI_RENDER_CREATE_RENDER, HdiServiceCreatRender},
372 {AUDIO_HDI_RENDER_DESTROY, HdiServiceRenderDestory},
373 {AUDIO_HDI_RENDER_START, HdiServiceRenderStart},
374 {AUDIO_HDI_RENDER_STOP, HdiServiceRenderStop},
375 {AUDIO_HDI_RENDER_PAUSE, HdiServiceRenderPause},
376 {AUDIO_HDI_RENDER_RESUME, HdiServiceRenderResume},
377 {AUDIO_HDI_RENDER_FLUSH, HdiServiceRenderFlush},
378 {AUDIO_HDI_RENDER_GET_FRAME_SIZE, HdiServiceRenderGetFrameSize},
379 {AUDIO_HDI_RENDER_GET_FRAME_COUNT, HdiServiceRenderGetFrameCount},
380 {AUDIO_HDI_RENDER_SET_SAMPLE_ATTR, HdiServiceRenderSetSampleAttr},
381 {AUDIO_HDI_RENDER_GET_SAMPLE_ATTR, HdiServiceRenderGetSampleAttr},
382 {AUDIO_HDI_RENDER_GET_CUR_CHANNEL_ID, HdiServiceRenderGetCurChannelId},
383 {AUDIO_HDI_RENDER_CHECK_SCENE_CAPABILITY, HdiServiceRenderCheckSceneCapability},
384 {AUDIO_HDI_RENDER_SELECT_SCENE, HdiServiceRenderSelectScene},
385 {AUDIO_HDI_RENDER_GET_MUTE, HdiServiceRenderGetMute},
386 {AUDIO_HDI_RENDER_SET_MUTE, HdiServiceRenderSetMute},
387 {AUDIO_HDI_RENDER_SET_VOLUME, HdiServiceRenderSetVolume},
388 {AUDIO_HDI_RENDER_GET_VOLUME, HdiServiceRenderGetVolume},
389 {AUDIO_HDI_RENDER_GET_GAIN_THRESHOLD, HdiServiceRenderGetGainThreshold},
390 {AUDIO_HDI_RENDER_GET_GAIN, HdiServiceRenderGetGain},
391 {AUDIO_HDI_RENDER_SET_GAIN, HdiServiceRenderSetGain},
392 {AUDIO_HDI_RENDER_GET_LATENCY, HdiServiceRenderGetLatency},
393 {AUDIO_HDI_RENDER_RENDER_FRAME, HdiServiceRenderRenderFrame},
394 {AUDIO_HDI_RENDER_GET_RENDER_POSITION, HdiServiceRenderGetRenderPosition},
395 {AUDIO_HDI_RENDER_GET_SPEED, HdiServiceRenderGetSpeed},
396 {AUDIO_HDI_RENDER_SET_SPEED, HdiServiceRenderSetSpeed},
397 {AUDIO_HDI_RENDER_SET_CHANNEL_MODE, HdiServiceRenderSetChannelMode},
398 {AUDIO_HDI_RENDER_GET_CHANNEL_MODE, HdiServiceRenderGetChannelMode},
399 {AUDIO_HDI_RENDER_SET_EXTRA_PARAMS, HdiServiceRenderSetExtraParams},
400 {AUDIO_HDI_RENDER_GET_EXTRA_PARAMS, HdiServiceRenderGetExtraParams},
401 {AUDIO_HDI_RENDER_REQ_MMAP_BUFFER, HdiServiceRenderReqMmapBuffer},
402 {AUDIO_HDI_RENDER_GET_MMAP_POSITION, HdiServiceRenderGetMmapPosition},
403 {AUDIO_HDI_RENDER_TURN_STAND_BY_MODE, HdiServiceRenderTurnStandbyMode},
404 {AUDIO_HDI_RENDER_DEV_DUMP, HdiServiceRenderDevDump},
405 {AUDIO_HDI_RENDER_REG_CALLBACK, HdiServiceRenderRegCallback},
406 {AUDIO_HDI_RENDER_DRAIN_BUFFER, HdiServiceRenderDrainBuffer},
407 {AUDIO_HDI_CAPTURE_CREATE_CAPTURE, HdiServiceCreateCapture},
408 {AUDIO_HDI_CAPTURE_DESTROY, HdiServiceCaptureDestory},
409 {AUDIO_HDI_CAPTURE_START, HdiServiceCaptureStart},
410 {AUDIO_HDI_CAPTURE_STOP, HdiServiceCaptureStop},
411 {AUDIO_HDI_CAPTURE_PAUSE, HdiServiceCapturePause},
412 {AUDIO_HDI_CAPTURE_RESUME, HdiServiceCaptureResume},
413 {AUDIO_HDI_CAPTURE_FLUSH, HdiServiceCaptureFlush},
414 {AUDIO_HDI_CAPTURE_GET_MUTE, HdiServiceCaptureGetMute},
415 {AUDIO_HDI_CAPTURE_SET_MUTE, HdiServiceCaptureSetMute},
416 {AUDIO_HDI_CAPTURE_CAPTURE_FRAME, HdiServiceCaptureCaptureFrame},
417 };
418
HdiServiceDispatch(struct HdfDeviceIoClient * client,int cmdId,struct HdfSBuf * data,struct HdfSBuf * reply)419 static int32_t HdiServiceDispatch(struct HdfDeviceIoClient *client, int cmdId, struct HdfSBuf *data,
420 struct HdfSBuf *reply)
421 {
422 unsigned int i;
423 if (client == NULL || data == NULL || reply == NULL) {
424 HDF_LOGE("%{public}s: ControlDispatch: input para is NULL.", __func__);
425 return AUDIO_HAL_ERR_INVALID_PARAM;
426 }
427
428 if (!HdfDeviceObjectCheckInterfaceDesc(client->device, data)) {
429 return AUDIO_HAL_ERR_INVALID_PARAM;
430 }
431 if (cmdId > AUDIO_HDI_CAPTURE_SET_MUTE || cmdId < 0) {
432 HDF_LOGE("ControlDispatch: invalid cmdId = %{public}d", cmdId);
433 return AUDIO_HAL_ERR_INTERNAL;
434 } else if (cmdId <= AUDIO_HDI_CAPTURE_SET_MUTE) {
435 for (i = 0; i < sizeof(g_hdiServiceDispatchCmdHandleList) /
436 sizeof(g_hdiServiceDispatchCmdHandleList[0]); ++i) {
437 if ((cmdId == (int)(g_hdiServiceDispatchCmdHandleList[i].cmd)) &&
438 (g_hdiServiceDispatchCmdHandleList[i].func != NULL)) {
439 return g_hdiServiceDispatchCmdHandleList[i].func(client, data, reply);
440 }
441 }
442 }
443 return AUDIO_HAL_ERR_INTERNAL;
444 }
445
AudioHdiServerRelease(struct HdfDeviceObject * deviceObject)446 void AudioHdiServerRelease(struct HdfDeviceObject *deviceObject)
447 {
448 LOG_FUN_INFO();
449 /* g_renderAndCaptureManage release */
450 AdaptersServerManageInfomationRecycle();
451
452 if (deviceObject == NULL) {
453 HDF_LOGE("%{public}s: deviceObject is null!", __func__);
454 return;
455 }
456 deviceObject->service = NULL;
457 return;
458 }
459
AudioHdiServerBind(struct HdfDeviceObject * deviceObject)460 int AudioHdiServerBind(struct HdfDeviceObject *deviceObject)
461 {
462 LOG_FUN_INFO();
463 if (deviceObject == NULL) {
464 HDF_LOGE("%{public}s: deviceObject is null!", __func__);
465 return AUDIO_HAL_ERR_INVALID_PARAM;
466 }
467 static struct IDeviceIoService hdiService = {
468 .Open = NULL,
469 .Dispatch = HdiServiceDispatch,
470 .Release = NULL,
471 };
472 if (HdiServiceGetFuncs()) {
473 return AUDIO_HAL_ERR_INTERNAL;
474 }
475 int ret = HdfDeviceObjectSetInterfaceDesc(deviceObject, "ohos.hdi.audio_bluetooth_service");
476 if (ret != HDF_SUCCESS) {
477 HDF_LOGE("failed to set interface desc");
478 return ret;
479 }
480 deviceObject->service = &hdiService;
481 return AUDIO_HAL_SUCCESS;
482 }
483
AudioHdiServerInit(struct HdfDeviceObject * deviceObject)484 int AudioHdiServerInit(struct HdfDeviceObject *deviceObject)
485 {
486 LOG_FUN_INFO();
487 if (deviceObject == NULL) {
488 HDF_LOGE("%{public}s: deviceObject is null!", __func__);
489 return AUDIO_HAL_ERR_INVALID_PARAM;
490 }
491 if (!HdfDeviceSetClass(deviceObject, DEVICE_CLASS_AUDIO)) {
492 HDF_LOGE("%{public}s: set audio class failed!", __func__);
493 return AUDIO_HAL_ERR_INTERNAL;
494 }
495 return AUDIO_HAL_SUCCESS;
496 }
497
498 struct HdfDriverEntry g_hdiServerEntry = {
499 .moduleVersion = 1,
500 .moduleName = "audio_bluetooth_hdi_adapter_server",
501 .Bind = AudioHdiServerBind,
502 .Init = AudioHdiServerInit,
503 .Release = AudioHdiServerRelease,
504 };
505
506 #ifdef __cplusplus
507 extern "C" {
508 #endif
509
510 HDF_INIT(g_hdiServerEntry);
511
512 #ifdef __cplusplus
513 }
514 #endif
515 }