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 #ifdef CFG_BT_STACK
16 #ifndef CFG_BLE_ONLY
17 /*chipsea_ohos proguard begin*/
18 #include "cs_proguard.h"
19 /*chipsea_ohos proguard end*/
20 #include "cs_adp_api.h"
21 #include "app_bt.h"
22 #include "app_bt_queue.h"
23
24 #include "app_a2dp.h"
25 #include "app_avrcp.h"
26 #include "app_hfp.h"
27 #include "app_hsp.h"
28 #include "app_spp.h"
29 #include "app_test.h"
30 #include <string.h>
31 #include "app_a2dp_source.h"
32 #include "app_tws.h"
33 #include "pwrkey_api.h"
34 #if PLF_BT_OTA
35 #include "app_ota_box.h"
36 #endif
37 #include "reg_sysctrl.h"
38 #include "sysctrl_api.h"
39
40 app_bt_state_t s_bt_state;
41 char bt_local_name[32] = "CS_BT";
42
43 #if TEST_MODE_ROLE_SEND == 1
44 uint8_t bt_addr[6] = {
45 0xaa,0xc0,0x00,0x88,0x88,0x33
46 };
47 uint8_t ble_addr[6] = {
48 0xa9,0xc0,0x00,0x45,0x56,0x67
49 };
50 #else
51 uint8_t bt_addr[6] = {
52 0xaa,0xc0,0x00,0x88,0x88,0x33
53 };
54 uint8_t ble_addr[6] = {
55 0xaa,0xc0,0x00,0x45,0x56,0x67
56 };
57 #endif
58 app_connect_manager app_bt_connect_struct[LINK_MAX];
59 app_connect_manager *app_con_ptr[LINK_MAX];
60 app_bt_key_handler app_bt_key[KEY_MAX_MODULE];
61 AppBtScanMode bt_scan_mode = 0xff;
62 TimerHandle_t app_bt_pd_timer = NULL;
63
app_bt_powerdown_timer(TimerHandle_t xTimer)64 void app_bt_powerdown_timer( TimerHandle_t xTimer )
65 {
66 pmic_chip_shutdown();
67 }
68
app_bt_create_powerdown_timer(void)69 void app_bt_create_powerdown_timer(void)
70 {
71 if(app_bt_pd_timer == NULL)
72 app_bt_pd_timer = rtos_timer_create("APP_BT_POWERD",100,pdFALSE,NULL,app_bt_powerdown_timer);
73 }
74
app_bt_start_pd_timer(void)75 void app_bt_start_pd_timer(void)
76 {
77 rtos_timer_start(app_bt_pd_timer,0,false);
78 }
79
80
app_get_bt_state(void)81 app_bt_state_t app_get_bt_state(void)
82 {
83 return s_bt_state;
84 }
85
app_set_bt_state(app_bt_state_t state)86 void app_set_bt_state(app_bt_state_t state)
87 {
88 TRACE("APP:set bt state = %d\n",state);
89 s_bt_state = state;
90 }
91
app_bt_set_scan_mode(AppBtScanMode mode)92 void app_bt_set_scan_mode(AppBtScanMode mode)
93 {
94 #if APP_SUPPORT_OTA_BOX
95 return;
96 #endif
97 if(bt_scan_mode == mode){
98 return;
99 }
100 bt_scan_mode = mode;
101 app_bt_setscanmode(mode);
102 TRACE("app_bt_set_scan_mode access_mode=%x\n",mode);
103 if(mode == BT_ALLSCAN){
104 app_media_play_internalaudio(PROMPT_ID_BT_PAIRING);
105 }
106 }
107
108 /*************************************************************/
109 /* @func : app_bt_open_cs_vender_adv */
110 /* @brief: only used for two cs device connection process*/
111 /* used by CS Vendor-Defined BLE ADV and SCAN. */
112 /*************************************************************/
app_bt_open_cs_vender_adv(void)113 void app_bt_open_cs_vender_adv(void)
114 {
115 #if TWS_BLE_CONNECT == 1
116 BT_ADDR temp_bdaddr;
117 APP_BT_MGR *app_bt_manager_ptr = cs_adp_get_app_bt_mgr_ptr();
118
119 if(app_bt_manager_ptr->connect_index == 0){
120 memcpy(temp_bdaddr.addr,bt_addr,sizeof(BT_ADDR));
121 cs_adp_tws_start_adv(temp_bdaddr);
122 }
123 #endif
124 }
125
app_bt_volume_absolute_mute(void)126 void app_bt_volume_absolute_mute(void)
127 {
128 MediaCommonStruct tmp;
129 memset((U8*)&tmp, 0, sizeof(MediaCommonStruct));
130 tmp.p.vol_ctrl.vol_in.mute = 1;
131 tmp.p.vol_ctrl.vol_out.mute = 1;
132 app_media_mgr_set_command(MC_SETVOLUME,&tmp);
133 }
134
app_bt_local_volume_convert(uint8_t src_vol,uint8_t src_vol_max,uint8_t dst_max)135 uint8_t app_bt_local_volume_convert(uint8_t src_vol,uint8_t src_vol_max, uint8_t dst_max)
136 {
137 const uint8_t src_min = 0;
138 const uint8_t dst_min = 0;
139 uint8_t dst_vol;
140
141 if(src_vol >= src_vol_max){
142 dst_vol = dst_max;
143 }else if(src_min == src_vol){
144 dst_vol = dst_min;
145 }else{
146 dst_vol = ((uint32_t) src_vol * (dst_max + 1)) / src_vol_max;
147 if(dst_vol >= dst_max){
148 dst_vol = dst_max - 1;
149 }else if(dst_min == dst_vol){
150 dst_vol = dst_min + 1;
151 }else{
152 }
153 }
154 return dst_vol;
155 }
156
app_bt_local_volume_handle(uint8_t mode,uint8_t volume)157 void app_bt_local_volume_handle(uint8_t mode, uint8_t volume)
158 {
159 MediaCommonStruct param;
160 uint8_t out_vol;
161 uint8_t in_vol;
162 memset((U8*)¶m, 0, sizeof(MediaCommonStruct));
163 out_vol = app_bt_local_volume_convert(volume,(AUD_VOLUME_LEVEL_15 - AUD_VOLUME_LEVEL_0),APP_VOLUME_MAX_OUT_LEVEL);
164 param.p.vol_ctrl.vol_out.vol_level = out_vol&0x3f;
165 if(out_vol & (1<<6))
166 param.p.vol_ctrl.vol_out.extera6dB = 1;
167 if(out_vol & (1<<7))
168 param.p.vol_ctrl.vol_out.extera12dB = 1;
169 TRACE("APP: vol out src %x dst %x.\n",volume,out_vol);
170 if(mode){
171 in_vol = app_bt_local_volume_convert(volume,(AUD_VOLUME_LEVEL_15 - AUD_VOLUME_LEVEL_0),APP_VOLUME_MAX_IN_LEVEL);
172 param.p.vol_ctrl.vol_in.vol_level = in_vol&0x0f;
173 TRACE("APP: vol in src %x dst %x.\n",volume,in_vol);
174 }
175 app_media_mgr_set_command(MC_SETVOLUME,¶m);
176 }
177
app_bt_local_volume_change(uint32_t key)178 void app_bt_local_volume_change(uint32_t key)
179 {
180 uint8_t mode = 0;
181 int8_t volume = (AUD_VOLUME_LEVEL_7 - AUD_VOLUME_LEVEL_0);
182 APP_DEVLIST * tmp_devinfo = NULL;
183 key = key&0xffff0000;
184
185
186 #if APP_SUPPORT_HFP == 1
187 if(app_get_hfp_state() > APP_CONNECTED){
188 tmp_devinfo = cs_adp_get_hfp_current_devinfo();
189 if(tmp_devinfo == NULL){
190 return;
191 }
192 mode = 1;
193 volume = tmp_devinfo->peer_volume_hfp;
194 }else
195 #endif
196 {
197 #if APP_SUPPORT_A2DP_SBC == 1 || APP_SUPPORT_A2DP_AAC ==1 ||APP_SUPPORT_A2DP_SOURCE == 1
198 if(app_get_a2dp_state() >= A2DP_CONNECTED){
199 tmp_devinfo = cs_adp_get_a2dp_current_devinfo();
200 if(tmp_devinfo == NULL){
201 return;
202 }
203 volume = tmp_devinfo->peer_volume_a2dp;
204 }
205 #endif
206 }
207
208 if(key == APP_KEY_VOLADD){
209 volume++;
210 if(volume > (AUD_VOLUME_LEVEL_15 - AUD_VOLUME_LEVEL_0)){
211 volume = (AUD_VOLUME_LEVEL_15 - AUD_VOLUME_LEVEL_0);
212 }
213 }
214 if(key == APP_KEY_VOLSUB){
215 volume--;
216 #if APP_SUPPORT_HFP == 1//call volume at least TGT_VOLUME_LEVEL_1,don't mute it.
217 if(app_get_hfp_state() > APP_CONNECTED){
218 if(volume < (AUD_VOLUME_LEVEL_0 - AUD_VOLUME_LEVEL_0)){
219 volume = (AUD_VOLUME_LEVEL_1 - AUD_VOLUME_LEVEL_0);
220 }
221 }else
222 #endif
223 if(volume < (AUD_VOLUME_LEVEL_0 - AUD_VOLUME_LEVEL_0)){
224 volume = (AUD_VOLUME_LEVEL_0 - AUD_VOLUME_LEVEL_0);
225 }
226 }
227 #if APP_SUPPORT_TWS == 1
228 #if APP_SUPPORT_TWS_LOCAL_VOL_SYNC == 1
229 app_tws_volume_sync_handle(mode,volume);
230 app_bt_local_volume_handle(mode,volume);
231 #endif
232 #else
233 //do change local volume reg process in there.
234 app_bt_local_volume_handle(mode,volume);
235 //do end
236 #endif
237 #if APP_SUPPORT_HFP == 1
238 if(app_get_hfp_state() > APP_CONNECTED){
239 app_set_hfp_volume(&tmp_devinfo->bdaddr,volume);
240 }else
241 #endif
242 {
243 #if (APP_SUPPORT_A2DP_SBC == 1 || APP_SUPPORT_A2DP_AAC ==1 ||APP_SUPPORT_A2DP_SOURCE == 1) && APP_SUPPORT_AVRCP == 1
244 if(app_get_a2dp_state() >= A2DP_CONNECTED){
245 app_set_avrcp_volume(&tmp_devinfo->bdaddr,(8*(volume+1) - 1));
246 }
247 #endif
248 }
249 }
250
app_bt_state_machine(CS_EVENT * Event)251 static void app_bt_state_machine(CS_EVENT *Event)
252 {
253 switch(Event->EventId){
254 case CS_ADP_STACK_INIT:
255 if(app_get_bt_state() == BT_ACTIVE_PENDING)
256 {
257 app_set_bt_state(BT_ACTIVED);
258 }
259 app_media_play_internalaudio(PROMPT_ID_POWER_ON);
260 break;
261 case CS_ADP_ACL_CONNECT_IND:
262 case CS_ADP_ACL_CONNECT_CNF:
263 {
264 CS_ADP_MGR_EVENT *cs_mgr_msg = (CS_ADP_MGR_EVENT *)Event->Param;
265 if(cs_mgr_msg->p.reason == BT_NO_ERROR){
266 app_set_bt_state(BT_CONNECTED);
267 }else{
268
269 }
270 }
271 break;
272 case CS_ADP_ACL_DISCONNECT:
273 {
274 if(app_get_bt_state() > BT_ACTIVE_PENDING){
275 app_set_bt_state(BT_ACTIVED);
276 }
277 }
278 break;
279 case CS_ADP_PAIRING_COMPLETE:
280 {
281 CS_ADP_MGR_EVENT *cs_mgr_msg = (CS_ADP_MGR_EVENT *)Event->Param;
282 if(cs_mgr_msg->p.reason == BT_NO_ERROR){
283 #if APP_SUPPORT_TWS == 1
284 if(tws_app_get_role() != TWS_SLAVE){
285 app_media_play_internalaudio(PROMPT_ID_BT_PAIRING_SUCCESS);
286 }
287 #else
288 app_media_play_internalaudio(PROMPT_ID_BT_PAIRING_SUCCESS);
289 #endif
290 }else{
291 #if APP_SUPPORT_TWS == 1
292 if(tws_app_get_role() != TWS_SLAVE){
293 app_media_play_internalaudio(PROMPT_ID_BT_PAIRING_FAIL);
294 }
295 #else
296 app_media_play_internalaudio(PROMPT_ID_BT_PAIRING_FAIL);
297 #endif
298 }
299 }
300 break;
301 default:
302 break;
303 }
304 }
305
app_bt_common_handle(CS_EVENT * Event)306 static void app_bt_common_handle(CS_EVENT *Event)
307 {
308 app_bt_state_machine(Event);
309 switch(Event->EventId){
310 case CS_ADP_STACK_INIT:
311 if(Event->Param == 0){
312 TRACE("APP: bt_stack_init success.\n");
313 #if 0
314 *(volatile uint32_t *)(0x40500028) = 4;
315 #if 1
316 *(volatile uint32_t *)(0x406200f0) = 0x00002222;
317 *(volatile uint32_t *)(0x40600450) = 0x92b0e5e4;
318 #else
319 *(volatile uint32_t *)(0x406200f0) = 0x00002222;
320 *(volatile uint32_t *)(0x40600450) = 0xdf929b9c;
321 *(volatile uint32_t *)(0x40620100) = 0x07060403;
322 *(volatile uint32_t *)(0x40620104) = 0x0f0d0c08;
323 *(volatile uint32_t *)(0x40620108) = 0x13121110;
324 *(volatile uint32_t *)(0x4062010c) = 0x1f1e1d19;
325
326 *(volatile uint32_t *)(0x40620814) = 0x100;
327 *(volatile uint32_t *)(0x40620810) = 0x640004;
328 *(volatile uint32_t *)(0x40620814) = 0x107;
329 #endif
330 *(volatile uint32_t *)(0x40620508) = 0x54a53013;
331 TRACE("BTDRV:write done 0x%x, 0x%x, 0x%x\n",*(volatile uint32_t *)(0x40500028),*(volatile uint32_t *)(0x406200f0),*(volatile uint32_t *)(0x40600450));
332 #endif
333 #if PLF_LS_MODULE
334 ls_send_start_check(LS_CHECK_PERIOD,0);
335 #endif
336
337 #if SCO_CVSD_PLC_TEST == 1 || (APP_SUPPORT_TWS == 1 && PXP == 1)
338 #if TEST_MODE_ROLE_SEND == 1
339 app_bt_set_scan_mode(BT_NOSCAN);
340 #else
341 app_bt_set_scan_mode(BT_CONNECTABLE);
342 #endif
343 #else
344 app_bt_set_scan_mode(BT_ALLSCAN);
345 #endif
346
347 #if MAX_THROUGHPUT_TEST == 1 && TEST_MODE_ROLE_SEND == 1
348 app_spp_connect_test();
349 #else
350 #if APP_SUPPORT_HFG == 1
351 #if TWS_BLE_CONNECT == 1
352 cs_adp_tws_set_scan_para(1);
353 #endif
354 #else
355 #if APP_SUPPORT_TWS == 0
356 app_bt_connect();
357 #else
358 app_tws_default_connect();
359 #endif
360 #endif
361 #endif
362 }
363 break;
364 case CS_ADP_ACCESSIBLE_CHANGE:
365 {
366 #if SCO_CVSD_PLC_TEST == 1 && TEST_MODE_ROLE_SEND == 1
367 static uint8_t flag = 0;
368 if(flag == 0 && Event->Param == 0)
369 {
370 flag = 1;
371 app_test_connect_default();
372 }
373 #endif
374 TRACE("APP:accessible mode = %d\n",Event->Param);
375 }
376 break;
377 case CS_ADP_ENCRYPYION_CHANGE:
378 #if SCO_CVSD_PLC_TEST == 1 && TEST_MODE_ROLE_SEND == 1
379 if (connect_sco_timer == NULL)
380 connect_sco_timer = rtos_timer_create("Cs_TEST_Timer", \
381 1000, \
382 pdFALSE,\
383 NULL,\
384 app_test_connect_sco);
385 rtos_timer_change_period(connect_sco_timer,10,0);
386
387 #endif
388 break;
389 default:
390 break;
391 }
392 }
393
app_bt_manager_handle(CS_EVENT * Event)394 static void app_bt_manager_handle(CS_EVENT *Event)
395 {
396 CS_ADP_MGR_EVENT *cs_mgr_msg = (CS_ADP_MGR_EVENT *)Event->Param;
397 APP_BT_MGR *app_bt_manager_ptr = cs_adp_get_app_bt_mgr_ptr();
398 app_bt_state_machine(Event);
399 TRACE("APP:app_bt_mgr_handle evt = %d\n",Event->EventId);
400
401 switch (Event->EventId) {
402 case CS_ADP_ACL_CONNECT_IND:
403 case CS_ADP_ACL_CONNECT_CNF:
404 #if APP_SUPPORT_MULTIPLE_PHONE == 1
405 if(app_bt_manager_ptr->connect_index == 0){
406 app_bt_set_scan_mode(BT_ALLSCAN);
407 }else if(app_bt_manager_ptr->connect_index == 1){
408 #if APP_SUPPORT_LINK_ONE_ONLY == 1
409 app_bt_set_scan_mode(BT_NOSCAN);
410 #else
411 app_bt_set_scan_mode(BT_CONNECTABLE);
412 #endif
413 }else if(app_bt_manager_ptr->connect_index >= 2){
414 app_bt_set_scan_mode(BT_NOSCAN);
415 }
416 #if TWS_BLE_CONNECT == 1
417 if(cs_mgr_msg->bdaddr.addr[5] == bt_addr[5]
418 && cs_mgr_msg->bdaddr.addr[4] == bt_addr[4]
419 && cs_mgr_msg->bdaddr.addr[3] == bt_addr[3]){
420 cs_adp_tws_stop_adv();
421 }
422 #endif
423 #else
424 #if APP_SUPPORT_TWS == 1
425 if(app_bt_manager_ptr->connect_index == 0){
426 app_bt_set_scan_mode(BT_ALLSCAN);
427 }else if(app_bt_manager_ptr->connect_index == 1){
428 if(cs_adp_check_cmp_twsaddr(cs_mgr_msg->bdaddr)){
429 if(cs_tws_get_porttype() == TWS_SERVER_PORT){
430 #if TWS_SLAVE_CONNECT_MASTER == 1
431 #if PXP == 1
432 app_bt_set_scan_mode(BT_NOSCAN);
433 #else
434 app_bt_set_scan_mode(BT_ALLSCAN);
435 #endif
436 #else
437 app_bt_set_scan_mode(BT_NOSCAN);
438 #endif
439 }else{
440 #if TWS_SLAVE_CONNECT_MASTER == 1
441 app_bt_set_scan_mode(BT_NOSCAN);
442 #else
443 #if PXP == 1
444 app_bt_set_scan_mode(BT_NOSCAN);
445 #else
446 app_bt_set_scan_mode(BT_ALLSCAN);
447 #endif
448 #endif
449 }
450 }else{
451 #if TWS_BLE_CONNECT == 1
452 app_bt_set_scan_mode(BT_CONNECTABLE);
453 #endif
454 }
455 }else if(app_bt_manager_ptr->connect_index >= 2){
456 app_bt_set_scan_mode(BT_NOSCAN);
457 }
458
459 #else
460 if(app_bt_manager_ptr->connect_index == 0){
461 app_bt_set_scan_mode(BT_ALLSCAN);
462 }
463 #if APP_SUPPORT_A2DP_SOURCE == 0
464 else if(app_bt_manager_ptr->connect_index >= 1){
465 app_bt_set_scan_mode(BT_NOSCAN);
466 }
467 #else
468 else if(app_bt_manager_ptr->connect_index == 1){
469 app_bt_set_scan_mode(BT_ALLSCAN);
470 }else if(app_bt_manager_ptr->connect_index >= 2){
471 app_bt_set_scan_mode(BT_NOSCAN);
472 }
473 #endif
474 #endif
475 #endif
476 break;
477 case CS_ADP_ACL_DISCONNECT:
478 TRACE("APP:acl_disconnect reason = %d\n",cs_mgr_msg->p.reason);
479 #if APP_SUPPORT_MULTIPLE_PHONE == 1
480 if(app_bt_manager_ptr->connect_index == 0){
481 app_bt_set_scan_mode(BT_ALLSCAN);
482 #if APP_SUPPORT_HFG == 1
483 #if TWS_BLE_CONNECT == 1
484 cs_adp_tws_set_scan_para(1);
485 #endif
486 #endif
487 }else if(app_bt_manager_ptr->connect_index == 1){
488 #if APP_SUPPORT_LINK_ONE_ONLY == 1
489 app_bt_set_scan_mode(BT_NOSCAN);
490 #else
491 app_bt_set_scan_mode(BT_CONNECTABLE);
492 #endif
493 }
494 #else
495 #if APP_SUPPORT_TWS == 1
496 if(app_bt_manager_ptr->connect_index == 0){
497 app_bt_set_scan_mode(BT_ALLSCAN);
498 }else if(app_bt_manager_ptr->connect_index == 1){
499 if(cs_adp_check_cmp_twsaddr(cs_mgr_msg->bdaddr)){
500 #if APP_SUPPORT_A2DP_SBC == 1 || APP_SUPPORT_A2DP_AAC ==1 ||APP_SUPPORT_A2DP_SOURCE == 1
501 if(app_get_a2dp_state() != A2DP_PLAY && app_get_hfp_state() != APP_PLAY_SCO)
502 #endif
503 app_bt_set_scan_mode(BT_ALLSCAN);
504 }else{
505 if(cs_mgr_msg->p.reason == BT_CONNECTION_TIMEOUT)
506 app_bt_set_scan_mode(BT_CONNECTABLE);
507 else
508 app_bt_set_scan_mode(BT_ALLSCAN);
509 }
510 }
511 #endif
512 #endif
513 break;
514 case CS_ADP_PAIRING_COMPLETE:
515 if(cs_mgr_msg->p.reason == BT_NO_ERROR){
516
517 }else{
518
519 }
520 break;
521 case CS_ADP_SCO_CONNECT_IND:
522 case CS_ADP_SCO_CONNECT_CNF:
523 if(cs_mgr_msg->p.reason == BT_NO_ERROR){
524 #if APP_SUPPORT_TWS == 1
525 if(tws_app_get_role() == TWS_MASTER){
526 app_bt_set_scan_mode(BT_NOSCAN);
527 }else{
528 if (app_bt_manager_ptr->connect_index == 1){
529 app_bt_set_scan_mode(BT_CONNECTABLE);
530 }else if(app_bt_manager_ptr->connect_index >= 2){
531 app_bt_set_scan_mode(BT_NOSCAN);
532 }
533 }
534 #else
535 app_bt_set_scan_mode(BT_NOSCAN);
536 #endif
537 }
538 break;
539 case CS_ADP_SCO_DISCONNECTED:
540 if(app_bt_manager_ptr->connect_index == 1){
541 app_bt_set_scan_mode(BT_CONNECTABLE);
542 }
543 break;
544 case CS_ADP_INQUIRY_RESULT:
545 {
546 bt_class_of_device cod = (bt_class_of_device)cs_mgr_msg->p.inqResultP.cod;
547 TRACE("APP: cod = 0x%x ,addr 0 = 0x%x,1 = 0x%x,2 = 0x%x,3 = 0x%x,4 = 0x%x,5 = 0x%x\n",cod ,cs_mgr_msg->bdaddr.addr[0],cs_mgr_msg->bdaddr.addr[1],
548 cs_mgr_msg->bdaddr.addr[2],cs_mgr_msg->bdaddr.addr[3],cs_mgr_msg->bdaddr.addr[4],cs_mgr_msg->bdaddr.addr[5]);
549 }
550 break;
551 case CS_ADP_INQUIRY_COMPLETE:
552
553 break;
554 /** The Inquiry process is canceled. */
555 case CS_ADP_INQUIRY_CANCELED:
556
557 break;
558 case CS_ADP_BLE_ADV_DATA:
559 {
560 #if TWS_BLE_CONNECT == 1 && APP_SUPPORT_HFG == 1
561 host_data_struct *rx_data = (host_data_struct *)Event->Param;
562 BT_ADDR remove_addr;
563
564 memcpy(remove_addr.addr, &rx_data->data[26], 6);
565 TRACE("APP:remove addr %x,%x,%x,%x,%x,%x\n",remove_addr.addr[0],remove_addr.addr[1],remove_addr.addr[2],\
566 remove_addr.addr[3],remove_addr.addr[4],remove_addr.addr[5]);
567 if(remove_addr.addr[5] == bt_addr[5]
568 && remove_addr.addr[4] == bt_addr[4]
569 && remove_addr.addr[3] == bt_addr[3]){
570 cs_adp_tws_set_scan_disable();
571 app_bt_connect_hfg(&remove_addr);
572 }
573 #endif
574 }
575 break;
576 default:
577 break;
578 }
579
580 }
581
app_bt_wearing_state_hanlde(uint32_t state)582 void app_bt_wearing_state_hanlde(uint32_t state)
583 {
584 TRACE("APP: %s,%x\n",__func__,state);
585 #if APP_SUPPORT_TWS == 1
586 app_tws_wearing_state_handle(state);
587 #endif
588 }
589
app_bt_key_handle(uint32_t key)590 BOOL app_bt_key_handle(uint32_t key)
591 {
592 BOOL ret = FALSE;
593
594 TRACE("APP: key enter 0x%x\n",key);
595 switch(key)
596 {
597 case APP_KEY_VOLADD|APP_KEY_PRESS:
598 case APP_KEY_VOLADD|APP_KEY_HOLD:
599 case APP_KEY_VOLSUB|APP_KEY_PRESS:
600 case APP_KEY_VOLSUB|APP_KEY_HOLD:
601 // do local volume change function.
602 app_bt_local_volume_change(key);
603 break;
604 case APP_KEY_VOLADD|APP_KEY_UP:
605 case APP_KEY_VOLSUB|APP_KEY_UP:
606 // do function after local volume key up
607 break;
608 case APP_KEY_HOLD_5S:
609 #if APP_SUPPORT_TWS == 1
610 if (tws_app_get_role() >= TWS_NOROLE)
611 #endif
612 {
613 app_bt_disconnect_all();
614 cs_adp_close_dev();
615 }
616 break;
617 case APP_KEY_POWER|APP_KEY_HOLD_2S:
618 #if PLF_CS_VENDOR_ADV
619 app_bt_open_cs_vender_adv();
620 #endif
621 break;
622 default:
623 switch(KEY_NAME_GET(key)){
624 case APP_MSG_BATT:
625 {
626 uint32_t batt_level = KEY_FUNC_GET(key);
627 #if APP_SUPPORT_HFP == 1
628 cs_adp_hfp_set_battery_level((uint8_t)batt_level);
629 #endif
630 }
631 break;
632 case APP_MSG_POWER_DOWN:
633 app_bt_start_pd_timer();
634 case APP_MSG_LOW_POWER:
635 //do some for led or play internal audio.
636 break;
637 case APP_KEY_POWER:
638 {
639 #if (PLF_KEY_MODULE) && (PLF_GSENSOR == 0)
640 uint32_t change_key;
641 change_key = APP_KEY_PLAY|KEY_FUNC_GET(key);
642 app_bt_send_key(change_key);
643 #endif
644 }
645 break;
646 default:
647 break;
648 }
649 break;
650 }
651 for(U8 i = 0;i < KEY_MAX_MODULE ; i++){
652 if(app_bt_key[i].callback){
653 ret = app_bt_key[i].callback(key);
654 if(ret == TRUE)
655 break;
656 }
657 }
658 return ret;
659 }
660
app_bt_key_register(cs_bt_key_module module,app_bt_key_handle_cb callback)661 void app_bt_key_register(cs_bt_key_module module,app_bt_key_handle_cb callback)
662 {
663 TRACE("APP:app_bt_key_register module = %d\n",module);
664 for(U8 i = 0;i < KEY_MAX_MODULE ; i++){
665 if(app_bt_key[i].callback == NULL){
666 app_bt_key[i].callback = callback;
667 app_bt_key[i].module = module;
668 break;
669 }
670 }
671 }
672
app_bt_key_register_init(void)673 void app_bt_key_register_init(void)
674 {
675 #if APP_SUPPORT_TWS == 1
676 app_bt_key_register(KEY_TWS ,app_tws_key_handle);
677 #endif
678 #if APP_SUPPORT_HFP == 1
679 app_bt_key_register(KEY_HFP ,app_hfp_key_handle);
680 #endif
681 #if APP_SUPPORT_HSP == 1
682 app_bt_key_register(KEY_HSP ,app_hsp_key_handle);
683 #endif
684 #if APP_SUPPORT_AVRCP == 1
685 app_bt_key_register(KEY_AVRCP ,app_avrcp_key_handle);
686 #endif
687 #if APP_SUPPORT_HID == 1
688 app_bt_key_register(KEY_HID ,app_hid_key_handle);
689 #endif
690 }
691
app_bt_key_driver_init(void)692 void app_bt_key_driver_init(void)
693 {
694 #if (PLF_KEY_MODULE)
695 #if PLF_GSENSOR
696 int ret;
697 uint32_t key_bond_id[MAX_GPIO_KEY_REG_LIST_NUM][6] = {
698 {PB_3 , APP_KEY_GSENSOR , KEY_MAX_HOLD_TYPE , KEY_MAX_CLICK_2 , DEFAULT_PIN_PULL_DOWN , HW_FILTER},
699 };
700 uint32_t pwrmd = pwrctrl_pwrmd_cpusys_sw_record_getf();
701 TRACE("APP: app_bt_key_driver_init %x\n",pwrmd);
702 if (pwrmd < CPU_SYS_POWER_DOWN) {
703 TRACE("APP: da280_i2c_open\n");
704 da280_i2c_open();
705 ret = da280_init();
706 if (!ret) {
707 ret = da280_open_interrupt();
708 if (ret) {
709 TRACE("APP: fail to open da280 irq\n");
710 da280_close_interrupt();
711 }
712 } else {
713 da280_reset();
714 TRACE("APP: fail to init da280\n");
715 }
716 }
717 key_set_key_config(app_bt_send_key,key_bond_id,(sizeof(key_bond_id)/KEY_REG_LIST_ONE_NUM_SIZE));
718 #else
719 uint32_t key_bond_id[][6] = {
720 {PIN_PWR, APP_KEY_POWER , KEY_MAX_HOLD_TYPE , KEY_MAX_CLICK_NUM , DEFAULT_PIN_PULL_DOWN , HW_FILTER},
721 //{PA_1, APP_KEY_VOLADD , APP_KEY_PRESS , KEY_MAX_CLICK_1 , DEFAULT_PIN_PULL_DOWN , SFT_FILTER},
722 //{PA_2, APP_KEY_VOLSUB , APP_KEY_PRESS , KEY_MAX_CLICK_1 , DEFAULT_PIN_PULL_DOWN , SFT_FILTER},
723 };
724 key_set_key_config(app_bt_send_key,key_bond_id,(sizeof(key_bond_id)/KEY_REG_LIST_ONE_NUM_SIZE));
725 #endif
726 #endif
727 }
728
app_bt_led_init(void)729 void app_bt_led_init(void)
730 {
731 #if PLF_LED_MODULE
732 #if PLF_PMIC_VER_LITE
733 led_register_gpio_pin(PB_3,LED_BULE);
734 led_register_gpio_pin(PB_4,LED_RED);
735 #endif
736 #if PLF_PMIC_VER_AUD
737 led_register_gpio_pin(PB_6,LED_BULE);
738 led_register_gpio_pin(PB_7,LED_RED);
739 #endif
740 #endif
741 }
742
app_register_app_msg_handle(void)743 void app_register_app_msg_handle(void)
744 {
745 cs_adp_register_app_msg_handle(CS_COMMON ,app_bt_common_handle);
746 cs_adp_register_app_msg_handle(CS_MGR ,app_bt_manager_handle);
747 #if APP_SUPPORT_A2DP_SBC == 1 || APP_SUPPORT_A2DP_AAC == 1 || APP_SUPPORT_A2DP_SOURCE == 1
748 cs_adp_register_app_msg_handle(CS_A2DP ,app_a2dp_msg_handle);
749 #endif
750 #if APP_SUPPORT_AVRCP == 1
751 cs_adp_register_app_msg_handle(CS_AVRCP ,app_avrcp_msg_handle);
752 #endif
753 #if APP_SUPPORT_HFP == 1
754 cs_adp_register_app_msg_handle(CS_HFP ,app_hfp_msg_handle);
755 #endif
756 #if APP_SUPPORT_HSP == 1
757 cs_adp_register_app_msg_handle(CS_HSP ,app_hsp_msg_handle);
758 #endif
759 #if APP_SUPPORT_HID == 1
760 cs_adp_register_app_msg_handle(CS_HID ,app_hid_msg_handle);
761 #endif
762 #if APP_SUPPORT_SPP == 1
763 cs_adp_register_app_msg_handle(CS_SPP ,app_spp_msg_handle);
764 #endif
765 #if SCO_CVSD_PLC_TEST == 1
766 cs_adp_register_app_msg_handle(CS_TEST ,app_test_msg_handle);
767 #endif
768 #if APP_SUPPORT_TWS == 1
769 cs_adp_register_app_msg_handle(CS_TWS ,app_tws_msg_handle);
770 #endif
771 #if PLF_BT_OTA == 1
772 cs_adp_register_app_msg_handle(CS_TEST ,app_ota_msg_handle);
773 #endif
774 }
775
app_bt_profile_register(void)776 void app_bt_profile_register(void)
777 {
778 #if APP_SUPPORT_A2DP_SOURCE == 1
779 cs_adp_a2dp_register_source();
780 #endif
781 #if APP_SUPPORT_A2DP_CP == 1
782 cs_adp_a2dp_support_cb();
783 #endif
784 #if APP_SUPPORT_A2DP_SBC == 1
785 cs_adp_a2dp_register_sink_sbc();
786 #endif
787 #if APP_SUPPORT_A2DP_AAC == 1
788 cs_adp_a2dp_register_sink_aac();
789 #endif
790 #if APP_SUPPORT_AVRCP == 1
791 cs_adp_avrcp_register();
792 #endif
793 #if APP_SUPPORT_HFP == 1
794 cs_adp_hfp_register();
795 #endif
796 #if APP_SUPPORT_HSP == 1
797 cs_adp_hsp_register();
798 #endif
799 #if APP_SUPPORT_HID == 1
800 cs_adp_hid_register();
801 #endif
802 }
803
804
app_adp_init(void)805 void app_adp_init(void)
806 {
807 #if APP_SUPPORT_A2DP_SOURCE == 1
808 cs_adp_a2dp_source_init();
809 app_a2dp_source_init();
810 #endif
811 #if APP_SUPPORT_A2DP_SBC == 1 || APP_SUPPORT_A2DP_AAC == 1
812 cs_adp_a2dp_init();
813 #endif
814 #if APP_SUPPORT_AVRCP == 1
815 cs_adp_avrcp_init();
816 #endif
817 #if APP_SUPPORT_HFP == 1
818 #if APP_SUPPORT_HFG == 1
819 cs_adp_hfp_init(HANDSFREE_AG);
820 #else
821 cs_adp_hfp_init(HANDSFREE);
822 #endif
823 #endif
824 #if APP_SUPPORT_HSP == 1
825 cs_adp_hsp_init();
826 #endif
827 #if APP_SUPPORT_SPP == 1
828 cs_adp_spp_init();
829 #endif
830 #if APP_SUPPORT_TWS == 1
831 cs_adp_tws_init();
832 app_tws_init();
833 #endif
834
835 #if SCO_CVSD_PLC_TEST == 1 || PLF_BT_OTA == 1
836 cs_adp_test_init();
837 #if APP_SUPPORT_OTA_BOX
838 app_ota_init();
839 #endif
840 #endif
841 cs_adp_mgr_init();
842
843
844 }
845
app_bt_init(void)846 void app_bt_init(void)
847 {
848 #if FPGA == 0
849 bt_factory_info_t bt_factory_info;
850 if(flash_btdm_bt_factory_read((void *)&bt_factory_info, sizeof(bt_factory_info_t)) == INFO_READ_DONE){
851 memcpy(bt_addr , bt_factory_info.local_bt_addr ,6);
852 memcpy(ble_addr , bt_factory_info.local_ble_addr ,6);
853 memcpy(bt_local_name , bt_factory_info.local_dev_name ,32);
854 if(bt_factory_info.bt_flash_erased){
855 app_bt_erased_flash();
856 bt_factory_info.bt_flash_erased = 0;
857 flash_btdm_bt_factory_write((void *)&bt_factory_info,sizeof(bt_factory_info_t));
858 }
859 }
860 #endif
861 TRACE("app_bt_init\n");
862 app_set_bt_state(BT_ACTIVE_PENDING);
863 app_adp_init();
864 app_bt_profile_register();
865 app_register_app_msg_handle();
866 app_bt_queue_init();
867 app_bt_key_register_init();
868 app_bt_connect_init();
869 app_bt_create_powerdown_timer();
870 #if CO_MAIN_AUTO_POWER_DOWEN == 1
871 co_main_batt_register_cb(app_bt_send_key);
872 #endif
873 app_bt_key_driver_init();
874 app_bt_led_init();
875 #if PLF_LS_MODULE
876 ls_register_evt_callback(app_bt_send_wearing_state);
877 #endif
878
879 /* bt local name */
880 cs_adp_set_bt_name((const unsigned char*)bt_local_name, strlen(bt_local_name) + 1);
881 TRACE("app_bt_init success\n");
882 }
883
884
885
886
887
app_bt_connect_init(void)888 void app_bt_connect_init(void)
889 {
890 uint8_t i=0;
891
892 for (i=0;i<LINK_MAX;i++){
893 app_con_ptr[i] = &app_bt_connect_struct[i];
894 app_con_ptr[i]->profile.all_connected = FALSE;
895 app_con_ptr[i]->profile.hfp_connect = CONNECT_IDLE;
896 app_con_ptr[i]->profile.hsp_connect = CONNECT_IDLE;
897 app_con_ptr[i]->profile.a2dp_connect = CONNECT_IDLE;
898
899 app_con_ptr[i]->reconnect.connect_retry_cnt = 0;
900 app_con_ptr[i]->reconnect.connect_timer_handle = NULL;
901 app_con_ptr[i]->reconnect.reconnect_mode = RECONNECT_IDLE;
902 app_con_ptr[i]->reconnect.connect_timer_cb = NULL;
903
904 memset(app_con_ptr[i]->remotedev_addr.addr,0 ,BD_ADDR_SIZE);
905 #if PLF_AON_SUPPORT == 1
906 app_con_ptr[i]->reconnect.cb_param = (void *)app_con_ptr[i];
907 #else
908 if (app_con_ptr[i]->reconnect.connect_timer_handle == NULL)
909 app_con_ptr[i]->reconnect.connect_timer_handle = rtos_timer_create("Cs_BT_Connect_Timer", \
910 10000, \
911 pdFALSE,\
912 (void *)app_con_ptr[i],\
913 app_bt_connect_timer);
914 #endif
915 }
916 TRACE("APP:app_bt_connect_init success\n");
917 }
918
app_bt_get_con_ptr_by_addr(BT_ADDR * bdaddr)919 app_connect_manager *app_bt_get_con_ptr_by_addr(BT_ADDR * bdaddr)
920 {
921 for(uint8_t i=0;i<LINK_MAX;i++){
922 if(!memcmp(app_con_ptr[i]->remotedev_addr.addr, bdaddr->addr, BD_ADDR_SIZE)){
923 return app_con_ptr[i];
924 }
925 }
926 return NULL;
927 }
928
app_bt_get_unused_con_ptr(void)929 app_connect_manager *app_bt_get_unused_con_ptr(void)
930 {
931 for(uint8_t i=0;i<LINK_MAX;i++){
932 if(app_con_ptr[i]->profile.a2dp_connect != CONNECTED
933 && app_con_ptr[i]->profile.hfp_connect != CONNECTED){
934 return app_con_ptr[i];
935 }
936 }
937 return NULL;
938 }
939
940 #if APP_SUPPORT_MULTIPLE_PHONE == 1
app_bt_connect_multiple_phone(void)941 void app_bt_connect_multiple_phone(void)
942 {
943 if(app_con_ptr[LINK_2]->reconnect.reconnect_mode == RECONNECT_POWERON){
944 #if PLF_AON_SUPPORT
945 app_bt_start_reconnect(&app_con_ptr[LINK_2]->reconnect.connect_timer_handle,app_con_ptr[LINK_2]->reconnect.cb_param,100);
946 #else
947 app_bt_start_reconnect(app_con_ptr[LINK_2]->reconnect.connect_timer_handle,100);
948 #endif
949 }
950 }
951 #endif
952
app_bt_report_connect_internal_audio(app_connect_manager * app_bt_con)953 void app_bt_report_connect_internal_audio(app_connect_manager * app_bt_con)
954 {
955 if(!app_bt_con->profile.all_connected){
956 if(TRUE
957 #if APP_SUPPORT_A2DP_SBC == 1|| APP_SUPPORT_A2DP_AAC == 1
958 && app_bt_con->profile.a2dp_connect == CONNECTED
959 #endif
960 #if APP_SUPPORT_HFP == 1
961 && app_bt_con->profile.hfp_connect == CONNECTED
962 #endif
963 #if APP_SUPPORT_HSP == 1
964 && app_bt_con->profile.hsp_connect == CONNECTED
965 #endif
966 ){
967 app_bt_con->profile.all_connected = TRUE;
968 app_bt_con->reconnect.reconnect_mode = RECONNECT_IDLE;
969 //report media connect successful
970 #if APP_SUPPORT_TWS == 1
971 if(tws_app_get_role() != TWS_SLAVE){
972 app_media_play_internalaudio(PROMPT_ID_BT_CONNECTED);
973 }
974 #else
975 app_media_play_internalaudio(PROMPT_ID_BT_CONNECTED);
976 #endif
977 cs_adp_save_flash();
978 #if APP_SUPPORT_MULTIPLE_PHONE == 1 && APP_SUPPORT_LINK_ONE_ONLY == 0
979 app_bt_connect_multiple_phone();
980 #endif
981 }
982
983 }else{
984 if(TRUE
985 #if APP_SUPPORT_A2DP_SBC == 1|| APP_SUPPORT_A2DP_AAC == 1
986 && app_bt_con->profile.a2dp_connect != CONNECTED
987 #endif
988 #if APP_SUPPORT_HFP == 1
989 && app_bt_con->profile.hfp_connect != CONNECTED
990 #endif
991 #if APP_SUPPORT_HSP == 1
992 && app_bt_con->profile.hsp_connect != CONNECTED
993 #endif
994 ){
995 app_bt_con->profile.all_connected = FALSE;
996 //report media disconnect successful
997 #if APP_SUPPORT_TWS == 1
998 if(tws_app_get_role() != TWS_SLAVE){
999 app_media_play_internalaudio(PROMPT_ID_BT_DISCONNECT);
1000 }
1001 #else
1002 app_media_play_internalaudio(PROMPT_ID_BT_DISCONNECT);
1003 #endif
1004 }
1005 }
1006 }
1007
app_bt_connect(void)1008 void app_bt_connect(void)
1009 {
1010 #if APP_SUPPORT_TWS == 0
1011 APP_BT_MGR *app_bt_manager_ptr = cs_adp_get_app_bt_mgr_ptr();
1012 BT_ADDR *bdaddr = &app_bt_manager_ptr->device_list[LINK_1].bdaddr;
1013 if(!app_bt_check_invalid_bdaddr(bdaddr)){
1014 btdev_info* dev_info = cs_adp_get_devinfo_by_addr(bdaddr);
1015 if(dev_info){
1016 app_con_ptr[LINK_1]->reconnect.reconnect_mode = RECONNECT_POWERON;
1017 memcpy(app_con_ptr[LINK_1]->remotedev_addr.addr, bdaddr->addr, BD_ADDR_SIZE);
1018 TRACE("APP:hf_state = %x,a2dp_state = %x\n",dev_info->hf_state,dev_info->a2dp_state);
1019 if(0){
1020 //do nothing
1021 }
1022 #if APP_SUPPORT_A2DP_SOURCE == 1
1023 else if(dev_info->a2dp_role == BT_A2DP_SOURCE){
1024 //do nothing
1025 }
1026 #endif
1027 #if APP_SUPPORT_HFP == 1
1028 else if(dev_info->hf_state){
1029 app_bt_connect_hfp(bdaddr);
1030 }
1031 #endif
1032 #if APP_SUPPORT_A2DP_SBC == 1|| APP_SUPPORT_A2DP_AAC == 1
1033 else if(dev_info->a2dp_state){
1034 app_bt_connect_a2dp(bdaddr);
1035 }
1036 #endif
1037 else{
1038 app_con_ptr[LINK_1]->reconnect.reconnect_mode = RECONNECT_IDLE;
1039 memset(app_con_ptr[LINK_1]->remotedev_addr.addr,0 ,BD_ADDR_SIZE);
1040 }
1041 }
1042 }
1043 #if APP_SUPPORT_MULTIPLE_PHONE == 1
1044 bdaddr = &app_bt_manager_ptr->device_list[LINK_2].bdaddr;
1045 if(!app_bt_check_invalid_bdaddr(bdaddr)){
1046 btdev_info* dev_info = cs_adp_get_devinfo_by_addr(bdaddr);
1047 if(dev_info){
1048 app_con_ptr[LINK_2]->reconnect.reconnect_mode = RECONNECT_POWERON;
1049 memcpy(app_con_ptr[LINK_2]->remotedev_addr.addr, bdaddr->addr, BD_ADDR_SIZE);
1050 if(0){
1051 //do nothing
1052 }
1053 #if APP_SUPPORT_HFP == 1
1054 else if(dev_info->hf_state){
1055
1056 }
1057 #endif
1058 #if APP_SUPPORT_A2DP_SBC == 1|| APP_SUPPORT_A2DP_AAC == 1
1059 else if(dev_info->a2dp_state){
1060
1061 }
1062 #endif
1063 else{
1064 app_con_ptr[LINK_2]->reconnect.reconnect_mode = RECONNECT_IDLE;
1065 memset(app_con_ptr[LINK_2]->remotedev_addr.addr,0 ,BD_ADDR_SIZE);
1066 }
1067 }
1068 }
1069 #endif
1070 #else
1071 APP_BT_MGR *app_bt_manager_ptr = cs_adp_get_app_bt_mgr_ptr();
1072
1073 for(uint8_t i = 0; i < LINK_MAX; i++){
1074 BT_ADDR *bdaddr = &app_bt_manager_ptr->device_list[i].bdaddr;
1075 if(!app_bt_check_invalid_bdaddr(bdaddr)){
1076 if(!cs_adp_check_cmp_twsaddr(*bdaddr) && app_bt_manager_ptr->device_list[i].adp_state == APP_MGR_STATE_IDLE ){
1077 btdev_info* dev_info = cs_adp_get_devinfo_by_addr(bdaddr);
1078 if(dev_info){
1079 app_con_ptr[LINK_1]->reconnect.reconnect_mode = RECONNECT_POWERON;
1080 memcpy(app_con_ptr[LINK_1]->remotedev_addr.addr, bdaddr->addr, BD_ADDR_SIZE);
1081 TRACE("APP:hf_state = %x,a2dp_state = %x\n",dev_info->hf_state,dev_info->a2dp_state);
1082 if(0){
1083 //do nothing
1084 }
1085 #if APP_SUPPORT_A2DP_SOURCE == 1
1086 else if(dev_info->a2dp_role == BT_A2DP_SOURCE){
1087 //do nothing
1088 }
1089 #endif
1090 #if APP_SUPPORT_HFP == 1
1091 else if(dev_info->hf_state){
1092 app_bt_connect_hfp(bdaddr);
1093 }
1094 #endif
1095 #if APP_SUPPORT_A2DP_SBC == 1|| APP_SUPPORT_A2DP_AAC == 1
1096 else if(dev_info->a2dp_state){
1097 app_bt_connect_a2dp(bdaddr);
1098 }
1099 #endif
1100 else{
1101 app_con_ptr[LINK_1]->reconnect.reconnect_mode = RECONNECT_IDLE;
1102 memset(app_con_ptr[LINK_1]->remotedev_addr.addr,0 ,BD_ADDR_SIZE);
1103 }
1104 }
1105 }
1106 }
1107 }
1108 #endif
1109 }
1110
1111
1112
1113
1114 #if PLF_AON_SUPPORT
app_bt_start_reconnect(co_timer ** timer,void * cb_param,uint32_t t)1115 void app_bt_start_reconnect(co_timer **timer, void *cb_param, uint32_t t)
1116 {
1117 co_timer_start(timer, t, cb_param, app_bt_connect_timer,0);
1118 }
1119
app_bt_connect_timer(void * cb_param)1120 void app_bt_connect_timer(void *cb_param)
1121 {
1122 app_connect_manager * app_con_ptr_tmp = NULL;
1123 app_con_ptr_tmp = (app_connect_manager *)cb_param;
1124
1125 if(app_con_ptr_tmp->reconnect.connect_timer_cb){
1126 app_con_ptr_tmp->reconnect.connect_timer_cb(cb_param);
1127 app_con_ptr_tmp->reconnect.connect_timer_cb = NULL;
1128 }else{
1129 if(0){
1130 //do nothing
1131 }
1132 #if APP_SUPPORT_HFP == 1
1133 else if(app_con_ptr_tmp->profile.hfp_connect != CONNECTED){
1134 app_bt_connect_hfp(&app_con_ptr_tmp->remotedev_addr);
1135 }
1136 #endif
1137 #if APP_SUPPORT_A2DP_SBC == 1 || APP_SUPPORT_A2DP_AAC == 1
1138 else if(app_con_ptr_tmp->profile.a2dp_connect != CONNECTED){
1139 app_bt_connect_a2dp(&app_con_ptr_tmp->remotedev_addr);
1140 }
1141 #endif
1142 }
1143 }
1144 #else
app_bt_start_reconnect(TimerHandle_t xTimer,uint32_t t)1145 void app_bt_start_reconnect( TimerHandle_t xTimer ,uint32_t t)
1146 {
1147 rtos_timer_change_period(xTimer,t ,0);
1148 }
1149
app_bt_connect_timer(TimerHandle_t xTimer)1150 void app_bt_connect_timer( TimerHandle_t xTimer )
1151 {
1152 app_connect_manager * app_con_ptr_tmp = NULL;
1153 app_con_ptr_tmp = (app_connect_manager *)rtos_timer_get_pvTimerID(xTimer);
1154
1155 if(app_con_ptr_tmp->reconnect.connect_timer_cb){
1156 app_con_ptr_tmp->reconnect.connect_timer_cb(xTimer);
1157 app_con_ptr_tmp->reconnect.connect_timer_cb = NULL;
1158 }else{
1159 if(0){
1160 //do nothing
1161 }
1162 #if APP_SUPPORT_HFP == 1
1163 else if(app_con_ptr_tmp->profile.hfp_connect != CONNECTED){
1164 app_bt_connect_hfp(&app_con_ptr_tmp->remotedev_addr);
1165 }
1166 #endif
1167 #if APP_SUPPORT_A2DP_SBC == 1 || APP_SUPPORT_A2DP_AAC == 1
1168 else if(app_con_ptr_tmp->profile.a2dp_connect != CONNECTED){
1169 app_bt_connect_a2dp(&app_con_ptr_tmp->remotedev_addr);
1170 }
1171 #endif
1172 }
1173 }
1174 #endif
1175
app_bt_disconnect_all(void)1176 void app_bt_disconnect_all(void)
1177 {
1178 APP_BT_MGR *app_bt_manager_ptr = cs_adp_get_app_bt_mgr_ptr();
1179
1180 if(app_bt_manager_ptr){
1181 for(U8 i = 0; i < app_bt_manager_ptr->max_device_num ; i++){
1182 #if APP_SUPPORT_TWS == 1
1183 if(tws_app_get_role() == TWS_SLAVE){
1184 if(app_bt_manager_ptr->device_list[i].adp_state == APP_MGR_STATE_CONNECTED && cs_adp_check_cmp_twsaddr(app_bt_manager_ptr->device_list[i].bdaddr)){
1185 cs_adp_disconnect_acl(app_bt_manager_ptr->device_list[i].bdaddr);
1186 }
1187 }else
1188 #endif
1189 {
1190 if(app_bt_manager_ptr->device_list[i].adp_state == APP_MGR_STATE_CONNECTED){
1191 cs_adp_disconnect_acl(app_bt_manager_ptr->device_list[i].bdaddr);
1192 }
1193 }
1194 }
1195 }
1196 }
1197 #endif
1198 #endif
1199