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