1 /*
2 * SPDX-FileCopyrightText: 2015-2023 Espressif Systems (Shanghai) CO LTD
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 */
6
7 #include "common/bt_target.h"
8 #include <string.h>
9 #include "esp_err.h"
10 #include "esp_hf_client_api.h"
11 #include "esp_bt_main.h"
12 #include "btc/btc_manage.h"
13 #include "btc_hf_client.h"
14 #include "bta/bta_api.h"
15 #include "bta/bta_hf_client_api.h"
16
17 #if BTC_HF_CLIENT_INCLUDED
esp_hf_client_register_callback(esp_hf_client_cb_t callback)18 esp_err_t esp_hf_client_register_callback(esp_hf_client_cb_t callback)
19 {
20 if (esp_bluedroid_get_status() != ESP_BLUEDROID_STATUS_ENABLED) {
21 return ESP_ERR_INVALID_STATE;
22 }
23
24 if (callback == NULL) {
25 return ESP_FAIL;
26 }
27
28 btc_profile_cb_set(BTC_PID_HF_CLIENT, callback);
29 return ESP_OK;
30 }
31
esp_hf_client_init(void)32 esp_err_t esp_hf_client_init(void)
33 {
34 if (esp_bluedroid_get_status() != ESP_BLUEDROID_STATUS_ENABLED) {
35 return ESP_ERR_INVALID_STATE;
36 }
37
38 btc_msg_t msg;
39
40 msg.sig = BTC_SIG_API_CALL;
41 msg.pid = BTC_PID_HF_CLIENT;
42 msg.act = BTC_HF_CLIENT_INIT_EVT;
43
44 /* Switch to BTC context */
45 bt_status_t stat = btc_transfer_context(&msg, NULL, 0, NULL, NULL);
46 return (stat == BT_STATUS_SUCCESS) ? ESP_OK : ESP_FAIL;
47 }
48
esp_hf_client_deinit(void)49 esp_err_t esp_hf_client_deinit(void)
50 {
51 if (esp_bluedroid_get_status() != ESP_BLUEDROID_STATUS_ENABLED) {
52 return ESP_ERR_INVALID_STATE;
53 }
54
55 btc_msg_t msg;
56
57 msg.sig = BTC_SIG_API_CALL;
58 msg.pid = BTC_PID_HF_CLIENT;
59 msg.act = BTC_HF_CLIENT_DEINIT_EVT;
60
61 /* Switch to BTC context */
62 bt_status_t stat = btc_transfer_context(&msg, NULL, 0, NULL, NULL);
63 return (stat == BT_STATUS_SUCCESS) ? ESP_OK : ESP_FAIL;
64 }
65
esp_hf_client_connect(esp_bd_addr_t remote_bda)66 esp_err_t esp_hf_client_connect(esp_bd_addr_t remote_bda)
67 {
68 if (esp_bluedroid_get_status() != ESP_BLUEDROID_STATUS_ENABLED) {
69 return ESP_ERR_INVALID_STATE;
70 }
71
72 bt_status_t stat;
73 btc_hf_client_args_t arg;
74 btc_msg_t msg;
75
76 msg.sig = BTC_SIG_API_CALL;
77 msg.pid = BTC_PID_HF_CLIENT;
78 msg.act = BTC_HF_CLIENT_CONNECT_EVT;
79
80 memset(&arg, 0, sizeof(btc_hf_client_args_t));
81
82 /* Switch to BTC context */
83 memcpy(&(arg.connect), remote_bda, sizeof(bt_bdaddr_t));
84 stat = btc_transfer_context(&msg, &arg, sizeof(btc_hf_client_args_t), NULL, NULL);
85 return (stat == BT_STATUS_SUCCESS) ? ESP_OK : ESP_FAIL;
86 }
87
esp_hf_client_disconnect(esp_bd_addr_t remote_bda)88 esp_err_t esp_hf_client_disconnect(esp_bd_addr_t remote_bda)
89 {
90 if (esp_bluedroid_get_status() != ESP_BLUEDROID_STATUS_ENABLED) {
91 return ESP_ERR_INVALID_STATE;
92 }
93
94 bt_status_t stat;
95 btc_hf_client_args_t arg;
96 btc_msg_t msg;
97
98 msg.sig = BTC_SIG_API_CALL;
99 msg.pid = BTC_PID_HF_CLIENT;
100 msg.act = BTC_HF_CLIENT_DISCONNECT_EVT;
101
102 memset(&arg, 0, sizeof(btc_hf_client_args_t));
103
104 /* Switch to BTC context */
105 memcpy(&(arg.disconnect), remote_bda, sizeof(bt_bdaddr_t));
106 stat = btc_transfer_context(&msg, &arg, sizeof(btc_hf_client_args_t), NULL, NULL);
107 return (stat == BT_STATUS_SUCCESS) ? ESP_OK : ESP_FAIL;
108 }
109
esp_hf_client_connect_audio(esp_bd_addr_t remote_bda)110 esp_err_t esp_hf_client_connect_audio(esp_bd_addr_t remote_bda)
111 {
112 if (esp_bluedroid_get_status() != ESP_BLUEDROID_STATUS_ENABLED) {
113 return ESP_ERR_INVALID_STATE;
114 }
115
116 bt_status_t stat;
117 btc_hf_client_args_t arg;
118 btc_msg_t msg;
119
120 msg.sig = BTC_SIG_API_CALL;
121 msg.pid = BTC_PID_HF_CLIENT;
122 msg.act = BTC_HF_CLIENT_CONNECT_AUDIO_EVT;
123
124 memset(&arg, 0, sizeof(btc_hf_client_args_t));
125
126 /* Switch to BTC context */
127 memcpy(&(arg.connect_audio), remote_bda, sizeof(bt_bdaddr_t));
128 stat = btc_transfer_context(&msg, &arg, sizeof(btc_hf_client_args_t), NULL, NULL);
129 return (stat == BT_STATUS_SUCCESS) ? ESP_OK : ESP_FAIL;
130 }
131
esp_hf_client_disconnect_audio(esp_bd_addr_t remote_bda)132 esp_err_t esp_hf_client_disconnect_audio(esp_bd_addr_t remote_bda)
133 {
134 if (esp_bluedroid_get_status() != ESP_BLUEDROID_STATUS_ENABLED) {
135 return ESP_ERR_INVALID_STATE;
136 }
137
138 bt_status_t stat;
139 btc_hf_client_args_t arg;
140 btc_msg_t msg;
141
142 msg.sig = BTC_SIG_API_CALL;
143 msg.pid = BTC_PID_HF_CLIENT;
144 msg.act = BTC_HF_CLIENT_DISCONNECT_AUDIO_EVT;
145
146 memset(&arg, 0, sizeof(btc_hf_client_args_t));
147
148 /* Switch to BTC context */
149 memcpy(&(arg.disconnect_audio), remote_bda, sizeof(bt_bdaddr_t));
150 stat = btc_transfer_context(&msg, &arg, sizeof(btc_hf_client_args_t), NULL, NULL);
151 return (stat == BT_STATUS_SUCCESS) ? ESP_OK : ESP_FAIL;
152 }
153
154
esp_hf_client_start_voice_recognition(void)155 esp_err_t esp_hf_client_start_voice_recognition(void)
156 {
157 if (esp_bluedroid_get_status() != ESP_BLUEDROID_STATUS_ENABLED) {
158 return ESP_ERR_INVALID_STATE;
159 }
160
161 btc_msg_t msg;
162
163 msg.sig = BTC_SIG_API_CALL;
164 msg.pid = BTC_PID_HF_CLIENT;
165 msg.act = BTC_HF_CLIENT_START_VOICE_RECOGNITION_EVT;
166
167 /* Switch to BTC context */
168 bt_status_t stat = btc_transfer_context(&msg, NULL, 0, NULL, NULL);
169 return (stat == BT_STATUS_SUCCESS) ? ESP_OK : ESP_FAIL;
170 }
171
esp_hf_client_stop_voice_recognition(void)172 esp_err_t esp_hf_client_stop_voice_recognition(void)
173 {
174 if (esp_bluedroid_get_status() != ESP_BLUEDROID_STATUS_ENABLED) {
175 return ESP_ERR_INVALID_STATE;
176 }
177
178 btc_msg_t msg;
179
180 msg.sig = BTC_SIG_API_CALL;
181 msg.pid = BTC_PID_HF_CLIENT;
182 msg.act = BTC_HF_CLIENT_STOP_VOICE_RECOGNITION_EVT;
183
184 /* Switch to BTC context */
185 bt_status_t stat = btc_transfer_context(&msg, NULL, 0, NULL, NULL);
186 return (stat == BT_STATUS_SUCCESS) ? ESP_OK : ESP_FAIL;
187 }
188
esp_hf_client_volume_update(esp_hf_volume_control_target_t type,int volume)189 esp_err_t esp_hf_client_volume_update(esp_hf_volume_control_target_t type, int volume)
190 {
191 if (esp_bluedroid_get_status() != ESP_BLUEDROID_STATUS_ENABLED) {
192 return ESP_ERR_INVALID_STATE;
193 }
194
195 btc_msg_t msg;
196 btc_hf_client_args_t arg;
197
198 msg.sig = BTC_SIG_API_CALL;
199 msg.pid = BTC_PID_HF_CLIENT;
200 msg.act = BTC_HF_CLIENT_VOLUME_UPDATE_EVT;
201
202 memset(&arg, 0, sizeof(btc_hf_client_args_t));
203 arg.volume_update.type = type;
204 arg.volume_update.volume = volume;
205
206 /* Switch to BTC context */
207 bt_status_t stat = btc_transfer_context(&msg, &arg, sizeof(btc_hf_client_args_t), NULL, NULL);
208 return (stat == BT_STATUS_SUCCESS) ? ESP_OK : ESP_FAIL;
209 }
210
esp_hf_client_dial(const char * number)211 esp_err_t esp_hf_client_dial(const char *number)
212 {
213 if (esp_bluedroid_get_status() != ESP_BLUEDROID_STATUS_ENABLED) {
214 return ESP_ERR_INVALID_STATE;
215 }
216
217 btc_msg_t msg;
218 btc_hf_client_args_t arg;
219
220 if (number != NULL && strlen(number) > ESP_BT_HF_CLIENT_NUMBER_LEN) {
221 return ESP_ERR_INVALID_ARG;
222 }
223
224 msg.sig = BTC_SIG_API_CALL;
225 msg.pid = BTC_PID_HF_CLIENT;
226 msg.act = BTC_HF_CLIENT_DIAL_EVT;
227
228 memset(&arg, 0, sizeof(btc_hf_client_args_t));
229 if (number != NULL) {
230 strcpy(arg.dial.number, number);
231 } else {
232 arg.dial.number[0] = '\0';
233 }
234
235 /* Switch to BTC context */
236 bt_status_t stat = btc_transfer_context(&msg, &arg, sizeof(btc_hf_client_args_t), NULL, NULL);
237 return (stat == BT_STATUS_SUCCESS) ? ESP_OK : ESP_FAIL;
238 }
239
esp_hf_client_dial_memory(int location)240 esp_err_t esp_hf_client_dial_memory(int location)
241 {
242 if (esp_bluedroid_get_status() != ESP_BLUEDROID_STATUS_ENABLED) {
243 return ESP_ERR_INVALID_STATE;
244 }
245
246 btc_msg_t msg;
247 btc_hf_client_args_t arg;
248
249 msg.sig = BTC_SIG_API_CALL;
250 msg.pid = BTC_PID_HF_CLIENT;
251 msg.act = BTC_HF_CLIENT_DIAL_MEMORY_EVT;
252
253 memset(&arg, 0, sizeof(btc_hf_client_args_t));
254 arg.dial_memory.location = location;
255
256 /* Switch to BTC context */
257 bt_status_t stat = btc_transfer_context(&msg, &arg, sizeof(btc_hf_client_args_t), NULL, NULL);
258 return (stat == BT_STATUS_SUCCESS) ? ESP_OK : ESP_FAIL;
259 }
260
esp_hf_client_send_chld_cmd(esp_hf_chld_type_t chld,int idx)261 esp_err_t esp_hf_client_send_chld_cmd(esp_hf_chld_type_t chld, int idx)
262 {
263 if (esp_bluedroid_get_status() != ESP_BLUEDROID_STATUS_ENABLED) {
264 return ESP_ERR_INVALID_STATE;
265 }
266
267 btc_msg_t msg;
268 btc_hf_client_args_t arg;
269
270 msg.sig = BTC_SIG_API_CALL;
271 msg.pid = BTC_PID_HF_CLIENT;
272 msg.act = BTC_HF_CLIENT_SEND_CHLD_CMD_EVT;
273
274 memset(&arg, 0, sizeof(btc_hf_client_args_t));
275 arg.chld.type = chld;
276 arg.chld.idx = idx;
277
278 /* Switch to BTC context */
279 bt_status_t stat = btc_transfer_context(&msg, &arg, sizeof(btc_hf_client_args_t), NULL, NULL);
280 return (stat == BT_STATUS_SUCCESS) ? ESP_OK : ESP_FAIL;
281 }
282
esp_hf_client_send_btrh_cmd(esp_hf_btrh_cmd_t btrh)283 esp_err_t esp_hf_client_send_btrh_cmd(esp_hf_btrh_cmd_t btrh)
284 {
285 if (esp_bluedroid_get_status() != ESP_BLUEDROID_STATUS_ENABLED) {
286 return ESP_ERR_INVALID_STATE;
287 }
288
289 btc_msg_t msg;
290 btc_hf_client_args_t arg;
291
292 msg.sig = BTC_SIG_API_CALL;
293 msg.pid = BTC_PID_HF_CLIENT;
294 msg.act = BTC_HF_CLIENT_SEND_BTRH_CMD_EVT;
295
296 memset(&arg, 0, sizeof(btc_hf_client_args_t));
297 arg.btrh.cmd = btrh;
298
299 /* Switch to BTC context */
300 bt_status_t stat = btc_transfer_context(&msg, &arg, sizeof(btc_hf_client_args_t), NULL, NULL);
301 return (stat == BT_STATUS_SUCCESS) ? ESP_OK : ESP_FAIL;
302 }
303
esp_hf_client_answer_call(void)304 esp_err_t esp_hf_client_answer_call(void)
305 {
306 if (esp_bluedroid_get_status() != ESP_BLUEDROID_STATUS_ENABLED) {
307 return ESP_ERR_INVALID_STATE;
308 }
309
310 btc_msg_t msg;
311
312 msg.sig = BTC_SIG_API_CALL;
313 msg.pid = BTC_PID_HF_CLIENT;
314 msg.act = BTC_HF_CLIENT_ANSWER_CALL_EVT;
315
316 /* Switch to BTC context */
317 bt_status_t stat = btc_transfer_context(&msg, NULL, 0, NULL, NULL);
318 return (stat == BT_STATUS_SUCCESS) ? ESP_OK : ESP_FAIL;
319 }
320
esp_hf_client_reject_call(void)321 esp_err_t esp_hf_client_reject_call(void)
322 {
323 if (esp_bluedroid_get_status() != ESP_BLUEDROID_STATUS_ENABLED) {
324 return ESP_ERR_INVALID_STATE;
325 }
326
327 btc_msg_t msg;
328
329 msg.sig = BTC_SIG_API_CALL;
330 msg.pid = BTC_PID_HF_CLIENT;
331 msg.act = BTC_HF_CLIENT_REJECT_CALL_EVT;
332
333 /* Switch to BTC context */
334 bt_status_t stat = btc_transfer_context(&msg, NULL, 0, NULL, NULL);
335 return (stat == BT_STATUS_SUCCESS) ? ESP_OK : ESP_FAIL;
336 }
337
esp_hf_client_query_current_calls(void)338 esp_err_t esp_hf_client_query_current_calls(void)
339 {
340 if (esp_bluedroid_get_status() != ESP_BLUEDROID_STATUS_ENABLED) {
341 return ESP_ERR_INVALID_STATE;
342 }
343
344 btc_msg_t msg;
345
346 msg.sig = BTC_SIG_API_CALL;
347 msg.pid = BTC_PID_HF_CLIENT;
348 msg.act = BTC_HF_CLIENT_QUERY_CURRENT_CALLS_EVT;
349
350 /* Switch to BTC context */
351 bt_status_t stat = btc_transfer_context(&msg, NULL, 0, NULL, NULL);
352 return (stat == BT_STATUS_SUCCESS) ? ESP_OK : ESP_FAIL;
353 }
354
esp_hf_client_query_current_operator_name(void)355 esp_err_t esp_hf_client_query_current_operator_name(void)
356 {
357 if (esp_bluedroid_get_status() != ESP_BLUEDROID_STATUS_ENABLED) {
358 return ESP_ERR_INVALID_STATE;
359 }
360
361 btc_msg_t msg;
362
363 msg.sig = BTC_SIG_API_CALL;
364 msg.pid = BTC_PID_HF_CLIENT;
365 msg.act = BTC_HF_CLIENT_QUERY_CURRENT_OPERATOR_NAME_EVT;
366
367 /* Switch to BTC context */
368 bt_status_t stat = btc_transfer_context(&msg, NULL, 0, NULL, NULL);
369 return (stat == BT_STATUS_SUCCESS) ? ESP_OK : ESP_FAIL;
370 }
371
esp_hf_client_retrieve_subscriber_info(void)372 esp_err_t esp_hf_client_retrieve_subscriber_info(void)
373 {
374 if (esp_bluedroid_get_status() != ESP_BLUEDROID_STATUS_ENABLED) {
375 return ESP_ERR_INVALID_STATE;
376 }
377
378 btc_msg_t msg;
379
380 msg.sig = BTC_SIG_API_CALL;
381 msg.pid = BTC_PID_HF_CLIENT;
382 msg.act = BTC_HF_CLIENT_RETRIEVE_SUBSCRIBER_INFO_EVT;
383
384 /* Switch to BTC context */
385 bt_status_t stat = btc_transfer_context(&msg, NULL, 0, NULL, NULL);
386 return (stat == BT_STATUS_SUCCESS) ? ESP_OK : ESP_FAIL;
387 }
388
esp_hf_client_send_dtmf(char code)389 esp_err_t esp_hf_client_send_dtmf(char code)
390 {
391 if (esp_bluedroid_get_status() != ESP_BLUEDROID_STATUS_ENABLED) {
392 return ESP_ERR_INVALID_STATE;
393 }
394
395 btc_msg_t msg;
396 btc_hf_client_args_t arg;
397
398 msg.sig = BTC_SIG_API_CALL;
399 msg.pid = BTC_PID_HF_CLIENT;
400 msg.act = BTC_HF_CLIENT_SEND_DTMF_EVT;
401
402 memset(&arg, 0, sizeof(btc_hf_client_args_t));
403 arg.send_dtmf.code = code;
404
405 /* Switch to BTC context */
406 bt_status_t stat = btc_transfer_context(&msg, &arg, sizeof(btc_hf_client_args_t), NULL, NULL);
407 return (stat == BT_STATUS_SUCCESS) ? ESP_OK : ESP_FAIL;
408 }
409
esp_hf_client_send_xapl(char * information,uint32_t features)410 esp_err_t esp_hf_client_send_xapl(char *information, uint32_t features)
411 {
412 if (esp_bluedroid_get_status() != ESP_BLUEDROID_STATUS_ENABLED) {
413 return ESP_ERR_INVALID_STATE;
414 }
415
416 if (information == NULL || strlen(information) != ESP_BT_HF_AT_SEND_XAPL_LEN) {
417 return ESP_ERR_INVALID_ARG;
418 }
419
420 btc_msg_t msg;
421 btc_hf_client_args_t arg;
422
423 msg.sig = BTC_SIG_API_CALL;
424 msg.pid = BTC_PID_HF_CLIENT;
425 msg.act = BTC_HF_CLIENT_SEND_XAPL_EVT;
426
427 memset(&arg, 0, sizeof(btc_hf_client_args_t));
428 strcpy(arg.send_xapl.information, information);
429 arg.send_xapl.features = features;
430
431 /* Switch to BTC context */
432 bt_status_t stat = btc_transfer_context(&msg, &arg, sizeof(btc_hf_client_args_t), NULL, NULL);
433 return (stat == BT_STATUS_SUCCESS) ? ESP_OK : ESP_FAIL;
434 }
435
esp_hf_client_send_iphoneaccev(uint32_t bat_level,bool docked)436 esp_err_t esp_hf_client_send_iphoneaccev(uint32_t bat_level, bool docked)
437 {
438 if (esp_bluedroid_get_status() != ESP_BLUEDROID_STATUS_ENABLED) {
439 return ESP_ERR_INVALID_STATE;
440 }
441
442 if (bat_level > 9) {
443 return ESP_ERR_INVALID_ARG;
444 }
445
446 btc_msg_t msg;
447 btc_hf_client_args_t arg;
448
449 msg.sig = BTC_SIG_API_CALL;
450 msg.pid = BTC_PID_HF_CLIENT;
451 msg.act = BTC_HF_CLIENT_SEND_IPHONEACCEV_EVT;
452
453 memset(&arg, 0, sizeof(btc_hf_client_args_t));
454 arg.send_iphoneaccev.bat_level = bat_level;
455 arg.send_iphoneaccev.docked = docked;
456
457 /* Switch to BTC context */
458 bt_status_t stat = btc_transfer_context(&msg, &arg, sizeof(btc_hf_client_args_t), NULL, NULL);
459 return (stat == BT_STATUS_SUCCESS) ? ESP_OK : ESP_FAIL;
460 }
461
462
esp_hf_client_request_last_voice_tag_number(void)463 esp_err_t esp_hf_client_request_last_voice_tag_number(void)
464 {
465 if (esp_bluedroid_get_status() != ESP_BLUEDROID_STATUS_ENABLED) {
466 return ESP_ERR_INVALID_STATE;
467 }
468
469 btc_msg_t msg;
470
471 msg.sig = BTC_SIG_API_CALL;
472 msg.pid = BTC_PID_HF_CLIENT;
473 msg.act = BTC_HF_CLIENT_REQUEST_LAST_VOICE_TAG_NUMBER_EVT;
474
475 /* Switch to BTC context */
476 bt_status_t stat = btc_transfer_context(&msg, NULL, 0, NULL, NULL);
477 return (stat == BT_STATUS_SUCCESS) ? ESP_OK : ESP_FAIL;
478 }
479
esp_hf_client_send_nrec(void)480 esp_err_t esp_hf_client_send_nrec(void)
481 {
482 if (esp_bluedroid_get_status() != ESP_BLUEDROID_STATUS_ENABLED) {
483 return ESP_ERR_INVALID_STATE;
484 }
485
486 btc_msg_t msg;
487 msg.sig = BTC_SIG_API_CALL;
488 msg.pid = BTC_PID_HF_CLIENT;
489 msg.act = BTC_HF_CLIENT_SEND_NREC_EVT;
490
491 /* Switch to BTC context */
492 bt_status_t stat = btc_transfer_context(&msg, NULL, 0, NULL, NULL);
493 return (stat == BT_STATUS_SUCCESS) ? ESP_OK : ESP_FAIL;
494 }
495
esp_hf_client_register_data_callback(esp_hf_client_incoming_data_cb_t recv,esp_hf_client_outgoing_data_cb_t send)496 esp_err_t esp_hf_client_register_data_callback(esp_hf_client_incoming_data_cb_t recv,
497 esp_hf_client_outgoing_data_cb_t send)
498 {
499 if (esp_bluedroid_get_status() != ESP_BLUEDROID_STATUS_ENABLED) {
500 return ESP_ERR_INVALID_STATE;
501 }
502
503 btc_msg_t msg;
504 msg.sig = BTC_SIG_API_CALL;
505 msg.pid = BTC_PID_HF_CLIENT;
506 msg.act = BTC_HF_CLIENT_REGISTER_DATA_CALLBACK_EVT;
507
508 btc_hf_client_args_t arg;
509 memset(&arg, 0, sizeof(btc_hf_client_args_t));
510 arg.reg_data_cb.recv = recv;
511 arg.reg_data_cb.send = send;
512
513 /* Switch to BTC context */
514 bt_status_t stat = btc_transfer_context(&msg, &arg, sizeof(btc_hf_client_args_t), NULL, NULL);
515 return (stat == BT_STATUS_SUCCESS) ? ESP_OK : ESP_FAIL;
516 }
517
518 #if (BTM_SCO_HCI_INCLUDED == TRUE)
esp_hf_client_pkt_stat_nums_get(uint16_t sync_conn_handle)519 esp_err_t esp_hf_client_pkt_stat_nums_get(uint16_t sync_conn_handle)
520 {
521 if (esp_bluedroid_get_status() != ESP_BLUEDROID_STATUS_ENABLED) {
522 return ESP_ERR_INVALID_STATE;
523 }
524
525 btc_msg_t msg;
526 msg.sig = BTC_SIG_API_CALL;
527 msg.pid = BTC_PID_HF_CLIENT;
528 msg.act = BTC_HF_CLIENT_REQUEST_PKT_STAT_EVT;
529
530 btc_hf_client_args_t arg;
531 memset(&arg, 0, sizeof(btc_hf_client_args_t));
532 arg.pkt_sync_hd.sync_conn_handle = sync_conn_handle;
533
534 /* Switch to BTC context */
535 bt_status_t stat = btc_transfer_context(&msg, &arg, sizeof(btc_hf_client_args_t), NULL, NULL);
536 return (stat == BT_STATUS_SUCCESS) ? ESP_OK : ESP_FAIL;
537 }
538
esp_hf_client_outgoing_data_ready(void)539 void esp_hf_client_outgoing_data_ready(void)
540 {
541 BTA_HfClientCiData();
542 }
543
esp_hf_client_pcm_resample_init(uint32_t src_sps,uint32_t bits,uint32_t channels)544 void esp_hf_client_pcm_resample_init(uint32_t src_sps, uint32_t bits, uint32_t channels)
545 {
546 BTA_DmPcmInitSamples(src_sps, bits, channels);
547 }
548
esp_hf_client_pcm_resample_deinit(void)549 void esp_hf_client_pcm_resample_deinit(void)
550 {
551 BTA_DmPcmDeinitSamples();
552 }
553
esp_hf_client_pcm_resample(void * src,uint32_t in_bytes,void * dst)554 int32_t esp_hf_client_pcm_resample(void *src, uint32_t in_bytes, void *dst)
555 {
556 return BTA_DmPcmResample(src, in_bytes, dst);
557 }
558
559 #endif /* #if (BTM_SCO_HCI_INCLUDED == TRUE) */
560
561 #endif /* BTC_HF_CLIENT_INCLUDED */
562
