bta/av/bta_av_main.cc

   1 /******************************************************************************
   2  *
   3  *  Copyright 2004-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  *  This is the main implementation file for the BTA advanced audio/video.
  22  *
  23  ******************************************************************************/
  24
  25 #define LOG_TAG "bt_bta_av"
  26
  27 #include <cstdint>
  28
  29 #include "bt_target.h"  // Must be first to define build configuration
  30
  31 #include "bta/av/bta_av_int.h"
  32 #include "bta/include/bta_ar_api.h"
  33 #include "bta/include/utl.h"
  34 #include "btif/avrcp/avrcp_service.h"
  35 #include "btif/include/btif_av_co.h"
  36 #include "btif/include/btif_config.h"
  37 #include "main/shim/dumpsys.h"
  38 #include "osi/include/log.h"
  39 #include "osi/include/osi.h"  // UNUSED_ATTR
  40 #include "osi/include/properties.h"
  41 #include "stack/include/acl_api.h"
  42 #include "types/hci_role.h"
  43
  44 /*****************************************************************************
  45  * Constants and types
  46  ****************************************************************************/
  47
  48 #ifndef BTA_AV_RET_TOUT
  49 #define BTA_AV_RET_TOUT 4
  50 #endif
  51
  52 #ifndef BTA_AV_SIG_TOUT
  53 #define BTA_AV_SIG_TOUT 4
  54 #endif
  55
  56 #ifndef BTA_AV_IDLE_TOUT
  57 #define BTA_AV_IDLE_TOUT 10
  58 #endif
  59
  60 /* the delay time in milliseconds to retry role switch */
  61 #ifndef BTA_AV_RS_TIME_VAL
  62 #define BTA_AV_RS_TIME_VAL 1000
  63 #endif
  64
  65 #ifndef AVRCP_VERSION_PROPERTY
  66 #define AVRCP_VERSION_PROPERTY "persist.bluetooth.avrcpversion"
  67 #endif
  68
  69 #ifndef AVRCP_1_6_STRING
  70 #define AVRCP_1_6_STRING "avrcp16"
  71 #endif
  72
  73 #ifndef AVRCP_1_5_STRING
  74 #define AVRCP_1_5_STRING "avrcp15"
  75 #endif
  76
  77 #ifndef AVRCP_1_4_STRING
  78 #define AVRCP_1_4_STRING "avrcp14"
  79 #endif
  80
  81 #ifndef AVRCP_1_3_STRING
  82 #define AVRCP_1_3_STRING "avrcp13"
  83 #endif
  84
  85 #ifndef AVRCP_DEFAULT_VERSION
  86 #define AVRCP_DEFAULT_VERSION AVRCP_1_5_STRING
  87 #endif
  88
  89 /* state machine states */
  90 enum { BTA_AV_INIT_ST, BTA_AV_OPEN_ST };
  91
  92 typedef void (*tBTA_AV_NSM_ACT)(tBTA_AV_DATA* p_data);
  93 static void bta_av_api_enable(tBTA_AV_DATA* p_data);
  94 static void bta_av_api_register(tBTA_AV_DATA* p_data);
  95 static void bta_av_ci_data(tBTA_AV_DATA* p_data);
  96 static void bta_av_rpc_conn(tBTA_AV_DATA* p_data);
  97 static void bta_av_api_to_ssm(tBTA_AV_DATA* p_data);
  98
  99 static void bta_av_sco_chg_cback(tBTA_SYS_CONN_STATUS status, uint8_t id,
 100                                  uint8_t app_id, const RawAddress& peer_addr);
 101 static void bta_av_sys_rs_cback(tBTA_SYS_CONN_STATUS status, uint8_t id,
 102                                 uint8_t app_id, const RawAddress& peer_addr);
 103
 104 /*****************************************************************************
 105  * Global data
 106  ****************************************************************************/
 107
 108 /* AV control block */
 109 tBTA_AV_CB bta_av_cb = {};
 110
 111 static const char* bta_av_st_code(uint8_t state);
 112
 113 /*******************************************************************************
 114  *
 115  * Function         bta_av_api_enable
 116  *
 117  * Description      Handle an API enable event.
 118  *
 119  *
 120  * Returns          void
 121  *
 122  ******************************************************************************/
 123 static void bta_av_api_enable(tBTA_AV_DATA* p_data) {
 124   if (bta_av_cb.disabling) {
 125     APPL_TRACE_WARNING(
 126         "%s: previous (reg_audio=%#x) is still disabling (attempts=%d)",
 127         __func__, bta_av_cb.reg_audio, bta_av_cb.enabling_attempts);
 128     if (++bta_av_cb.enabling_attempts <= kEnablingAttemptsCountMaximum) {
 129       tBTA_AV_API_ENABLE* p_buf =
 130           (tBTA_AV_API_ENABLE*)osi_malloc(sizeof(tBTA_AV_API_ENABLE));
 131       memcpy(p_buf, &p_data->api_enable, sizeof(tBTA_AV_API_ENABLE));
 132       bta_sys_sendmsg_delayed(p_buf, base::TimeDelta::FromMilliseconds(
 133                                          kEnablingAttemptsIntervalMs));
 134       return;
 135     }
 136     if (bta_av_cb.sdp_a2dp_handle) {
 137       SDP_DeleteRecord(bta_av_cb.sdp_a2dp_handle);
 138       bta_sys_remove_uuid(UUID_SERVCLASS_AUDIO_SOURCE);
 139     }
 140 #if (BTA_AV_SINK_INCLUDED == TRUE)
 141     if (bta_av_cb.sdp_a2dp_snk_handle) {
 142       SDP_DeleteRecord(bta_av_cb.sdp_a2dp_snk_handle);
 143       bta_sys_remove_uuid(UUID_SERVCLASS_AUDIO_SINK);
 144     }
 145 #endif
 146     // deregister from AVDT
 147     bta_ar_dereg_avdt();
 148
 149     // deregister from AVCT
 150     bta_ar_dereg_avrc(UUID_SERVCLASS_AV_REMOTE_CONTROL);
 151     bta_ar_dereg_avrc(UUID_SERVCLASS_AV_REM_CTRL_TARGET);
 152     bta_ar_dereg_avct();
 153   }
 154
 155   /* initialize control block */
 156   memset(&bta_av_cb, 0, sizeof(tBTA_AV_CB));
 157
 158   for (int i = 0; i < BTA_AV_NUM_RCB; i++)
 159     bta_av_cb.rcb[i].handle = BTA_AV_RC_HANDLE_NONE;
 160
 161   bta_av_cb.rc_acp_handle = BTA_AV_RC_HANDLE_NONE;
 162
 163   /*
 164    * TODO: The "disable" event handling is missing - there we need
 165    * to alarm_free() the alarms below.
 166    */
 167   bta_av_cb.link_signalling_timer = alarm_new("bta_av.link_signalling_timer");
 168   bta_av_cb.accept_signalling_timer =
 169       alarm_new("bta_av.accept_signalling_timer");
 170
 171   /* store parameters */
 172   bta_av_cb.p_cback = p_data->api_enable.p_cback;
 173   bta_av_cb.features = p_data->api_enable.features;
 174
 175   tBTA_AV_ENABLE enable;
 176   enable.features = bta_av_cb.features;
 177
 178   /* Register for SCO change event */
 179   bta_sys_sco_register(bta_av_sco_chg_cback);
 180
 181   /* call callback with enable event */
 182   tBTA_AV bta_av_data;
 183   bta_av_data.enable = enable;
 184   (*bta_av_cb.p_cback)(BTA_AV_ENABLE_EVT, &bta_av_data);
 185 }
 186
 187 /*******************************************************************************
 188  *
 189  * Function         bta_av_addr_to_scb
 190  *
 191  * Description      find the stream control block by the peer addr
 192  *
 193  * Returns          void
 194  *
 195  ******************************************************************************/
 196 tBTA_AV_SCB* bta_av_addr_to_scb(const RawAddress& bd_addr) {
 197   tBTA_AV_SCB* p_scb = NULL;
 198   int xx;
 199
 200   for (xx = 0; xx < BTA_AV_NUM_STRS; xx++) {
 201     if (bta_av_cb.p_scb[xx]) {
 202       if (bd_addr == bta_av_cb.p_scb[xx]->PeerAddress()) {
 203         p_scb = bta_av_cb.p_scb[xx];
 204         break;
 205       }
 206     }
 207   }
 208   return p_scb;
 209 }
 210
 211 int BTA_AvObtainPeerChannelIndex(const RawAddress& peer_address) {
 212   // Find the entry for the peer (if exists)
 213   tBTA_AV_SCB* p_scb = bta_av_addr_to_scb(peer_address);
 214   if (p_scb != nullptr) {
 215     return p_scb->hdi;
 216   }
 217
 218   // Find the index for an entry that is not used
 219   for (int index = 0; index < BTA_AV_NUM_STRS; index++) {
 220     tBTA_AV_SCB* p_scb = bta_av_cb.p_scb[index];
 221     if (p_scb == nullptr) {
 222       continue;
 223     }
 224     if (p_scb->PeerAddress().IsEmpty()) {
 225       return p_scb->hdi;
 226     }
 227   }
 228
 229   return -1;
 230 }
 231
 232 /*******************************************************************************
 233  *
 234  * Function         bta_av_hndl_to_scb
 235  *
 236  * Description      find the stream control block by the handle
 237  *
 238  * Returns          void
 239  *
 240  ******************************************************************************/
 241 tBTA_AV_SCB* bta_av_hndl_to_scb(uint16_t handle) {
 242   tBTA_AV_HNDL hndl = (tBTA_AV_HNDL)handle;
 243   tBTA_AV_SCB* p_scb = NULL;
 244   uint8_t idx = (hndl & BTA_AV_HNDL_MSK);
 245
 246   if (idx && (idx <= BTA_AV_NUM_STRS)) {
 247     p_scb = bta_av_cb.p_scb[idx - 1];
 248   }
 249   return p_scb;
 250 }
 251
 252 /*******************************************************************************
 253  *
 254  * Function         bta_av_alloc_scb
 255  *
 256  * Description      allocate stream control block,
 257  *                  register the service to stack
 258  *                  create SDP record
 259  *
 260  * Returns          void
 261  *
 262  ******************************************************************************/
 263 static tBTA_AV_SCB* bta_av_alloc_scb(tBTA_AV_CHNL chnl) {
 264   if (chnl != BTA_AV_CHNL_AUDIO) {
 265     APPL_TRACE_ERROR("%s: bad channel: %d", __func__, chnl);
 266     return nullptr;
 267   }
 268
 269   for (int xx = 0; xx < BTA_AV_NUM_STRS; xx++) {
 270     if (bta_av_cb.p_scb[xx] != nullptr) continue;
 271     // Found an empty spot
 272     // TODO: After tBTA_AV_SCB is changed to a proper class, the entry
 273     // here should be allocated by C++ 'new' statement.
 274     tBTA_AV_SCB* p_ret = (tBTA_AV_SCB*)osi_calloc(sizeof(tBTA_AV_SCB));
 275     p_ret->rc_handle = BTA_AV_RC_HANDLE_NONE;
 276     p_ret->chnl = chnl;
 277     p_ret->hndl = (tBTA_AV_HNDL)((xx + 1) | chnl);
 278     p_ret->hdi = xx;
 279     p_ret->a2dp_list = list_new(nullptr);
 280     p_ret->avrc_ct_timer = alarm_new("bta_av.avrc_ct_timer");
 281     bta_av_cb.p_scb[xx] = p_ret;
 282     return p_ret;
 283   }
 284
 285   return nullptr;
 286 }
 287
 288 void bta_av_free_scb(tBTA_AV_SCB* p_scb) {
 289   if (p_scb == nullptr) return;
 290   uint8_t scb_index = p_scb->hdi;
 291   CHECK(scb_index < BTA_AV_NUM_STRS);
 292
 293   CHECK(p_scb == bta_av_cb.p_scb[scb_index]);
 294   bta_av_cb.p_scb[scb_index] = nullptr;
 295   alarm_free(p_scb->avrc_ct_timer);
 296   // TODO: After tBTA_AV_SCB is changed to a proper class, the entry
 297   // here should be de-allocated by C++ 'delete' statement.
 298   osi_free(p_scb);
 299 }
 300
 301 void tBTA_AV_SCB::OnConnected(const RawAddress& peer_address) {
 302   peer_address_ = peer_address;
 303
 304   if (peer_address.IsEmpty()) {
 305     LOG_ERROR("%s: Invalid peer address: %s", __func__,
 306               peer_address.ToString().c_str());
 307     return;
 308   }
 309
 310   // Read and restore the AVDTP version from local storage
 311   uint16_t avdtp_version = 0;
 312   size_t version_value_size = sizeof(avdtp_version);
 313   if (!btif_config_get_bin(peer_address_.ToString(), AVDTP_VERSION_CONFIG_KEY,
 314                            (uint8_t*)&avdtp_version, &version_value_size)) {
 315     LOG_WARN("%s: Failed to read cached peer AVDTP version for %s", __func__,
 316              peer_address_.ToString().c_str());
 317   } else {
 318     SetAvdtpVersion(avdtp_version);
 319   }
 320 }
 321
 322 void tBTA_AV_SCB::OnDisconnected() {
 323   peer_address_ = RawAddress::kEmpty;
 324   SetAvdtpVersion(0);
 325 }
 326
 327 void tBTA_AV_SCB::SetAvdtpVersion(uint16_t avdtp_version) {
 328   avdtp_version_ = avdtp_version;
 329   LOG_INFO("%s: AVDTP version for %s set to 0x%x", __func__,
 330            peer_address_.ToString().c_str(), avdtp_version_);
 331 }
 332
 333 /*******************************************************************************
 334  ******************************************************************************/
 335 void bta_av_conn_cback(UNUSED_ATTR uint8_t handle, const RawAddress& bd_addr,
 336                        uint8_t event, tAVDT_CTRL* p_data, uint8_t scb_index) {
 337   uint16_t evt = 0;
 338   tBTA_AV_SCB* p_scb = NULL;
 339
 340   if (event == BTA_AR_AVDT_CONN_EVT || event == AVDT_CONNECT_IND_EVT ||
 341       event == AVDT_DISCONNECT_IND_EVT)
 342   {
 343     evt = BTA_AV_SIG_CHG_EVT;
 344     if (event == AVDT_DISCONNECT_IND_EVT) {
 345       p_scb = bta_av_addr_to_scb(bd_addr);
 346     } else if (event == AVDT_CONNECT_IND_EVT) {
 347       APPL_TRACE_DEBUG("%s: CONN_IND is ACP:%d", __func__,
 348                        p_data->hdr.err_param);
 349     }
 350
 351     tBTA_AV_STR_MSG* p_msg =
 352         (tBTA_AV_STR_MSG*)osi_malloc(sizeof(tBTA_AV_STR_MSG));
 353     p_msg->hdr.event = evt;
 354     p_msg->hdr.layer_specific = event;
 355     p_msg->hdr.offset = p_data->hdr.err_param;
 356     p_msg->bd_addr = bd_addr;
 357     p_msg->scb_index = scb_index;
 358     if (p_scb) {
 359       APPL_TRACE_DEBUG("%s: bta_handle x%x, role x%x", __func__, p_scb->hndl,
 360                        p_scb->role);
 361     }
 362     LOG_INFO("%s: conn_cback bd_addr: %s", __func__,
 363              bd_addr.ToString().c_str());
 364     bta_sys_sendmsg(p_msg);
 365   }
 366 }
 367
 368 /*******************************************************************************
 369  *
 370  * Function         bta_av_a2dp_report_cback
 371  *
 372  * Description      A2DP report callback.
 373  *
 374  * Returns          void
 375  *
 376  ******************************************************************************/
 377 static void bta_av_a2dp_report_cback(UNUSED_ATTR uint8_t handle,
 378                                      UNUSED_ATTR AVDT_REPORT_TYPE type,
 379                                      UNUSED_ATTR tAVDT_REPORT_DATA* p_data) {
 380   /* Do not need to handle report data for now.
 381    * This empty function is here for conformance reasons. */
 382 }
 383
 384 /*******************************************************************************
 385  *
 386  * Function         bta_av_api_register
 387  *
 388  * Description      allocate stream control block,
 389  *                  register the service to stack
 390  *                  create SDP record
 391  *
 392  * Returns          void
 393  *
 394  ******************************************************************************/
 395 static void bta_av_api_register(tBTA_AV_DATA* p_data) {
 396   tBTA_AV_REGISTER registr;
 397   tBTA_AV_SCB* p_scb; /* stream control block */
 398   AvdtpRcb reg;
 399   AvdtpStreamConfig avdtp_stream_config;
 400   char* p_service_name;
 401   tBTA_UTL_COD cod;
 402
 403   if (bta_av_cb.disabling || (bta_av_cb.features == 0)) {
 404     APPL_TRACE_WARNING(
 405         "%s: AV instance (features=%#x, reg_audio=%#x) is not "
 406         "ready for app_id %d",
 407         __func__, bta_av_cb.features, bta_av_cb.reg_audio,
 408         p_data->api_reg.app_id);
 409     tBTA_AV_API_REG* p_buf =
 410         (tBTA_AV_API_REG*)osi_malloc(sizeof(tBTA_AV_API_REG));
 411     memcpy(p_buf, &p_data->api_reg, sizeof(tBTA_AV_API_REG));
 412     bta_sys_sendmsg_delayed(
 413         p_buf, base::TimeDelta::FromMilliseconds(kEnablingAttemptsIntervalMs));
 414     return;
 415   }
 416
 417   avdtp_stream_config.Reset();
 418
 419   registr.status = BTA_AV_FAIL_RESOURCES;
 420   registr.app_id = p_data->api_reg.app_id;
 421   registr.chnl = (tBTA_AV_CHNL)p_data->hdr.layer_specific;
 422
 423   char avrcp_version[PROPERTY_VALUE_MAX] = {0};
 424   osi_property_get(AVRCP_VERSION_PROPERTY, avrcp_version,
 425                    AVRCP_DEFAULT_VERSION);
 426   LOG_INFO("%s: AVRCP version used for sdp: \"%s\"", __func__, avrcp_version);
 427
 428   uint16_t profile_initialized = p_data->api_reg.service_uuid;
 429   if (profile_initialized == UUID_SERVCLASS_AUDIO_SINK) {
 430     p_bta_av_cfg = &bta_avk_cfg;
 431   } else if (profile_initialized == UUID_SERVCLASS_AUDIO_SOURCE) {
 432     p_bta_av_cfg = &bta_av_cfg;
 433
 434     if (!strncmp(AVRCP_1_3_STRING, avrcp_version, sizeof(AVRCP_1_3_STRING))) {
 435       LOG_INFO("%s: AVRCP 1.3 capabilites used", __func__);
 436       p_bta_av_cfg = &bta_av_cfg_compatibility;
 437     }
 438   }
 439
 440   APPL_TRACE_DEBUG("%s: profile: 0x%x", __func__, profile_initialized);
 441   if (p_bta_av_cfg == NULL) {
 442     APPL_TRACE_ERROR("%s: AV configuration is null!", __func__);
 443     return;
 444   }
 445
 446   do {
 447     p_scb = bta_av_alloc_scb(registr.chnl);
 448     if (p_scb == NULL) {
 449       APPL_TRACE_ERROR("%s: failed to alloc SCB", __func__);
 450       break;
 451     }
 452
 453     registr.hndl = p_scb->hndl;
 454     p_scb->app_id = registr.app_id;
 455
 456     /* initialize the stream control block */
 457     registr.status = BTA_AV_SUCCESS;
 458
 459     if (bta_av_cb.reg_audio == 0) {
 460       /* the first channel registered. register to AVDTP */
 461       reg.ctrl_mtu = 672;
 462       reg.ret_tout = BTA_AV_RET_TOUT;
 463       reg.sig_tout = BTA_AV_SIG_TOUT;
 464       reg.idle_tout = BTA_AV_IDLE_TOUT;
 465       reg.scb_index = p_scb->hdi;
 466       bta_ar_reg_avdt(&reg, bta_av_conn_cback);
 467       bta_sys_role_chg_register(&bta_av_sys_rs_cback);
 468
 469       /* create remote control TG service if required */
 470       if (bta_av_cb.features & (BTA_AV_FEAT_RCTG)) {
 471         /* register with no authorization; let AVDTP use authorization instead
 472          */
 473         bta_ar_reg_avct();
 474
 475         /* For the Audio Sink role we support additional TG to support
 476          * absolute volume.
 477          */
 478         if (is_new_avrcp_enabled()) {
 479           APPL_TRACE_DEBUG("%s: newavrcp is the owner of the AVRCP Target SDP "
 480               "record. Don't create the SDP record", __func__);
 481         } else {
 482           APPL_TRACE_DEBUG("%s: newavrcp is not enabled. Create SDP record",
 483               __func__);
 484
 485           uint16_t profile_version = AVRC_REV_1_0;
 486           if (!strncmp(AVRCP_1_6_STRING, avrcp_version,
 487                       sizeof(AVRCP_1_6_STRING))) {
 488             profile_version = AVRC_REV_1_6;
 489           } else if (!strncmp(AVRCP_1_5_STRING, avrcp_version,
 490                               sizeof(AVRCP_1_5_STRING))) {
 491             profile_version = AVRC_REV_1_5;
 492           } else if (!strncmp(AVRCP_1_3_STRING, avrcp_version,
 493                               sizeof(AVRCP_1_3_STRING))) {
 494             profile_version = AVRC_REV_1_3;
 495           } else {
 496             profile_version = AVRC_REV_1_4;
 497           }
 498
 499           bta_ar_reg_avrc(
 500               UUID_SERVCLASS_AV_REM_CTRL_TARGET, "AV Remote Control Target", NULL,
 501               p_bta_av_cfg->avrc_tg_cat,
 502               (bta_av_cb.features & BTA_AV_FEAT_BROWSE), profile_version);
 503         }
 504       }
 505
 506       /* Set the Capturing service class bit */
 507       if (profile_initialized == UUID_SERVCLASS_AUDIO_SOURCE)
 508         cod.service = BTM_COD_SERVICE_CAPTURING;
 509       else if (profile_initialized == UUID_SERVCLASS_AUDIO_SINK)
 510         cod.service = BTM_COD_SERVICE_RENDERING;
 511       utl_set_device_class(&cod, BTA_UTL_SET_COD_SERVICE_CLASS);
 512     } /* if 1st channel */
 513
 514     /* get stream configuration and create stream */
 515     avdtp_stream_config.cfg.num_codec = 1;
 516     avdtp_stream_config.nsc_mask = AvdtpStreamConfig::AVDT_NSC_RECONFIG;
 517     if (!(bta_av_cb.features & BTA_AV_FEAT_PROTECT)) {
 518       avdtp_stream_config.nsc_mask |= AvdtpStreamConfig::AVDT_NSC_SECURITY;
 519     }
 520     APPL_TRACE_DEBUG("%s: nsc_mask: 0x%x", __func__,
 521                      avdtp_stream_config.nsc_mask);
 522
 523     if (p_data->api_reg.p_service_name[0] == 0) {
 524       p_service_name = NULL;
 525     } else {
 526       p_service_name = p_data->api_reg.p_service_name;
 527     }
 528
 529     p_scb->suspend_sup = true;
 530     p_scb->recfg_sup = true;
 531
 532     avdtp_stream_config.scb_index = p_scb->hdi;
 533     avdtp_stream_config.p_avdt_ctrl_cback = &bta_av_proc_stream_evt;
 534
 535     /* set up the audio stream control block */
 536     p_scb->p_cos = &bta_av_a2dp_cos;
 537     p_scb->media_type = AVDT_MEDIA_TYPE_AUDIO;
 538     avdtp_stream_config.cfg.psc_mask = AVDT_PSC_TRANS;
 539     avdtp_stream_config.media_type = AVDT_MEDIA_TYPE_AUDIO;
 540     avdtp_stream_config.mtu = MAX_3MBPS_AVDTP_MTU;
 541     btav_a2dp_codec_index_t codec_index_min = BTAV_A2DP_CODEC_INDEX_SOURCE_MIN;
 542     btav_a2dp_codec_index_t codec_index_max = BTAV_A2DP_CODEC_INDEX_SOURCE_MAX;
 543
 544     if (bta_av_cb.features & BTA_AV_FEAT_REPORT) {
 545       avdtp_stream_config.cfg.psc_mask |= AVDT_PSC_REPORT;
 546       avdtp_stream_config.p_report_cback = bta_av_a2dp_report_cback;
 547     }
 548     if (bta_av_cb.features & BTA_AV_FEAT_DELAY_RPT)
 549       avdtp_stream_config.cfg.psc_mask |= AVDT_PSC_DELAY_RPT;
 550
 551     if (profile_initialized == UUID_SERVCLASS_AUDIO_SOURCE) {
 552       avdtp_stream_config.tsep = AVDT_TSEP_SRC;
 553       codec_index_min = BTAV_A2DP_CODEC_INDEX_SOURCE_MIN;
 554       codec_index_max = BTAV_A2DP_CODEC_INDEX_SOURCE_MAX;
 555     } else if (profile_initialized == UUID_SERVCLASS_AUDIO_SINK) {
 556       avdtp_stream_config.tsep = AVDT_TSEP_SNK;
 557       avdtp_stream_config.p_sink_data_cback = bta_av_sink_data_cback;
 558       codec_index_min = BTAV_A2DP_CODEC_INDEX_SINK_MIN;
 559       codec_index_max = BTAV_A2DP_CODEC_INDEX_SINK_MAX;
 560     }
 561
 562     /* Initialize handles to zero */
 563     for (int xx = 0; xx < BTAV_A2DP_CODEC_INDEX_MAX; xx++) {
 564       p_scb->seps[xx].av_handle = 0;
 565     }
 566
 567     /* keep the configuration in the stream control block */
 568     p_scb->cfg = avdtp_stream_config.cfg;
 569     for (int i = codec_index_min; i < codec_index_max; i++) {
 570       btav_a2dp_codec_index_t codec_index =
 571           static_cast<btav_a2dp_codec_index_t>(i);
 572       if (!bta_av_co_is_supported_codec(codec_index)) {
 573         continue;
 574       }
 575       if (!(*bta_av_a2dp_cos.init)(codec_index, &avdtp_stream_config.cfg)) {
 576         continue;
 577       }
 578       if (AVDT_CreateStream(p_scb->app_id, &p_scb->seps[codec_index].av_handle,
 579                             avdtp_stream_config) != AVDT_SUCCESS) {
 580         APPL_TRACE_WARNING(
 581             "%s: bta_handle=0x%x (app_id %d) failed to alloc an SEP index:%d",
 582             __func__, p_scb->hndl, p_scb->app_id, codec_index);
 583         continue;
 584       }
 585       /* Save a copy of the codec */
 586       memcpy(p_scb->seps[codec_index].codec_info,
 587              avdtp_stream_config.cfg.codec_info, AVDT_CODEC_SIZE);
 588       p_scb->seps[codec_index].tsep = avdtp_stream_config.tsep;
 589       if (avdtp_stream_config.tsep == AVDT_TSEP_SNK) {
 590         p_scb->seps[codec_index].p_app_sink_data_cback =
 591             p_data->api_reg.p_app_sink_data_cback;
 592       } else {
 593         /* In case of A2DP SOURCE we don't need a callback to
 594          * handle media packets.
 595          */
 596         p_scb->seps[codec_index].p_app_sink_data_cback = NULL;
 597       }
 598     }
 599
 600     if (!bta_av_cb.reg_audio) {
 601       bta_av_cb.sdp_a2dp_handle = 0;
 602       bta_av_cb.sdp_a2dp_snk_handle = 0;
 603       if (profile_initialized == UUID_SERVCLASS_AUDIO_SOURCE) {
 604         /* create the SDP records on the 1st audio channel */
 605         bta_av_cb.sdp_a2dp_handle = SDP_CreateRecord();
 606         A2DP_AddRecord(UUID_SERVCLASS_AUDIO_SOURCE, p_service_name, NULL,
 607                        A2DP_SUPF_PLAYER, bta_av_cb.sdp_a2dp_handle);
 608         bta_sys_add_uuid(UUID_SERVCLASS_AUDIO_SOURCE);
 609       } else if (profile_initialized == UUID_SERVCLASS_AUDIO_SINK) {
 610 #if (BTA_AV_SINK_INCLUDED == TRUE)
 611         bta_av_cb.sdp_a2dp_snk_handle = SDP_CreateRecord();
 612         A2DP_AddRecord(UUID_SERVCLASS_AUDIO_SINK, p_service_name, NULL,
 613                        A2DP_SUPF_PLAYER, bta_av_cb.sdp_a2dp_snk_handle);
 614         bta_sys_add_uuid(UUID_SERVCLASS_AUDIO_SINK);
 615 #endif
 616       }
 617       /* start listening when A2DP is registered */
 618       if (bta_av_cb.features & BTA_AV_FEAT_RCTG)
 619         bta_av_rc_create(&bta_av_cb, AVCT_ACP, 0, BTA_AV_NUM_LINKS + 1);
 620
 621       /* if the AV and AVK are both supported, it cannot support the CT role
 622        */
 623       if (bta_av_cb.features & (BTA_AV_FEAT_RCCT)) {
 624         /* if TG is not supported, we need to register to AVCT now */
 625         if ((bta_av_cb.features & (BTA_AV_FEAT_RCTG)) == 0) {
 626           bta_ar_reg_avct();
 627           bta_av_rc_create(&bta_av_cb, AVCT_ACP, 0, BTA_AV_NUM_LINKS + 1);
 628         }
 629         /* create an SDP record as AVRC CT. We create 1.3 for SOURCE
 630          * because we rely on feature bits being scanned by external
 631          * devices more than the profile version itself.
 632          *
 633          * We create 1.4 for SINK since we support browsing.
 634          */
 635         if (profile_initialized == UUID_SERVCLASS_AUDIO_SOURCE) {
 636           bta_ar_reg_avrc(UUID_SERVCLASS_AV_REMOTE_CONTROL, NULL, NULL,
 637                           p_bta_av_cfg->avrc_ct_cat,
 638                           (bta_av_cb.features & BTA_AV_FEAT_BROWSE),
 639                           AVRC_REV_1_3);
 640         } else if (profile_initialized == UUID_SERVCLASS_AUDIO_SINK) {
 641           bta_ar_reg_avrc(UUID_SERVCLASS_AV_REMOTE_CONTROL, NULL, NULL,
 642                           p_bta_av_cfg->avrc_ct_cat,
 643                           (bta_av_cb.features & BTA_AV_FEAT_BROWSE),
 644                           AVRC_REV_1_6);
 645         }
 646       }
 647     }
 648     bta_av_cb.reg_audio |= BTA_AV_HNDL_TO_MSK(p_scb->hdi);
 649     APPL_TRACE_DEBUG("%s: reg_audio: 0x%x", __func__, bta_av_cb.reg_audio);
 650   } while (0);
 651
 652   /* call callback with register event */
 653   tBTA_AV bta_av_data;
 654   bta_av_data.registr = registr;
 655   (*bta_av_cb.p_cback)(BTA_AV_REGISTER_EVT, &bta_av_data);
 656 }
 657
 658 /*******************************************************************************
 659  *
 660  * Function         bta_av_api_deregister
 661  *
 662  * Description      de-register a channel
 663  *
 664  *
 665  * Returns          void
 666  *
 667  ******************************************************************************/
 668 void bta_av_api_deregister(tBTA_AV_DATA* p_data) {
 669   tBTA_AV_SCB* p_scb = bta_av_hndl_to_scb(p_data->hdr.layer_specific);
 670
 671   if (p_scb) {
 672     p_scb->deregistering = true;
 673     bta_av_ssm_execute(p_scb, BTA_AV_API_CLOSE_EVT, p_data);
 674   } else {
 675     bta_av_dereg_comp(p_data);
 676   }
 677 }
 678
 679 /*******************************************************************************
 680  *
 681  * Function         bta_av_ci_data
 682  *
 683  * Description      Forward the BTA_AV_CI_SRC_DATA_READY_EVT to stream state
 684  *                  machine.
 685  *
 686  *
 687  * Returns          void
 688  *
 689  ******************************************************************************/
 690 static void bta_av_ci_data(tBTA_AV_DATA* p_data) {
 691   tBTA_AV_SCB* p_scb;
 692   int i;
 693   uint8_t chnl = (uint8_t)p_data->hdr.layer_specific;
 694
 695   for (i = 0; i < BTA_AV_NUM_STRS; i++) {
 696     p_scb = bta_av_cb.p_scb[i];
 697
 698     if (p_scb && p_scb->chnl == chnl) {
 699       bta_av_ssm_execute(p_scb, BTA_AV_SRC_DATA_READY_EVT, p_data);
 700     }
 701   }
 702 }
 703
 704 /*******************************************************************************
 705  *
 706  * Function         bta_av_rpc_conn
 707  *
 708  * Description      report report channel open
 709  *
 710  * Returns          void
 711  *
 712  ******************************************************************************/
 713 static void bta_av_rpc_conn(UNUSED_ATTR tBTA_AV_DATA* p_data) {}
 714
 715 /*******************************************************************************
 716  *
 717  * Function         bta_av_api_to_ssm
 718  *
 719  * Description      forward the API request to stream state machine
 720  *
 721  *
 722  * Returns          void
 723  *
 724  ******************************************************************************/
 725 static void bta_av_api_to_ssm(tBTA_AV_DATA* p_data) {
 726   uint16_t event =
 727       p_data->hdr.event - BTA_AV_FIRST_A2S_API_EVT + BTA_AV_FIRST_A2S_SSM_EVT;
 728   tBTA_AV_HNDL handle = p_data->hdr.layer_specific;
 729   tBTA_AV_SCB* p_scb = bta_av_hndl_to_scb(handle);
 730
 731   if (p_scb != nullptr) {
 732     bta_av_ssm_execute(p_scb, event, p_data);
 733   }
 734 }
 735
 736 /*******************************************************************************
 737  *
 738  * Function         bta_av_chk_start
 739  *
 740  * Description      if this is audio channel, check if more than one audio
 741  *                  channel is connected & already started.
 742  *                  This function needs to be kept very similar to
 743  *                  bta_av_chk_2nd_start
 744  *
 745  * Returns          true, if need api_start
 746  *
 747  ******************************************************************************/
 748 bool bta_av_chk_start(tBTA_AV_SCB* p_scb) {
 749   bool start = false;
 750
 751   if ((p_scb->chnl == BTA_AV_CHNL_AUDIO) && (bta_av_cb.audio_open_cnt >= 2) &&
 752       (((p_scb->role & BTA_AV_ROLE_AD_ACP) == 0) ||  // Outgoing connection or
 753        (bta_av_cb.features & BTA_AV_FEAT_ACP_START))) {  // Auto-starting option
 754     // More than one audio channel is connected.
 755     // If this is the 2nd stream as ACP, give INT a chance to issue the START
 756     // command.
 757     for (int i = 0; i < BTA_AV_NUM_STRS; i++) {
 758       tBTA_AV_SCB* p_scbi = bta_av_cb.p_scb[i];
 759       if (p_scbi && p_scbi->chnl == BTA_AV_CHNL_AUDIO && p_scbi->co_started) {
 760         start = true;
 761         // May need to update the flush timeout of this already started stream
 762         if (p_scbi->co_started != bta_av_cb.audio_open_cnt) {
 763           p_scbi->co_started = bta_av_cb.audio_open_cnt;
 764         }
 765       }
 766     }
 767   }
 768
 769   LOG_INFO(
 770       "%s: peer %s channel:%d bta_av_cb.audio_open_cnt:%d role:0x%x "
 771       "features:0x%x start:%s",
 772       __func__, p_scb->PeerAddress().ToString().c_str(), p_scb->chnl,
 773       bta_av_cb.audio_open_cnt, p_scb->role, bta_av_cb.features,
 774       logbool(start).c_str());
 775   return start;
 776 }
 777
 778 /*******************************************************************************
 779  *
 780  * Function         bta_av_restore_switch
 781  *
 782  * Description      assume that the caller of this function already makes
 783  *                  sure that there's only one ACL connection left
 784  *
 785  * Returns          void
 786  *
 787  ******************************************************************************/
 788 void bta_av_restore_switch(void) {
 789   tBTA_AV_CB* p_cb = &bta_av_cb;
 790   int i;
 791   uint8_t mask;
 792
 793   APPL_TRACE_DEBUG("%s: reg_audio: 0x%x", __func__, bta_av_cb.reg_audio);
 794   for (i = 0; i < BTA_AV_NUM_STRS; i++) {
 795     mask = BTA_AV_HNDL_TO_MSK(i);
 796     if (p_cb->conn_audio == mask) {
 797       if (p_cb->p_scb[i]) {
 798         BTM_unblock_role_switch_for(p_cb->p_scb[i]->PeerAddress());
 799       }
 800       break;
 801     }
 802   }
 803 }
 804
 805 /*******************************************************************************
 806  *
 807  * Function         bta_av_sys_rs_cback
 808  *
 809  * Description      Receives the role change event from dm
 810  *
 811  * Returns          (BTA_SYS_ROLE_CHANGE, new_role, hci_status, p_bda)
 812  *
 813  ******************************************************************************/
 814 static void bta_av_sys_rs_cback(UNUSED_ATTR tBTA_SYS_CONN_STATUS status,
 815                                 uint8_t id, uint8_t app_id,
 816                                 const RawAddress& peer_addr) {
 817   int i;
 818   tBTA_AV_SCB* p_scb = NULL;
 819   tHCI_ROLE cur_role;
 820   uint8_t peer_idx = 0;
 821
 822   APPL_TRACE_DEBUG(
 823       "%s: peer %s new_role:%d hci_status:0x%x bta_av_cb.rs_idx:%d", __func__,
 824       peer_addr.ToString().c_str(), id, app_id, bta_av_cb.rs_idx);
 825
 826   for (i = 0; i < BTA_AV_NUM_STRS; i++) {
 827     /* loop through all the SCBs to find matching peer addresses and report the
 828      * role change event */
 829     /* note that more than one SCB (a2dp & vdp) maybe waiting for this event */
 830     p_scb = bta_av_cb.p_scb[i];
 831     if (p_scb && p_scb->PeerAddress() == peer_addr) {
 832       tBTA_AV_ROLE_RES* p_buf =
 833           (tBTA_AV_ROLE_RES*)osi_malloc(sizeof(tBTA_AV_ROLE_RES));
 834       APPL_TRACE_DEBUG(
 835           "%s: peer %s found: new_role:%d, hci_status:0x%x bta_handle:0x%x",
 836           __func__, peer_addr.ToString().c_str(), id, app_id, p_scb->hndl);
 837       p_buf->hdr.event = BTA_AV_ROLE_CHANGE_EVT;
 838       p_buf->hdr.layer_specific = p_scb->hndl;
 839       p_buf->new_role = id;
 840       p_buf->hci_status = app_id;
 841       bta_sys_sendmsg(p_buf);
 842
 843       peer_idx = p_scb->hdi + 1; /* Handle index for the peer_addr */
 844     }
 845   }
 846
 847   /* restore role switch policy, if role switch failed */
 848   if ((HCI_SUCCESS != app_id) &&
 849       (BTM_GetRole(peer_addr, &cur_role) == BTM_SUCCESS) &&
 850       (cur_role == HCI_ROLE_PERIPHERAL)) {
 851     BTM_unblock_role_switch_for(peer_addr);
 852   }
 853
 854   /* if BTA_AvOpen() was called for other device, which caused the role switch
 855    * of the peer_addr,  */
 856   /* we need to continue opening process for the BTA_AvOpen(). */
 857   if ((bta_av_cb.rs_idx != 0) && (bta_av_cb.rs_idx != peer_idx)) {
 858     if ((bta_av_cb.rs_idx - 1) < BTA_AV_NUM_STRS) {
 859       p_scb = bta_av_cb.p_scb[bta_av_cb.rs_idx - 1];
 860     }
 861     if (p_scb && p_scb->q_tag == BTA_AV_Q_TAG_OPEN) {
 862       APPL_TRACE_DEBUG("%s: peer %s rs_idx:%d, bta_handle:0x%x q_tag:%d",
 863                        __func__, p_scb->PeerAddress().ToString().c_str(),
 864                        bta_av_cb.rs_idx, p_scb->hndl, p_scb->q_tag);
 865
 866       if (HCI_SUCCESS == app_id || HCI_ERR_NO_CONNECTION == app_id) {
 867         p_scb->q_info.open.switch_res = BTA_AV_RS_OK;
 868       } else {
 869         APPL_TRACE_ERROR(
 870             "%s: peer %s (p_scb peer %s) role switch failed: new_role:%d "
 871             "hci_status:0x%x",
 872             __func__, peer_addr.ToString().c_str(),
 873             p_scb->PeerAddress().ToString().c_str(), id, app_id);
 874         p_scb->q_info.open.switch_res = BTA_AV_RS_FAIL;
 875       }
 876
 877       /* Continue av open process */
 878       bta_av_do_disc_a2dp(p_scb, (tBTA_AV_DATA*)&(p_scb->q_info.open));
 879     }
 880
 881     bta_av_cb.rs_idx = 0;
 882   }
 883 }
 884
 885 /*******************************************************************************
 886  *
 887  * Function         bta_av_sco_chg_cback
 888  *
 889  * Description      receive & process the SCO connection up/down event from sys.
 890  *                  call setup also triggers this callback, to suspend av before
 891  *                  SCO activity happens, or to resume av once call ends.
 892  *
 893  * Returns          void
 894  *
 895  ******************************************************************************/
 896 static void bta_av_sco_chg_cback(tBTA_SYS_CONN_STATUS status, uint8_t id,
 897                                  UNUSED_ATTR uint8_t app_id,
 898                                  UNUSED_ATTR const RawAddress& peer_addr) {
 899   tBTA_AV_SCB* p_scb;
 900   int i;
 901   tBTA_AV_API_STOP stop;
 902
 903   LOG(INFO) << __func__ << ": status=" << bta_sys_conn_status_text(status)
 904             << ", num_links=" << +id;
 905   if (id) {
 906     bta_av_cb.sco_occupied = true;
 907     LOG_DEBUG("SCO occupied peer:%s status:%s", PRIVATE_ADDRESS(peer_addr),
 908               bta_sys_conn_status_text(status).c_str());
 909
 910     if (bta_av_cb.features & BTA_AV_FEAT_NO_SCO_SSPD) {
 911       return;
 912     }
 913
 914     /* either BTA_SYS_SCO_OPEN or BTA_SYS_SCO_CLOSE with remaining active SCO */
 915     for (i = 0; i < BTA_AV_NUM_STRS; i++) {
 916       p_scb = bta_av_cb.p_scb[i];
 917
 918       if (p_scb && p_scb->co_started && (!p_scb->sco_suspend)) {
 919         VLOG(1) << __func__ << ": suspending scb:" << i;
 920         /* scb is used and started, not suspended automatically */
 921         p_scb->sco_suspend = true;
 922         stop.flush = false;
 923         stop.suspend = true;
 924         stop.reconfig_stop = false;
 925         bta_av_ssm_execute(p_scb, BTA_AV_AP_STOP_EVT, (tBTA_AV_DATA*)&stop);
 926       }
 927     }
 928   } else {
 929     bta_av_cb.sco_occupied = false;
 930     LOG_DEBUG("SCO unoccupied peer:%s status:%s", PRIVATE_ADDRESS(peer_addr),
 931               bta_sys_conn_status_text(status).c_str());
 932
 933     if (bta_av_cb.features & BTA_AV_FEAT_NO_SCO_SSPD) {
 934       return;
 935     }
 936
 937     for (i = 0; i < BTA_AV_NUM_STRS; i++) {
 938       p_scb = bta_av_cb.p_scb[i];
 939
 940       if (p_scb && p_scb->sco_suspend) /* scb is used and suspended for SCO */
 941       {
 942         VLOG(1) << __func__ << ": starting scb:" << i;
 943         bta_av_ssm_execute(p_scb, BTA_AV_AP_START_EVT, NULL);
 944       }
 945     }
 946   }
 947 }
 948
 949 /*******************************************************************************
 950  *
 951  * Function         bta_av_switch_if_needed
 952  *
 953  * Description      This function checks if there is another existing AV
 954  *                  channel that is local as peripheral role.
 955  *                  If so, role switch and remove it from link policy.
 956  *
 957  * Returns          true, if role switch is done
 958  *
 959  ******************************************************************************/
 960 bool bta_av_switch_if_needed(tBTA_AV_SCB* p_scb) {
 961   // TODO: A workaround for devices that are connected first, become
 962   // Central, and block follow-up role changes - b/72122792 .
 963   return false;
 964 #if 0
 965   uint8_t role;
 966   bool needed = false;
 967   tBTA_AV_SCB* p_scbi;
 968   int i;
 969   uint8_t mask;
 970
 971   for (i = 0; i < BTA_AV_NUM_STRS; i++) {
 972     mask = BTA_AV_HNDL_TO_MSK(i);
 973     p_scbi = bta_av_cb.p_scb[i];
 974     if (p_scbi && (p_scb->hdi != i) &&   /* not the original channel */
 975         ((bta_av_cb.conn_audio & mask))) /* connected audio */
 976     {
 977       BTM_GetRole(p_scbi->PeerAddress(), &role);
 978       /* this channel is open - clear the role switch link policy for this link
 979        */
 980       if (HCI_ROLE_CENTRAL != role) {
 981         if (bta_av_cb.features & BTA_AV_FEAT_CENTRAL)
 982           BTM_block_role_switch_for(p_scbi->PeerAddress());
 983         if (BTM_CMD_STARTED !=
 984             BTM_SwitchRole(p_scbi->PeerAddress(), HCI_ROLE_CENTRAL)) {
 985           /* can not switch role on SCBI
 986            * start the timer on SCB - because this function is ONLY called when
 987            * SCB gets API_OPEN */
 988           bta_sys_start_timer(p_scb->avrc_ct_timer, BTA_AV_RS_TIME_VAL,
 989                               BTA_AV_AVRC_TIMER_EVT, p_scb->hndl);
 990         }
 991         needed = true;
 992         /* mark the original channel as waiting for RS result */
 993         bta_av_cb.rs_idx = p_scb->hdi + 1;
 994         break;
 995       }
 996     }
 997   }
 998   return needed;
 999 #endif
1000 }
1001
1002 /*******************************************************************************
1003  *
1004  * Function         bta_av_link_role_ok
1005  *
1006  * Description      This function checks if the SCB has existing ACL connection
1007  *                  If so, check if the link role fits the requirements.
1008  *
1009  * Returns          true, if role is ok
1010  *
1011  ******************************************************************************/
1012 bool bta_av_link_role_ok(tBTA_AV_SCB* p_scb, uint8_t bits) {
1013   tHCI_ROLE role;
1014   if (BTM_GetRole(p_scb->PeerAddress(), &role) != BTM_SUCCESS) {
1015     LOG_WARN("Unable to find link role for device:%s",
1016              PRIVATE_ADDRESS(p_scb->PeerAddress()));
1017     return true;
1018   }
1019
1020   if (role != HCI_ROLE_CENTRAL && (A2DP_BitsSet(bta_av_cb.conn_audio) > bits)) {
1021     LOG_INFO(
1022         "Switch link role to central peer:%s bta_handle:0x%x current_role:%s"
1023         " conn_audio:0x%x bits:%d features:0x%x",
1024         PRIVATE_ADDRESS(p_scb->PeerAddress()), p_scb->hndl,
1025         RoleText(role).c_str(), bta_av_cb.conn_audio, bits, bta_av_cb.features);
1026     const tBTM_STATUS status = BTM_SwitchRoleToCentral(p_scb->PeerAddress());
1027     switch (status) {
1028       case BTM_CMD_STARTED:
1029         break;
1030       case BTM_MODE_UNSUPPORTED:
1031       case BTM_DEV_RESTRICT_LISTED:
1032         // Role switch can never happen, but indicate to caller
1033         // a result such that a timer will not start to repeatedly
1034         // try something not possible.
1035         LOG_ERROR("Link can never role switch to central device:%s",
1036                   PRIVATE_ADDRESS(p_scb->PeerAddress()));
1037         break;
1038       default:
1039         /* can not switch role on SCB - start the timer on SCB */
1040         p_scb->wait |= BTA_AV_WAIT_ROLE_SW_RES_START;
1041         LOG_ERROR("Unable to switch role to central device:%s error:%s",
1042                   PRIVATE_ADDRESS(p_scb->PeerAddress()),
1043                   btm_status_text(status).c_str());
1044         return false;
1045     }
1046   }
1047   return true;
1048 }
1049
1050 /*******************************************************************************
1051  *
1052  * Function         bta_av_dup_audio_buf
1053  *
1054  * Description      dup the audio data to the q_info.a2dp of other audio
1055  *                  channels
1056  *
1057  * Returns          void
1058  *
1059  ******************************************************************************/
1060 void bta_av_dup_audio_buf(tBTA_AV_SCB* p_scb, BT_HDR* p_buf) {
1061   /* Test whether there is more than one audio channel connected */
1062   if ((p_buf == NULL) || (bta_av_cb.audio_open_cnt < 2)) return;
1063
1064   uint16_t copy_size = BT_HDR_SIZE + p_buf->len + p_buf->offset;
1065   for (int i = 0; i < BTA_AV_NUM_STRS; i++) {
1066     tBTA_AV_SCB* p_scbi = bta_av_cb.p_scb[i];
1067
1068     if (i == p_scb->hdi) continue; /* Ignore the original channel */
1069     if ((p_scbi == NULL) || !p_scbi->co_started)
1070       continue; /* Ignore if SCB is not used or started */
1071     if (!(bta_av_cb.conn_audio & BTA_AV_HNDL_TO_MSK(i)))
1072       continue; /* Audio is not connected */
1073
1074     /* Enqueue the data */
1075     BT_HDR* p_new = (BT_HDR*)osi_malloc(copy_size);
1076     memcpy(p_new, p_buf, copy_size);
1077     list_append(p_scbi->a2dp_list, p_new);
1078
1079     if (list_length(p_scbi->a2dp_list) > p_bta_av_cfg->audio_mqs) {
1080       // Drop the oldest packet
1081       bta_av_co_audio_drop(p_scbi->hndl, p_scbi->PeerAddress());
1082       BT_HDR* p_buf_drop = static_cast<BT_HDR*>(list_front(p_scbi->a2dp_list));
1083       list_remove(p_scbi->a2dp_list, p_buf_drop);
1084       osi_free(p_buf_drop);
1085     }
1086   }
1087 }
1088
1089 static void bta_av_non_state_machine_event(uint16_t event,
1090                                            tBTA_AV_DATA* p_data) {
1091   switch (event) {
1092     case BTA_AV_API_ENABLE_EVT:
1093       bta_av_api_enable(p_data);
1094       break;
1095     case BTA_AV_API_REGISTER_EVT:
1096       bta_av_api_register(p_data);
1097       break;
1098     case BTA_AV_API_DEREGISTER_EVT:
1099       bta_av_api_deregister(p_data);
1100       break;
1101     case BTA_AV_API_DISCONNECT_EVT:
1102       bta_av_api_disconnect(p_data);
1103       break;
1104     case BTA_AV_CI_SRC_DATA_READY_EVT:
1105       bta_av_ci_data(p_data);
1106       break;
1107     case BTA_AV_SIG_CHG_EVT:
1108       bta_av_sig_chg(p_data);
1109       break;
1110     case BTA_AV_SIGNALLING_TIMER_EVT:
1111       bta_av_signalling_timer(p_data);
1112       break;
1113     case BTA_AV_SDP_AVRC_DISC_EVT:
1114       bta_av_rc_disc_done(p_data);
1115       break;
1116     case BTA_AV_AVRC_CLOSE_EVT:
1117       bta_av_rc_closed(p_data);
1118       break;
1119     case BTA_AV_AVRC_BROWSE_OPEN_EVT:
1120       bta_av_rc_browse_opened(p_data);
1121       break;
1122     case BTA_AV_AVRC_BROWSE_CLOSE_EVT:
1123       bta_av_rc_browse_closed(p_data);
1124       break;
1125     case BTA_AV_CONN_CHG_EVT:
1126       bta_av_conn_chg(p_data);
1127       break;
1128     case BTA_AV_DEREG_COMP_EVT:
1129       bta_av_dereg_comp(p_data);
1130       break;
1131     case BTA_AV_AVDT_RPT_CONN_EVT:
1132       bta_av_rpc_conn(p_data);
1133       break;
1134     case BTA_AV_API_START_EVT:
1135       bta_av_api_to_ssm(p_data);
1136       break;
1137     case BTA_AV_API_STOP_EVT:
1138       bta_av_api_to_ssm(p_data);
1139       break;
1140   }
1141 }
1142
1143 static void bta_av_better_state_machine(tBTA_AV_CB* p_cb, uint16_t event,
1144                                         tBTA_AV_DATA* p_data) {
1145   switch (p_cb->state) {
1146     case BTA_AV_INIT_ST:
1147       switch (event) {
1148         case BTA_AV_API_DISABLE_EVT:
1149           bta_av_disable(p_cb, p_data);
1150           break;
1151         case BTA_AV_API_META_RSP_EVT:
1152           bta_av_rc_free_rsp(p_cb, p_data);
1153           break;
1154         case BTA_AV_AVRC_OPEN_EVT:
1155           p_cb->state = BTA_AV_OPEN_ST;
1156           bta_av_rc_opened(p_cb, p_data);
1157           break;
1158         case BTA_AV_AVRC_MSG_EVT:
1159           bta_av_rc_free_browse_msg(p_cb, p_data);
1160           break;
1161       }
1162       break;
1163     case BTA_AV_OPEN_ST:
1164       switch (event) {
1165         case BTA_AV_API_DISABLE_EVT:
1166           p_cb->state = BTA_AV_INIT_ST;
1167           bta_av_disable(p_cb, p_data);
1168           break;
1169         case BTA_AV_API_REMOTE_CMD_EVT:
1170           bta_av_rc_remote_cmd(p_cb, p_data);
1171           break;
1172         case BTA_AV_API_VENDOR_CMD_EVT:
1173           bta_av_rc_vendor_cmd(p_cb, p_data);
1174           break;
1175         case BTA_AV_API_VENDOR_RSP_EVT:
1176           bta_av_rc_vendor_rsp(p_cb, p_data);
1177           break;
1178         case BTA_AV_API_META_RSP_EVT:
1179           bta_av_rc_meta_rsp(p_cb, p_data);
1180           break;
1181         case BTA_AV_API_RC_CLOSE_EVT:
1182           bta_av_rc_close(p_cb, p_data);
1183           break;
1184         case BTA_AV_AVRC_OPEN_EVT:
1185           bta_av_rc_opened(p_cb, p_data);
1186           break;
1187         case BTA_AV_AVRC_MSG_EVT:
1188           bta_av_rc_msg(p_cb, p_data);
1189           break;
1190         case BTA_AV_AVRC_NONE_EVT:
1191           p_cb->state = BTA_AV_INIT_ST;
1192           break;
1193       }
1194       break;
1195   }
1196 }
1197
1198 void bta_av_sm_execute(tBTA_AV_CB* p_cb, uint16_t event, tBTA_AV_DATA* p_data) {
1199   APPL_TRACE_EVENT("%s: AV event=0x%x(%s) state=%d(%s)", __func__, event,
1200                    bta_av_evt_code(event), p_cb->state,
1201                    bta_av_st_code(p_cb->state));
1202   bta_av_better_state_machine(p_cb, event, p_data);
1203 }
1204
1205 /*******************************************************************************
1206  *
1207  * Function         bta_av_hdl_event
1208  *
1209  * Description      Advanced audio/video main event handling function.
1210  *
1211  *
1212  * Returns          bool
1213  *
1214  ******************************************************************************/
1215 bool bta_av_hdl_event(BT_HDR_RIGID* p_msg) {
1216   if (p_msg->event > BTA_AV_LAST_EVT) {
1217     return true; /* to free p_msg */
1218   }
1219   if (p_msg->event >= BTA_AV_FIRST_NSM_EVT) {
1220     APPL_TRACE_VERBOSE("%s: AV nsm event=0x%x(%s)", __func__, p_msg->event,
1221                        bta_av_evt_code(p_msg->event));
1222     bta_av_non_state_machine_event(p_msg->event, (tBTA_AV_DATA*)p_msg);
1223   } else if (p_msg->event >= BTA_AV_FIRST_SM_EVT &&
1224              p_msg->event <= BTA_AV_LAST_SM_EVT) {
1225     APPL_TRACE_VERBOSE("%s: AV sm event=0x%x(%s)", __func__, p_msg->event,
1226                        bta_av_evt_code(p_msg->event));
1227     /* state machine events */
1228     bta_av_sm_execute(&bta_av_cb, p_msg->event, (tBTA_AV_DATA*)p_msg);
1229   } else {
1230     APPL_TRACE_VERBOSE("%s: bta_handle=0x%x", __func__, p_msg->layer_specific);
1231     /* stream state machine events */
1232     bta_av_ssm_execute(bta_av_hndl_to_scb(p_msg->layer_specific), p_msg->event,
1233                        (tBTA_AV_DATA*)p_msg);
1234   }
1235   return true;
1236 }
1237
1238 /*****************************************************************************
1239  *  Debug Functions
1240  ****************************************************************************/
1241 /*******************************************************************************
1242  *
1243  * Function         bta_av_st_code
1244  *
1245  * Description
1246  *
1247  * Returns          char *
1248  *
1249  ******************************************************************************/
1250 static const char* bta_av_st_code(uint8_t state) {
1251   switch (state) {
1252     case BTA_AV_INIT_ST:
1253       return "INIT";
1254     case BTA_AV_OPEN_ST:
1255       return "OPEN";
1256     default:
1257       return "unknown";
1258   }
1259 }
1260 /*******************************************************************************
1261  *
1262  * Function         bta_av_evt_code
1263  *
1264  * Description
1265  *
1266  * Returns          char *
1267  *
1268  ******************************************************************************/
1269 const char* bta_av_evt_code(uint16_t evt_code) {
1270   switch (evt_code) {
1271     case BTA_AV_API_DISABLE_EVT:
1272       return "API_DISABLE";
1273     case BTA_AV_API_REMOTE_CMD_EVT:
1274       return "API_REMOTE_CMD";
1275     case BTA_AV_API_VENDOR_CMD_EVT:
1276       return "API_VENDOR_CMD";
1277     case BTA_AV_API_VENDOR_RSP_EVT:
1278       return "API_VENDOR_RSP";
1279     case BTA_AV_API_META_RSP_EVT:
1280       return "API_META_RSP_EVT";
1281     case BTA_AV_API_RC_CLOSE_EVT:
1282       return "API_RC_CLOSE";
1283     case BTA_AV_AVRC_OPEN_EVT:
1284       return "AVRC_OPEN";
1285     case BTA_AV_AVRC_MSG_EVT:
1286       return "AVRC_MSG";
1287     case BTA_AV_AVRC_NONE_EVT:
1288       return "AVRC_NONE";
1289
1290     case BTA_AV_API_OPEN_EVT:
1291       return "API_OPEN";
1292     case BTA_AV_API_CLOSE_EVT:
1293       return "API_CLOSE";
1294     case BTA_AV_AP_START_EVT:
1295       return "AP_START";
1296     case BTA_AV_AP_STOP_EVT:
1297       return "AP_STOP";
1298     case BTA_AV_API_RECONFIG_EVT:
1299       return "API_RECONFIG";
1300     case BTA_AV_API_PROTECT_REQ_EVT:
1301       return "API_PROTECT_REQ";
1302     case BTA_AV_API_PROTECT_RSP_EVT:
1303       return "API_PROTECT_RSP";
1304     case BTA_AV_API_RC_OPEN_EVT:
1305       return "API_RC_OPEN";
1306     case BTA_AV_SRC_DATA_READY_EVT:
1307       return "SRC_DATA_READY";
1308     case BTA_AV_CI_SETCONFIG_OK_EVT:
1309       return "CI_SETCONFIG_OK";
1310     case BTA_AV_CI_SETCONFIG_FAIL_EVT:
1311       return "CI_SETCONFIG_FAIL";
1312     case BTA_AV_SDP_DISC_OK_EVT:
1313       return "SDP_DISC_OK";
1314     case BTA_AV_SDP_DISC_FAIL_EVT:
1315       return "SDP_DISC_FAIL";
1316     case BTA_AV_STR_DISC_OK_EVT:
1317       return "STR_DISC_OK";
1318     case BTA_AV_STR_DISC_FAIL_EVT:
1319       return "STR_DISC_FAIL";
1320     case BTA_AV_STR_GETCAP_OK_EVT:
1321       return "STR_GETCAP_OK";
1322     case BTA_AV_STR_GETCAP_FAIL_EVT:
1323       return "STR_GETCAP_FAIL";
1324     case BTA_AV_STR_OPEN_OK_EVT:
1325       return "STR_OPEN_OK";
1326     case BTA_AV_STR_OPEN_FAIL_EVT:
1327       return "STR_OPEN_FAIL";
1328     case BTA_AV_STR_START_OK_EVT:
1329       return "STR_START_OK";
1330     case BTA_AV_STR_START_FAIL_EVT:
1331       return "STR_START_FAIL";
1332     case BTA_AV_STR_CLOSE_EVT:
1333       return "STR_CLOSE";
1334     case BTA_AV_STR_CONFIG_IND_EVT:
1335       return "STR_CONFIG_IND";
1336     case BTA_AV_STR_SECURITY_IND_EVT:
1337       return "STR_SECURITY_IND";
1338     case BTA_AV_STR_SECURITY_CFM_EVT:
1339       return "STR_SECURITY_CFM";
1340     case BTA_AV_STR_WRITE_CFM_EVT:
1341       return "STR_WRITE_CFM";
1342     case BTA_AV_STR_SUSPEND_CFM_EVT:
1343       return "STR_SUSPEND_CFM";
1344     case BTA_AV_STR_RECONFIG_CFM_EVT:
1345       return "STR_RECONFIG_CFM";
1346     case BTA_AV_AVRC_TIMER_EVT:
1347       return "AVRC_TIMER";
1348     case BTA_AV_AVDT_CONNECT_EVT:
1349       return "AVDT_CONNECT";
1350     case BTA_AV_AVDT_DISCONNECT_EVT:
1351       return "AVDT_DISCONNECT";
1352     case BTA_AV_ROLE_CHANGE_EVT:
1353       return "ROLE_CHANGE";
1354     case BTA_AV_AVDT_DELAY_RPT_EVT:
1355       return "AVDT_DELAY_RPT";
1356     case BTA_AV_ACP_CONNECT_EVT:
1357       return "ACP_CONNECT";
1358     case BTA_AV_API_OFFLOAD_START_EVT:
1359       return "OFFLOAD_START";
1360     case BTA_AV_API_OFFLOAD_START_RSP_EVT:
1361       return "OFFLOAD_START_RSP";
1362
1363     case BTA_AV_API_ENABLE_EVT:
1364       return "API_ENABLE";
1365     case BTA_AV_API_REGISTER_EVT:
1366       return "API_REG";
1367     case BTA_AV_API_DEREGISTER_EVT:
1368       return "API_DEREG";
1369     case BTA_AV_API_DISCONNECT_EVT:
1370       return "API_DISCNT";
1371     case BTA_AV_CI_SRC_DATA_READY_EVT:
1372       return "CI_DATA_READY";
1373     case BTA_AV_SIG_CHG_EVT:
1374       return "SIG_CHG";
1375     case BTA_AV_SIGNALLING_TIMER_EVT:
1376       return "SIGNALLING_TIMER";
1377     case BTA_AV_SDP_AVRC_DISC_EVT:
1378       return "SDP_AVRC_DISC";
1379     case BTA_AV_AVRC_CLOSE_EVT:
1380       return "AVRC_CLOSE";
1381     case BTA_AV_AVRC_BROWSE_OPEN_EVT:
1382       return "AVRC_BROWSE_OPEN";
1383     case BTA_AV_AVRC_BROWSE_CLOSE_EVT:
1384       return "AVRC_BROWSE_CLOSE";
1385     case BTA_AV_CONN_CHG_EVT:
1386       return "CONN_CHG";
1387     case BTA_AV_DEREG_COMP_EVT:
1388       return "DEREG_COMP";
1389     case BTA_AV_AVDT_RPT_CONN_EVT:
1390       return "RPT_CONN";
1391     case BTA_AV_API_START_EVT:
1392       return "API_START";
1393     case BTA_AV_API_STOP_EVT:
1394       return "API_STOP";
1395     default:
1396       return "unknown";
1397   }
1398 }
1399
1400 void bta_debug_av_dump(int fd) {
1401   if (appl_trace_level < BT_TRACE_LEVEL_DEBUG) return;
1402
1403   dprintf(fd, "\nBTA AV State:\n");
1404   dprintf(fd, "  State Machine State: %s\n", bta_av_st_code(bta_av_cb.state));
1405   dprintf(fd, "  Link signalling timer: %s\n",
1406           alarm_is_scheduled(bta_av_cb.link_signalling_timer)
1407               ? "Scheduled"
1408               : "Not scheduled");
1409   dprintf(fd, "  Accept signalling timer: %s\n",
1410           alarm_is_scheduled(bta_av_cb.accept_signalling_timer)
1411               ? "Scheduled"
1412               : "Not scheduled");
1413   dprintf(fd, "  SDP A2DP source handle: %d\n", bta_av_cb.sdp_a2dp_handle);
1414   dprintf(fd, "  SDP A2DP sink handle: %d\n", bta_av_cb.sdp_a2dp_snk_handle);
1415   dprintf(fd, "  Features: 0x%x\n", bta_av_cb.features);
1416   dprintf(fd, "  SDP handle: %d\n", bta_av_cb.handle);
1417   dprintf(fd, "  Disabling: %s\n", bta_av_cb.disabling ? "true" : "false");
1418   dprintf(fd, "  SCO occupied: %s\n",
1419           bta_av_cb.sco_occupied ? "true" : "false");
1420   dprintf(fd, "  Connected audio channels: %d\n", bta_av_cb.audio_open_cnt);
1421   dprintf(fd, "  Connected audio channels mask: 0x%x\n", bta_av_cb.conn_audio);
1422   dprintf(fd, "  Registered audio channels mask: 0x%x\n", bta_av_cb.reg_audio);
1423   dprintf(fd, "  Connected LCBs mask: 0x%x\n", bta_av_cb.conn_lcb);
1424
1425   for (size_t i = 0; i < sizeof(bta_av_cb.lcb) / sizeof(bta_av_cb.lcb[0]);
1426        i++) {
1427     const tBTA_AV_LCB& lcb = bta_av_cb.lcb[i];
1428     if (lcb.addr.IsEmpty()) {
1429       continue;
1430     }
1431     dprintf(fd, "\n  Link control block: %zu peer: %s\n", i,
1432             lcb.addr.ToString().c_str());
1433     dprintf(fd, "    Connected stream handle mask: 0x%x\n", lcb.conn_msk);
1434     dprintf(fd, "    Index(+1) to LCB: %d\n", lcb.lidx);
1435   }
1436   for (size_t i = 0; i < BTA_AV_NUM_STRS; i++) {
1437     const tBTA_AV_SCB* p_scb = bta_av_cb.p_scb[i];
1438     if (p_scb == nullptr) {
1439       continue;
1440     }
1441     if (p_scb->PeerAddress().IsEmpty()) {
1442       continue;
1443     }
1444     dprintf(fd, "\n  BTA ID: %zu peer: %s\n", i,
1445             p_scb->PeerAddress().ToString().c_str());
1446     dprintf(fd, "    SDP discovery started: %s\n",
1447             p_scb->sdp_discovery_started ? "true" : "false");
1448     for (size_t j = 0; j < BTAV_A2DP_CODEC_INDEX_MAX; j++) {
1449       const tBTA_AV_SEP& sep = p_scb->seps[j];
1450       if (sep.av_handle == 0) {
1451         continue;
1452       }
1453       dprintf(fd, "    SEP ID: %zu\n", j);
1454       dprintf(fd, "      SEP AVDTP handle: %d\n", sep.av_handle);
1455       dprintf(fd, "      Local SEP type: %d\n", sep.tsep);
1456       dprintf(fd, "      Codec: %s\n", A2DP_CodecName(sep.codec_info));
1457     }
1458     dprintf(fd, "    BTA info tag: %d\n", p_scb->q_tag);
1459     dprintf(fd, "    API Open peer: %s\n",
1460             p_scb->q_info.open.bd_addr.ToString().c_str());
1461     dprintf(fd, "      Use AVRCP: %s\n",
1462             p_scb->q_info.open.use_rc ? "true" : "false");
1463     dprintf(fd, "      Switch result: %d\n", p_scb->q_info.open.switch_res);
1464     dprintf(fd, "      Initiator UUID: 0x%x\n", p_scb->q_info.open.uuid);
1465     dprintf(fd, "    Saved API Open peer: %s\n",
1466             p_scb->open_api.bd_addr.ToString().c_str());
1467     dprintf(fd, "      Use AVRCP: %s\n",
1468             p_scb->open_api.use_rc ? "true" : "false");
1469     dprintf(fd, "      Switch result: %d\n", p_scb->open_api.switch_res);
1470     dprintf(fd, "      Initiator UUID: 0x%x\n", p_scb->open_api.uuid);
1471     // TODO: Print p_scb->sep_info[], cfg, avrc_ct_timer, current_codec ?
1472     dprintf(fd, "    L2CAP Channel ID: %d\n", p_scb->l2c_cid);
1473     dprintf(fd, "    Stream MTU: %d\n", p_scb->stream_mtu);
1474     dprintf(fd, "    AVDTP version: 0x%x\n", p_scb->AvdtpVersion());
1475     dprintf(fd, "    Media type: %d\n", p_scb->media_type);
1476     dprintf(fd, "    Congested: %s\n", p_scb->cong ? "true" : "false");
1477     dprintf(fd, "    Open status: %d\n", p_scb->open_status);
1478     dprintf(fd, "    Channel: %d\n", p_scb->chnl);
1479     dprintf(fd, "    BTA handle: 0x%x\n", p_scb->hndl);
1480     dprintf(fd, "    Protocol service capabilities mask: 0x%x\n",
1481             p_scb->cur_psc_mask);
1482     dprintf(fd, "    AVDTP handle: %d\n", p_scb->avdt_handle);
1483     dprintf(fd, "    Stream control block index: %d\n", p_scb->hdi);
1484     dprintf(fd, "    State machine state: %s(%d)\n",
1485             bta_av_sst_code(p_scb->state), p_scb->state);
1486     dprintf(fd, "    AVDTP label: 0x%x\n", p_scb->avdt_label);
1487     dprintf(fd, "    Application ID: %d\n", p_scb->app_id);
1488     dprintf(fd, "    Role: 0x%x\n", p_scb->role);
1489     dprintf(fd, "    Queued L2CAP buffers: %d\n", p_scb->l2c_bufs);
1490     dprintf(fd, "    AVRCP allowed: %s\n", p_scb->use_rc ? "true" : "false");
1491     dprintf(fd, "    Stream started: %s\n", p_scb->started ? "true" : "false");
1492     dprintf(fd, "    Stream call-out started: %d\n", p_scb->co_started);
1493     dprintf(fd, "    AVDTP Reconfig supported: %s\n",
1494             p_scb->recfg_sup ? "true" : "false");
1495     dprintf(fd, "    AVDTP Suspend supported: %s\n",
1496             p_scb->suspend_sup ? "true" : "false");
1497     dprintf(fd, "    Deregistering: %s\n",
1498             p_scb->deregistering ? "true" : "false");
1499     dprintf(fd, "    SCO automatic Suspend: %s\n",
1500             p_scb->sco_suspend ? "true" : "false");
1501     dprintf(fd, "    Incoming/outgoing connection collusion mask: 0x%x\n",
1502             p_scb->coll_mask);
1503     dprintf(fd, "    Wait mask: 0x%x\n", p_scb->wait);
1504     dprintf(fd, "    Don't use RTP header: %s\n",
1505             p_scb->no_rtp_header ? "true" : "false");
1506     dprintf(fd, "    Intended UUID of Initiator to connect to: 0x%x\n",
1507             p_scb->uuid_int);
1508   }
1509 }