1 /*
2 * Copyright (c) 2021 Chipsea Technologies (Shenzhen) Corp., Ltd. All rights reserved.
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 /*chipsea_ohos proguard begin*/
16 #include "cs_proguard.h"
17 /*chipsea_ohos proguard end*/
18 #include "cs_target_config.h"
19 #if APP_SUPPORT_HFP == 1
20 #include "cs_adp_api.h"
21 #include "al_rtos.h"
22 #include "app_bt.h"
23 #include "app_hfp.h"
24 #include "app_a2dp.h"
25 #if APP_SUPPORT_TWS == 1
26 #include "app_tws.h"
27 #endif
28 #include "bt_task_msg.h"
29 #include "driver_pub.h"
30
31 #define CFG_CUR_TIME_INFORMER 0
32 #if CFG_CUR_TIME_INFORMER
33 #include "uart1_api.h"
34 #endif
35
36 /* hfp */
37 app_hfp_state_t s_hfp_state = APP_IDLE;
38 uint16_t s_hfp_scocodec = MEDIA_SCO_CODEC_NONE;
39 TimerHandle_t app_hfp_cclk_check_timer_handle = NULL;
40 int at_cclk_acked = 0;
41
42 #if SCO_LOOPBACK_TEST == 1
43 ScoSendData_t tmpdata;
44 #else
45 HF_SENDBUFF_T hf_sendbuff;
46 #endif
47
app_hfp_cclk_check_timer(TimerHandle_t xTimer)48 void app_hfp_cclk_check_timer( TimerHandle_t xTimer )
49 {
50 if (!at_cclk_acked) {
51 TRACE("APP:cclk_check is error\n");
52 } else {
53 uint32_t tv_sec, tv_usec;
54 struct tm tim_st;
55 char buffer[48] = {0,};
56 cs_time_get(SINCE_EPOCH, &tv_sec, &tv_usec);
57 gmtime_offset_r((const time_t *)&tv_sec, &tim_st, 8);
58 dbg_snprintf(buffer, sizeof(buffer), "BJ TIME: %d-%02d-%02d %02d:%02d:%02d\r\n",
59 tim_st.tm_year + YEAR0,tim_st.tm_mon,tim_st.tm_mday,tim_st.tm_hour,tim_st.tm_min,tim_st.tm_sec);
60 uart_puts(buffer);
61 #if CFG_CUR_TIME_INFORMER
62 uart1_puts(buffer);
63 #endif
64 }
65 #if CFG_CUR_TIME_INFORMER
66 rtos_timer_start(app_hfp_cclk_check_timer_handle, 0, false);
67 #endif
68 }
69
app_hfp_send_at_cclk(BT_ADDR bdaddr)70 int app_hfp_send_at_cclk(BT_ADDR bdaddr)
71 {
72 cs_adp_hfp_send_at_cclk(bdaddr);
73 if(app_hfp_cclk_check_timer_handle == NULL)
74 app_hfp_cclk_check_timer_handle = rtos_timer_create("cclk ckeck timer",1000,pdFALSE,\
75 NULL,app_hfp_cclk_check_timer);
76 rtos_timer_start(app_hfp_cclk_check_timer_handle, 0, false);
77 return 0;
78 }
79
app_hfp_siri_report(BT_ADDR bdaddr)80 int app_hfp_siri_report(BT_ADDR bdaddr)
81 {
82 cs_adp_hfp_send_siri_report(bdaddr);
83 return 0;
84 }
85
app_hfp_siri_voiceRecognition(BT_ADDR bdaddr)86 int app_hfp_siri_voiceRecognition(BT_ADDR bdaddr)
87 {
88 cs_adp_hfp_send_voice_recognition(bdaddr, 1);
89 return 0;
90 }
91
app_get_hfp_state(void)92 app_hfp_state_t app_get_hfp_state(void)
93 {
94 return s_hfp_state;
95 }
96
97
app_set_hfp_state(app_hfp_state_t state)98 void app_set_hfp_state(app_hfp_state_t state)
99 {
100 if((state == APP_CALL_ACTIVE && s_hfp_state == APP_PLAY_SCO)
101 ||(state == APP_CALL_OUTGOING && s_hfp_state == APP_PLAY_SCO)){
102 state = APP_PLAY_SCO;
103 }
104 TRACE("APP:set hfp state = %d\n",state);
105 s_hfp_state = state;
106 }
107
app_get_hfp_scocodec(void)108 uint16_t app_get_hfp_scocodec(void)
109 {
110 return s_hfp_scocodec;
111 }
112
113
app_set_hfp_scocodec(uint16_t scocodec)114 void app_set_hfp_scocodec(uint16_t scocodec)
115 {
116 TRACE("APP:set hfp scocodec = %d\n",scocodec);
117 s_hfp_scocodec = scocodec;
118 }
119
app_set_hfp_volume(BT_ADDR * bdaddr,S8 volume)120 void app_set_hfp_volume(BT_ADDR *bdaddr,S8 volume)
121 {
122 APP_DEVLIST *tmp = NULL;
123 tmp = app_bt_get_mgr_devinfo(*bdaddr);
124
125 btdev_info* dev_info = cs_adp_get_devinfo_by_addr(bdaddr);
126 if(tmp && dev_info){
127 tmp->peer_volume_hfp = dev_info->peer_hfp_vol = volume;
128 }
129 }
130
app_get_hfp_volume(BT_ADDR * bdaddr)131 S8 app_get_hfp_volume(BT_ADDR *bdaddr)
132 {
133 U8 volume = 15;
134 btdev_info* dev_info = cs_adp_get_devinfo_by_addr(bdaddr);
135 if(dev_info){
136 if(dev_info->peer_hfp_vol == 0){
137 volume = 15;
138 }else{
139 if(dev_info->peer_hfp_vol > 0 && dev_info->peer_hfp_vol <= 15){
140 volume = dev_info->peer_hfp_vol;
141 }else{
142 volume = dev_info->peer_hfp_vol = 15;
143 }
144 }
145 }
146 TRACE("APP:app_get_hfp_volume %d\n",volume);
147 return volume;
148 }
149
app_hfp_stop(void)150 void app_hfp_stop(void)
151 {
152 TRACE("APP:app_hfp_stop.\n");
153 if(app_get_hfp_state()== APP_PLAY_SCO)
154 app_media_play(AUD_BT_SCO ,MC_STOP,0,true);
155 app_set_hfp_state(APP_CONNECTED);
156 }
157
app_hfp_play(BT_ADDR bdaddr)158 void app_hfp_play(BT_ADDR bdaddr)
159 {
160 uint16_t scohandle = 0;
161 uint16_t negotiated_codec = 0;
162 MediaCommonStruct tmp;
163 TRACE("APP:app_hfp_play.\n");
164
165 memset((U8*)&tmp, 0, sizeof(MediaCommonStruct));
166 scohandle = cs_adp_hfp_get_scohandle_by_addr(bdaddr);
167 if(scohandle){
168 app_set_hfp_state(APP_PLAY_SCO);
169 negotiated_codec = cs_adp_hfp_get_negotiated_codec_by_addr(bdaddr);
170 switch (negotiated_codec)
171 {
172 case MEDIA_SCO_CODEC_CVSD:
173 tmp.p.voc_ctrl.scocodec = MEDIA_SCO_CODEC_CVSD;
174 break;
175 case MEDIA_SCO_CODEC_MSBC:
176 tmp.p.voc_ctrl.scocodec = MEDIA_SCO_CODEC_MSBC;
177 break;
178 default:
179 tmp.p.voc_ctrl.scocodec = MEDIA_SCO_CODEC_CVSD;
180 break;
181 }
182 #if APP_SUPPORT_TWS == 1
183 if(tws_app_get_role() == TWS_MASTER)
184 app_media_play(AUD_BT_SCO ,MC_OPEN,&tmp,false);
185 else{
186 app_media_play(AUD_BT_SCO ,MC_PLAY,&tmp,true);
187 }
188 #else
189 {
190 app_media_play(AUD_BT_SCO ,MC_PLAY,&tmp,true);
191 }
192 #endif
193 }
194 }
195
app_handle_hfp_connect_status(CS_EVENT * event)196 void app_handle_hfp_connect_status(CS_EVENT *event)
197 {
198 CS_ADP_HFP_EVENT *cs_hfp_msg = (CS_ADP_HFP_EVENT *)event->Param;
199 app_connect_manager * app_bt_con = NULL;
200
201 app_bt_con = app_bt_get_con_ptr_by_addr(&cs_hfp_msg->bdaddr);
202 if(!app_bt_con ){
203 app_bt_con = app_bt_get_unused_con_ptr();
204 if(!app_bt_con){
205 TRACE("APP:app hfp get con ptr error\n");
206 ASSERT_ERR(0);
207 }
208 memcpy(app_bt_con->remotedev_addr.addr,cs_hfp_msg->bdaddr.addr, BD_ADDR_SIZE);
209 }
210
211 if(app_bt_con->reconnect.connect_timer_handle){
212 #if PLF_AON_SUPPORT
213 co_timer_stop(app_bt_con->reconnect.connect_timer_handle);
214 #else
215 rtos_timer_stop(app_bt_con->reconnect.connect_timer_handle,0);
216 #endif
217 app_bt_con->reconnect.connect_timer_cb = NULL;
218 }
219
220 switch(event->EventId){
221 case CS_ADP_HFP_CONNECTED:
222 {
223 btdev_info* dev_info = cs_adp_get_devinfo_by_addr(&cs_hfp_msg->bdaddr);
224
225 if(cs_hfp_msg->p.conP.reason){
226 return;
227 }
228 if(dev_info){
229 dev_info->hf_state = 1;
230 }
231 app_bt_con->profile.hfp_connect = CONNECTED;
232 memcpy(app_bt_con->remotedev_addr.addr, cs_hfp_msg->bdaddr.addr, BD_ADDR_SIZE);
233 app_bt_con->reconnect.connect_retry_cnt = 0;
234
235 switch(app_bt_con->reconnect.reconnect_mode){
236 case RECONNECT_POWERON:
237 if(app_bt_con->profile.a2dp_connect != CONNECTED){
238 app_bt_connect_a2dp(&app_bt_con->remotedev_addr);
239 }
240 break;
241 case RECONNECT_AFTER_DISC:
242 if(app_bt_con->profile.a2dp_connect != CONNECTED){
243 app_bt_connect_a2dp(&app_bt_con->remotedev_addr);
244 }
245 break;
246 default:
247 app_bt_con->reconnect.reconnect_mode = RECONNECT_IDLE;
248 break;
249 }
250 }
251 break;
252 case CS_ADP_HFP_DISCONNECTED:
253 {
254 app_bt_con->profile.hfp_connect = DISCONNECTED;
255
256 switch(app_bt_con->reconnect.reconnect_mode){
257 case RECONNECT_POWERON:
258 app_bt_con->reconnect.reconnect_mode = RECONNECT_IDLE;
259 break;
260 case RECONNECT_AFTER_DISC:
261 if(app_bt_con->reconnect.connect_retry_cnt < APP_RECONNECT_NUM){
262 #if PLF_AON_SUPPORT
263 app_bt_start_reconnect(&app_bt_con->reconnect.connect_timer_handle,app_bt_con->reconnect.cb_param
264 ,APP_RECONNECT_INCREASE_TIME*app_bt_con->reconnect.connect_retry_cnt + APP_RECONNECT_TIME);
265 #else
266 app_bt_start_reconnect(app_bt_con->reconnect.connect_timer_handle
267 ,APP_RECONNECT_INCREASE_TIME*app_bt_con->reconnect.connect_retry_cnt + APP_RECONNECT_TIME);
268 #endif
269 app_bt_con->reconnect.connect_retry_cnt++;
270 }else{
271 app_bt_con->reconnect.reconnect_mode = RECONNECT_IDLE;
272 #if APP_SUPPORT_TWS == 1
273 app_tws_power_down();
274 #endif
275 }
276 break;
277 default:
278 #if APP_SUPPORT_HFG == 1
279 if(cs_hfp_msg->p.discP.reason == BT_CONNECTION_TIMEOUT){
280 app_bt_con->profile.hfp_connect = CONNECT_IDLE;
281 break;
282 }
283 #endif
284 if(cs_hfp_msg->p.discP.reason == BT_CONNECTION_TIMEOUT){
285 app_bt_con->reconnect.reconnect_mode = RECONNECT_AFTER_DISC;
286 TRACE("APP:hfp start reconnect\n");
287 #if PLF_AON_SUPPORT
288 app_bt_start_reconnect(&app_bt_con->reconnect.connect_timer_handle,app_bt_con->reconnect.cb_param,APP_RECONNECT_TIME);
289 #else
290 app_bt_start_reconnect(app_bt_con->reconnect.connect_timer_handle ,APP_RECONNECT_TIME);
291 #endif
292 }else{
293 app_bt_con->profile.hfp_connect = CONNECT_IDLE;
294 }
295
296 break;
297 }
298
299 }
300 break;
301 default:
302 break;
303 }
304 app_bt_report_connect_internal_audio(app_bt_con);
305 }
306
307
308
app_hfp_state_machine(CS_EVENT * event)309 void app_hfp_state_machine(CS_EVENT *event)
310 {
311 CS_ADP_HFP_EVENT *cs_hfp_msg = (CS_ADP_HFP_EVENT *)event->Param;
312 switch(event->EventId)
313 {
314 case CS_ADP_HFP_CONNECTED:
315 if(app_get_hfp_state() == APP_IDLE)
316 {
317 app_set_hfp_state(APP_CONNECTED);
318 }
319 break;
320 case CS_ADP_HFP_DISCONNECTED:
321 {
322 app_set_hfp_state(APP_IDLE);
323 app_set_hfp_scocodec(MEDIA_SCO_CODEC_NONE);
324 }
325 break;
326 case CS_ADP_HFP_AUDIO_CONNECTED:
327 {
328 uint16_t scohandle = 0;
329 uint16_t negotiated_codec = 0;
330
331 scohandle = cs_adp_hfp_get_scohandle_by_addr(cs_hfp_msg->bdaddr);
332 if(scohandle){
333 negotiated_codec = cs_adp_hfp_get_negotiated_codec_by_addr(cs_hfp_msg->bdaddr);
334 switch (negotiated_codec)
335 {
336 case MEDIA_SCO_CODEC_CVSD:
337 app_set_hfp_scocodec(MEDIA_SCO_CODEC_CVSD);
338 break;
339 case MEDIA_SCO_CODEC_MSBC:
340 app_set_hfp_scocodec(MEDIA_SCO_CODEC_MSBC);
341 break;
342 default:
343 app_set_hfp_scocodec(MEDIA_SCO_CODEC_CVSD);
344 break;
345 }
346 }
347 }
348 break;
349 case CS_ADP_HFP_AUDIO_DISCONNECTED:
350 {
351 app_set_hfp_scocodec(MEDIA_SCO_CODEC_NONE);
352 }
353 break;
354 case CS_ADP_HFP_CALL_STATUS_IND:
355 {
356 bt_hfp_adp_call_status call_state = cs_hfp_msg->p.callP.callS;
357 if(call_state == BT_CALL_STATUS_ACTIVE){
358 app_set_hfp_state(APP_CALL_ACTIVE);
359 }else{
360 //app_set_hfp_state(APP_CONNECTED);
361 }
362 }
363 break;
364 case CS_ADP_HFP_CALLSETUP_STATUS_IND:
365 {
366 bt_hfp_adp_call_status call_state = cs_hfp_msg->p.callsetupP.callS;
367 switch(call_state){
368 case BT_CALL_STATUS_INCOMING:
369 app_set_hfp_state(APP_CALL_INCOMING);
370 break;
371 case BT_CALL_STATUS_OUTGOING:
372 case BT_CALL_STATUS_ALERT:
373 app_set_hfp_state(APP_CALL_OUTGOING);
374 break;
375 case BT_CALL_STATUS_NONE:
376 break;
377 default:
378 break;
379 }
380 }
381 break;
382 case CS_ADP_HFP_CALLHOLD_STATUS_IND:
383 {
384 bt_hfp_adp_callhold_status hfp_call_hold = cs_hfp_msg->p.callholdP.callholdS;
385 TRACE("APP:hfp_call_hold = %d\n",hfp_call_hold);
386 }
387 break;
388
389 default:
390 break;
391 }
392 }
393
app_hfp_key_handle(uint32_t key)394 BOOL app_hfp_key_handle(uint32_t key)
395 {
396 BOOL ret = FALSE;
397 APP_DEVLIST * hfp_devinfo = NULL;
398
399 hfp_devinfo = cs_adp_get_hfp_current_devinfo();
400 if(hfp_devinfo == NULL){
401 return ret;
402 }
403
404 switch(key){
405 case APP_KEY_PLAY|APP_KEY_PRESS:
406 {
407 TRACE("APP:hfp state %d ,call status %d\n",hfp_devinfo->hfp_state,hfp_devinfo->hfp_call_status);
408 if(hfp_devinfo->hfp_state == HFP_ADP_STATE_CONNECTED){
409 if(hfp_devinfo->hfp_call_status == BT_CALL_STATUS_ACTIVE ||
410 hfp_devinfo->hfp_call_status == BT_CALL_STATUS_OUTGOING ||
411 hfp_devinfo->hfp_call_status == BT_CALL_STATUS_ALERT ||
412 cs_adp_hfp_get_voicerecognition_state(hfp_devinfo->bdaddr)){
413 cs_adp_hfp_call_release(hfp_devinfo->bdaddr);
414 ret = TRUE;
415 }else if(hfp_devinfo->hfp_call_status == BT_CALL_STATUS_INCOMING){
416 cs_adp_hfp_call_answer(hfp_devinfo->bdaddr);
417 ret = TRUE;
418 }
419 }
420 }
421 break;
422 case APP_KEY_VOLADD|APP_KEY_PRESS:
423 case APP_KEY_VOLADD|APP_KEY_HOLD:
424 case APP_KEY_VOLSUB|APP_KEY_PRESS:
425 case APP_KEY_VOLSUB|APP_KEY_HOLD:
426 TRACE("APP:hfp state %d ,call status %d\n",hfp_devinfo->hfp_state,hfp_devinfo->hfp_call_status);
427 if(hfp_devinfo->hfp_call_status != BT_CALL_STATUS_NONE){
428 cs_adp_hfp_send_volume(hfp_devinfo->bdaddr ,app_get_hfp_volume(&hfp_devinfo->bdaddr));
429 ret = TRUE;
430 }
431 break;
432 case APP_KEY_PLAY|APP_KEY_DOUBLE_CLICK:
433 if(hfp_devinfo->hfp_call_status == BT_CALL_STATUS_INCOMING)
434 {
435 cs_adp_hfp_call_release(hfp_devinfo->bdaddr);
436 ret = TRUE;
437 }
438 else if(hfp_devinfo->hfp_call_status == BT_CALL_STATUS_NONE)
439 {
440 cs_adp_hfp_call_redial(hfp_devinfo->bdaddr);
441 ret = TRUE;
442 }
443 break;
444 case APP_KEY_PLAY|APP_KEY_HOLD:
445 if(hfp_devinfo->hfp_call_status == BT_CALL_STATUS_INCOMING)
446 {
447 cs_adp_hfp_call_release(hfp_devinfo->bdaddr);
448 ret = TRUE;
449 }
450 else if(hfp_devinfo->hfp_call_status == BT_CALL_STATUS_NONE)
451 {
452 app_hfp_siri_voiceRecognition(hfp_devinfo->bdaddr);
453 ret = TRUE;
454 }
455 break;
456 default:
457 break;
458 }
459 return ret;
460 }
461
app_hfp_msg_handle(CS_EVENT * event)462 void app_hfp_msg_handle(CS_EVENT *event)
463 {
464 CS_ADP_HFP_EVENT *cs_hfp_msg = (CS_ADP_HFP_EVENT *)event->Param;
465 app_hfp_state_machine(event);
466
467 switch(event->EventId)
468 {
469 case CS_ADP_HFP_CONNECTED:
470 TRACE("APP:app_hfp_connect , result = %d\n",cs_hfp_msg->p.conP.reason);
471
472 if(cs_hfp_msg->p.conP.reason == BT_NO_ERROR){
473 if(cs_hfp_msg->role == HANDSFREE){
474 #if APP_SUPPORT_NREC_OFF == 1
475 cs_adp_hfp_disable_NREC(cs_hfp_msg->bdaddr);
476 #endif
477 cs_adp_hfp_set_battery_level(7);
478 cs_adp_hfp_send_volume(cs_hfp_msg->bdaddr ,app_get_hfp_volume(&cs_hfp_msg->bdaddr));
479 app_hfp_siri_report(cs_hfp_msg->bdaddr);
480 app_hfp_send_at_cclk(cs_hfp_msg->bdaddr);
481 }else{
482 #if APP_SUPPORT_HFG && PLF_USB_BT
483 usb_bt_msg_queue_write(USB_BT_CONNECTED,0,0);
484 #endif
485 }
486 }
487 app_bt_handler_register(HANDLER_REG_3,cs_adp_hfp_battery_report_proc);
488 app_handle_hfp_connect_status(event);
489 break;
490 case CS_ADP_HFP_DISCONNECTED:
491 {
492 uint8_t discReason = (uint8_t)cs_hfp_msg->p.discP.reason;
493 TRACE("APP:app_hfp_disconnect , reason = %d\n",discReason);
494
495 if(cs_hfp_msg->role == HANDSFREE){
496 app_hfp_stop();
497 }else{
498 #if APP_SUPPORT_HFG && PLF_USB_BT
499 usb_bt_msg_queue_write(USB_BT_DISCONNECTED,0,0);
500 #endif
501 }
502 app_bt_handler_register(HANDLER_REG_3,NULL);
503 app_handle_hfp_connect_status(event);
504 }
505 break;
506 case CS_ADP_HFP_AUDIO_CONNECTED:
507 TRACE("APP:hfp_sco_connect\n");
508 #if defined(HFP_1_6_ENABLE)
509 TRACE("APP:hfp_codec_type = %d\n",cs_hfp_msg->p.scoP.negotiated_codec);
510 #endif
511 #if PLF_USB_BT == 0
512 if(cs_hfp_msg->role == HANDSFREE){
513 cs_adp_hfp_send_volume(cs_hfp_msg->bdaddr ,app_get_hfp_volume(&cs_hfp_msg->bdaddr));
514 }
515 if(cs_hfp_msg->p.scoP.reason == BT_NO_ERROR)
516 app_hfp_play(cs_hfp_msg->bdaddr);
517 #endif
518 break;
519 case CS_ADP_HFP_AUDIO_DISCONNECTED:
520 #if PLF_USB_BT == 0
521 app_hfp_stop();
522 #endif
523 break;
524 case CS_ADP_HFP_AUDIO_DATA_SENT:
525
526 break;
527 case CS_ADP_HFP_AUDIO_DATA_IND:
528 {
529 CS_ADP_HFP_AUDIO_DATA *audiodata = (CS_ADP_HFP_AUDIO_DATA *)cs_hfp_msg->p.dataindP.buff;
530 CS_ADP_HFP_AUDIO_DATA sendaudiodata;
531
532 //TRACE("APP:sco data ind data = 0x%x ,len = %d\n",audiodata->data,audiodata->len);
533 #if PLF_USB_BT
534 usb_bt_dongle_data_recv(audiodata->data ,audiodata->len);
535 uint32_t idx = hf_sendbuff.idx % HF_SENDBUFF_MEMPOOL_NUM;
536 usb_bt_dongle_data_send(&hf_sendbuff.mempool[idx].buffer[0], audiodata->len);
537 hf_sendbuff.mempool[idx].len = audiodata->len;
538 sendaudiodata.data = hf_sendbuff.mempool[idx].buffer;
539 sendaudiodata.len = hf_sendbuff.mempool[idx].len;
540 //TRACE("APP:sco send data = 0x%x ,len = %d\n",sendaudiodata.data,sendaudiodata.len);
541 if(sendaudiodata.len)
542 cs_adp_hfp_send_sco_data(cs_hfp_msg->bdaddr,&sendaudiodata);
543 hf_sendbuff.idx++;
544 #else
545 AppReceive_ScoData(audiodata->data ,audiodata->len);
546 #if SCO_LOOPBACK_TEST == 1
547 memcpy(tmpdata.buffer, audiodata->data ,audiodata->len);
548 tmpdata.len = audiodata->len;
549 sendaudiodata.data = tmpdata.buffer;
550 sendaudiodata.len = tmpdata.len;
551 TRACE("APP:sco send data = 0x%x ,len = %d\n",sendaudiodata.data,sendaudiodata.len);
552 if(sendaudiodata.len)
553 cs_adp_hfp_send_sco_data(cs_hfp_msg->bdaddr,&sendaudiodata);
554 #else
555 uint32_t idx = hf_sendbuff.idx % HF_SENDBUFF_MEMPOOL_NUM;
556 AppPrepareSend_ScoData(&hf_sendbuff.mempool[idx].buffer[0], audiodata->len);
557 hf_sendbuff.mempool[idx].len = audiodata->len;
558 sendaudiodata.data = hf_sendbuff.mempool[idx].buffer;
559 sendaudiodata.len = hf_sendbuff.mempool[idx].len;
560 //TRACE("APP:sco send data = 0x%x ,len = %d\n",sendaudiodata.data,sendaudiodata.len);
561 if(sendaudiodata.len)
562 cs_adp_hfp_send_sco_data(cs_hfp_msg->bdaddr,&sendaudiodata);
563 hf_sendbuff.idx++;
564 #endif
565 #endif
566 }
567 break;
568 case CS_ADP_HFP_CALL_STATUS_IND:
569 {
570 bt_hfp_adp_call_status call_state = cs_hfp_msg->p.callP.callS;
571 if(call_state == BT_CALL_STATUS_ACTIVE){
572 //stop playing internal audio of (ring and phone call number),and then start sco playing
573 }
574 }
575 break;
576 case CS_ADP_HFP_CALLSETUP_STATUS_IND:
577 {
578 bt_hfp_adp_call_status call_state = cs_hfp_msg->p.callsetupP.callS;
579 TRACE("APP:call_setup_state = %d\n",call_state);
580 }
581 break;
582 case CS_ADP_HFP_CALLHOLD_STATUS_IND:
583 {
584 bt_hfp_adp_callhold_status hfp_call_hold = cs_hfp_msg->p.callholdP.callholdS;
585 TRACE("APP:hfp_call_hold = %d\n",hfp_call_hold);
586 }
587 break;
588 case CS_ADP_HFP_RING_IND:
589
590 break;
591 case CS_ADP_HFP_SIRI_STATUS:
592 TRACE("APP: siri status = %d\n",cs_hfp_msg->p.siriP.siriS);
593 break;
594 case CS_ADP_HFP_CURRENT_CALL_NUM:
595
596 break;
597 case CS_ADP_HFP_SPEAKER_VOLUME:
598 {
599 U8 volume = (U8)cs_hfp_msg->p.volP.volume;
600 TRACE("APP:HFP_SPEAKER_VOLUME = %d\n",volume);
601 app_set_hfp_volume(&cs_hfp_msg->bdaddr,volume);
602 #if APP_SUPPORT_TWS == 0
603 app_bt_local_volume_handle(1,app_get_hfp_volume(&cs_hfp_msg->bdaddr));
604 #endif
605 }
606 break;
607 case CS_ADP_HFP_COMMON_AT_RESULT_IND:
608 {
609 U8 *at_resualt_string = (U8 *)cs_hfp_msg->p.atP.at_result;
610 // example: +CCLK:"21/01/12, 11:59:13"
611 struct tm timer = {0,};
612 time_t gmt;
613 timer.tm_year = 2000 + (at_resualt_string[7] - '0') * 10 + (at_resualt_string[8] - '0') - YEAR0;
614 timer.tm_mon = (at_resualt_string[10] - '0') * 10 + (at_resualt_string[11] - '0');
615 timer.tm_mday = (at_resualt_string[13] - '0') * 10 + (at_resualt_string[14] - '0');
616 timer.tm_hour = (at_resualt_string[17] - '0') * 10 + (at_resualt_string[18] - '0');
617 timer.tm_min = (at_resualt_string[20] - '0') * 10 + (at_resualt_string[21] - '0');
618 timer.tm_sec = (at_resualt_string[23] - '0') * 10 + (at_resualt_string[24] - '0');
619 gmt = mk_gmtime_offset_r(&timer, 8);
620 cs_time_update((uint32_t)gmt, 0);
621 TRACE("APP:at result = %s\n",at_resualt_string);
622 TRACE("APP:time = %d-%02d-%02d %02d:%02d:%02d %d\n",timer.tm_year+YEAR0,timer.tm_mon,timer.tm_mday,
623 timer.tm_hour,timer.tm_min,timer.tm_sec,(uint32_t)gmt);
624 at_cclk_acked = 1;
625 }
626 default:
627 break;
628 }
629 }
630
631
632
633
634 #endif
635