1 /******************************************************************************
2 *
3 * Copyright (C) 2009-2012 Broadcom Corporation
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 ******************************************************************************/
18
19
20 /*****************************************************************************
21 *
22 * Filename: btif_av.c
23 *
24 * Description: Bluedroid AV implementation
25 *
26 *****************************************************************************/
27
28 #include <hardware/bluetooth.h>
29 #include "hardware/bt_av.h"
30
31 #define LOG_TAG "BTIF_AV"
32
33 #include "btif_av.h"
34 #include "btif_util.h"
35 #include "btif_profile_queue.h"
36 #include "bta_api.h"
37 #include "btif_media.h"
38 #include "bta_av_api.h"
39 #include "gki.h"
40 #include "bd.h"
41 #include "btu.h"
42
43 /*****************************************************************************
44 ** Constants & Macros
45 ******************************************************************************/
46 #define BTIF_AV_SERVICE_NAME "Advanced Audio"
47
48 #define BTIF_TIMEOUT_AV_OPEN_ON_RC_SECS 2
49
50 typedef enum {
51 BTIF_AV_STATE_IDLE = 0x0,
52 BTIF_AV_STATE_OPENING,
53 BTIF_AV_STATE_OPENED,
54 BTIF_AV_STATE_STARTED,
55 BTIF_AV_STATE_CLOSING
56 } btif_av_state_t;
57
58 /* Should not need dedicated suspend state as actual actions are no
59 different than open state. Suspend flags are needed however to prevent
60 media task from trying to restart stream during remote suspend or while
61 we are in the process of a local suspend */
62
63 #define BTIF_AV_FLAG_LOCAL_SUSPEND_PENDING 0x1
64 #define BTIF_AV_FLAG_REMOTE_SUSPEND 0x2
65 #define BTIF_AV_FLAG_PENDING_START 0x4
66 #define BTIF_AV_FLAG_PENDING_STOP 0x8
67
68 /*****************************************************************************
69 ** Local type definitions
70 ******************************************************************************/
71
72 typedef struct
73 {
74 tBTA_AV_HNDL bta_handle;
75 bt_bdaddr_t peer_bda;
76 btif_sm_handle_t sm_handle;
77 UINT8 flags;
78 tBTA_AV_EDR edr;
79 } btif_av_cb_t;
80
81 /*****************************************************************************
82 ** Static variables
83 ******************************************************************************/
84 static btav_callbacks_t *bt_av_callbacks = NULL;
85 static btif_av_cb_t btif_av_cb;
86 static TIMER_LIST_ENT tle_av_open_on_rc;
87
88 /* both interface and media task needs to be ready to alloc incoming request */
89 #define CHECK_BTAV_INIT() if ((bt_av_callbacks == NULL) || (btif_av_cb.sm_handle == NULL))\
90 {\
91 BTIF_TRACE_WARNING1("%s: BTAV not initialized", __FUNCTION__);\
92 return BT_STATUS_NOT_READY;\
93 }\
94 else\
95 {\
96 BTIF_TRACE_EVENT1("%s", __FUNCTION__);\
97 }
98
99 /* Helper macro to avoid code duplication in the state machine handlers */
100 #define CHECK_RC_EVENT(e, d) \
101 case BTA_AV_RC_OPEN_EVT: \
102 case BTA_AV_RC_CLOSE_EVT: \
103 case BTA_AV_REMOTE_CMD_EVT: \
104 case BTA_AV_VENDOR_CMD_EVT: \
105 case BTA_AV_META_MSG_EVT: \
106 case BTA_AV_RC_FEAT_EVT: \
107 { \
108 btif_rc_handler(e, d);\
109 }break; \
110
111 static BOOLEAN btif_av_state_idle_handler(btif_sm_event_t event, void *data);
112 static BOOLEAN btif_av_state_opening_handler(btif_sm_event_t event, void *data);
113 static BOOLEAN btif_av_state_opened_handler(btif_sm_event_t event, void *data);
114 static BOOLEAN btif_av_state_started_handler(btif_sm_event_t event, void *data);
115 static BOOLEAN btif_av_state_closing_handler(btif_sm_event_t event, void *data);
116
117 static const btif_sm_handler_t btif_av_state_handlers[] =
118 {
119 btif_av_state_idle_handler,
120 btif_av_state_opening_handler,
121 btif_av_state_opened_handler,
122 btif_av_state_started_handler,
123 btif_av_state_closing_handler
124 };
125
126 /*************************************************************************
127 ** Extern functions
128 *************************************************************************/
129 extern void btif_rc_handler(tBTA_AV_EVT event, tBTA_AV *p_data);
130 extern BOOLEAN btif_rc_get_connected_peer(BD_ADDR peer_addr);
131 extern void btif_rc_check_handle_pending_play (BD_ADDR peer_addr, BOOLEAN bSendToApp);
132
133 /*****************************************************************************
134 ** Local helper functions
135 ******************************************************************************/
136
dump_av_sm_state_name(btif_av_state_t state)137 const char *dump_av_sm_state_name(btif_av_state_t state)
138 {
139 switch (state)
140 {
141 CASE_RETURN_STR(BTIF_AV_STATE_IDLE)
142 CASE_RETURN_STR(BTIF_AV_STATE_OPENING)
143 CASE_RETURN_STR(BTIF_AV_STATE_OPENED)
144 CASE_RETURN_STR(BTIF_AV_STATE_STARTED)
145 CASE_RETURN_STR(BTIF_AV_STATE_CLOSING)
146 default: return "UNKNOWN_STATE";
147 }
148 }
149
dump_av_sm_event_name(btif_av_sm_event_t event)150 const char *dump_av_sm_event_name(btif_av_sm_event_t event)
151 {
152 switch((int)event)
153 {
154 CASE_RETURN_STR(BTA_AV_ENABLE_EVT)
155 CASE_RETURN_STR(BTA_AV_REGISTER_EVT)
156 CASE_RETURN_STR(BTA_AV_OPEN_EVT)
157 CASE_RETURN_STR(BTA_AV_CLOSE_EVT)
158 CASE_RETURN_STR(BTA_AV_START_EVT)
159 CASE_RETURN_STR(BTA_AV_STOP_EVT)
160 CASE_RETURN_STR(BTA_AV_PROTECT_REQ_EVT)
161 CASE_RETURN_STR(BTA_AV_PROTECT_RSP_EVT)
162 CASE_RETURN_STR(BTA_AV_RC_OPEN_EVT)
163 CASE_RETURN_STR(BTA_AV_RC_CLOSE_EVT)
164 CASE_RETURN_STR(BTA_AV_REMOTE_CMD_EVT)
165 CASE_RETURN_STR(BTA_AV_REMOTE_RSP_EVT)
166 CASE_RETURN_STR(BTA_AV_VENDOR_CMD_EVT)
167 CASE_RETURN_STR(BTA_AV_VENDOR_RSP_EVT)
168 CASE_RETURN_STR(BTA_AV_RECONFIG_EVT)
169 CASE_RETURN_STR(BTA_AV_SUSPEND_EVT)
170 CASE_RETURN_STR(BTA_AV_PENDING_EVT)
171 CASE_RETURN_STR(BTA_AV_META_MSG_EVT)
172 CASE_RETURN_STR(BTA_AV_REJECT_EVT)
173 CASE_RETURN_STR(BTA_AV_RC_FEAT_EVT)
174 CASE_RETURN_STR(BTIF_SM_ENTER_EVT)
175 CASE_RETURN_STR(BTIF_SM_EXIT_EVT)
176 CASE_RETURN_STR(BTIF_AV_CONNECT_REQ_EVT)
177 CASE_RETURN_STR(BTIF_AV_DISCONNECT_REQ_EVT)
178 CASE_RETURN_STR(BTIF_AV_START_STREAM_REQ_EVT)
179 CASE_RETURN_STR(BTIF_AV_STOP_STREAM_REQ_EVT)
180 CASE_RETURN_STR(BTIF_AV_SUSPEND_STREAM_REQ_EVT)
181 CASE_RETURN_STR(BTIF_AV_RECONFIGURE_REQ_EVT)
182
183 default: return "UNKNOWN_EVENT";
184 }
185 }
186
187 /****************************************************************************
188 ** Local helper functions
189 *****************************************************************************/
190 /*******************************************************************************
191 **
192 ** Function btif_initiate_av_open_tmr_hdlr
193 **
194 ** Description Timer to trigger AV open if the remote headset establishes
195 ** RC connection w/o AV connection. The timer is needed to IOP
196 ** with headsets that do establish AV after RC connection.
197 **
198 ** Returns void
199 **
200 *******************************************************************************/
btif_initiate_av_open_tmr_hdlr(TIMER_LIST_ENT * tle)201 static void btif_initiate_av_open_tmr_hdlr(TIMER_LIST_ENT *tle)
202 {
203 BD_ADDR peer_addr;
204
205 /* is there at least one RC connection - There should be */
206 if (btif_rc_get_connected_peer(peer_addr)) {
207 BTIF_TRACE_DEBUG1("%s Issuing connect to the remote RC peer", __FUNCTION__);
208 btif_sm_dispatch(btif_av_cb.sm_handle, BTIF_AV_CONNECT_REQ_EVT, (void*)&peer_addr);
209 }
210 else
211 {
212 BTIF_TRACE_ERROR1("%s No connected RC peers", __FUNCTION__);
213 }
214 }
215
216 /*****************************************************************************
217 ** Static functions
218 ******************************************************************************/
219
220 /*****************************************************************************
221 **
222 ** Function btif_av_state_idle_handler
223 **
224 ** Description State managing disconnected AV link
225 **
226 ** Returns TRUE if event was processed, FALSE otherwise
227 **
228 *******************************************************************************/
229
btif_av_state_idle_handler(btif_sm_event_t event,void * p_data)230 static BOOLEAN btif_av_state_idle_handler(btif_sm_event_t event, void *p_data)
231 {
232 BTIF_TRACE_DEBUG3("%s event:%s flags %x", __FUNCTION__,
233 dump_av_sm_event_name(event), btif_av_cb.flags);
234
235 switch (event)
236 {
237 case BTIF_SM_ENTER_EVT:
238 /* clear the peer_bda */
239 memset(&btif_av_cb.peer_bda, 0, sizeof(bt_bdaddr_t));
240 btif_av_cb.flags = 0;
241 btif_av_cb.edr = 0;
242 btif_a2dp_on_idle();
243 break;
244
245 case BTIF_SM_EXIT_EVT:
246 break;
247
248 case BTA_AV_ENABLE_EVT:
249 break;
250
251 case BTA_AV_REGISTER_EVT:
252 btif_av_cb.bta_handle = ((tBTA_AV*)p_data)->registr.hndl;
253 break;
254
255 case BTA_AV_PENDING_EVT:
256 case BTIF_AV_CONNECT_REQ_EVT:
257 {
258 if (event == BTIF_AV_CONNECT_REQ_EVT)
259 {
260 memcpy(&btif_av_cb.peer_bda, (bt_bdaddr_t*)p_data, sizeof(bt_bdaddr_t));
261 }
262 else if (event == BTA_AV_PENDING_EVT)
263 {
264 bdcpy(btif_av_cb.peer_bda.address, ((tBTA_AV*)p_data)->pend.bd_addr);
265 }
266 BTA_AvOpen(btif_av_cb.peer_bda.address, btif_av_cb.bta_handle,
267 TRUE, BTA_SEC_NONE);
268 btif_sm_change_state(btif_av_cb.sm_handle, BTIF_AV_STATE_OPENING);
269 } break;
270
271 case BTA_AV_RC_OPEN_EVT:
272 /* IOP_FIX: Jabra 620 only does RC open without AV open whenever it connects. So
273 * as per the AV WP, an AVRC connection cannot exist without an AV connection. Therefore,
274 * we initiate an AV connection if an RC_OPEN_EVT is received when we are in AV_CLOSED state.
275 * We initiate the AV connection after a small 3s timeout to avoid any collisions from the
276 * headsets, as some headsets initiate the AVRC connection first and then
277 * immediately initiate the AV connection
278 *
279 * TODO: We may need to do this only on an AVRCP Play. FixMe
280 */
281
282 BTIF_TRACE_DEBUG0("BTA_AV_RC_OPEN_EVT received w/o AV");
283 memset(&tle_av_open_on_rc, 0, sizeof(tle_av_open_on_rc));
284 tle_av_open_on_rc.param = (UINT32)btif_initiate_av_open_tmr_hdlr;
285 btu_start_timer(&tle_av_open_on_rc, BTU_TTYPE_USER_FUNC,
286 BTIF_TIMEOUT_AV_OPEN_ON_RC_SECS);
287 btif_rc_handler(event, p_data);
288 break;
289
290 case BTA_AV_REMOTE_CMD_EVT:
291 case BTA_AV_VENDOR_CMD_EVT:
292 case BTA_AV_META_MSG_EVT:
293 case BTA_AV_RC_FEAT_EVT:
294 btif_rc_handler(event, (tBTA_AV*)p_data);
295 break;
296
297 case BTA_AV_RC_CLOSE_EVT:
298 if (tle_av_open_on_rc.in_use) {
299 BTIF_TRACE_DEBUG0("BTA_AV_RC_CLOSE_EVT: Stopping AV timer.");
300 btu_stop_timer(&tle_av_open_on_rc);
301 }
302 btif_rc_handler(event, p_data);
303 break;
304
305 default:
306 BTIF_TRACE_WARNING2("%s : unhandled event:%s", __FUNCTION__,
307 dump_av_sm_event_name(event));
308 return FALSE;
309
310 }
311 return TRUE;
312 }
313 /*****************************************************************************
314 **
315 ** Function btif_av_state_opening_handler
316 **
317 ** Description Intermediate state managing events during establishment
318 ** of avdtp channel
319 **
320 ** Returns TRUE if event was processed, FALSE otherwise
321 **
322 *******************************************************************************/
323
btif_av_state_opening_handler(btif_sm_event_t event,void * p_data)324 static BOOLEAN btif_av_state_opening_handler(btif_sm_event_t event, void *p_data)
325 {
326 BTIF_TRACE_DEBUG3("%s event:%s flags %x", __FUNCTION__,
327 dump_av_sm_event_name(event), btif_av_cb.flags);
328
329 switch (event)
330 {
331 case BTIF_SM_ENTER_EVT:
332 /* inform the application that we are entering connecting state */
333 HAL_CBACK(bt_av_callbacks, connection_state_cb,
334 BTAV_CONNECTION_STATE_CONNECTING, &(btif_av_cb.peer_bda));
335 break;
336
337 case BTIF_SM_EXIT_EVT:
338 break;
339
340 case BTA_AV_OPEN_EVT:
341 {
342 tBTA_AV *p_bta_data = (tBTA_AV*)p_data;
343 btav_connection_state_t state;
344 btif_sm_state_t av_state;
345 BTIF_TRACE_DEBUG2("status:%d, edr 0x%x",p_bta_data->open.status,
346 p_bta_data->open.edr);
347
348 if (p_bta_data->open.status == BTA_AV_SUCCESS)
349 {
350 state = BTAV_CONNECTION_STATE_CONNECTED;
351 av_state = BTIF_AV_STATE_OPENED;
352 btif_av_cb.edr = p_bta_data->open.edr;
353 }
354 else
355 {
356 BTIF_TRACE_WARNING1("BTA_AV_OPEN_EVT::FAILED status: %d",
357 p_bta_data->open.status );
358 state = BTAV_CONNECTION_STATE_DISCONNECTED;
359 av_state = BTIF_AV_STATE_IDLE;
360 }
361
362 /* inform the application of the event */
363 HAL_CBACK(bt_av_callbacks, connection_state_cb,
364 state, &(btif_av_cb.peer_bda));
365 /* change state to open/idle based on the status */
366 btif_sm_change_state(btif_av_cb.sm_handle, av_state);
367 /* if queued PLAY command, send it now */
368 btif_rc_check_handle_pending_play(p_bta_data->open.bd_addr,
369 (p_bta_data->open.status == BTA_AV_SUCCESS));
370 btif_queue_advance();
371 } break;
372
373 CHECK_RC_EVENT(event, p_data);
374
375 default:
376 BTIF_TRACE_WARNING2("%s : unhandled event:%s", __FUNCTION__,
377 dump_av_sm_event_name(event));
378 return FALSE;
379
380 }
381 return TRUE;
382 }
383
384
385 /*****************************************************************************
386 **
387 ** Function btif_av_state_closing_handler
388 **
389 ** Description Intermediate state managing events during closing
390 ** of avdtp channel
391 **
392 ** Returns TRUE if event was processed, FALSE otherwise
393 **
394 *******************************************************************************/
395
btif_av_state_closing_handler(btif_sm_event_t event,void * p_data)396 static BOOLEAN btif_av_state_closing_handler(btif_sm_event_t event, void *p_data)
397 {
398 BTIF_TRACE_DEBUG3("%s event:%s flags %x", __FUNCTION__,
399 dump_av_sm_event_name(event), btif_av_cb.flags);
400
401 switch (event)
402 {
403 case BTIF_SM_ENTER_EVT:
404
405 /* immediately stop transmission of frames */
406 btif_a2dp_set_tx_flush(TRUE);
407 /* wait for audioflinger to stop a2dp */
408 break;
409
410 case BTA_AV_STOP_EVT:
411 case BTIF_AV_STOP_STREAM_REQ_EVT:
412 /* immediately flush any pending tx frames while suspend is pending */
413 btif_a2dp_set_tx_flush(TRUE);
414
415 btif_a2dp_on_stopped(NULL);
416
417 break;
418
419 case BTIF_SM_EXIT_EVT:
420 break;
421
422 case BTA_AV_CLOSE_EVT:
423
424 /* inform the application that we are disconnecting */
425 HAL_CBACK(bt_av_callbacks, connection_state_cb,
426 BTAV_CONNECTION_STATE_DISCONNECTED, &(btif_av_cb.peer_bda));
427
428 btif_sm_change_state(btif_av_cb.sm_handle, BTIF_AV_STATE_IDLE);
429 break;
430
431 /* Handle the RC_CLOSE event for the cleanup */
432 case BTA_AV_RC_CLOSE_EVT:
433 btif_rc_handler(event, (tBTA_AV*)p_data);
434 break;
435
436 default:
437 BTIF_TRACE_WARNING2("%s : unhandled event:%s", __FUNCTION__,
438 dump_av_sm_event_name(event));
439 return FALSE;
440 }
441 return TRUE;
442 }
443
444
445 /*****************************************************************************
446 **
447 ** Function btif_av_state_opened_handler
448 **
449 ** Description Handles AV events while AVDTP is in OPEN state
450 **
451 ** Returns TRUE if event was processed, FALSE otherwise
452 **
453 *******************************************************************************/
454
btif_av_state_opened_handler(btif_sm_event_t event,void * p_data)455 static BOOLEAN btif_av_state_opened_handler(btif_sm_event_t event, void *p_data)
456 {
457 tBTA_AV *p_av = (tBTA_AV*)p_data;
458
459 BTIF_TRACE_DEBUG3("%s event:%s flags %x", __FUNCTION__,
460 dump_av_sm_event_name(event), btif_av_cb.flags);
461
462 if ( (event == BTA_AV_REMOTE_CMD_EVT) && (btif_av_cb.flags & BTIF_AV_FLAG_REMOTE_SUSPEND) &&
463 (p_av->remote_cmd.rc_id == BTA_AV_RC_PLAY) )
464 {
465 BTIF_TRACE_EVENT1("%s: Resetting remote suspend flag on RC PLAY", __FUNCTION__);
466 btif_av_cb.flags &= ~BTIF_AV_FLAG_REMOTE_SUSPEND;
467 }
468
469 switch (event)
470 {
471 case BTIF_SM_ENTER_EVT:
472 btif_av_cb.flags &= ~BTIF_AV_FLAG_PENDING_STOP;
473 btif_av_cb.flags &= ~BTIF_AV_FLAG_PENDING_START;
474 break;
475
476 case BTIF_SM_EXIT_EVT:
477 btif_av_cb.flags &= ~BTIF_AV_FLAG_PENDING_START;
478 break;
479
480 case BTIF_AV_START_STREAM_REQ_EVT:
481 btif_a2dp_setup_codec();
482 BTA_AvStart();
483 btif_av_cb.flags |= BTIF_AV_FLAG_PENDING_START;
484 break;
485
486 case BTA_AV_START_EVT:
487 {
488 BTIF_TRACE_EVENT3("BTA_AV_START_EVT status %d, suspending %d, init %d",
489 p_av->start.status, p_av->start.suspending, p_av->start.initiator);
490
491 if ((p_av->start.status == BTA_SUCCESS) && (p_av->start.suspending == TRUE))
492 return TRUE;
493
494 if (btif_a2dp_on_started(&p_av->start,
495 ((btif_av_cb.flags & BTIF_AV_FLAG_PENDING_START) != 0))) {
496 /* only clear pending flag after acknowledgement */
497 btif_av_cb.flags &= ~BTIF_AV_FLAG_PENDING_START;
498 }
499
500 /* remain in open state if status failed */
501 if (p_av->start.status != BTA_AV_SUCCESS)
502 return FALSE;
503
504 /* change state to started, send acknowledgement if start is pending */
505 if (btif_av_cb.flags & BTIF_AV_FLAG_PENDING_START) {
506 btif_a2dp_on_started(NULL, TRUE);
507 /* pending start flag will be cleared when exit current state */
508 }
509 btif_sm_change_state(btif_av_cb.sm_handle, BTIF_AV_STATE_STARTED);
510
511 } break;
512
513 case BTIF_AV_DISCONNECT_REQ_EVT:
514 BTA_AvClose(btif_av_cb.bta_handle);
515
516 /* inform the application that we are disconnecting */
517 HAL_CBACK(bt_av_callbacks, connection_state_cb,
518 BTAV_CONNECTION_STATE_DISCONNECTING, &(btif_av_cb.peer_bda));
519 break;
520
521 case BTA_AV_CLOSE_EVT:
522
523 /* avdtp link is closed */
524 btif_a2dp_on_stopped(NULL);
525
526 /* inform the application that we are disconnected */
527 HAL_CBACK(bt_av_callbacks, connection_state_cb,
528 BTAV_CONNECTION_STATE_DISCONNECTED, &(btif_av_cb.peer_bda));
529
530 /* change state to idle, send acknowledgement if start is pending */
531 if (btif_av_cb.flags & BTIF_AV_FLAG_PENDING_START) {
532 btif_a2dp_ack_fail();
533 /* pending start flag will be cleared when exit current state */
534 }
535 btif_sm_change_state(btif_av_cb.sm_handle, BTIF_AV_STATE_IDLE);
536 break;
537
538 case BTA_AV_RECONFIG_EVT:
539 if((btif_av_cb.flags & BTIF_AV_FLAG_PENDING_START) &&
540 (p_av->reconfig.status == BTA_AV_SUCCESS))
541 {
542 APPL_TRACE_WARNING0("reconfig done BTA_AVstart()");
543 BTA_AvStart();
544 }
545 else if(btif_av_cb.flags & BTIF_AV_FLAG_PENDING_START)
546 {
547 btif_av_cb.flags &= ~BTIF_AV_FLAG_PENDING_START;
548 btif_a2dp_ack_fail();
549 }
550 break;
551
552 CHECK_RC_EVENT(event, p_data);
553
554 default:
555 BTIF_TRACE_WARNING2("%s : unhandled event:%s", __FUNCTION__,
556 dump_av_sm_event_name(event));
557 return FALSE;
558
559 }
560 return TRUE;
561 }
562
563 /*****************************************************************************
564 **
565 ** Function btif_av_state_started_handler
566 **
567 ** Description Handles AV events while A2DP stream is started
568 **
569 ** Returns TRUE if event was processed, FALSE otherwise
570 **
571 *******************************************************************************/
572
btif_av_state_started_handler(btif_sm_event_t event,void * p_data)573 static BOOLEAN btif_av_state_started_handler(btif_sm_event_t event, void *p_data)
574 {
575 tBTA_AV *p_av = (tBTA_AV*)p_data;
576
577 BTIF_TRACE_DEBUG3("%s event:%s flags %x", __FUNCTION__,
578 dump_av_sm_event_name(event), btif_av_cb.flags);
579
580 switch (event)
581 {
582 case BTIF_SM_ENTER_EVT:
583
584 /* we are again in started state, clear any remote suspend flags */
585 btif_av_cb.flags &= ~BTIF_AV_FLAG_REMOTE_SUSPEND;
586
587 HAL_CBACK(bt_av_callbacks, audio_state_cb,
588 BTAV_AUDIO_STATE_STARTED, &(btif_av_cb.peer_bda));
589 break;
590
591 case BTIF_SM_EXIT_EVT:
592 break;
593
594 case BTIF_AV_START_STREAM_REQ_EVT:
595 /* we were remotely started, just ack back the local request */
596 btif_a2dp_on_started(NULL, TRUE);
597 break;
598
599 /* fixme -- use suspend = true always to work around issue with BTA AV */
600 case BTIF_AV_STOP_STREAM_REQ_EVT:
601 case BTIF_AV_SUSPEND_STREAM_REQ_EVT:
602
603 /* set pending flag to ensure btif task is not trying to restart
604 stream while suspend is in progress */
605 btif_av_cb.flags |= BTIF_AV_FLAG_LOCAL_SUSPEND_PENDING;
606
607 /* if we were remotely suspended but suspend locally, local suspend
608 always overrides */
609 btif_av_cb.flags &= ~BTIF_AV_FLAG_REMOTE_SUSPEND;
610
611 /* immediately stop transmission of frames while suspend is pending */
612 btif_a2dp_set_tx_flush(TRUE);
613
614 BTA_AvStop(TRUE);
615 break;
616
617 case BTIF_AV_DISCONNECT_REQ_EVT:
618
619 /* request avdtp to close */
620 BTA_AvClose(btif_av_cb.bta_handle);
621
622 /* inform the application that we are disconnecting */
623 HAL_CBACK(bt_av_callbacks, connection_state_cb,
624 BTAV_CONNECTION_STATE_DISCONNECTING, &(btif_av_cb.peer_bda));
625
626 /* wait in closing state until fully closed */
627 btif_sm_change_state(btif_av_cb.sm_handle, BTIF_AV_STATE_CLOSING);
628 break;
629
630 case BTA_AV_SUSPEND_EVT:
631
632 BTIF_TRACE_EVENT2("BTA_AV_SUSPEND_EVT status %d, init %d",
633 p_av->suspend.status, p_av->suspend.initiator);
634
635 /* a2dp suspended, stop media task until resumed */
636 btif_a2dp_on_suspended(&p_av->suspend);
637
638 /* if not successful, remain in current state */
639 if (p_av->suspend.status != BTA_AV_SUCCESS)
640 {
641 btif_av_cb.flags &= ~BTIF_AV_FLAG_LOCAL_SUSPEND_PENDING;
642
643 /* suspend failed, reset back tx flush state */
644 btif_a2dp_set_tx_flush(FALSE);
645 return FALSE;
646 }
647
648 if (p_av->suspend.initiator != TRUE)
649 {
650 /* remote suspend, notify HAL and await audioflinger to
651 suspend/stop stream */
652
653 /* set remote suspend flag to block media task from restarting
654 stream only if we did not already initiate a local suspend */
655 if ((btif_av_cb.flags & BTIF_AV_FLAG_LOCAL_SUSPEND_PENDING) == 0)
656 btif_av_cb.flags |= BTIF_AV_FLAG_REMOTE_SUSPEND;
657
658 HAL_CBACK(bt_av_callbacks, audio_state_cb,
659 BTAV_AUDIO_STATE_REMOTE_SUSPEND, &(btif_av_cb.peer_bda));
660 }
661 else
662 {
663 HAL_CBACK(bt_av_callbacks, audio_state_cb,
664 BTAV_AUDIO_STATE_STOPPED, &(btif_av_cb.peer_bda));
665 }
666
667 btif_sm_change_state(btif_av_cb.sm_handle, BTIF_AV_STATE_OPENED);
668
669 /* suspend completed and state changed, clear pending status */
670 btif_av_cb.flags &= ~BTIF_AV_FLAG_LOCAL_SUSPEND_PENDING;
671 break;
672
673 case BTA_AV_STOP_EVT:
674
675 btif_av_cb.flags |= BTIF_AV_FLAG_PENDING_STOP;
676
677 btif_a2dp_on_stopped(&p_av->suspend);
678
679 HAL_CBACK(bt_av_callbacks, audio_state_cb,
680 BTAV_AUDIO_STATE_STOPPED, &(btif_av_cb.peer_bda));
681
682 /* if stop was successful, change state to open */
683 if (p_av->suspend.status == BTA_AV_SUCCESS)
684 btif_sm_change_state(btif_av_cb.sm_handle, BTIF_AV_STATE_OPENED);
685
686 break;
687
688 case BTA_AV_CLOSE_EVT:
689
690 btif_av_cb.flags |= BTIF_AV_FLAG_PENDING_STOP;
691
692 /* avdtp link is closed */
693
694 btif_a2dp_on_stopped(NULL);
695
696 /* inform the application that we are disconnected */
697 HAL_CBACK(bt_av_callbacks, connection_state_cb,
698 BTAV_CONNECTION_STATE_DISCONNECTED, &(btif_av_cb.peer_bda));
699
700 btif_sm_change_state(btif_av_cb.sm_handle, BTIF_AV_STATE_IDLE);
701 break;
702
703 CHECK_RC_EVENT(event, p_data);
704
705 default:
706 BTIF_TRACE_WARNING2("%s : unhandled event:%s", __FUNCTION__,
707 dump_av_sm_event_name(event));
708 return FALSE;
709
710 }
711 return TRUE;
712 }
713
714 /*****************************************************************************
715 ** Local event handlers
716 ******************************************************************************/
717
btif_av_handle_event(UINT16 event,char * p_param)718 static void btif_av_handle_event(UINT16 event, char* p_param)
719 {
720 btif_sm_dispatch(btif_av_cb.sm_handle, event, (void*)p_param);
721 }
722
bte_av_callback(tBTA_AV_EVT event,tBTA_AV * p_data)723 static void bte_av_callback(tBTA_AV_EVT event, tBTA_AV *p_data)
724 {
725 /* Switch to BTIF context */
726 btif_transfer_context(btif_av_handle_event, event,
727 (char*)p_data, sizeof(tBTA_AV), NULL);
728 }
729
730 /*******************************************************************************
731 **
732 ** Function btif_av_init
733 **
734 ** Description Initializes btif AV if not already done
735 **
736 ** Returns bt_status_t
737 **
738 *******************************************************************************/
739
btif_av_init(void)740 bt_status_t btif_av_init(void)
741 {
742 if (btif_av_cb.sm_handle == NULL)
743 {
744 if (btif_a2dp_start_media_task() != GKI_SUCCESS)
745 return BT_STATUS_FAIL;
746
747 btif_enable_service(BTA_A2DP_SERVICE_ID);
748
749 /* Also initialize the AV state machine */
750 btif_av_cb.sm_handle = btif_sm_init((const btif_sm_handler_t*)btif_av_state_handlers, BTIF_AV_STATE_IDLE);
751
752 btif_a2dp_on_init();
753
754 return BT_STATUS_SUCCESS;
755 }
756
757 return BT_STATUS_DONE;
758 }
759
760 /*******************************************************************************
761 **
762 ** Function init
763 **
764 ** Description Initializes the AV interface
765 **
766 ** Returns bt_status_t
767 **
768 *******************************************************************************/
769
init(btav_callbacks_t * callbacks)770 static bt_status_t init(btav_callbacks_t* callbacks )
771 {
772 int status;
773
774 BTIF_TRACE_EVENT1("%s", __FUNCTION__);
775
776 if (bt_av_callbacks)
777 return BT_STATUS_DONE;
778
779 bt_av_callbacks = callbacks;
780 btif_av_cb.sm_handle = NULL;
781
782 return btif_av_init();
783 }
784
785 /*******************************************************************************
786 **
787 ** Function connect
788 **
789 ** Description Establishes the AV signalling channel with the remote headset
790 **
791 ** Returns bt_status_t
792 **
793 *******************************************************************************/
794
connect_int(bt_bdaddr_t * bd_addr)795 static bt_status_t connect_int(bt_bdaddr_t *bd_addr)
796 {
797 BTIF_TRACE_EVENT1("%s", __FUNCTION__);
798
799 btif_sm_dispatch(btif_av_cb.sm_handle, BTIF_AV_CONNECT_REQ_EVT, (char*)bd_addr);
800
801 return BT_STATUS_SUCCESS;
802 }
803
connect(bt_bdaddr_t * bd_addr)804 static bt_status_t connect(bt_bdaddr_t *bd_addr)
805 {
806 BTIF_TRACE_EVENT1("%s", __FUNCTION__);
807 CHECK_BTAV_INIT();
808
809 return btif_queue_connect(UUID_SERVCLASS_AUDIO_SOURCE, bd_addr, connect_int);
810 }
811
812 /*******************************************************************************
813 **
814 ** Function disconnect
815 **
816 ** Description Tears down the AV signalling channel with the remote headset
817 **
818 ** Returns bt_status_t
819 **
820 *******************************************************************************/
disconnect(bt_bdaddr_t * bd_addr)821 static bt_status_t disconnect(bt_bdaddr_t *bd_addr)
822 {
823 BTIF_TRACE_EVENT1("%s", __FUNCTION__);
824
825 CHECK_BTAV_INIT();
826
827 /* Switch to BTIF context */
828 return btif_transfer_context(btif_av_handle_event, BTIF_AV_DISCONNECT_REQ_EVT,
829 (char*)bd_addr, sizeof(bt_bdaddr_t), NULL);
830 }
831
832 /*******************************************************************************
833 **
834 ** Function cleanup
835 **
836 ** Description Shuts down the AV interface and does the cleanup
837 **
838 ** Returns None
839 **
840 *******************************************************************************/
cleanup(void)841 static void cleanup(void)
842 {
843 BTIF_TRACE_EVENT1("%s", __FUNCTION__);
844
845 if (bt_av_callbacks)
846 {
847 btif_a2dp_stop_media_task();
848
849 btif_disable_service(BTA_A2DP_SERVICE_ID);
850 bt_av_callbacks = NULL;
851
852 /* Also shut down the AV state machine */
853 btif_sm_shutdown(btif_av_cb.sm_handle);
854 btif_av_cb.sm_handle = NULL;
855 }
856 return;
857 }
858
859 static const btav_interface_t bt_av_interface = {
860 sizeof(btav_interface_t),
861 init,
862 connect,
863 disconnect,
864 cleanup,
865 };
866
867 /*******************************************************************************
868 **
869 ** Function btif_av_get_sm_handle
870 **
871 ** Description Fetches current av SM handle
872 **
873 ** Returns None
874 **
875 *******************************************************************************/
876
btif_av_get_sm_handle(void)877 btif_sm_handle_t btif_av_get_sm_handle(void)
878 {
879 return btif_av_cb.sm_handle;
880 }
881
882 /*******************************************************************************
883 **
884 ** Function btif_av_stream_ready
885 **
886 ** Description Checks whether AV is ready for starting a stream
887 **
888 ** Returns None
889 **
890 *******************************************************************************/
891
btif_av_stream_ready(void)892 BOOLEAN btif_av_stream_ready(void)
893 {
894 btif_sm_state_t state = btif_sm_get_state(btif_av_cb.sm_handle);
895
896 BTIF_TRACE_DEBUG3("btif_av_stream_ready : sm hdl %d, state %d, flags %x",
897 btif_av_cb.sm_handle, state, btif_av_cb.flags);
898
899 /* also make sure main adapter is enabled */
900 if (btif_is_enabled() == 0)
901 {
902 BTIF_TRACE_EVENT0("main adapter not enabled");
903 return FALSE;
904 }
905
906 /* check if we are remotely suspended or stop is pending */
907 if (btif_av_cb.flags & (BTIF_AV_FLAG_REMOTE_SUSPEND|BTIF_AV_FLAG_PENDING_STOP))
908 return FALSE;
909
910 return (state == BTIF_AV_STATE_OPENED);
911 }
912
913 /*******************************************************************************
914 **
915 ** Function btif_av_stream_started_ready
916 **
917 ** Description Checks whether AV ready for media start in streaming state
918 **
919 ** Returns None
920 **
921 *******************************************************************************/
922
btif_av_stream_started_ready(void)923 BOOLEAN btif_av_stream_started_ready(void)
924 {
925 btif_sm_state_t state = btif_sm_get_state(btif_av_cb.sm_handle);
926
927 BTIF_TRACE_DEBUG3("btif_av_stream_started : sm hdl %d, state %d, flags %x",
928 btif_av_cb.sm_handle, state, btif_av_cb.flags);
929
930 /* disallow media task to start if we have pending actions */
931 if (btif_av_cb.flags & (BTIF_AV_FLAG_LOCAL_SUSPEND_PENDING | BTIF_AV_FLAG_REMOTE_SUSPEND
932 | BTIF_AV_FLAG_PENDING_STOP))
933 return FALSE;
934
935 return (state == BTIF_AV_STATE_STARTED);
936 }
937
938 /*******************************************************************************
939 **
940 ** Function btif_dispatch_sm_event
941 **
942 ** Description Send event to AV statemachine
943 **
944 ** Returns None
945 **
946 *******************************************************************************/
947
948 /* used to pass events to AV statemachine from other tasks */
btif_dispatch_sm_event(btif_av_sm_event_t event,void * p_data,int len)949 void btif_dispatch_sm_event(btif_av_sm_event_t event, void *p_data, int len)
950 {
951 /* Switch to BTIF context */
952 btif_transfer_context(btif_av_handle_event, event,
953 (char*)p_data, len, NULL);
954 }
955
956 /*******************************************************************************
957 **
958 ** Function btif_av_execute_service
959 **
960 ** Description Initializes/Shuts down the service
961 **
962 ** Returns BT_STATUS_SUCCESS on success, BT_STATUS_FAIL otherwise
963 **
964 *******************************************************************************/
btif_av_execute_service(BOOLEAN b_enable)965 bt_status_t btif_av_execute_service(BOOLEAN b_enable)
966 {
967 if (b_enable)
968 {
969 /* TODO: Removed BTA_SEC_AUTHORIZE since the Java/App does not
970 * handle this request in order to allow incoming connections to succeed.
971 * We need to put this back once support for this is added */
972
973 /* Added BTA_AV_FEAT_NO_SCO_SSPD - this ensures that the BTA does not
974 * auto-suspend av streaming on AG events(SCO or Call). The suspend shall
975 * be initiated by the app/audioflinger layers */
976 #if (AVRC_METADATA_INCLUDED == TRUE)
977 BTA_AvEnable(BTA_SEC_AUTHENTICATE,
978 BTA_AV_FEAT_RCTG|BTA_AV_FEAT_METADATA|BTA_AV_FEAT_VENDOR|BTA_AV_FEAT_NO_SCO_SSPD
979 #if (AVRC_ADV_CTRL_INCLUDED == TRUE)
980 |BTA_AV_FEAT_RCCT
981 |BTA_AV_FEAT_ADV_CTRL
982 #endif
983 ,bte_av_callback);
984 #else
985 BTA_AvEnable(BTA_SEC_AUTHENTICATE, (BTA_AV_FEAT_RCTG | BTA_AV_FEAT_NO_SCO_SSPD),
986 bte_av_callback);
987 #endif
988 BTA_AvRegister(BTA_AV_CHNL_AUDIO, BTIF_AV_SERVICE_NAME, 0);
989 }
990 else {
991 BTA_AvDeregister(btif_av_cb.bta_handle);
992 BTA_AvDisable();
993 }
994 return BT_STATUS_SUCCESS;
995 }
996
997 /*******************************************************************************
998 **
999 ** Function btif_av_get_interface
1000 **
1001 ** Description Get the AV callback interface
1002 **
1003 ** Returns btav_interface_t
1004 **
1005 *******************************************************************************/
btif_av_get_interface(void)1006 const btav_interface_t *btif_av_get_interface(void)
1007 {
1008 BTIF_TRACE_EVENT1("%s", __FUNCTION__);
1009 return &bt_av_interface;
1010 }
1011
1012 /*******************************************************************************
1013 **
1014 ** Function btif_av_is_connected
1015 **
1016 ** Description Checks if av has a connected sink
1017 **
1018 ** Returns BOOLEAN
1019 **
1020 *******************************************************************************/
btif_av_is_connected(void)1021 BOOLEAN btif_av_is_connected(void)
1022 {
1023 btif_sm_state_t state = btif_sm_get_state(btif_av_cb.sm_handle);
1024 return ((state == BTIF_AV_STATE_OPENED) || (state == BTIF_AV_STATE_STARTED));
1025 }
1026
1027 /*******************************************************************************
1028 **
1029 ** Function btif_av_is_peer_edr
1030 **
1031 ** Description Check if the connected a2dp device supports
1032 ** EDR or not. Only when connected this function
1033 ** will accurately provide a true capability of
1034 ** remote peer. If not connected it will always be false.
1035 **
1036 ** Returns TRUE if remote device is capable of EDR
1037 **
1038 *******************************************************************************/
btif_av_is_peer_edr(void)1039 BOOLEAN btif_av_is_peer_edr(void)
1040 {
1041 ASSERTC(btif_av_is_connected(), "No active a2dp connection", 0);
1042
1043 if (btif_av_cb.edr)
1044 return TRUE;
1045 else
1046 return FALSE;
1047 }
1048
1049