btif_av.c revision 379743beded881127703334e1dda2cd327ec651d 
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
50typedef 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
72typedef 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******************************************************************************/
84static btav_callbacks_t *bt_av_callbacks = NULL;
85static btif_av_cb_t btif_av_cb;
86static 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}\
94else\
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
111static BOOLEAN btif_av_state_idle_handler(btif_sm_event_t event, void *data);
112static BOOLEAN btif_av_state_opening_handler(btif_sm_event_t event, void *data);
113static BOOLEAN btif_av_state_opened_handler(btif_sm_event_t event, void *data);
114static BOOLEAN btif_av_state_started_handler(btif_sm_event_t event, void *data);
115static BOOLEAN btif_av_state_closing_handler(btif_sm_event_t event, void *data);
116
117static 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*************************************************************************/
129extern void btif_rc_handler(tBTA_AV_EVT event, tBTA_AV *p_data);
130extern BOOLEAN btif_rc_get_connected_peer(BD_ADDR peer_addr);
131extern void btif_rc_check_handle_pending_play (BD_ADDR peer_addr, BOOLEAN bSendToApp);
132
133/*****************************************************************************
134** Local helper functions
135******************************************************************************/
136
137const 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
150const 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*******************************************************************************/
201static 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
230static 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
324static 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
396static 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
455static 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
573static 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
718static 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
723static 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
740bt_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
770static 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
795static 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
804static 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*******************************************************************************/
821static 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*******************************************************************************/
841static 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
859static 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
877btif_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
892BOOLEAN 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
923BOOLEAN 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 */
949void 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*******************************************************************************/
965bt_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*******************************************************************************/
1006const 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*******************************************************************************/
1021BOOLEAN 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*******************************************************************************/
1039BOOLEAN 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