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 #include "audio_proxy_manager.h"
16 #include <hdf_log.h>
17 #include <hdf_remote_service.h>
18 #include <servmgr_hdi.h>
19 #include <osal_mem.h>
20 #include "audio_proxy_common.h"
21 #include "audio_proxy_internal.h"
22 #include "audio_adapter_info_common.h"
23
24 namespace OHOS::HDI::Audio_Bluetooth {
25 constexpr const char *HDI_SERVER_NAME = "audio_bluetooth_hdi_service";
26
AudioProxyManagerGetAllAdapters(struct AudioProxyManager * manager,struct AudioAdapterDescriptor ** descs,int * size)27 int32_t AudioProxyManagerGetAllAdapters(struct AudioProxyManager *manager,
28 struct AudioAdapterDescriptor **descs,
29 int *size)
30 {
31 HDF_LOGI("%{public}s, ", __func__);
32 struct HdfSBuf *data = NULL;
33 struct HdfSBuf *reply = NULL;
34 int32_t ret;
35 if (manager == NULL || manager->remote == NULL || descs == NULL || size == NULL) {
36 return AUDIO_HAL_ERR_INVALID_PARAM;
37 }
38 if (AudioProxyPreprocessSBuf(&data, &reply) < 0) {
39 return AUDIO_HAL_ERR_INTERNAL;
40 }
41 HDF_LOGI("%{public}s, call HdfRemoteServiceWriteInterfaceToken ", __func__);
42 if (!HdfRemoteServiceWriteInterfaceToken(manager->remote, data)) {
43 HDF_LOGE("%{public}s, call HdfRemoteServiceWriteInterfaceToken error ", __func__);
44 AudioProxyBufReplyRecycle(data, reply);
45 return AUDIO_HAL_ERR_INTERNAL;
46 }
47 ret = AudioAdaptersForUser(descs, size);
48 if (ret < 0) {
49 AudioProxyBufReplyRecycle(data, reply);
50 HDF_LOGE("AudioAdaptersForUser FAIL!");
51 return AUDIO_HAL_ERR_NOTREADY; // Failed to read sound card configuration file
52 }
53 HDF_LOGI("%{public}s, call AudioProxyDispatchCall ", __func__);
54 ret = AudioProxyDispatchCall(manager->remote, AUDIO_HDI_MGR_GET_ALL_ADAPTER, data, reply);
55 if (ret != AUDIO_HAL_SUCCESS) {
56 AudioProxyBufReplyRecycle(data, reply);
57 HDF_LOGE("Failed to send service call!");
58 return ret;
59 }
60 AudioProxyBufReplyRecycle(data, reply);
61 return AUDIO_HAL_SUCCESS;
62 }
63
AudioProxyManagerLoadAdapter(struct AudioProxyManager * manager,const struct AudioAdapterDescriptor * desc,struct AudioAdapter ** adapter)64 int32_t AudioProxyManagerLoadAdapter(struct AudioProxyManager *manager, const struct AudioAdapterDescriptor *desc,
65 struct AudioAdapter **adapter)
66 {
67 HDF_LOGI("%{public}s, ", __func__);
68 struct HdfSBuf *data = NULL;
69 struct HdfSBuf *reply = NULL;
70
71 if (manager == NULL || manager->remote == NULL || desc == NULL ||
72 desc->adapterName == NULL || desc->ports == NULL || adapter == NULL) {
73 return AUDIO_HAL_ERR_INVALID_PARAM;
74 }
75 if (AudioAdapterExist(desc->adapterName) || (AudioProxyPreprocessSBuf(&data, &reply) < 0)) {
76 return AUDIO_HAL_ERR_INTERNAL;
77 }
78 if (!HdfRemoteServiceWriteInterfaceToken(manager->remote, data)) {
79 AudioProxyBufReplyRecycle(data, reply);
80 return AUDIO_HAL_ERR_INTERNAL;
81 }
82 if (!HdfSbufWriteString(data, desc->adapterName)) {
83 AudioProxyBufReplyRecycle(data, reply);
84 return AUDIO_HAL_ERR_INTERNAL;
85 }
86 uint32_t tempDir = (uint32_t)desc->ports->dir;
87 if (!HdfSbufWriteUint32(data, tempDir)) {
88 AudioProxyBufReplyRecycle(data, reply);
89 return AUDIO_HAL_ERR_INTERNAL;
90 }
91 struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)calloc(1, sizeof(struct AudioHwAdapter));
92 if (hwAdapter == NULL) {
93 AudioProxyBufReplyRecycle(data, reply);
94 return AUDIO_HAL_ERR_MALLOC_FAIL;
95 }
96 int32_t ret = AudioProxyDispatchCall(manager->remote, AUDIO_HDI_MGR_LOAD_ADAPTER, data, reply);
97 if (ret < 0) {
98 AudioProxyBufReplyRecycle(data, reply);
99 AudioMemFree((void **)&hwAdapter);
100 return ret;
101 }
102 hwAdapter->common.InitAllPorts = AudioProxyAdapterInitAllPorts;
103 hwAdapter->common.CreateRender = AudioProxyAdapterCreateRender;
104 hwAdapter->common.DestroyRender = AudioProxyAdapterDestroyRender;
105 hwAdapter->common.GetPortCapability = AudioProxyAdapterGetPortCapability;
106 hwAdapter->common.SetPassthroughMode = AudioProxyAdapterSetPassthroughMode;
107 hwAdapter->common.GetPassthroughMode = AudioProxyAdapterGetPassthroughMode;
108 hwAdapter->adapterDescriptor = *desc;
109 hwAdapter->proxyRemoteHandle = manager->remote; // get dispatch Server
110 *adapter = &hwAdapter->common;
111 AudioProxyBufReplyRecycle(data, reply);
112 return AUDIO_HAL_SUCCESS;
113 }
114
AudioProxyManagerUnloadAdapter(const struct AudioProxyManager * manager,const struct AudioAdapter * adapter)115 void AudioProxyManagerUnloadAdapter(const struct AudioProxyManager *manager, const struct AudioAdapter *adapter)
116 {
117 struct HdfSBuf *data = NULL;
118 struct HdfSBuf *reply = NULL;
119 const char *adapterName = NULL;
120 int32_t i = 0;
121 int32_t portNum;
122 const struct AudioHwAdapter *hwAdapter = reinterpret_cast<const struct AudioHwAdapter *>(adapter);
123 if (manager == NULL || manager->remote == NULL || adapter == NULL) {
124 return;
125 }
126 if (hwAdapter->portCapabilitys != NULL) {
127 portNum = hwAdapter->adapterDescriptor.portNum;
128 while (i < portNum) {
129 if (&hwAdapter->portCapabilitys[i] != NULL) {
130 AudioMemFree((void **)&hwAdapter->portCapabilitys[i].capability.subPorts);
131 }
132 i++;
133 }
134 AudioMemFree((void **)&hwAdapter->portCapabilitys);
135 }
136 if (AudioProxyPreprocessSBuf(&data, &reply) == AUDIO_HAL_SUCCESS) {
137 adapterName = hwAdapter->adapterDescriptor.adapterName;
138 if (!HdfRemoteServiceWriteInterfaceToken(manager->remote, data)) {
139 AudioProxyBufReplyRecycle(data, reply);
140 return;
141 }
142 if (HdfSbufWriteString(data, adapterName)) {
143 int32_t ret = AudioProxyDispatchCall(manager->remote, AUDIO_HDI_MGR_UNLOAD_ADAPTER, data, reply);
144 if (ret < 0) {
145 HDF_LOGE("Send Server fail!");
146 }
147 }
148 AudioProxyBufReplyRecycle(data, reply);
149 }
150 AudioMemFree((void **)&adapter);
151 return;
152 }
153
ProxyMgrConstruct(struct AudioProxyManager * proxyMgr)154 static void ProxyMgrConstruct(struct AudioProxyManager *proxyMgr)
155 {
156 proxyMgr->GetAllAdapters = AudioProxyManagerGetAllAdapters;
157 proxyMgr->LoadAdapter = AudioProxyManagerLoadAdapter;
158 proxyMgr->UnloadAdapter = AudioProxyManagerUnloadAdapter;
159 }
160
GetAudioProxyManagerFuncs(void)161 struct AudioProxyManager *GetAudioProxyManagerFuncs(void)
162 {
163 HDF_LOGI("%{public}s, ", __func__);
164 struct HDIServiceManager *serviceMgr = HDIServiceManagerGet();
165 if (serviceMgr == NULL) {
166 HDF_LOGE("HDIServiceManagerGet failed!");
167 return NULL;
168 }
169 struct HdfRemoteService *remote = serviceMgr->GetService(serviceMgr, HDI_SERVER_NAME);
170 if (remote == NULL) {
171 HDF_LOGE("Remote GetService failed!");
172 HDIServiceManagerRelease(serviceMgr);
173 return NULL;
174 }
175 HDIServiceManagerRelease(serviceMgr);
176 HDF_LOGE("HdfRemoteServiceSetInterfaceDesc");
177 if (!HdfRemoteServiceSetInterfaceDesc(remote, "ohos.hdi.audio_bluetooth_service")) {
178 HDF_LOGE("failed to init interface desc");
179 HdfRemoteServiceRecycle(remote);
180 return NULL;
181 }
182 struct AudioProxyManager *proxyDevMgr = (AudioProxyManager *)OsalMemAlloc(sizeof(struct AudioProxyManager));
183 if (proxyDevMgr == NULL) {
184 HDF_LOGE("malloc failed!");
185 HdfRemoteServiceRecycle(remote);
186 return NULL;
187 }
188 ProxyMgrConstruct(proxyDevMgr);
189 proxyDevMgr->remote = remote;
190 return proxyDevMgr;
191 }
192 }