1 /*
2  * Copyright (c) 2023-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 "hdf_audio_server_manager.h"
17 #include "audio_adapter_info_common.h"
18 #include "audio_uhdf_log.h"
19 #include "osal_mem.h"
20 
21 #define MAX_AUDIO_ADAPTER_NUM_SERVER 8 // Limit the number of sound cards supported to a maximum of 8
22 #define MANAGER_ADAPTER_NAME_LEN     32
23 
24 static struct AudioInfoInAdapter g_renderAndCaptureManage[MAX_AUDIO_ADAPTER_NUM_SERVER];
25 static int32_t g_serverAdapterNum = 0;
26 
AudioServerGetAdapterNum(void)27 int32_t AudioServerGetAdapterNum(void)
28 {
29     return g_serverAdapterNum;
30 }
31 
AudioInfoInAdapterFindDesc(int32_t index,const char * adapterName)32 static int32_t AudioInfoInAdapterFindDesc(int32_t index, const char *adapterName)
33 {
34     if (adapterName == NULL) {
35         AUDIO_FUNC_LOGE("adapterName is NULL");
36         return HDF_ERR_INVALID_PARAM;
37     }
38 
39     for (int i = 0; i < g_serverAdapterNum; i++) {
40         if (g_renderAndCaptureManage[i].adapterName == NULL) {
41             AUDIO_FUNC_LOGW("g_renderAndCaptureManage[%{public}d].adapterName is NULL", i);
42             continue;
43         }
44         if (strncmp(g_renderAndCaptureManage[i].adapterName, adapterName, strlen(adapterName)) == 0) {
45             if (i != index) {
46                 (void)memcpy_s(&g_renderAndCaptureManage[index], sizeof(struct AudioInfoInAdapter),
47                     &g_renderAndCaptureManage[i], sizeof(struct AudioInfoInAdapter));
48                 (void)memset_s(&g_renderAndCaptureManage[i], sizeof(struct AudioInfoInAdapter),
49                     0, sizeof(struct AudioInfoInAdapter));
50             }
51             return HDF_SUCCESS;
52         }
53     }
54 
55     return HDF_FAILURE;
56 }
57 
AudioAdapterInfoInit(struct AudioInfoInAdapter * adapterManage,const char * adapterName)58 static int32_t AudioAdapterInfoInit(struct AudioInfoInAdapter *adapterManage, const char *adapterName)
59 {
60     if (adapterManage == NULL || adapterName == NULL) {
61         AUDIO_FUNC_LOGE("Parameter error! ");
62         return HDF_ERR_INVALID_PARAM;
63     }
64 
65     if (adapterManage->adapterName != NULL) {
66         AUDIO_FUNC_LOGI("adapterManage->adapterName = %{public}s", adapterManage->adapterName);
67     } else {
68         adapterManage->adapterName = (char *)OsalMemCalloc(MANAGER_ADAPTER_NAME_LEN);
69     }
70 
71     if (adapterManage->adapterName == NULL) {
72         AUDIO_FUNC_LOGE("alloc adapter name failed!");
73         return HDF_FAILURE;
74     }
75 
76     int32_t ret = memcpy_s((void *)adapterManage->adapterName, MANAGER_ADAPTER_NAME_LEN,
77         adapterName, strlen(adapterName));
78     if (ret != EOK) {
79         AUDIO_FUNC_LOGE("memcpy adapter name fail!");
80         OsalMemFree((void *)&adapterManage->adapterName);
81         return HDF_FAILURE;
82     }
83 
84     adapterManage->adapter = NULL;
85     adapterManage->adapterUserNum = 0;
86     adapterManage->renderStatus = 0;
87     adapterManage->renderPriority = -1;
88     adapterManage->render = NULL;
89     adapterManage->renderBusy = false;
90     adapterManage->renderDestory = false;
91     adapterManage->renderPid = 0;
92     adapterManage->captureStatus = 0;
93     adapterManage->capturePriority = -1;
94     adapterManage->capture = NULL;
95     adapterManage->captureBusy = false;
96     adapterManage->captureDestory = false;
97     adapterManage->capturePid = 0;
98 
99     return HDF_SUCCESS;
100 }
101 
AdapterManageInit(const struct AudioAdapterDescriptor * descs,int32_t num)102 int32_t AdapterManageInit(const struct AudioAdapterDescriptor *descs, int32_t num)
103 {
104     int32_t index = 0;
105 
106     struct AudioInfoInAdapter *adapterManage = g_renderAndCaptureManage;
107 
108     for (index = 0; index < num; index++) {
109         if (AudioInfoInAdapterFindDesc(index, descs[index].adapterName) != HDF_SUCCESS) {
110             if (AudioAdapterInfoInit(&adapterManage[index], descs[index].adapterName)) {
111                 return HDF_FAILURE;
112             }
113         }
114     }
115 
116     g_serverAdapterNum = num;
117     return HDF_SUCCESS;
118 }
119 
ServerManageGetAdapterNum(int32_t serverAdapterNum)120 int32_t ServerManageGetAdapterNum(int32_t serverAdapterNum)
121 {
122     return ((serverAdapterNum > MAX_AUDIO_ADAPTER_NUM_SERVER) ? MAX_AUDIO_ADAPTER_NUM_SERVER : serverAdapterNum);
123 }
124 
AdaptersServerManageRelease(struct AudioInfoInAdapter * adaptersManage,int32_t num)125 static void AdaptersServerManageRelease(struct AudioInfoInAdapter *adaptersManage, int32_t num)
126 {
127     int32_t i;
128 
129     if (adaptersManage == NULL || num <= 0) {
130         AUDIO_FUNC_LOGE("Parameter error! ");
131 
132         return;
133     }
134     num = ServerManageGetAdapterNum(num);
135     for (i = 0; i < num; i++) {
136         if (adaptersManage[i].adapterName != NULL) {
137             OsalMemFree((void *)&adaptersManage[i].adapterName);
138         }
139     }
140 
141     (void)memset_s(adaptersManage, MAX_AUDIO_ADAPTER_NUM_SERVER * sizeof(struct AudioInfoInAdapter),
142         0, MAX_AUDIO_ADAPTER_NUM_SERVER * sizeof(struct AudioInfoInAdapter));
143 }
144 
AdaptersServerManageInfomationRecycle(void)145 void AdaptersServerManageInfomationRecycle(void)
146 {
147     AdaptersServerManageRelease(g_renderAndCaptureManage, g_serverAdapterNum);
148     g_serverAdapterNum = 0;
149 }
150 
AudioAdapterListGetAdapterCapture(const char * adapterName,struct AudioAdapter ** adapter,struct AudioCapture ** capture)151 int32_t AudioAdapterListGetAdapterCapture(const char *adapterName,
152     struct AudioAdapter **adapter, struct AudioCapture **capture)
153 {
154     int32_t i;
155 
156     if (adapterName == NULL || adapter == NULL || capture == NULL) {
157         AUDIO_FUNC_LOGE("The pointer is null ");
158         return HDF_ERR_INVALID_PARAM;
159     }
160 
161     int32_t num = ServerManageGetAdapterNum(g_serverAdapterNum);
162     for (i = 0; i < num; i++) {
163         if (g_renderAndCaptureManage[i].adapterName == NULL) {
164             AUDIO_FUNC_LOGE("The pointer is null ");
165             return HDF_ERR_INVALID_PARAM;
166         }
167         if (strcmp(g_renderAndCaptureManage[i].adapterName, adapterName) == 0) {
168             *adapter = g_renderAndCaptureManage[i].adapter;
169             *capture = g_renderAndCaptureManage[i].capture;
170             return HDF_SUCCESS;
171         }
172     }
173     return HDF_ERR_INVALID_PARAM;
174 }
175 
AudioDestroyCaptureInfoInAdapter(const char * adapterName)176 int32_t AudioDestroyCaptureInfoInAdapter(const char *adapterName)
177 {
178     int32_t i;
179 
180     if (adapterName == NULL) {
181         AUDIO_FUNC_LOGE("Param Is NULL ");
182         return HDF_FAILURE;
183     }
184 
185     int32_t num = ServerManageGetAdapterNum(g_serverAdapterNum);
186     for (i = 0; i < num; i++) {
187         if (g_renderAndCaptureManage[i].adapterName == NULL) {
188             return HDF_FAILURE;
189         }
190         if (strcmp(g_renderAndCaptureManage[i].adapterName, adapterName) == 0) {
191             g_renderAndCaptureManage[i].captureStatus = 0;
192             g_renderAndCaptureManage[i].capturePriority = -1;
193             g_renderAndCaptureManage[i].capture = NULL;
194             g_renderAndCaptureManage[i].capturePid = 0;
195             return HDF_SUCCESS;
196         }
197     }
198     AUDIO_FUNC_LOGE("Can not find Adapter! ");
199     return HDF_FAILURE;
200 }
201 
AudioDestroyFormerCapture(struct AudioInfoInAdapter * captureManage)202 static int32_t AudioDestroyFormerCapture(struct AudioInfoInAdapter *captureManage)
203 {
204     if (captureManage == NULL || captureManage->adapter == NULL || captureManage->capture == NULL) {
205         AUDIO_FUNC_LOGE("input para is NULL ");
206         return HDF_FAILURE;
207     }
208     int count = 0;
209     captureManage->captureDestory = true;
210     while (captureManage->captureBusy) {
211         if (count > 1000) { // Less than 1000
212             AUDIO_FUNC_LOGE(", count = %{public}d", count);
213             captureManage->captureDestory = false;
214             return AUDIO_HAL_ERR_AI_BUSY; // capture is busy now
215         }
216         usleep(500); // sleep 500us
217         count++;
218     }
219     captureManage->capturePid = 0;
220     if (captureManage->adapter->DestroyCapture(captureManage->adapter, captureManage->capture)) {
221         captureManage->captureDestory = false;
222         return HDF_FAILURE;
223     }
224     captureManage->capture = NULL;
225     captureManage->captureStatus = 0;
226     captureManage->captureBusy = false;
227     captureManage->captureDestory = false;
228     captureManage->renderPriority = -1;
229     return HDF_SUCCESS;
230 }
231 
AudioJudgeCapturePriority(const int32_t priority,int which)232 static int32_t AudioJudgeCapturePriority(const int32_t priority, int which)
233 {
234     int num = ServerManageGetAdapterNum(g_serverAdapterNum);
235     if (which < 0 || which >= num) {
236         AUDIO_FUNC_LOGE("invalid value! ");
237         return HDF_FAILURE;
238     }
239     if (!(g_renderAndCaptureManage[which].captureStatus)) {
240         return HDF_SUCCESS;
241     } else {
242         if (g_renderAndCaptureManage[which].capturePriority <= priority) {
243             return AudioDestroyFormerCapture(&g_renderAndCaptureManage[which]);
244         } else {
245             return AUDIO_HAL_ERR_AI_BUSY; // capture is busy now
246         }
247     }
248     return HDF_FAILURE;
249 }
250 
AudioCreatCaptureCheck(const char * adapterName,const int32_t priority)251 int32_t AudioCreatCaptureCheck(const char *adapterName, const int32_t priority)
252 {
253     int32_t i;
254 
255     if (adapterName == NULL) {
256         AUDIO_FUNC_LOGE("adapterName is NULL! ");
257         return HDF_FAILURE;
258     }
259     int32_t num = ServerManageGetAdapterNum(g_serverAdapterNum);
260     for (i = 0; i < num; i++) {
261         if (g_renderAndCaptureManage[i].adapterName == NULL) {
262             AUDIO_FUNC_LOGE("g_renderAndCaptureManage[%{public}d].adapterName is NULL! ", i);
263             return HDF_FAILURE;
264         }
265         if (strcmp(g_renderAndCaptureManage[i].adapterName, adapterName) == 0) {
266             return AudioJudgeCapturePriority(priority, i);
267         }
268     }
269     AUDIO_FUNC_LOGE("Can not find Adapter! ");
270     return HDF_FAILURE;
271 }
272 
AudioAddCaptureInfoInAdapter(const char * adapterName,struct AudioCapture * capture,const struct AudioAdapter * adapter,const int32_t priority,uint32_t capturePid)273 int32_t AudioAddCaptureInfoInAdapter(const char *adapterName, struct AudioCapture *capture,
274     const struct AudioAdapter *adapter, const int32_t priority, uint32_t capturePid)
275 {
276     int32_t i;
277 
278     if (adapterName == NULL || adapter == NULL || capture == NULL) {
279         AUDIO_FUNC_LOGE("input para is NULL. ");
280         return HDF_FAILURE;
281     }
282     int32_t num = ServerManageGetAdapterNum(g_serverAdapterNum);
283     for (i = 0; i < num; i++) {
284         if (g_renderAndCaptureManage[i].adapterName == NULL) {
285             AUDIO_FUNC_LOGE("g_renderAndCaptureManage[%{public}d].adapterName is NULL! ", i);
286             return HDF_FAILURE;
287         }
288         if (strcmp(g_renderAndCaptureManage[i].adapterName, adapterName) == 0) {
289             g_renderAndCaptureManage[i].captureStatus = 1;
290             g_renderAndCaptureManage[i].capturePriority = priority;
291             g_renderAndCaptureManage[i].capture = capture;
292             g_renderAndCaptureManage[i].capturePid = capturePid;
293             return HDF_SUCCESS;
294         }
295     }
296     AUDIO_FUNC_LOGE("Can not find Adapter! ");
297     return HDF_FAILURE;
298 }
299 
AudioAdapterListGetAdapter(const char * adapterName,struct AudioAdapter ** adapter)300 int32_t AudioAdapterListGetAdapter(const char *adapterName, struct AudioAdapter **adapter)
301 {
302     int32_t i;
303 
304     AUDIO_FUNC_LOGI();
305     if (adapterName == NULL || adapter == NULL) {
306         AUDIO_FUNC_LOGE("The pointer is null ");
307         return HDF_ERR_INVALID_PARAM;
308     }
309 
310     int32_t num = ServerManageGetAdapterNum(g_serverAdapterNum);
311     for (i = 0; i < num; i++) {
312         if (g_renderAndCaptureManage[i].adapterName == NULL) {
313             AUDIO_FUNC_LOGE("g_renderAndCaptureManage[%{public}d].adapterName is NULL! ", i);
314             return HDF_ERR_INVALID_PARAM;
315         }
316         if (strcmp(g_renderAndCaptureManage[i].adapterName, adapterName) == 0) {
317             *adapter = g_renderAndCaptureManage[i].adapter;
318             return HDF_SUCCESS;
319         }
320     }
321     return HDF_ERR_INVALID_PARAM;
322 }
323 
AudioDestroyFormerRender(struct AudioInfoInAdapter * renderManage)324 static int32_t AudioDestroyFormerRender(struct AudioInfoInAdapter *renderManage)
325 {
326     AUDIO_FUNC_LOGI();
327     if (renderManage == NULL || renderManage->adapter == NULL || renderManage->render == NULL) {
328         AUDIO_FUNC_LOGE("input para is NULL. ");
329         return HDF_FAILURE;
330     }
331     int count = 0;
332     renderManage->renderDestory = true;
333     while (renderManage->renderBusy) {
334         if (count > 1000) { // Less than 1000
335             AUDIO_FUNC_LOGE(", count = %{public}d", count);
336             renderManage->renderDestory = false;
337             return AUDIO_HAL_ERR_AO_BUSY; // render is busy now
338         }
339         usleep(500); // sleep 500us
340         count++;
341     }
342     renderManage->renderPid = 0;
343     if (renderManage->adapter->DestroyRender(renderManage->adapter, renderManage->render)) {
344         renderManage->renderDestory = false;
345         return HDF_FAILURE;
346     }
347     renderManage->render = NULL;
348     renderManage->renderStatus = 0;
349     renderManage->renderBusy = false;
350     renderManage->renderDestory = false;
351     renderManage->renderPriority = -1;
352     return HDF_SUCCESS;
353 }
354 
AudioJudgeRenderPriority(const int32_t priority,int which)355 static int32_t AudioJudgeRenderPriority(const int32_t priority, int which)
356 {
357     int32_t num = ServerManageGetAdapterNum(g_serverAdapterNum);
358     if (which < 0 || which >= num) {
359         AUDIO_FUNC_LOGE("invalid value! ");
360         return HDF_FAILURE;
361     }
362     if (g_renderAndCaptureManage[which].renderPriority <= priority) {
363         if (AudioDestroyFormerRender(&g_renderAndCaptureManage[which])) {
364             AUDIO_FUNC_LOGE("AudioDestroyFormerRender: Fail. ");
365             return HDF_FAILURE;
366         }
367         return HDF_SUCCESS;
368     } else {
369         return AUDIO_HAL_ERR_AO_BUSY; // render is busy now
370     }
371     return HDF_FAILURE;
372 }
373 
AudioCreatRenderCheck(const char * adapterName,const int32_t priority)374 int32_t AudioCreatRenderCheck(const char *adapterName, const int32_t priority)
375 {
376     int32_t i;
377 
378     if (adapterName == NULL) {
379         return HDF_FAILURE;
380     }
381 
382     int32_t num = ServerManageGetAdapterNum(g_serverAdapterNum);
383     for (i = 0; i < num; i++) {
384         if (g_renderAndCaptureManage[i].adapterName == NULL) {
385             AUDIO_FUNC_LOGE("g_renderAndCaptureManage[%{public}d].adapterName is NULL! ", i);
386             return HDF_FAILURE;
387         }
388         if (strcmp(g_renderAndCaptureManage[i].adapterName, adapterName) == 0) {
389             if (!(g_renderAndCaptureManage[i].renderStatus)) {
390                 return HDF_SUCCESS;
391             } else {
392                 return AudioJudgeRenderPriority(priority, i);
393             }
394         }
395     }
396     AUDIO_FUNC_LOGE("Can not find Adapter! ");
397     return HDF_FAILURE;
398 }
399 
AudioAddRenderInfoInAdapter(const char * adapterName,struct AudioRender * render,const struct AudioAdapter * adapter,const int32_t priority,uint32_t renderPid)400 int32_t AudioAddRenderInfoInAdapter(const char *adapterName, struct AudioRender *render,
401     const struct AudioAdapter *adapter, const int32_t priority, uint32_t renderPid)
402 {
403     int32_t i;
404 
405     if (adapterName == NULL || adapter == NULL || render == NULL) {
406         AUDIO_FUNC_LOGE("input para is NULL. ");
407         return HDF_FAILURE;
408     }
409     int32_t num = ServerManageGetAdapterNum(g_serverAdapterNum);
410     for (i = 0; i < num; i++) {
411         if (g_renderAndCaptureManage[i].adapterName == NULL) {
412             AUDIO_FUNC_LOGE("g_renderAndCaptureManage[%{public}d].adapterName is NULL! ", i);
413             return HDF_FAILURE;
414         }
415         if (strcmp(g_renderAndCaptureManage[i].adapterName, adapterName) == 0) {
416             g_renderAndCaptureManage[i].renderStatus = 1;
417             g_renderAndCaptureManage[i].renderPriority = priority;
418             g_renderAndCaptureManage[i].render = render;
419             g_renderAndCaptureManage[i].renderPid = renderPid;
420             return HDF_SUCCESS;
421         }
422     }
423     AUDIO_FUNC_LOGE("Can not find Adapter! ");
424     return HDF_FAILURE;
425 }
426 
AudioSetRenderStatus(const char * adapterName,bool renderStatus)427 void AudioSetRenderStatus(const char *adapterName, bool renderStatus)
428 {
429     int32_t i;
430     if (adapterName == NULL) {
431         AUDIO_FUNC_LOGE("adapterName is null ");
432         return;
433     }
434 
435     int32_t num = ServerManageGetAdapterNum(g_serverAdapterNum);
436     for (i = 0; i < num; i++) {
437         if (g_renderAndCaptureManage[i].adapterName == NULL) {
438             AUDIO_FUNC_LOGE("g_renderAndCaptureManage[%{public}d].adapterName is NULL! ", i);
439             return;
440         }
441         if (strcmp(g_renderAndCaptureManage[i].adapterName, adapterName) == 0) {
442             g_renderAndCaptureManage[i].renderBusy = renderStatus;
443             return;
444         }
445     }
446     AUDIO_FUNC_LOGE("AudioDestroyRenderInfoInAdapter: Can not find Adapter! ");
447     return;
448 }
449 
AudioGetRenderStatus(const char * adapterName)450 int32_t AudioGetRenderStatus(const char *adapterName)
451 {
452     int32_t i;
453 
454     if (adapterName == NULL) {
455         return HDF_FAILURE;
456     }
457 
458     int32_t num = ServerManageGetAdapterNum(g_serverAdapterNum);
459     for (i = 0; i < num; i++) {
460         if (g_renderAndCaptureManage[i].adapterName == NULL) {
461             AUDIO_FUNC_LOGE("g_renderAndCaptureManage[%{public}d].adapterName is NULL!", i);
462             return HDF_FAILURE;
463         }
464         if (strcmp(g_renderAndCaptureManage[i].adapterName, adapterName) == 0) {
465             if (!g_renderAndCaptureManage[i].renderDestory) {
466                 return HDF_SUCCESS;
467             } else {
468                 g_renderAndCaptureManage[i].renderBusy = false;
469                 AUDIO_FUNC_LOGE("g_renderAndCaptureManage[%{public}d].renderBusy is NULL!", i);
470                 return HDF_FAILURE;
471             }
472         }
473     }
474     AUDIO_FUNC_LOGE("AudioDestroyRenderInfoInAdapter: Can not find Adapter!");
475     return HDF_FAILURE;
476 }
477 
AudioDestroyRenderInfoInAdapter(const char * adapterName)478 int32_t AudioDestroyRenderInfoInAdapter(const char *adapterName)
479 {
480     int32_t i;
481 
482     if (adapterName == NULL) {
483         AUDIO_FUNC_LOGE("adapterName is null ");
484         return HDF_FAILURE;
485     }
486 
487     int32_t num = ServerManageGetAdapterNum(g_serverAdapterNum);
488     for (i = 0; i < num; i++) {
489         if (g_renderAndCaptureManage[i].adapterName == NULL) {
490             AUDIO_FUNC_LOGE("g_renderAndCaptureManage[%{public}d].adapterName is NULL! ", i);
491             return HDF_FAILURE;
492         }
493         if (strcmp(g_renderAndCaptureManage[i].adapterName, adapterName) == 0) {
494             g_renderAndCaptureManage[i].renderStatus = 0;
495             g_renderAndCaptureManage[i].renderPriority = -1;
496             g_renderAndCaptureManage[i].render = NULL;
497             g_renderAndCaptureManage[i].renderPid = 0;
498             return HDF_SUCCESS;
499         }
500     }
501     AUDIO_FUNC_LOGE("Can not find Adapter! ");
502     return HDF_FAILURE;
503 }
504 
AudioAdapterListGetAdapterRender(const char * adapterName,struct AudioAdapter ** adapter,struct AudioRender ** render)505 int32_t AudioAdapterListGetAdapterRender(const char *adapterName,
506     struct AudioAdapter **adapter, struct AudioRender **render)
507 {
508     int32_t i;
509 
510     if (adapterName == NULL || adapter == NULL || render == NULL) {
511         AUDIO_FUNC_LOGE("The pointer is null ");
512         return HDF_ERR_INVALID_PARAM;
513     }
514 
515     int32_t num = ServerManageGetAdapterNum(g_serverAdapterNum);
516     for (i = 0; i < num; i++) {
517         if (g_renderAndCaptureManage[i].adapterName == NULL) {
518             AUDIO_FUNC_LOGE("g_renderAndCaptureManage[%{public}d].adapterName is NULL! ", i);
519             return HDF_ERR_INVALID_PARAM;
520         }
521         if (strcmp(g_renderAndCaptureManage[i].adapterName, adapterName) == 0) {
522             *adapter = g_renderAndCaptureManage[i].adapter;
523             *render = g_renderAndCaptureManage[i].render;
524             return HDF_SUCCESS;
525         }
526     }
527     AUDIO_FUNC_LOGE("AudioAdapterListGetAdapterRender failed!");
528     return HDF_ERR_INVALID_PARAM;
529 }
530 
AudioAdapterListGetRender(const char * adapterName,struct AudioRender ** render,uint32_t pid)531 int32_t AudioAdapterListGetRender(const char *adapterName, struct AudioRender **render, uint32_t pid)
532 {
533     if (adapterName == NULL || render == NULL) {
534         AUDIO_FUNC_LOGE("pointer is null ");
535         return HDF_ERR_INVALID_PARAM;
536     }
537     int32_t num = ServerManageGetAdapterNum(g_serverAdapterNum);
538     for (int32_t i = 0; i < num; i++) {
539         if (g_renderAndCaptureManage[i].adapterName == NULL) {
540             AUDIO_FUNC_LOGE("g_renderAndCaptureManage[%{public}d].adapterName is NULL! ", i);
541             return HDF_ERR_INVALID_PARAM;
542         }
543         if (strcmp(g_renderAndCaptureManage[i].adapterName, adapterName) == 0) {
544             if (g_renderAndCaptureManage[i].renderPid != pid) {
545                 AUDIO_FUNC_LOGE("[%{public}d].renderPid:%{public}d != pid:%{public}d ", i,
546                     g_renderAndCaptureManage[i].renderPid, pid);
547                 return AUDIO_HAL_ERR_INVALID_OBJECT;
548             }
549             *render = g_renderAndCaptureManage[i].render;
550             return HDF_SUCCESS;
551         }
552     }
553     AUDIO_FUNC_LOGE("AudioAdapterListGetRender failed!");
554     return HDF_ERR_INVALID_PARAM;
555 }
556 
AudioAdapterListGetCapture(const char * adapterName,struct AudioCapture ** capture,uint32_t pid)557 int32_t AudioAdapterListGetCapture(const char *adapterName, struct AudioCapture **capture, uint32_t pid)
558 {
559     int32_t i;
560     if (adapterName == NULL || capture == NULL) {
561         AUDIO_FUNC_LOGE("The pointer is null");
562         return HDF_ERR_INVALID_PARAM;
563     }
564     int32_t num = ServerManageGetAdapterNum(g_serverAdapterNum);
565     for (i = 0; i < num; i++) {
566         if (g_renderAndCaptureManage[i].adapterName == NULL) {
567             AUDIO_FUNC_LOGE("g_renderAndCaptureManage[%{public}d].adapterName is NULL! ", i);
568             return HDF_ERR_INVALID_PARAM;
569         }
570         if (strcmp(g_renderAndCaptureManage[i].adapterName, adapterName) == 0) {
571             if (g_renderAndCaptureManage[i].capturePid != pid) {
572                 AUDIO_FUNC_LOGE("managerList[%{public}d].capturePid:%{public}d != pid:%{public}d ", i,
573                     g_renderAndCaptureManage[i].capturePid, pid);
574                 return AUDIO_HAL_ERR_INVALID_OBJECT;
575             }
576             *capture = g_renderAndCaptureManage[i].capture;
577             return HDF_SUCCESS;
578         }
579     }
580     AUDIO_FUNC_LOGE("AudioAdapterListGetCapture failed!");
581     return HDF_ERR_INVALID_PARAM;
582 }
583 
AudioAdapterFrameGetCapture(const char * adapterName,struct AudioCapture ** capture,uint32_t pid,uint32_t * index)584 int32_t AudioAdapterFrameGetCapture(const char *adapterName,
585     struct AudioCapture **capture, uint32_t pid, uint32_t *index)
586 {
587     int32_t i;
588     if (adapterName == NULL || capture == NULL || index == NULL) {
589         AUDIO_FUNC_LOGE("The pointer is null");
590         return HDF_ERR_INVALID_PARAM;
591     }
592     int32_t num = ServerManageGetAdapterNum(g_serverAdapterNum);
593     *index = MAX_AUDIO_ADAPTER_NUM_SERVER;
594     for (i = 0; i < num; i++) {
595         if (g_renderAndCaptureManage[i].adapterName == NULL) {
596             AUDIO_FUNC_LOGE("g_renderAndCaptureManage[%{public}d].adapterName is NULL! ", i);
597             return HDF_ERR_INVALID_PARAM;
598         }
599         if (strcmp(g_renderAndCaptureManage[i].adapterName, adapterName) == 0) {
600             if (g_renderAndCaptureManage[i].capturePid != pid) {
601                 AUDIO_FUNC_LOGE("[%{public}d].capturePid: %{public}d != pid: %{public}d ", i,
602                     g_renderAndCaptureManage[i].capturePid, pid);
603                 return AUDIO_HAL_ERR_INVALID_OBJECT;
604             }
605             if (!g_renderAndCaptureManage[i].captureDestory) {
606                 *capture = g_renderAndCaptureManage[i].capture;
607                 *index = i;
608                 return HDF_SUCCESS;
609             } else {
610                 g_renderAndCaptureManage[i].captureBusy = false;
611                 AUDIO_FUNC_LOGE("g_renderAndCaptureManage[%{public}d].captureBusy is false! ", i);
612                 return HDF_FAILURE;
613             }
614         }
615     }
616     AUDIO_FUNC_LOGE("AudioAdapterFrameGetCapture failed!");
617     return HDF_FAILURE;
618 }
619 
AudioAdapterCheckListExist(const char * adapterName)620 int32_t AudioAdapterCheckListExist(const char *adapterName)
621 {
622     int32_t i;
623 
624     if (adapterName == NULL) {
625         AUDIO_FUNC_LOGE("The pointer is null.");
626         return AUDIO_HAL_ERR_INVALID_PARAM;
627     }
628 
629     int32_t num = ServerManageGetAdapterNum(g_serverAdapterNum);
630     for (i = 0; i < num; i++) {
631         if (g_renderAndCaptureManage[i].adapterName == NULL) {
632             AUDIO_FUNC_LOGE("g_renderAndCaptureManage[%{public}d].adapterName is NULL! ", i);
633             return AUDIO_HAL_ERR_INVALID_PARAM;
634         }
635         if (strcmp(g_renderAndCaptureManage[i].adapterName, adapterName) == 0) {
636             if (g_renderAndCaptureManage[i].adapterUserNum == 0) {
637                 AUDIO_FUNC_LOGE("g_renderAndCaptureManage[%{public}d].adapterUserNum is zero! ", i);
638                 return AUDIO_HAL_ERR_INTERNAL;
639             } else if (g_renderAndCaptureManage[i].adapterUserNum > 0) {
640                 g_renderAndCaptureManage[i].adapterUserNum++;
641                 return AUDIO_HAL_SUCCESS;
642             }
643         }
644     }
645     AUDIO_FUNC_LOGE("AudioAdapterCheckListExist failed!");
646     return AUDIO_HAL_ERR_INVALID_PARAM;
647 }
648 
AudioAdapterListDestory(const char * adapterName,struct AudioAdapter ** adapter)649 int32_t AudioAdapterListDestory(const char *adapterName, struct AudioAdapter **adapter)
650 {
651     int32_t i;
652     if (adapter == NULL || adapterName == NULL) {
653         AUDIO_FUNC_LOGE("adapter or adapterName is NULL.");
654         return AUDIO_HAL_ERR_INVALID_PARAM;
655     }
656 
657     int32_t num = ServerManageGetAdapterNum(g_serverAdapterNum);
658     for (i = 0; i < num; i++) {
659         if (g_renderAndCaptureManage[i].adapterName == NULL) {
660             AUDIO_FUNC_LOGE("g_renderAndCaptureManage[%{public}d].adapterName is NULL! ", i);
661             return AUDIO_HAL_ERR_INVALID_PARAM;
662         }
663         if (strcmp(g_renderAndCaptureManage[i].adapterName, adapterName) == 0) {
664             if (g_renderAndCaptureManage[i].adapterUserNum == 1) {
665                 g_renderAndCaptureManage[i].adapterUserNum--;
666                 *adapter = g_renderAndCaptureManage[i].adapter;
667                 g_renderAndCaptureManage[i].adapter = NULL;
668                 return AUDIO_HAL_SUCCESS;
669             } else if (g_renderAndCaptureManage[i].adapterUserNum > 1) {
670                 g_renderAndCaptureManage[i].adapterUserNum--;
671                 AUDIO_FUNC_LOGE("g_renderAndCaptureManage[%{public}d].adapterUserNum > 1! ", i);
672                 return AUDIO_HAL_ERR_INTERNAL;
673             }
674         }
675     }
676     AUDIO_FUNC_LOGE("AudioAdapterListDestory failed!");
677     return AUDIO_HAL_ERR_INVALID_PARAM;
678 }
679 
AudioAdapterListAdd(const char * adapterName,struct AudioAdapter * adapter)680 int32_t AudioAdapterListAdd(const char *adapterName, struct AudioAdapter *adapter)
681 {
682     int32_t i;
683 
684     if (adapterName == NULL || adapter == NULL) {
685         AUDIO_FUNC_LOGE("adapterName is NULL. ");
686         return HDF_ERR_INVALID_PARAM;
687     }
688     int32_t num = ServerManageGetAdapterNum(g_serverAdapterNum);
689     for (i = 0; i < num; i++) {
690         if (g_renderAndCaptureManage[i].adapterName == NULL) {
691             AUDIO_FUNC_LOGE("g_renderAndCaptureManage[%{public}d].adapterName is NULL! ", i);
692             return HDF_ERR_INVALID_PARAM;
693         }
694         if (strcmp(g_renderAndCaptureManage[i].adapterName, adapterName) == 0) {
695             g_renderAndCaptureManage[i].adapter = adapter;
696             g_renderAndCaptureManage[i].adapterUserNum = 1;
697             return HDF_SUCCESS;
698         }
699     }
700     AUDIO_FUNC_LOGE("AudioAdapterListAdd failed!");
701     return HDF_ERR_INVALID_PARAM;
702 }
703 
AudioSetCaptureStatus(const char * adapterName,bool captureStatus)704 void AudioSetCaptureStatus(const char *adapterName, bool captureStatus)
705 {
706     int32_t i;
707     if (adapterName == NULL) {
708         AUDIO_FUNC_LOGE("adapterName is NULL. ");
709         return;
710     }
711 
712     int32_t num = ServerManageGetAdapterNum(g_serverAdapterNum);
713     for (i = 0; i < num; i++) {
714         if (g_renderAndCaptureManage[i].adapterName == NULL) {
715             AUDIO_FUNC_LOGE("g_renderAndCaptureManage[%{public}d].adapterName is NULL! ", i);
716             return;
717         }
718         if (strcmp(g_renderAndCaptureManage[i].adapterName, adapterName) == 0) {
719             g_renderAndCaptureManage[i].captureBusy = captureStatus;
720             return;
721         }
722     }
723     AUDIO_FUNC_LOGE("AudioSetCaptureStatus failed! ");
724     return;
725 }
726 
AudioSetCaptureBusy(uint32_t index,bool captureStatus)727 void AudioSetCaptureBusy(uint32_t index, bool captureStatus)
728 {
729     if (index < MAX_AUDIO_ADAPTER_NUM_SERVER) {
730         g_renderAndCaptureManage[index].captureBusy = captureStatus;
731     }
732     return;
733 }
734 
AudioGetCaptureStatus(const char * adapterName)735 int32_t AudioGetCaptureStatus(const char *adapterName)
736 {
737     int32_t i;
738     if (adapterName == NULL) {
739         AUDIO_FUNC_LOGE("adapterName is NULL. ");
740         return HDF_FAILURE;
741     }
742 
743     int32_t num = ServerManageGetAdapterNum(g_serverAdapterNum);
744     for (i = 0; i < num; i++) {
745         if (g_renderAndCaptureManage[i].adapterName == NULL) {
746             AUDIO_FUNC_LOGE("g_renderAndCaptureManage[%{public}d].adapterName is NULL! ", i);
747             return HDF_FAILURE;
748         }
749         if (strcmp(g_renderAndCaptureManage[i].adapterName, adapterName) == 0) {
750             if (!g_renderAndCaptureManage[i].captureDestory) {
751                 return HDF_SUCCESS;
752             } else {
753                 g_renderAndCaptureManage[i].captureBusy = false;
754                 AUDIO_FUNC_LOGE("g_renderAndCaptureManage[%{public}d]! ", i);
755                 return HDF_FAILURE;
756             }
757         }
758     }
759     AUDIO_FUNC_LOGE("AudioGetCaptureStatus failed! ");
760     return HDF_FAILURE;
761 }