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 "app_tws.h"
19 #if APP_SUPPORT_TWS == 1
20 #include "al_rtos.h"
21 #include "app_a2dp.h"
22 #include "app_bt.h"
23 #include "app_hfp.h"
24 #include "app_avrcp.h"
25 #include "app_bt_queue.h"
26
27 #if PLF_PMIC_VER_LITE == 1
28 #define AUDIO_TWS_OFFSET 40
29 #define VOICE_TWS_MSBC_OFFSET 120
30 #define VOICE_TWS_CVSD_OFFSET 200
31 #elif PLF_PMIC_VER_AUD == 1
32 #define AUDIO_TWS_OFFSET 128
33 #define VOICE_TWS_MSBC_OFFSET 128
34 #define VOICE_TWS_CVSD_OFFSET 128
35 #endif
36
37 #if TWS_MSS_AUTO_TEST == 1
38 TimerHandle_t app_bt_tws_mss_timer = NULL;
39 #endif
40 #if TWS_SENDING_DATA_TEST == 1
41 TimerHandle_t app_bt_tws_test_send_timer = NULL;
42 U8 send_test[6] = {1,2,3,4,5,6};
43 #endif
44 extern uint8_t bt_addr[6];
45 APP_TWS_BLE_STATE app_ble_state = STATE_IDLE;
46 APP_TWS_POWER_DOWN_STATE app_tws_pd_state = STATE_PD_IDLE;
47 APP_TWS_WEAR_STATE app_tws_wearing_state = WEAR_OFF;
48
49 extern AUD_SAMPRATE_T bt_parse_sbc_sample_rate(uint8_t samp_rate);
50
app_tws_calloc(U8 ** tws_cmd,U16 len)51 int app_tws_calloc(U8 **tws_cmd,U16 len)
52 {
53 *tws_cmd = (U8 *)rtos_malloc(len);
54 TRACE("APP:tws malloc addr = 0x%x,len = %d\n ",(U32)*tws_cmd,len);
55 return 0;
56 }
57
app_tws_free(U8 * tws_cmd)58 int app_tws_free(U8 *tws_cmd)
59 {
60 TRACE("APP: tws free addr = 0x%x\n",(U32)tws_cmd);
61 rtos_free((void *)tws_cmd);
62 return 0;
63 }
64
app_tws_set_ble_state(APP_TWS_BLE_STATE state)65 void app_tws_set_ble_state(APP_TWS_BLE_STATE state)
66 {
67 app_ble_state = state;
68 TRACE("APP: tws ble state = 0x%x\n",state);
69 }
70
app_tws_get_ble_state(void)71 APP_TWS_BLE_STATE app_tws_get_ble_state(void)
72 {
73 return app_ble_state;
74 }
75
app_tws_set_pd_state(APP_TWS_POWER_DOWN_STATE state)76 void app_tws_set_pd_state(APP_TWS_POWER_DOWN_STATE state)
77 {
78 app_tws_pd_state = state;
79 TRACE("APP: app_tws_pd_state = 0x%x\n",app_tws_pd_state);
80 }
81
app_tws_get_pd_state(void)82 APP_TWS_POWER_DOWN_STATE app_tws_get_pd_state(void)
83 {
84 return app_tws_pd_state;
85 }
86
app_tws_get_wear_state(void)87 APP_TWS_WEAR_STATE app_tws_get_wear_state(void)
88 {
89 return app_tws_wearing_state;
90 }
91
app_connect_tws_test(void)92 void app_connect_tws_test(void)
93 {
94 #if TEST_MODE_ROLE_SEND == 1
95 BT_ADDR temp_bdaddr = {{0xaa,0xc0,0x00,0x88,0x88,0x33}};
96 #else
97 BT_ADDR temp_bdaddr = {{0xa9,0xc0,0x00,0x88,0x88,0x33}};
98 #endif
99 #if TWS_BLE_CONNECT == 1
100 memcpy(temp_bdaddr.addr,bt_addr,sizeof(BT_ADDR));
101 cs_adp_tws_start_adv(temp_bdaddr);
102 #else
103 cs_adp_connect_tws_peer_device(&temp_bdaddr);
104 #endif
105 }
106
107 #if TWS_SENDING_DATA_TEST == 1
app_tws_start_test_send(void)108 void app_tws_start_test_send(void)
109 {
110 TRACE("APP:app_tws_start_test_send.\n");
111 if(rtos_timer_change_period(app_bt_tws_test_send_timer, 100, 0) == 0){
112
113 }
114 }
115
app_tws_test_send_timer(TimerHandle_t xTimer)116 void app_tws_test_send_timer( TimerHandle_t xTimer )
117 {
118 TRACE("APP:app_tws_test_send_timer.\n");
119 app_bt_tws_send_data(send_test,6);
120 app_tws_start_test_send();
121 }
122
app_tws_create_test_send_timer(void)123 void app_tws_create_test_send_timer(void)
124 {
125 if(app_bt_tws_test_send_timer == NULL)
126 app_bt_tws_test_send_timer = rtos_timer_create("APP_TWS_TEST_SEND", \
127 10000, \
128 pdFALSE,\
129 NULL,\
130 app_tws_test_send_timer);
131 }
132 #endif
133
134 #if TWS_MSS_AUTO_TEST == 1
app_tws_mss_test_timer(TimerHandle_t xTimer)135 void app_tws_mss_test_timer( TimerHandle_t xTimer )
136 {
137 app_bt_tws_mss_control();
138 }
139
app_tws_create_mss_timer(void)140 void app_tws_create_mss_timer(void)
141 {
142 if(app_bt_tws_mss_timer == NULL)
143 app_bt_tws_mss_timer = rtos_timer_create("APP_TWS_MSS", \
144 10000, \
145 pdFALSE,\
146 NULL,\
147 app_tws_mss_test_timer);
148 }
149
app_tws_start_mss(void)150 void app_tws_start_mss(void)
151 {
152 if(rtos_timer_change_period(app_bt_tws_mss_timer, 2000, 0) == 0){
153
154 }
155 }
156 #endif
157
app_tws_default_connect(void)158 void app_tws_default_connect(void)
159 {
160 #if TEST_MODE_ROLE_SEND == 1
161 #if TWS_BLE_CONNECT == 1
162 #if FPGA == 1
163 app_connect_tws_test();
164 #else
165 switch(tws_app_get_flash_role()){
166 case TWS_MASTER:
167 cs_adp_tws_set_scan_para(0);
168 app_tws_set_ble_state(STATE_SCAN_EN);
169 break;
170 case TWS_SLAVE:
171 app_connect_tws_test();
172 app_tws_set_ble_state(STATE_ADV_EN);
173 break;
174 case TWS_NOROLE:
175 app_connect_tws_test();
176 app_tws_set_ble_state(STATE_ADV_EN);
177 break;
178 default:
179 break;
180 }
181 #endif
182 #endif
183 #else
184 #if TWS_BLE_CONNECT == 1
185 #if FPGA == 1
186 cs_adp_tws_set_scan_para(1);
187 #else
188 switch(tws_app_get_flash_role()){
189 case TWS_MASTER:
190 cs_adp_tws_set_scan_para(0);
191 app_tws_set_ble_state(STATE_SCAN_EN);
192 break;
193 case TWS_SLAVE:
194 app_connect_tws_test();
195 app_tws_set_ble_state(STATE_ADV_EN);
196 break;
197 case TWS_NOROLE:
198 cs_adp_tws_set_scan_para(1);
199 app_tws_set_ble_state(STATE_SCAN_EN);
200 break;
201 default:
202 break;
203 }
204 #endif
205 #endif
206 #endif
207 }
208
app_tws_send_data(uint8_t * ptrData,uint16_t length)209 BOOL app_tws_send_data(uint8_t* ptrData, uint16_t length)
210 {
211 return cs_adp_send_data(ptrData, length);
212 }
213
app_tws_pause_a2dp(void)214 void app_tws_pause_a2dp(void)
215 {
216 TRACE("APP:app_a2dp_pause.\n");
217 if(app_get_a2dp_state() == A2DP_PLAY){
218 app_media_play(AUD_BT_A2DP ,MC_STOP,0,true);
219 app_set_a2dp_state(A2DP_CONNECTED);
220 }
221 }
222
app_tws_play_a2dp(A2DP_AUDIO_CAP * audio_cap)223 void app_tws_play_a2dp(A2DP_AUDIO_CAP *audio_cap)
224 {
225 MediaCommonStruct audio_param;
226 memset((U8*)&audio_param, 0, sizeof(MediaCommonStruct));
227 TRACE("APP:app_a2dp_tws_play audio_cap = 0x%x\n",audio_cap);
228 if(audio_cap){
229 audio_param.p.aud_ctrl.a2dpcodec = audio_cap->codec_type;
230 audio_param.p.aud_ctrl.samplerate = bt_parse_sbc_sample_rate(audio_cap->sample_rate_bit);
231
232 audio_param.p.aud_ctrl.channel = audio_cap->channel;
233 audio_param.p.aud_ctrl.numBlocks = audio_cap->numBlocks;
234 audio_param.p.aud_ctrl.numSubBands = audio_cap->numSubBands;
235 audio_param.p.aud_ctrl.dpll_mode = AUD_DPLL_TWS;
236 app_media_play(AUD_BT_A2DP ,MC_STOP,0,false);
237 app_media_play(AUD_BT_A2DP ,MC_OPEN,&audio_param,true);
238 app_set_a2dp_state(A2DP_PLAY);
239 }
240 }
241
app_tws_stop_hfp(void)242 void app_tws_stop_hfp(void)
243 {
244 TRACE("APP:app_hfp_stop.\n");
245 #if APP_SUPPORT_HFP == 1
246 app_set_hfp_state(APP_CONNECTED);
247 #endif
248 #if APP_SUPPORT_A2DP_SBC == 1 || APP_SUPPORT_A2DP_AAC == 1
249 if(app_get_a2dp_state() != A2DP_PLAY)
250 #endif
251 {
252 app_media_play(AUD_BT_SCO ,MC_STOP,0,true);
253 }
254 }
255
app_tws_play_hfp(uint16_t negotiated_codec)256 void app_tws_play_hfp(uint16_t negotiated_codec)
257 {
258 MediaCommonStruct tmp;
259 TRACE("APP:app_hfp_play.\n");
260 memset((U8*)&tmp, 0, sizeof(MediaCommonStruct));
261 #if APP_SUPPORT_HFP == 1
262 app_set_hfp_state(APP_PLAY_SCO);
263 #endif
264 switch (negotiated_codec)
265 {
266 case MEDIA_SCO_CODEC_CVSD:
267 tmp.p.voc_ctrl.scocodec = MEDIA_SCO_CODEC_CVSD;
268 break;
269 case MEDIA_SCO_CODEC_MSBC:
270 tmp.p.voc_ctrl.scocodec = MEDIA_SCO_CODEC_MSBC;
271 break;
272 default:
273 tmp.p.voc_ctrl.scocodec = MEDIA_SCO_CODEC_CVSD;
274 break;
275 }
276 #if APP_SUPPORT_HFP == 1
277 app_set_hfp_scocodec(tmp.p.voc_ctrl.scocodec);
278 #endif
279 tmp.p.voc_ctrl.dpll_mode = AUD_DPLL_TWS;
280 app_media_play(AUD_BT_SCO ,MC_OPEN,&tmp,false);
281 }
282
app_tws_handle_trig_clk(rwip_time_t * bt_clk,uint32_t trig_num)283 uint32_t app_tws_handle_trig_clk(rwip_time_t *bt_clk,uint32_t trig_num)
284 {
285 uint32_t ret = 0;
286
287 ret = ((trig_num - bt_clk->hs)*625 - bt_clk->hus)*13;// 20*24/37:40M-->26M 13:26M 20:40M
288 return ret;
289 }
290 /*
291 - 40 :will fix the time of trigger -120 :fix msbc -200 :fix cvsd
292 */
app_tws_handle_trig_clk_and_strboff(rwip_time_t * bt_clk,AppTwsMediaDataStruct * trig_num)293 uint32_t app_tws_handle_trig_clk_and_strboff(rwip_time_t *bt_clk,AppTwsMediaDataStruct * trig_num)// 20*24/37:40M-->26M 13:26M 20:40M
294 {
295 uint32_t ret = 0;
296 uint32_t fix_time_offset = 0;
297 if(app_get_a2dp_state() == A2DP_PLAY)
298 fix_time_offset = AUDIO_TWS_OFFSET;
299 #if APP_SUPPORT_HFP == 1
300 else if(app_get_hfp_state() == APP_PLAY_SCO){
301 if(app_get_hfp_scocodec() == MEDIA_SCO_CODEC_MSBC)
302 fix_time_offset = VOICE_TWS_MSBC_OFFSET;
303 else
304 fix_time_offset = VOICE_TWS_CVSD_OFFSET;
305 }
306 #endif
307 if(trig_num->current_clk >= bt_clk->hs){
308 ret = ((trig_num->current_clk - bt_clk->hs)*625+trig_num->current_bt_counter-bt_clk->hus + trig_num->strb_cycle_offset*2 - fix_time_offset)*13;
309 }else{
310 ret = (trig_num->strb_cycle_offset*2 + trig_num->current_bt_counter - bt_clk->hus - (bt_clk->hs - trig_num->current_clk )*625 - fix_time_offset)*13;
311 }
312 return ret;
313 }
314
app_tws_set_trig_num(AppTwsMediaDataStruct * trig_num)315 void app_tws_set_trig_num(AppTwsMediaDataStruct *trig_num)
316 {
317 uint32_t protect;
318 MediaCommonStruct tmp;
319 rwip_time_t bt_clk;
320 memset((U8*)&tmp, 0, sizeof(MediaCommonStruct));
321 TRACE("APP:trig btclk = 0x%x btcounter = 0x%x ,btcounteroff = 0x%x,strb_offset = %d,counter_num = %d\n",trig_num->current_clk,trig_num->current_bt_counter,\
322 trig_num->current_bt_counter_offset,trig_num->strb_cycle_offset,trig_num->counterNum);
323
324 tmp.p.sync_ctrl.sync_param.counterNum = trig_num->counterNum;
325 protect = rtos_protect();
326 bt_clk = cs_adp_get_native_clk_plus_offset();
327 if(trig_num->strb_cycle_offset){
328 tmp.p.sync_ctrl.start_trig_num = app_tws_handle_trig_clk_and_strboff(&bt_clk,trig_num);
329 }else{
330 tmp.p.sync_ctrl.start_trig_num = app_tws_handle_trig_clk(&bt_clk,trig_num->current_clk);
331 }
332 app_media_mgr_set_command(MC_SET_TRIGNUM,&tmp);
333 rtos_unprotect(protect);
334
335 TRACE("APP:triger hs = 0x%x hus = %d\n",bt_clk.hs ,bt_clk.hus);
336 TRACE("APP:start_trig_num = %d \n",tmp.p.sync_ctrl.start_trig_num);
337 #if APP_SUPPORT_HFP == 1
338 if(app_get_hfp_state()== APP_PLAY_SCO && app_get_a2dp_state() != A2DP_PLAY){
339 if(tws_app_get_role() == TWS_MASTER)
340 tmp.p.sync_ctrl.need_clean = true;
341 else
342 tmp.p.sync_ctrl.need_clean = false;
343 app_media_play(AUD_BT_SCO,MC_PRELOAD_PLAY,&tmp,true);
344 }
345 else
346 #endif
347 if(app_get_a2dp_state() == A2DP_PLAY && tws_app_get_role() == TWS_SLAVE)
348 {
349 app_media_play(AUD_BT_A2DP,MC_TRIGNUM_PLAY,&tmp,true);
350 }
351 }
352
app_tws_set_audio_sync_param(AppTwsMediaDataStruct * audio_sync)353 void app_tws_set_audio_sync_param(AppTwsMediaDataStruct *audio_sync)
354 {
355 MediaCommonStruct tmp;
356 if(!audio_sync)
357 return;
358 memset((U8*)&tmp, 0, sizeof(MediaCommonStruct));
359
360 //TRACE("APP:ctNum = %d ,ct_lo = %d,btclk = 0x%x,bt_hus = %d,strb_cycle_offset = %d\n",audio_sync->counterNum, audio_sync->master_current_samplerate,audio_sync->current_clk,audio_sync->current_bt_counter,audio_sync->strb_cycle_offset);
361 tmp.p.sync_ctrl.sync_param.current_clk = audio_sync->current_clk;
362 tmp.p.sync_ctrl.sync_param.counterNum = audio_sync->counterNum;
363 tmp.p.sync_ctrl.sync_param.master_current_samplerate = audio_sync->master_current_samplerate;
364 tmp.p.sync_ctrl.sync_param.current_bt_counter = audio_sync->current_bt_counter;
365 tmp.p.sync_ctrl.sync_param.strb_cycle_offset = audio_sync->strb_cycle_offset;
366 tmp.p.sync_ctrl.sync_param.current_bt_counter_offset = audio_sync->current_bt_counter_offset;
367 app_media_mgr_send_command(AUD_COMMON,MC_SYNC_PARAM,&tmp);
368 }
369
app_bt_disconnect_tws(void)370 void app_bt_disconnect_tws(void)
371 {
372 APP_BT_MGR *app_bt_manager_ptr = cs_adp_get_app_bt_mgr_ptr();
373
374 if(app_bt_manager_ptr){
375 for(U8 i = 0; i < app_bt_manager_ptr->max_device_num ; i++){
376 if(tws_app_get_role() == TWS_MASTER){
377 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)){
378 cs_adp_disconnect_acl(app_bt_manager_ptr->device_list[i].bdaddr);
379 }
380 }else if(tws_app_get_role() == TWS_SLAVE){
381 U8 *tws_cmd = NULL;
382 app_tws_calloc(&tws_cmd,APP_TWS_LEN_2);
383 if(tws_cmd){
384 BOOL ret = FALSE;
385 tws_cmd[0] = TWS_LINK_CONTROL_PARAM;
386 tws_cmd[1] = 0;
387 ret = app_tws_send_data(tws_cmd,APP_TWS_LEN_2);
388 if(ret == FALSE){
389 app_tws_free(tws_cmd);
390 }
391 }
392 }
393 }
394 }
395 }
396
app_tws_begin_mss(void)397 void app_tws_begin_mss(void)
398 {
399 if(tws_app_get_role() == TWS_MASTER){
400 cs_adp_host_m_s_switch();
401 }else if(tws_app_get_role() == TWS_SLAVE){
402 U8 *tws_cmd = NULL;
403 app_tws_calloc(&tws_cmd,APP_TWS_LEN_2);
404 if(tws_cmd){
405 BOOL ret = FALSE;
406 tws_cmd[0] = TWS_MSS_PARAM;
407 tws_cmd[1] = 1;
408 ret = app_tws_send_data(tws_cmd,APP_TWS_LEN_2);
409 if(ret == FALSE){
410 app_tws_free(tws_cmd);
411 }
412 }
413 }
414 }
415
app_tws_power_down(void)416 void app_tws_power_down(void)
417 {
418 switch(tws_app_get_role()){
419 case TWS_MASTER:
420 case TWS_SLAVE:
421 {
422 #if PLF_KEY_MODULE
423 pwrdown_set_state(USER_POWER_DOWN);
424 #endif
425 if(app_tws_get_pd_state() == STATE_PD_IDLE){
426 U8 *tws_cmd = NULL;
427 app_tws_calloc(&tws_cmd,APP_TWS_LEN_2);
428 if(tws_cmd){
429 BOOL ret = FALSE;
430 tws_cmd[0] = TWS_POWERD_PARAM;
431 tws_cmd[1] = 1;
432 ret = app_tws_send_data(tws_cmd,APP_TWS_LEN_2);
433 if(ret == FALSE){
434 app_tws_free(tws_cmd);
435 }
436 }
437 }else{
438 rtos_task_suspend(500);
439 if(tws_app_get_role() == TWS_MASTER){
440 app_bt_disconnect_all();
441 }
442 cs_adp_close_dev();
443 app_bt_start_pd_timer();
444 }
445 }
446 break;
447 default:
448 break;
449 }
450
451 }
452
app_tws_wearing_state_handle(uint32_t state)453 void app_tws_wearing_state_handle(uint32_t state)
454 {
455 if(state){
456 app_tws_wearing_state = WEAR_ON;
457 //on
458 switch(tws_app_get_role()){
459 case TWS_MASTER:
460
461 break;
462 case TWS_SLAVE:
463
464 break;
465 default:
466 break;
467 }
468 }else{
469 //off
470 app_tws_wearing_state = WEAR_OFF;
471 switch(tws_app_get_role()){
472 case TWS_MASTER:
473 app_bt_tws_mss_control();
474 break;
475 case TWS_SLAVE:
476
477 break;
478 default:
479 break;
480 }
481 }
482 }
483
app_tws_volume_sync_handle(uint8_t mode,uint8_t volume)484 void app_tws_volume_sync_handle(uint8_t mode,uint8_t volume)
485 {
486 TRACE("APP: mode %x,volume %x\n",mode,volume);
487 switch(tws_app_get_role()){
488 case TWS_MASTER:
489 {
490 U8 *tws_cmd = NULL;
491 app_tws_calloc(&tws_cmd,APP_TWS_LEN_3);
492 if(tws_cmd){
493 BOOL ret = FALSE;
494 tws_cmd[0] = TWS_SET_VOLUME_PARAM;
495 tws_cmd[1] = mode;
496 tws_cmd[2] = volume;
497 ret = app_tws_send_data(tws_cmd,APP_TWS_LEN_3);
498 if(ret == FALSE){
499 app_tws_free(tws_cmd);
500 }
501 }
502 }
503 break;
504 case TWS_SLAVE:
505 {
506 APP_DEVLIST * tmp_devinfo = NULL;
507 app_bt_local_volume_handle(mode,volume);
508 if(mode){
509 tmp_devinfo = cs_adp_get_hfp_current_devinfo();
510 if(tmp_devinfo == NULL){
511 return;
512 }
513 tmp_devinfo->peer_volume_hfp = volume;
514 app_set_hfp_volume(&tmp_devinfo->bdaddr,volume);
515 }else{
516 tmp_devinfo = cs_adp_get_a2dp_current_devinfo();
517 if(tmp_devinfo == NULL){
518 return;
519 }
520 tmp_devinfo->peer_volume_a2dp = volume;
521 app_set_avrcp_volume(&tmp_devinfo->bdaddr,(8*(volume+1) - 1));
522 }
523 }
524 break;
525 default:
526 break;
527 }
528 }
529
app_tws_key_handle(uint32_t key)530 BOOL app_tws_key_handle(uint32_t key)
531 {
532 BOOL ret = FALSE;
533 uint32_t send_key = 0;
534
535 switch(key){
536 case APP_KEY_PLAY|APP_KEY_PRESS:
537 send_key = key;
538 break;
539 case APP_KEY_VOLADD|APP_KEY_PRESS:
540 case APP_KEY_VOLADD|APP_KEY_HOLD:
541 send_key = key;
542 case APP_KEY_VOLSUB|APP_KEY_PRESS:
543 case APP_KEY_VOLSUB|APP_KEY_HOLD:
544 send_key = key;
545 break;
546 case APP_KEY_NEXT|APP_KEY_PRESS:
547 send_key = key;
548 break;
549 case APP_KEY_PREV|APP_KEY_PRESS:
550 send_key = key;
551 break;
552 case APP_KEY_NEXT|APP_KEY_HOLD:
553 send_key = key;
554 break;
555 case APP_KEY_PREV|APP_KEY_HOLD:
556 send_key = key;
557 break;
558 case APP_KEY_NEXT|APP_KEY_UP:
559 send_key = key;
560 break;
561 case APP_KEY_PREV|APP_KEY_UP:
562 send_key = key;
563 break;
564 case APP_KEY_PLAY|APP_KEY_DOUBLE_CLICK:
565 send_key = key;
566 break;
567 case APP_KEY_GSENSOR|APP_KEY_PRESS:
568 if(tws_app_get_role() == TWS_MASTER){
569 uint32_t change_key;
570 change_key = APP_KEY_VOLADD|APP_KEY_PRESS;
571 app_bt_send_key(change_key);
572 }else if(tws_app_get_role() == TWS_SLAVE){
573 send_key = APP_KEY_VOLSUB|APP_KEY_PRESS;
574 }
575 break;
576 case APP_KEY_GSENSOR|APP_KEY_DOUBLE_CLICK:
577 if(tws_app_get_role() == TWS_MASTER){
578 uint32_t change_key;
579 change_key = APP_KEY_PLAY|APP_KEY_PRESS;
580 app_bt_send_key(change_key);
581 }else if(tws_app_get_role() == TWS_SLAVE){
582 send_key = APP_KEY_PLAY|APP_KEY_PRESS;
583 }
584 break;
585 case APP_KEY_GSENSOR|APP_KEY_TRIPLE_CLICK:
586 if(tws_app_get_role() == TWS_MASTER){
587 uint32_t change_key;
588 change_key = APP_KEY_NEXT|APP_KEY_PRESS;
589 app_bt_send_key(change_key);
590 }else if(tws_app_get_role() == TWS_SLAVE){
591 send_key = APP_KEY_PREV|APP_KEY_PRESS;
592 }
593 break;
594 case APP_KEY_HOLD_2S:
595 if(tws_app_get_role() == TWS_MASTER){
596 uint32_t change_key;
597 change_key = APP_KEY_PLAY|APP_KEY_HOLD;
598 app_bt_send_key(change_key);
599 }else if(tws_app_get_role() == TWS_SLAVE){
600 send_key = APP_KEY_PLAY|APP_KEY_HOLD;
601 }
602 break;
603 case APP_KEY_HOLD_5S:
604 app_tws_power_down();
605 break;
606 default:
607 break;
608 }
609
610 if(send_key && tws_app_get_role() == TWS_SLAVE){
611 U8 *tws_cmd = NULL;
612 ret = TRUE;
613 app_tws_calloc(&tws_cmd,APP_TWS_LEN_5);
614 if(tws_cmd){
615 BOOL ret = FALSE;
616
617 tws_cmd[0] = TWS_KEY_PARAM;
618 tws_cmd[1] = (U8)( send_key&0x000000ff);
619 tws_cmd[2] = (U8)((send_key&0x0000ff00)>>8);
620 tws_cmd[3] = (U8)((send_key&0x00ff0000)>>16);
621 tws_cmd[4] = (U8)((send_key&0xff000000)>>24);
622 ret = app_tws_send_data(tws_cmd,APP_TWS_LEN_5);
623 if(ret == FALSE){
624 app_tws_free(tws_cmd);
625 }
626 }
627 }
628 return ret;
629 }
630
app_tws_msg_handle(CS_EVENT * event)631 void app_tws_msg_handle(CS_EVENT *event)
632 {
633
634 switch(event->EventId){
635 case CS_ADP_TWS_CONNECTED_IND:
636 {
637 CS_ADP_TWS_EVENT *cs_adp_tws_msg = (CS_ADP_TWS_EVENT *)event->Param;
638 TRACE("APP:app_tws_connect_ind .status = %d\n",cs_adp_tws_msg->p.conP.reason);
639 }
640 break;
641 case CS_ADP_TWS_CONNECTED_CNF:
642 {
643 CS_ADP_TWS_EVENT *cs_adp_tws_msg = (CS_ADP_TWS_EVENT *)event->Param;
644 TRACE("APP:app_tws_connect_cnf .status = %d\n",cs_adp_tws_msg->p.conP.reason);
645 #if TWS_SENDING_DATA_TEST == 1
646 app_tws_start_test_send();
647 #endif
648 #if PXP == 1 && TWS_SENDING_DATA_TEST == 0
649 app_bt_set_scan_mode(BT_CONNECTABLE);
650 #endif
651 if(cs_adp_tws_msg->p.conP.reason){
652 #if TWS_BLE_CONNECT == 1
653 cs_adp_tws_set_scan_para(0);
654 app_tws_set_ble_state(STATE_SCAN_EN);
655 #endif
656 }else{
657 app_bt_connect();
658 }
659 }
660 break;
661 case CS_ADP_TWS_DISCONNECTED:
662 {
663 CS_ADP_TWS_EVENT *cs_adp_tws_msg = (CS_ADP_TWS_EVENT *)event->Param;
664 TRACE("APP:app_tws_disconnect ,reason = %d,last_role = %d\n",cs_adp_tws_msg->p.discP.reason,cs_adp_tws_msg->p.discP.last_role);
665 if(tws_app_get_flash_role() < TWS_NOROLE){
666 switch(cs_adp_tws_msg->p.discP.last_role){
667 case TWS_SLAVE:
668 #if TWS_BLE_CONNECT == 1
669 app_tws_pause_a2dp();
670 app_tws_stop_hfp();
671 app_connect_tws_test();
672 app_tws_set_ble_state(STATE_ADV_EN);
673 #endif
674 break;
675 case TWS_MASTER:
676 #if TWS_BLE_CONNECT == 1
677 cs_adp_tws_set_scan_para(0);
678 app_tws_set_ble_state(STATE_SCAN_EN);
679 #endif
680 break;
681 default:
682 break;
683 }
684 }else{
685 app_tws_default_connect();
686 }
687 #if APP_SUPPORT_HFP == 1
688 app_set_hfp_scocodec(MEDIA_SCO_CODEC_NONE);
689 #endif
690 }
691 break;
692 case CS_ADP_TWS_STREAM_STARTED:
693 {
694 CS_ADP_A2DP_EVENT *cs_a2dp_msg = (CS_ADP_A2DP_EVENT *)event->Param;
695 A2DP_AUDIO_CAP *audio_cap = (A2DP_AUDIO_CAP *)cs_a2dp_msg->p.signalingP.audioCodecP;
696 app_tws_play_a2dp(audio_cap);
697 }
698 break;
699 case CS_ADP_TWS_STREAM_SUSPENDED:
700 {
701 app_tws_pause_a2dp();
702 }
703 break;
704 case CS_ADP_TWS_STREAM_DATA_IND:
705 {
706 CS_ADP_A2DP_EVENT *cs_a2dp_msg = (CS_ADP_A2DP_EVENT *)event->Param;
707 A2DP_AUDIO_CAP *audio_cap = (A2DP_AUDIO_CAP *)cs_a2dp_msg->p.mediaP.audioCodecP;
708 A2DP_AUDIO_DATA *audio_data = (A2DP_AUDIO_DATA *)cs_a2dp_msg->p.mediaP.audioDataP;
709
710 if(app_get_a2dp_state() == A2DP_PLAY){
711 AppReceive_A2dpData(((unsigned char *)audio_data->data)+ audio_data->headerlen ,
712 audio_data->datalen - audio_data->headerlen,
713 audio_cap->sbc_frame_number ,
714 bt_parse_sbc_sample_rate(audio_cap->sample_rate_bit));
715 }else{
716 TRACE("APP:free a2dp stream data\n");
717 }
718 }
719 break;
720 case CS_ADP_TWS_SCO_CONNECT:
721 {
722 CS_ADP_HFP_EVENT *cs_hfp_msg = (CS_ADP_HFP_EVENT *)event->Param;
723 TRACE("APP:hfp_sco_connect\n");
724 TRACE("APP:hfp_codec_type = %d\n",cs_hfp_msg->p.scoP.negotiated_codec);
725 app_tws_play_hfp((U16)cs_hfp_msg->p.scoP.negotiated_codec);
726 }
727 break;
728 case CS_ADP_TWS_SCO_DISCONNECT:
729 {
730 app_tws_stop_hfp();
731 }
732 break;
733 case CS_ADP_TWS_SCO_DATA_IND:
734 {
735 CS_ADP_HFP_EVENT *cs_hfp_msg = (CS_ADP_HFP_EVENT *)event->Param;
736 CS_ADP_HFP_AUDIO_DATA *audiodata = (CS_ADP_HFP_AUDIO_DATA *)cs_hfp_msg->p.dataindP.buff;
737
738 //TRACE("APP:sco_data_int len = %d\n",audiodata->len);
739 AppReceive_ScoData(audiodata->data ,audiodata->len);
740 }
741 break;
742 case CS_ADP_TWS_TRIG_NUM:
743 {
744 CS_ADP_TWS_EVENT *cs_adp_tws_msg = (CS_ADP_TWS_EVENT *)event->Param;
745 app_tws_set_trig_num((AppTwsMediaDataStruct *)cs_adp_tws_msg->p.trigP.tws_trig_data);
746 }
747 break;
748 case CS_ADP_TWS_AUDIO_SYNC_MSG:
749 {
750 CS_ADP_TWS_EVENT *cs_adp_tws_msg = (CS_ADP_TWS_EVENT *)event->Param;
751 app_tws_set_audio_sync_param((AppTwsMediaDataStruct *)cs_adp_tws_msg->p.syncP.tws_sync_data);
752 }
753 break;
754 case CS_ADP_TWS_ADV_DATA:
755 {
756 #if TWS_BLE_CONNECT == 1
757 host_data_struct *rx_data = (host_data_struct *)event->Param;
758 BT_ADDR remove_addr;
759
760 memcpy(remove_addr.addr, &rx_data->data[26], 6);
761 TRACE("APP:remove addr %x,%x,%x,%x,%x,%x\n",remove_addr.addr[0],remove_addr.addr[1],remove_addr.addr[2],\
762 remove_addr.addr[3],remove_addr.addr[4],remove_addr.addr[5]);
763 cs_adp_tws_set_scan_disable();
764 cs_adp_connect_tws_peer_device(&remove_addr);
765 #endif
766 }
767 break;
768 case CS_ADP_TWS_LOST_SEQUENCE:
769 {
770 app_bt_send_bt_audio_restart();
771 }
772 break;
773 case CS_ADP_TWS_DATA_SEND:
774 {
775 CS_ADP_TWS_EVENT *cs_adp_tws_msg = (CS_ADP_TWS_EVENT *)event->Param;
776 host_data_struct *tx_done = (host_data_struct *)cs_adp_tws_msg->p.datasendP.buff;
777
778 switch(tx_done->data[0]){
779 case TWS_KEY_PARAM:
780 if(APP_TWS_LEN_5 == tx_done->len){
781 app_tws_free(tx_done->data);
782 }
783 break;
784 case TWS_SET_VOLUME_PARAM:
785 if(APP_TWS_LEN_3 == tx_done->len){
786 app_tws_free(tx_done->data);
787 }
788 break;
789 case TWS_LINK_CONTROL_PARAM:
790 if(APP_TWS_LEN_2 == tx_done->len){
791 app_tws_free(tx_done->data);
792 }
793 break;
794 case TWS_MSS_PARAM:
795 if(APP_TWS_LEN_2 == tx_done->len){
796 app_tws_free(tx_done->data);
797 }
798 break;
799 case TWS_POWERD_PARAM:
800 if(APP_TWS_LEN_2 == tx_done->len){
801 app_tws_free(tx_done->data);
802 app_tws_set_pd_state(STATE_PD_PENDING);
803 app_tws_power_down();
804 }
805 break;
806 default:
807 break;
808 }
809 }
810 break;
811 case CS_ADP_TWS_DATA_IND:
812 {
813 CS_ADP_TWS_EVENT *cs_adp_tws_msg = (CS_ADP_TWS_EVENT *)event->Param;
814 host_data_struct *rx_done = (host_data_struct *)cs_adp_tws_msg->p.dataindP.buff;
815 #if TWS_SENDING_DATA_TEST == 1
816 TRACE("APP:tws rx len:%d ;data:%x,%x,%x,%x,%x\n",rx_done->len,rx_done->data[0],\
817 rx_done->data[1],rx_done->data[2],rx_done->data[3],rx_done->data[4]);
818 #endif
819 #if PLF_BT_OTA
820 if(app_ota_get_access() == OTA_BY_SPP){
821 app_ota_receive_data(rx_done->data,rx_done->len);
822 break;
823 }
824 #endif
825 switch(rx_done->data[0])
826 {
827 case TWS_KEY_PARAM:
828 if(APP_TWS_LEN_5 == rx_done->len){
829 uint32_t key = 0;
830 uint8_t *data = rx_done->data;
831 key = ((uint32_t)data[1])|(((uint32_t)data[2])<<8)|(((uint32_t)data[3])<<16)|(((uint32_t)data[4])<<24);
832 app_bt_send_key(key);
833 }
834 break;
835 case TWS_SET_VOLUME_PARAM:
836 if(APP_TWS_LEN_3 == rx_done->len){
837 #if APP_SUPPORT_TWS_LOCAL_VOL_SYNC == 1
838 app_tws_volume_sync_handle(rx_done->data[1],rx_done->data[2]);
839 #endif
840 }
841 break;
842 case TWS_LINK_CONTROL_PARAM:
843 if(APP_TWS_LEN_2 == rx_done->len){
844 if(rx_done->data[1] == 0){
845 app_bt_disconnect_tws();
846 }
847 }
848 break;
849 case TWS_MSS_PARAM:
850 if(APP_TWS_LEN_2 == rx_done->len){
851 if(rx_done->data[1] == 1){
852 if(app_tws_get_wear_state() == WEAR_OFF)
853 app_tws_begin_mss();
854 }
855 }
856 break;
857 case TWS_POWERD_PARAM:
858 if(APP_TWS_LEN_2 == rx_done->len){
859 if(rx_done->data[1] == 1){
860 app_tws_set_pd_state(STATE_PD_PENDING);
861 app_tws_power_down();
862 }
863 }
864 break;
865 case TWS_OTA_PARAM:
866 {
867 #if PLF_BT_OTA
868 app_ota_receive_data(&rx_done->data[1],(rx_done->len-1));
869 #endif
870 }
871 break;
872 default :
873 break;
874 }
875 }
876 break;
877 case CS_ADP_TWS_MSS_COMPLETE:
878 {
879 #if TWS_MSS_AUTO_TEST == 1
880 app_tws_start_mss();
881 #endif
882 }
883 break;
884 default:
885 break;
886 }
887 }
888
app_tws_init(void)889 void app_tws_init(void)
890 {
891 #if TWS_MSS_AUTO_TEST == 1
892 app_tws_create_mss_timer();
893 #endif
894 #if TWS_SENDING_DATA_TEST == 1
895 app_tws_create_test_send_timer();
896 #endif
897 }
898 #endif
899