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 * Filename: btif_hf.c 22 * 23 * Description: Handsfree Profile Bluetooth Interface 24 * 25 * 26 ***********************************************************************************/ 27 28#define LOG_TAG "bt_btif_hf" 29 30#include <stdlib.h> 31#include <string.h> 32#include <time.h> 33 34#include <hardware/bluetooth.h> 35#include <hardware/bt_hf.h> 36 37#include "bta_ag_api.h" 38#include "btcore/include/bdaddr.h" 39#include "btif_common.h" 40#include "btif_profile_queue.h" 41#include "btif_util.h" 42 43/************************************************************************************ 44** Constants & Macros 45************************************************************************************/ 46#ifndef BTIF_HSAG_SERVICE_NAME 47#define BTIF_HSAG_SERVICE_NAME ("Headset Gateway") 48#endif 49 50#ifndef BTIF_HFAG_SERVICE_NAME 51#define BTIF_HFAG_SERVICE_NAME ("Handsfree Gateway") 52#endif 53 54#ifndef BTIF_HF_SERVICES 55#define BTIF_HF_SERVICES (BTA_HSP_SERVICE_MASK | BTA_HFP_SERVICE_MASK ) 56#endif 57 58#ifndef BTIF_HF_SERVICE_NAMES 59#define BTIF_HF_SERVICE_NAMES {BTIF_HSAG_SERVICE_NAME , BTIF_HFAG_SERVICE_NAME} 60#endif 61 62#ifndef BTIF_HF_SECURITY 63#define BTIF_HF_SECURITY (BTA_SEC_AUTHENTICATE | BTA_SEC_ENCRYPT) 64#endif 65 66#if (BTM_WBS_INCLUDED == TRUE ) 67#ifndef BTIF_HF_FEATURES 68#define BTIF_HF_FEATURES ( BTA_AG_FEAT_3WAY | \ 69 BTA_AG_FEAT_ECNR | \ 70 BTA_AG_FEAT_REJECT | \ 71 BTA_AG_FEAT_ECS | \ 72 BTA_AG_FEAT_EXTERR | \ 73 BTA_AG_FEAT_BTRH | \ 74 BTA_AG_FEAT_VREC | \ 75 BTA_AG_FEAT_CODEC |\ 76 BTA_AG_FEAT_HF_IND | \ 77 BTA_AG_FEAT_ESCO | \ 78 BTA_AG_FEAT_UNAT) 79#endif 80#else 81#ifndef BTIF_HF_FEATURES 82#define BTIF_HF_FEATURES ( BTA_AG_FEAT_3WAY | \ 83 BTA_AG_FEAT_ECNR | \ 84 BTA_AG_FEAT_REJECT | \ 85 BTA_AG_FEAT_ECS | \ 86 BTA_AG_FEAT_EXTERR | \ 87 BTA_AG_FEAT_BTRH | \ 88 BTA_AG_FEAT_VREC | \ 89 BTA_AG_FEAT_HF_IND | \ 90 BTA_AG_FEAT_ESCO | \ 91 BTA_AG_FEAT_UNAT) 92#endif 93#endif 94 95#define BTIF_HF_CALL_END_TIMEOUT 6 96 97#define BTIF_HF_INVALID_IDX -1 98 99/* Number of BTIF-HF control blocks */ 100#define BTIF_HF_NUM_CB 2 101 102/* Max HF clients supported from App */ 103UINT16 btif_max_hf_clients = 1; 104 105/* HF app ids for service registration */ 106typedef enum { 107 BTIF_HF_ID_1 = 0, 108 BTIF_HF_ID_2, 109#if (BTIF_HF_NUM_CB == 3) 110 BTIF_HF_ID_3 111#endif 112} bthf_hf_id_t; 113 114UINT16 bthf_hf_id[BTIF_HF_NUM_CB] = {BTIF_HF_ID_1, BTIF_HF_ID_2, 115 #if (BTIF_HF_NUM_CB == 3) 116 BTIF_HF_ID_3 117 #endif 118 }; 119 120/************************************************************************************ 121** Local type definitions 122************************************************************************************/ 123 124/************************************************************************************ 125** Static variables 126************************************************************************************/ 127static bthf_callbacks_t *bt_hf_callbacks = NULL; 128static int hf_idx = BTIF_HF_INVALID_IDX; 129 130#define CHECK_BTHF_INIT() if (bt_hf_callbacks == NULL)\ 131 {\ 132 BTIF_TRACE_WARNING("BTHF: %s: BTHF not initialized", __FUNCTION__);\ 133 return BT_STATUS_NOT_READY;\ 134 }\ 135 else\ 136 {\ 137 BTIF_TRACE_EVENT("BTHF: %s", __FUNCTION__);\ 138 } 139 140#define CHECK_BTHF_SLC_CONNECTED() if (bt_hf_callbacks == NULL)\ 141 {\ 142 BTIF_TRACE_WARNING("BTHF: %s: BTHF not initialized", __FUNCTION__);\ 143 return BT_STATUS_NOT_READY;\ 144 }\ 145 else if (btif_hf_cb.state != BTHF_CONNECTION_STATE_SLC_CONNECTED)\ 146 {\ 147 BTIF_TRACE_WARNING("BTHF: %s: SLC connection not up. state=%s", __FUNCTION__, dump_hf_conn_state(btif_hf_cb.state));\ 148 return BT_STATUS_NOT_READY;\ 149 }\ 150 else\ 151 {\ 152 BTIF_TRACE_EVENT("BTHF: %s", __FUNCTION__);\ 153 } 154 155/* BTIF-HF control block to map bdaddr to BTA handle */ 156typedef struct _btif_hf_cb 157{ 158 UINT16 handle; 159 bt_bdaddr_t connected_bda; 160 bthf_connection_state_t state; 161 bthf_vr_state_t vr_state; 162 tBTA_AG_PEER_FEAT peer_feat; 163 int num_active; 164 int num_held; 165 struct timespec call_end_timestamp; 166 struct timespec connected_timestamp; 167 bthf_call_state_t call_setup_state; 168} btif_hf_cb_t; 169 170static btif_hf_cb_t btif_hf_cb[BTIF_HF_NUM_CB]; 171 172/************************************************************************************ 173** Static functions 174************************************************************************************/ 175 176/************************************************************************************ 177** Externs 178************************************************************************************/ 179/* By default, even though codec negotiation is enabled, we will not use WBS as the default 180* codec unless this variable is set to TRUE. 181*/ 182#ifndef BTIF_HF_WBS_PREFERRED 183#define BTIF_HF_WBS_PREFERRED FALSE 184#endif 185 186BOOLEAN btif_conf_hf_force_wbs = BTIF_HF_WBS_PREFERRED; 187 188/************************************************************************************ 189** Functions 190************************************************************************************/ 191 192/******************************************************************************* 193** 194** Function is_connected 195** 196** Description Internal function to check if HF is connected 197** 198** Returns TRUE if connected 199** 200*******************************************************************************/ 201static BOOLEAN is_connected(bt_bdaddr_t *bd_addr) 202{ 203 int i; 204 for (i = 0; i < btif_max_hf_clients; ++i) 205 { 206 if (((btif_hf_cb[i].state == BTHF_CONNECTION_STATE_CONNECTED) || 207 (btif_hf_cb[i].state == BTHF_CONNECTION_STATE_SLC_CONNECTED)) && 208 ((bd_addr == NULL) || (bdcmp(bd_addr->address, 209 btif_hf_cb[i].connected_bda.address) == 0))) 210 return TRUE; 211 } 212 return FALSE; 213} 214 215/******************************************************************************* 216** 217** Function btif_hf_idx_by_bdaddr 218** 219** Description Internal function to get idx by bdaddr 220** 221** Returns idx 222** 223*******************************************************************************/ 224static int btif_hf_idx_by_bdaddr(bt_bdaddr_t *bd_addr) 225{ 226 int i; 227 for (i = 0; i < btif_max_hf_clients; ++i) 228 { 229 if ((bdcmp(bd_addr->address, 230 btif_hf_cb[i].connected_bda.address) == 0)) 231 return i; 232 } 233 return BTIF_HF_INVALID_IDX; 234} 235 236/******************************************************************************* 237** 238** Function callstate_to_callsetup 239** 240** Description Converts HAL call state to BTA call setup indicator value 241** 242** Returns BTA call indicator value 243** 244*******************************************************************************/ 245static UINT8 callstate_to_callsetup(bthf_call_state_t call_state) 246{ 247 UINT8 call_setup = 0; 248 if (call_state == BTHF_CALL_STATE_INCOMING) 249 call_setup = 1; 250 if (call_state == BTHF_CALL_STATE_DIALING) 251 call_setup = 2; 252 if (call_state == BTHF_CALL_STATE_ALERTING) 253 call_setup = 3; 254 255 return call_setup; 256} 257 258/******************************************************************************* 259** 260** Function send_at_result 261** 262** Description Send AT result code (OK/ERROR) 263** 264** Returns void 265** 266*******************************************************************************/ 267static void send_at_result(UINT8 ok_flag, UINT16 errcode, int idx) 268{ 269 tBTA_AG_RES_DATA ag_res; 270 memset (&ag_res, 0, sizeof (ag_res)); 271 272 ag_res.ok_flag = ok_flag; 273 if (ok_flag == BTA_AG_OK_ERROR) 274 { 275 ag_res.errcode = errcode; 276 } 277 278 BTA_AgResult (btif_hf_cb[idx].handle, BTA_AG_UNAT_RES, &ag_res); 279} 280 281/******************************************************************************* 282** 283** Function send_indicator_update 284** 285** Description Send indicator update (CIEV) 286** 287** Returns void 288** 289*******************************************************************************/ 290static void send_indicator_update (UINT16 indicator, UINT16 value) 291{ 292 tBTA_AG_RES_DATA ag_res; 293 294 memset(&ag_res, 0, sizeof(tBTA_AG_RES_DATA)); 295 ag_res.ind.id = indicator; 296 ag_res.ind.value = value; 297 298 BTA_AgResult(BTA_AG_HANDLE_ALL, BTA_AG_IND_RES, &ag_res); 299} 300 301void clear_phone_state_multihf(int idx) 302{ 303 btif_hf_cb[idx].call_setup_state = BTHF_CALL_STATE_IDLE; 304 btif_hf_cb[idx].num_active = btif_hf_cb[idx].num_held = 0; 305} 306 307/******************************************************************************* 308** 309** Function btif_hf_latest_connected_idx 310** 311** Description Returns idx for latest connected HF 312** 313** Returns int 314** 315*******************************************************************************/ 316static int btif_hf_latest_connected_idx() 317{ 318 struct timespec now, conn_time_delta; 319 int latest_conn_idx = BTIF_HF_INVALID_IDX, i; 320 321 clock_gettime(CLOCK_MONOTONIC, &now); 322 conn_time_delta.tv_sec = now.tv_sec; 323 324 for (i = 0; i < btif_max_hf_clients; i++) 325 { 326 if (btif_hf_cb[i].state == BTHF_CONNECTION_STATE_SLC_CONNECTED) 327 { 328 if ((now.tv_sec - btif_hf_cb[i].connected_timestamp.tv_sec) 329 < conn_time_delta.tv_sec) 330 { 331 conn_time_delta.tv_sec = 332 now.tv_sec - btif_hf_cb[i].connected_timestamp.tv_sec; 333 latest_conn_idx = i; 334 } 335 } 336 } 337 return latest_conn_idx; 338} 339 340/******************************************************************************* 341** 342** Function btif_hf_check_if_slc_connected 343** 344** Description Returns BT_STATUS_SUCCESS if SLC is up for any HF 345** 346** Returns bt_status_t 347** 348*******************************************************************************/ 349static bt_status_t btif_hf_check_if_slc_connected() 350{ 351 if (bt_hf_callbacks == NULL) 352 { 353 BTIF_TRACE_WARNING("BTHF: %s: BTHF not initialized", __FUNCTION__); 354 return BT_STATUS_NOT_READY; 355 } 356 else 357 { 358 int i; 359 for (i = 0; i < btif_max_hf_clients; i++) 360 { 361 if (btif_hf_cb[i].state == BTHF_CONNECTION_STATE_SLC_CONNECTED) 362 { 363 BTIF_TRACE_EVENT("BTHF: %s: slc connected for idx = %d", 364 __FUNCTION__, i); 365 return BT_STATUS_SUCCESS; 366 } 367 } 368 BTIF_TRACE_WARNING("BTHF: %s: No SLC connection up", __FUNCTION__); 369 return BT_STATUS_NOT_READY; 370 } 371} 372 373/***************************************************************************** 374** Section name (Group of functions) 375*****************************************************************************/ 376 377/***************************************************************************** 378** 379** btif hf api functions (no context switch) 380** 381*****************************************************************************/ 382 383/******************************************************************************* 384** 385** Function btif_hf_upstreams_evt 386** 387** Description Executes HF UPSTREAMS events in btif context 388** 389** Returns void 390** 391*******************************************************************************/ 392static void btif_hf_upstreams_evt(UINT16 event, char* p_param) 393{ 394 tBTA_AG *p_data = (tBTA_AG *)p_param; 395 bdstr_t bdstr; 396 int idx = p_data->hdr.handle - 1; 397 398 BTIF_TRACE_DEBUG("%s: event=%s", __FUNCTION__, dump_hf_event(event)); 399 400 if ((idx < 0) || (idx >= BTIF_HF_NUM_CB)) 401 { 402 BTIF_TRACE_ERROR("%s: Invalid index %d", __FUNCTION__, idx); 403 return; 404 } 405 406 switch (event) 407 { 408 case BTA_AG_ENABLE_EVT: 409 case BTA_AG_DISABLE_EVT: 410 break; 411 412 case BTA_AG_REGISTER_EVT: 413 btif_hf_cb[idx].handle = p_data->reg.hdr.handle; 414 BTIF_TRACE_DEBUG("%s: BTA_AG_REGISTER_EVT," 415 "btif_hf_cb.handle = %d", __FUNCTION__, btif_hf_cb[idx].handle); 416 break; 417 418 case BTA_AG_OPEN_EVT: 419 if (p_data->open.status == BTA_AG_SUCCESS) 420 { 421 bdcpy(btif_hf_cb[idx].connected_bda.address, 422 p_data->open.bd_addr); 423 btif_hf_cb[idx].state = BTHF_CONNECTION_STATE_CONNECTED; 424 btif_hf_cb[idx].peer_feat = 0; 425 clear_phone_state_multihf(idx); 426 } 427 else if (btif_hf_cb[idx].state == BTHF_CONNECTION_STATE_CONNECTING) 428 { 429 btif_hf_cb[idx].state = BTHF_CONNECTION_STATE_DISCONNECTED; 430 } 431 else 432 { 433 BTIF_TRACE_WARNING("%s: AG open failed, but another device connected. status=%d state=%d connected device=%s", 434 __FUNCTION__, p_data->open.status, btif_hf_cb[idx].state, 435 bdaddr_to_string(&btif_hf_cb[idx].connected_bda, bdstr, sizeof(bdstr))); 436 break; 437 } 438 439 HAL_CBACK(bt_hf_callbacks, connection_state_cb, btif_hf_cb[idx].state, 440 &btif_hf_cb[idx].connected_bda); 441 442 if (btif_hf_cb[idx].state == BTHF_CONNECTION_STATE_DISCONNECTED) 443 bdsetany(btif_hf_cb[idx].connected_bda.address); 444 445 if (p_data->open.status != BTA_AG_SUCCESS) 446 btif_queue_advance(); 447 break; 448 449 case BTA_AG_CLOSE_EVT: 450 btif_hf_cb[idx].connected_timestamp.tv_sec = 0; 451 btif_hf_cb[idx].state = BTHF_CONNECTION_STATE_DISCONNECTED; 452 BTIF_TRACE_DEBUG("%s: BTA_AG_CLOSE_EVT," 453 "idx = %d, btif_hf_cb.handle = %d", __FUNCTION__, idx, 454 btif_hf_cb[idx].handle); 455 HAL_CBACK(bt_hf_callbacks, connection_state_cb, btif_hf_cb[idx].state, 456 &btif_hf_cb[idx].connected_bda); 457 bdsetany(btif_hf_cb[idx].connected_bda.address); 458 btif_hf_cb[idx].peer_feat = 0; 459 clear_phone_state_multihf(idx); 460 hf_idx = btif_hf_latest_connected_idx(); 461 /* If AG_OPEN was received but SLC was not setup in a specified time (10 seconds), 462 ** then AG_CLOSE may be received. We need to advance the queue here 463 */ 464 btif_queue_advance(); 465 break; 466 467 case BTA_AG_CONN_EVT: 468 clock_gettime(CLOCK_MONOTONIC, 469 &btif_hf_cb[idx].connected_timestamp); 470 BTIF_TRACE_DEBUG("%s: BTA_AG_CONN_EVT, idx = %d ", 471 __FUNCTION__, idx); 472 btif_hf_cb[idx].peer_feat = p_data->conn.peer_feat; 473 btif_hf_cb[idx].state = BTHF_CONNECTION_STATE_SLC_CONNECTED; 474 hf_idx = btif_hf_latest_connected_idx(); 475 476 HAL_CBACK(bt_hf_callbacks, connection_state_cb, btif_hf_cb[idx].state, 477 &btif_hf_cb[idx].connected_bda); 478 btif_queue_advance(); 479 break; 480 481 case BTA_AG_AUDIO_OPEN_EVT: 482 hf_idx = idx; 483 HAL_CBACK(bt_hf_callbacks, audio_state_cb, BTHF_AUDIO_STATE_CONNECTED, 484 &btif_hf_cb[idx].connected_bda); 485 break; 486 487 case BTA_AG_AUDIO_CLOSE_EVT: 488 HAL_CBACK(bt_hf_callbacks, audio_state_cb, BTHF_AUDIO_STATE_DISCONNECTED, 489 &btif_hf_cb[idx].connected_bda); 490 break; 491 492 /* BTA auto-responds, silently discard */ 493 case BTA_AG_SPK_EVT: 494 case BTA_AG_MIC_EVT: 495 HAL_CBACK(bt_hf_callbacks, volume_cmd_cb, 496 (event == BTA_AG_SPK_EVT) ? BTHF_VOLUME_TYPE_SPK : 497 BTHF_VOLUME_TYPE_MIC, p_data->val.num, 498 &btif_hf_cb[idx].connected_bda); 499 break; 500 501 case BTA_AG_AT_A_EVT: 502 if ((btif_hf_cb[0].num_held + btif_hf_cb[0].num_active) == 0) 503 hf_idx = idx; 504 else 505 BTIF_TRACE_DEBUG("Donot set hf_idx for ATA since already in a call"); 506 507 HAL_CBACK(bt_hf_callbacks, answer_call_cmd_cb, 508 &btif_hf_cb[idx].connected_bda); 509 break; 510 511 /* Java needs to send OK/ERROR for these commands */ 512 case BTA_AG_AT_BLDN_EVT: 513 case BTA_AG_AT_D_EVT: 514 if ((btif_hf_cb[0].num_held + btif_hf_cb[0].num_active) == 0) 515 hf_idx = idx; 516 else 517 BTIF_TRACE_DEBUG("Donot set hf_idx for BLDN/D since already in a call"); 518 519 HAL_CBACK(bt_hf_callbacks, dial_call_cmd_cb, 520 (event == BTA_AG_AT_D_EVT) ? p_data->val.str : NULL, 521 &btif_hf_cb[idx].connected_bda); 522 break; 523 524 case BTA_AG_AT_CHUP_EVT: 525 HAL_CBACK(bt_hf_callbacks, hangup_call_cmd_cb, 526 &btif_hf_cb[idx].connected_bda); 527 break; 528 529 case BTA_AG_AT_CIND_EVT: 530 HAL_CBACK(bt_hf_callbacks, cind_cmd_cb, 531 &btif_hf_cb[idx].connected_bda); 532 break; 533 534 case BTA_AG_AT_VTS_EVT: 535 HAL_CBACK(bt_hf_callbacks, dtmf_cmd_cb, p_data->val.str[0], 536 &btif_hf_cb[idx].connected_bda); 537 break; 538 539 case BTA_AG_AT_BVRA_EVT: 540 HAL_CBACK(bt_hf_callbacks, vr_cmd_cb, 541 (p_data->val.num == 1) ? BTHF_VR_STATE_STARTED : 542 BTHF_VR_STATE_STOPPED, &btif_hf_cb[idx].connected_bda); 543 break; 544 545 case BTA_AG_AT_NREC_EVT: 546 HAL_CBACK(bt_hf_callbacks, nrec_cmd_cb, 547 (p_data->val.num == 1) ? BTHF_NREC_START : BTHF_NREC_STOP, 548 &btif_hf_cb[idx].connected_bda); 549 break; 550 551 /* TODO: Add a callback for CBC */ 552 case BTA_AG_AT_CBC_EVT: 553 break; 554 555 case BTA_AG_AT_CKPD_EVT: 556 HAL_CBACK(bt_hf_callbacks, key_pressed_cmd_cb, 557 &btif_hf_cb[idx].connected_bda); 558 break; 559 560#if (BTM_WBS_INCLUDED == TRUE ) 561 case BTA_AG_WBS_EVT: 562 BTIF_TRACE_DEBUG("BTA_AG_WBS_EVT Set codec status %d codec %d 1=CVSD 2=MSBC", \ 563 p_data->val.hdr.status, p_data->val.num); 564 if(p_data->val.num == BTA_AG_CODEC_CVSD) 565 { HAL_CBACK(bt_hf_callbacks, wbs_cb, BTHF_WBS_NO, &btif_hf_cb[idx].connected_bda);} 566 else if(p_data->val.num == BTA_AG_CODEC_MSBC) 567 {HAL_CBACK(bt_hf_callbacks, wbs_cb, BTHF_WBS_YES, &btif_hf_cb[idx].connected_bda);} 568 else 569 {HAL_CBACK(bt_hf_callbacks, wbs_cb, BTHF_WBS_NONE, &btif_hf_cb[idx].connected_bda);} 570 break; 571#endif 572 /* Java needs to send OK/ERROR for these commands */ 573 case BTA_AG_AT_CHLD_EVT: 574 HAL_CBACK(bt_hf_callbacks, chld_cmd_cb, atoi(p_data->val.str), 575 &btif_hf_cb[idx].connected_bda); 576 break; 577 578 case BTA_AG_AT_CLCC_EVT: 579 HAL_CBACK(bt_hf_callbacks, clcc_cmd_cb, 580 &btif_hf_cb[idx].connected_bda); 581 break; 582 583 case BTA_AG_AT_COPS_EVT: 584 HAL_CBACK(bt_hf_callbacks, cops_cmd_cb, 585 &btif_hf_cb[idx].connected_bda); 586 break; 587 588 case BTA_AG_AT_UNAT_EVT: 589 HAL_CBACK(bt_hf_callbacks, unknown_at_cmd_cb, p_data->val.str, 590 &btif_hf_cb[idx].connected_bda); 591 break; 592 593 case BTA_AG_AT_CNUM_EVT: 594 HAL_CBACK(bt_hf_callbacks, cnum_cmd_cb, 595 &btif_hf_cb[idx].connected_bda); 596 break; 597 598 /* TODO: Some of these commands may need to be sent to app. For now respond with error */ 599 case BTA_AG_AT_BINP_EVT: 600 case BTA_AG_AT_BTRH_EVT: 601 send_at_result(BTA_AG_OK_ERROR, BTA_AG_ERR_OP_NOT_SUPPORTED, idx); 602 break; 603 case BTA_AG_AT_BAC_EVT: 604 BTIF_TRACE_DEBUG("AG Bitmap of peer-codecs %d", p_data->val.num); 605#if (BTM_WBS_INCLUDED == TRUE ) 606 /* If the peer supports mSBC and the BTIF prefferred codec is also mSBC, then 607 we should set the BTA AG Codec to mSBC. This would trigger a +BCS to mSBC at the time 608 of SCO connection establishment */ 609 if ((btif_conf_hf_force_wbs == TRUE) && (p_data->val.num & BTA_AG_CODEC_MSBC)) 610 { 611 BTIF_TRACE_EVENT("%s btif_hf override-Preferred Codec to MSBC", __FUNCTION__); 612 BTA_AgSetCodec(btif_hf_cb[idx].handle,BTA_AG_CODEC_MSBC); 613 } 614 else 615 { 616 BTIF_TRACE_EVENT("%s btif_hf override-Preferred Codec to CVSD", __FUNCTION__); 617 BTA_AgSetCodec(btif_hf_cb[idx].handle,BTA_AG_CODEC_CVSD); 618 } 619#endif 620 break; 621 case BTA_AG_AT_BCS_EVT: 622 BTIF_TRACE_DEBUG("AG final seleded codec is %d 1=CVSD 2=MSBC", p_data->val.num); 623 /* no BTHF_WBS_NONE case, becuase HF1.6 supported device can send BCS */ 624 HAL_CBACK(bt_hf_callbacks, wbs_cb,(p_data->val.num == BTA_AG_CODEC_MSBC) ? \ 625 BTHF_WBS_YES : BTHF_WBS_NO, &btif_hf_cb[idx].connected_bda); 626 break; 627 628 case BTA_AG_AT_BIND_EVT: 629 if (p_data->val.hdr.status == BTA_AG_SUCCESS) 630 { 631 HAL_CBACK(bt_hf_callbacks, bind_cb,p_data->val.str, 632 &btif_hf_cb[idx].connected_bda); 633 } 634 break; 635 636 case BTA_AG_AT_BIEV_EVT: 637 if (p_data->val.hdr.status == BTA_AG_SUCCESS) 638 { 639 HAL_CBACK(bt_hf_callbacks, biev_cb, (bthf_hf_ind_type_t)p_data->val.lidx, (int)p_data->val.num, 640 &btif_hf_cb[idx].connected_bda); 641 } 642 break; 643 default: 644 BTIF_TRACE_WARNING("%s: Unhandled event: %d", __FUNCTION__, event); 645 break; 646 } 647} 648 649/******************************************************************************* 650** 651** Function bte_hf_evt 652** 653** Description Switches context from BTE to BTIF for all HF events 654** 655** Returns void 656** 657*******************************************************************************/ 658 659static void bte_hf_evt(tBTA_AG_EVT event, tBTA_AG *p_data) 660{ 661 bt_status_t status; 662 int param_len = 0; 663 664 /* TODO: BTA sends the union members and not tBTA_AG. If using param_len=sizeof(tBTA_AG), we get a crash on memcpy */ 665 if (BTA_AG_REGISTER_EVT == event) 666 param_len = sizeof(tBTA_AG_REGISTER); 667 else if (BTA_AG_OPEN_EVT == event) 668 param_len = sizeof(tBTA_AG_OPEN); 669 else if (BTA_AG_CONN_EVT == event) 670 param_len = sizeof(tBTA_AG_CONN); 671 else if ( (BTA_AG_CLOSE_EVT == event) || (BTA_AG_AUDIO_OPEN_EVT == event) || (BTA_AG_AUDIO_CLOSE_EVT == event)) 672 param_len = sizeof(tBTA_AG_HDR); 673 else if (p_data) 674 param_len = sizeof(tBTA_AG_VAL); 675 676 /* switch context to btif task context (copy full union size for convenience) */ 677 status = btif_transfer_context(btif_hf_upstreams_evt, (uint16_t)event, (void*)p_data, param_len, NULL); 678 679 /* catch any failed context transfers */ 680 ASSERTC(status == BT_STATUS_SUCCESS, "context transfer failed", status); 681} 682 683/******************************************************************************* 684** 685** Function btif_in_hf_generic_evt 686** 687** Description Processes generic events to be sent to JNI that are not triggered from the BTA. 688** Always runs in BTIF context 689** 690** Returns void 691** 692*******************************************************************************/ 693static void btif_in_hf_generic_evt(UINT16 event, char *p_param) 694{ 695 int idx = btif_hf_idx_by_bdaddr((bt_bdaddr_t *)p_param); 696 697 BTIF_TRACE_EVENT("%s: event=%d", __FUNCTION__, event); 698 699 if ((idx < 0) || (idx >= BTIF_HF_NUM_CB)) 700 { 701 BTIF_TRACE_ERROR("%s: Invalid index %d", __FUNCTION__, idx); 702 return; 703 } 704 705 switch (event) { 706 case BTIF_HFP_CB_AUDIO_CONNECTING: 707 { 708 HAL_CBACK(bt_hf_callbacks, audio_state_cb, BTHF_AUDIO_STATE_CONNECTING, 709 &btif_hf_cb[idx].connected_bda); 710 } break; 711 default: 712 { 713 BTIF_TRACE_WARNING("%s : Unknown event 0x%x", __FUNCTION__, event); 714 } 715 break; 716 } 717} 718 719/******************************************************************************* 720** 721** Function btif_hf_init 722** 723** Description initializes the hf interface 724** 725** Returns bt_status_t 726** 727*******************************************************************************/ 728static bt_status_t init( bthf_callbacks_t* callbacks, int max_hf_clients) 729{ 730 btif_max_hf_clients = max_hf_clients; 731 BTIF_TRACE_DEBUG("%s - max_hf_clients=%d", __func__, btif_max_hf_clients); 732 733 bt_hf_callbacks = callbacks; 734 memset(&btif_hf_cb, 0, sizeof(btif_hf_cb)); 735 736 /* Invoke the enable service API to the core to set the appropriate service_id 737 * Internally, the HSP_SERVICE_ID shall also be enabled if HFP is enabled (phone) 738 * othwerwise only HSP is enabled (tablet) 739 */ 740#if (defined(BTIF_HF_SERVICES) && (BTIF_HF_SERVICES & BTA_HFP_SERVICE_MASK)) 741 btif_enable_service(BTA_HFP_SERVICE_ID); 742#else 743 btif_enable_service(BTA_HSP_SERVICE_ID); 744#endif 745 746 for (int i = 0; i < btif_max_hf_clients; i++) 747 clear_phone_state_multihf(i); 748 749 return BT_STATUS_SUCCESS; 750} 751 752/******************************************************************************* 753** 754** Function connect 755** 756** Description connect to headset 757** 758** Returns bt_status_t 759** 760*******************************************************************************/ 761static bt_status_t connect_int(bt_bdaddr_t *bd_addr, uint16_t uuid) 762{ 763 CHECK_BTHF_INIT(); 764 int i; 765 for (i = 0; i < btif_max_hf_clients;) 766 { 767 if (((btif_hf_cb[i].state == BTHF_CONNECTION_STATE_CONNECTED) || 768 (btif_hf_cb[i].state == BTHF_CONNECTION_STATE_SLC_CONNECTED))) 769 i++; 770 else 771 break; 772 } 773 774 if (i == btif_max_hf_clients) 775 return BT_STATUS_BUSY; 776 777 if (!is_connected(bd_addr)) 778 { 779 btif_hf_cb[i].state = BTHF_CONNECTION_STATE_CONNECTING; 780 bdcpy(btif_hf_cb[i].connected_bda.address, bd_addr->address); 781 782 BTA_AgOpen(btif_hf_cb[i].handle, btif_hf_cb[i].connected_bda.address, 783 BTIF_HF_SECURITY, BTIF_HF_SERVICES); 784 return BT_STATUS_SUCCESS; 785 } 786 787 return BT_STATUS_BUSY; 788} 789 790static bt_status_t connect( bt_bdaddr_t *bd_addr ) 791{ 792 CHECK_BTHF_INIT(); 793 return btif_queue_connect(UUID_SERVCLASS_AG_HANDSFREE, bd_addr, connect_int); 794} 795 796/******************************************************************************* 797** 798** Function disconnect 799** 800** Description disconnect from headset 801** 802** Returns bt_status_t 803** 804*******************************************************************************/ 805static bt_status_t disconnect( bt_bdaddr_t *bd_addr ) 806{ 807 CHECK_BTHF_INIT(); 808 809 int idx = btif_hf_idx_by_bdaddr(bd_addr); 810 811 if ((idx < 0) || (idx >= BTIF_HF_NUM_CB)) 812 { 813 BTIF_TRACE_ERROR("%s: Invalid index %d", __FUNCTION__, idx); 814 return BT_STATUS_FAIL; 815 } 816 817 if (is_connected(bd_addr) && (idx != BTIF_HF_INVALID_IDX)) 818 { 819 BTA_AgClose(btif_hf_cb[idx].handle); 820 return BT_STATUS_SUCCESS; 821 } 822 823 return BT_STATUS_FAIL; 824} 825 826/******************************************************************************* 827** 828** Function connect_audio 829** 830** Description create an audio connection 831** 832** Returns bt_status_t 833** 834*******************************************************************************/ 835static bt_status_t connect_audio( bt_bdaddr_t *bd_addr ) 836{ 837 CHECK_BTHF_INIT(); 838 839 int idx = btif_hf_idx_by_bdaddr(bd_addr); 840 841 if ((idx < 0) || (idx >= BTIF_HF_NUM_CB)) 842 { 843 BTIF_TRACE_ERROR("%s: Invalid index %d", __FUNCTION__, idx); 844 return BT_STATUS_FAIL; 845 } 846 847 /* Check if SLC is connected */ 848 if (btif_hf_check_if_slc_connected() != BT_STATUS_SUCCESS) 849 return BT_STATUS_NOT_READY; 850 851 if (is_connected(bd_addr) && (idx != BTIF_HF_INVALID_IDX)) 852 { 853 BTA_AgAudioOpen(btif_hf_cb[idx].handle); 854 855 /* Inform the application that the audio connection has been initiated successfully */ 856 btif_transfer_context(btif_in_hf_generic_evt, BTIF_HFP_CB_AUDIO_CONNECTING, 857 (char *)bd_addr, sizeof(bt_bdaddr_t), NULL); 858 return BT_STATUS_SUCCESS; 859 } 860 861 return BT_STATUS_FAIL; 862} 863 864/******************************************************************************* 865** 866** Function disconnect_audio 867** 868** Description close the audio connection 869** 870** Returns bt_status_t 871** 872*******************************************************************************/ 873static bt_status_t disconnect_audio( bt_bdaddr_t *bd_addr ) 874{ 875 CHECK_BTHF_INIT(); 876 877 int idx = btif_hf_idx_by_bdaddr(bd_addr); 878 879 if ((idx < 0) || (idx >= BTIF_HF_NUM_CB)) 880 { 881 BTIF_TRACE_ERROR("%s: Invalid index %d", __FUNCTION__, idx); 882 return BT_STATUS_FAIL; 883 } 884 885 if (is_connected(bd_addr) && (idx != BTIF_HF_INVALID_IDX)) 886 { 887 BTA_AgAudioClose(btif_hf_cb[idx].handle); 888 return BT_STATUS_SUCCESS; 889 } 890 891 return BT_STATUS_FAIL; 892} 893 894/******************************************************************************* 895** 896** Function start_voice_recognition 897** 898** Description start voice recognition 899** 900** Returns bt_status_t 901** 902*******************************************************************************/ 903static bt_status_t start_voice_recognition(bt_bdaddr_t *bd_addr) 904{ 905 CHECK_BTHF_INIT(); 906 907 int idx = btif_hf_idx_by_bdaddr(bd_addr); 908 909 if ((idx < 0) || (idx >= BTIF_HF_NUM_CB)) 910 { 911 BTIF_TRACE_ERROR("%s: Invalid index %d", __FUNCTION__, idx); 912 return BT_STATUS_FAIL; 913 } 914 915 if (is_connected(bd_addr) && (idx != BTIF_HF_INVALID_IDX)) 916 { 917 if (btif_hf_cb[idx].peer_feat & BTA_AG_PEER_FEAT_VREC) 918 { 919 tBTA_AG_RES_DATA ag_res; 920 memset(&ag_res, 0, sizeof(ag_res)); 921 ag_res.state = 1; 922 BTA_AgResult (btif_hf_cb[idx].handle, BTA_AG_BVRA_RES, &ag_res); 923 924 return BT_STATUS_SUCCESS; 925 } 926 else 927 { 928 return BT_STATUS_UNSUPPORTED; 929 } 930 } 931 932 return BT_STATUS_NOT_READY; 933} 934 935/******************************************************************************* 936** 937** Function stop_voice_recognition 938** 939** Description stop voice recognition 940** 941** Returns bt_status_t 942** 943*******************************************************************************/ 944static bt_status_t stop_voice_recognition(bt_bdaddr_t *bd_addr) 945{ 946 CHECK_BTHF_INIT(); 947 948 int idx = btif_hf_idx_by_bdaddr(bd_addr); 949 950 if ((idx < 0) || (idx >= BTIF_HF_NUM_CB)) 951 { 952 BTIF_TRACE_ERROR("%s: Invalid index %d", __FUNCTION__, idx); 953 return BT_STATUS_FAIL; 954 } 955 956 if (is_connected(bd_addr) && (idx != BTIF_HF_INVALID_IDX)) 957 { 958 if (btif_hf_cb[idx].peer_feat & BTA_AG_PEER_FEAT_VREC) 959 { 960 tBTA_AG_RES_DATA ag_res; 961 memset(&ag_res, 0, sizeof(ag_res)); 962 ag_res.state = 0; 963 BTA_AgResult (btif_hf_cb[idx].handle, BTA_AG_BVRA_RES, &ag_res); 964 965 return BT_STATUS_SUCCESS; 966 } 967 else 968 { 969 return BT_STATUS_UNSUPPORTED; 970 } 971 } 972 973 return BT_STATUS_NOT_READY; 974} 975 976/******************************************************************************* 977** 978** Function volume_control 979** 980** Description volume control 981** 982** Returns bt_status_t 983** 984*******************************************************************************/ 985static bt_status_t volume_control(bthf_volume_type_t type, int volume, 986 bt_bdaddr_t *bd_addr) 987{ 988 CHECK_BTHF_INIT(); 989 990 int idx = btif_hf_idx_by_bdaddr(bd_addr); 991 992 if ((idx < 0) || (idx >= BTIF_HF_NUM_CB)) 993 { 994 BTIF_TRACE_ERROR("%s: Invalid index %d", __FUNCTION__, idx); 995 return BT_STATUS_FAIL; 996 } 997 998 tBTA_AG_RES_DATA ag_res; 999 memset(&ag_res, 0, sizeof(tBTA_AG_RES_DATA)); 1000 if (is_connected(bd_addr) && (idx != BTIF_HF_INVALID_IDX)) 1001 { 1002 ag_res.num = volume; 1003 BTA_AgResult(btif_hf_cb[idx].handle, 1004 (type == BTHF_VOLUME_TYPE_SPK) ? BTA_AG_SPK_RES : BTA_AG_MIC_RES, 1005 &ag_res); 1006 return BT_STATUS_SUCCESS; 1007 } 1008 1009 return BT_STATUS_FAIL; 1010} 1011 1012/******************************************************************************* 1013** 1014** Function device_status_notification 1015** 1016** Description Combined device status change notification 1017** 1018** Returns bt_status_t 1019** 1020*******************************************************************************/ 1021static bt_status_t device_status_notification(bthf_network_state_t ntk_state, 1022 bthf_service_type_t svc_type, int signal, int batt_chg) 1023{ 1024 CHECK_BTHF_INIT(); 1025 1026 if (is_connected(NULL)) 1027 { 1028 /* send all indicators to BTA. 1029 ** BTA will make sure no duplicates are sent out 1030 */ 1031 send_indicator_update(BTA_AG_IND_SERVICE, 1032 (ntk_state == BTHF_NETWORK_STATE_AVAILABLE) ? 1 : 0); 1033 send_indicator_update(BTA_AG_IND_ROAM, 1034 (svc_type == BTHF_SERVICE_TYPE_HOME) ? 0 : 1); 1035 send_indicator_update(BTA_AG_IND_SIGNAL, signal); 1036 send_indicator_update(BTA_AG_IND_BATTCHG, batt_chg); 1037 return BT_STATUS_SUCCESS; 1038 } 1039 1040 return BT_STATUS_SUCCESS; 1041} 1042 1043/******************************************************************************* 1044** 1045** Function cops_response 1046** 1047** Description Response for COPS command 1048** 1049** Returns bt_status_t 1050** 1051*******************************************************************************/ 1052static bt_status_t cops_response(const char *cops, bt_bdaddr_t *bd_addr) 1053{ 1054 CHECK_BTHF_INIT(); 1055 1056 int idx = btif_hf_idx_by_bdaddr(bd_addr); 1057 1058 if ((idx < 0) || (idx >= BTIF_HF_NUM_CB)) 1059 { 1060 BTIF_TRACE_ERROR("%s: Invalid index %d", __FUNCTION__, idx); 1061 return BT_STATUS_FAIL; 1062 } 1063 1064 if (is_connected(bd_addr) && (idx != BTIF_HF_INVALID_IDX)) 1065 { 1066 tBTA_AG_RES_DATA ag_res; 1067 1068 /* Format the response */ 1069 sprintf (ag_res.str, "0,0,\"%.16s\"", cops); 1070 ag_res.ok_flag = BTA_AG_OK_DONE; 1071 1072 BTA_AgResult (btif_hf_cb[idx].handle, BTA_AG_COPS_RES, &ag_res); 1073 return BT_STATUS_SUCCESS; 1074 } 1075 return BT_STATUS_FAIL; 1076} 1077 1078/******************************************************************************* 1079** 1080** Function cind_response 1081** 1082** Description Response for CIND command 1083** 1084** Returns bt_status_t 1085** 1086*******************************************************************************/ 1087static bt_status_t cind_response(int svc, int num_active, int num_held, 1088 bthf_call_state_t call_setup_state, 1089 int signal, int roam, int batt_chg, 1090 bt_bdaddr_t *bd_addr) 1091{ 1092 CHECK_BTHF_INIT(); 1093 1094 int idx = btif_hf_idx_by_bdaddr(bd_addr); 1095 1096 if ((idx < 0) || (idx >= BTIF_HF_NUM_CB)) 1097 { 1098 BTIF_TRACE_ERROR("%s: Invalid index %d", __FUNCTION__, idx); 1099 return BT_STATUS_FAIL; 1100 } 1101 1102 if (is_connected(bd_addr) && (idx != BTIF_HF_INVALID_IDX)) 1103 { 1104 tBTA_AG_RES_DATA ag_res; 1105 1106 memset (&ag_res, 0, sizeof (ag_res)); 1107 /* per the errata 2043, call=1 implies atleast one call is in progress (active/held) 1108 ** https://www.bluetooth.org/errata/errata_view.cfm?errata_id=2043 1109 **/ 1110 sprintf (ag_res.str, "%d,%d,%d,%d,%d,%d,%d", 1111 (num_active + num_held) ? 1 : 0, /* Call state */ 1112 callstate_to_callsetup(call_setup_state), /* Callsetup state */ 1113 svc, /* network service */ 1114 signal, /* Signal strength */ 1115 roam, /* Roaming indicator */ 1116 batt_chg, /* Battery level */ 1117 ((num_held == 0) ? 0 : ((num_active == 0) ? 2 : 1))); /* Call held */ 1118 1119 BTA_AgResult (btif_hf_cb[idx].handle, BTA_AG_CIND_RES, &ag_res); 1120 1121 return BT_STATUS_SUCCESS; 1122 } 1123 1124 return BT_STATUS_FAIL; 1125} 1126 1127/******************************************************************************* 1128** 1129** Function bind_response 1130** 1131** Description Send +BIND response 1132** 1133** Returns bt_status_t 1134** 1135*******************************************************************************/ 1136static bt_status_t bind_response(bthf_hf_ind_type_t ind_id, bthf_hf_ind_status_t ind_status, 1137 bt_bdaddr_t * bd_addr) 1138{ 1139 CHECK_BTHF_INIT(); 1140 1141 int index = btif_hf_idx_by_bdaddr(bd_addr); 1142 if (!is_connected(bd_addr) || index == BTIF_HF_INVALID_IDX) 1143 return BT_STATUS_FAIL; 1144 1145 tBTA_AG_RES_DATA ag_res; 1146 memset(&ag_res, 0, sizeof(ag_res)); 1147 ag_res.ind.id = ind_id; 1148 ag_res.ind.on_demand = (ind_status == BTHF_HF_IND_ENABLED); 1149 1150 BTA_AgResult(btif_hf_cb[index].handle, BTA_AG_BIND_RES, &ag_res); 1151 return BT_STATUS_SUCCESS; 1152} 1153 1154/******************************************************************************* 1155** 1156** Function formatted_at_response 1157** 1158** Description Pre-formatted AT response, typically in response to unknown AT cmd 1159** 1160** Returns bt_status_t 1161** 1162*******************************************************************************/ 1163static bt_status_t formatted_at_response(const char *rsp, bt_bdaddr_t *bd_addr) 1164{ 1165 CHECK_BTHF_INIT(); 1166 tBTA_AG_RES_DATA ag_res; 1167 int idx = btif_hf_idx_by_bdaddr(bd_addr); 1168 1169 if ((idx < 0) || (idx >= BTIF_HF_NUM_CB)) 1170 { 1171 BTIF_TRACE_ERROR("%s: Invalid index %d", __FUNCTION__, idx); 1172 return BT_STATUS_FAIL; 1173 } 1174 1175 if (is_connected(bd_addr) && (idx != BTIF_HF_INVALID_IDX)) 1176 { 1177 /* Format the response and send */ 1178 memset (&ag_res, 0, sizeof (ag_res)); 1179 strncpy(ag_res.str, rsp, BTA_AG_AT_MAX_LEN); 1180 BTA_AgResult (btif_hf_cb[idx].handle, BTA_AG_UNAT_RES, &ag_res); 1181 1182 return BT_STATUS_SUCCESS; 1183 } 1184 1185 return BT_STATUS_FAIL; 1186} 1187 1188/******************************************************************************* 1189** 1190** Function at_response 1191** 1192** Description ok/error response 1193** 1194** Returns bt_status_t 1195** 1196*******************************************************************************/ 1197static bt_status_t at_response(bthf_at_response_t response_code, 1198 int error_code, bt_bdaddr_t *bd_addr) 1199{ 1200 CHECK_BTHF_INIT(); 1201 1202 int idx = btif_hf_idx_by_bdaddr(bd_addr); 1203 1204 if ((idx < 0) || (idx >= BTIF_HF_NUM_CB)) 1205 { 1206 BTIF_TRACE_ERROR("%s: Invalid index %d", __FUNCTION__, idx); 1207 return BT_STATUS_FAIL; 1208 } 1209 1210 if (is_connected(bd_addr) && (idx != BTIF_HF_INVALID_IDX)) 1211 { 1212 send_at_result((response_code == BTHF_AT_RESPONSE_OK) ? BTA_AG_OK_DONE 1213 : BTA_AG_OK_ERROR, error_code, idx); 1214 return BT_STATUS_SUCCESS; 1215 } 1216 1217 return BT_STATUS_FAIL; 1218} 1219 1220/******************************************************************************* 1221** 1222** Function clcc_response 1223** 1224** Description response for CLCC command 1225** Can be iteratively called for each call index. Call index 1226** of 0 will be treated as NULL termination (Completes response) 1227** 1228** Returns bt_status_t 1229** 1230*******************************************************************************/ 1231static bt_status_t clcc_response(int index, bthf_call_direction_t dir, 1232 bthf_call_state_t state, bthf_call_mode_t mode, 1233 bthf_call_mpty_type_t mpty, const char *number, 1234 bthf_call_addrtype_t type, bt_bdaddr_t *bd_addr) 1235{ 1236 CHECK_BTHF_INIT(); 1237 1238 int idx = btif_hf_idx_by_bdaddr(bd_addr); 1239 1240 if ((idx < 0) || (idx >= BTIF_HF_NUM_CB)) 1241 { 1242 BTIF_TRACE_ERROR("%s: Invalid index %d", __FUNCTION__, idx); 1243 return BT_STATUS_FAIL; 1244 } 1245 1246 if (is_connected(bd_addr) && (idx != BTIF_HF_INVALID_IDX)) 1247 { 1248 tBTA_AG_RES_DATA ag_res; 1249 int xx; 1250 1251 memset (&ag_res, 0, sizeof (ag_res)); 1252 1253 /* Format the response */ 1254 if (index == 0) 1255 { 1256 ag_res.ok_flag = BTA_AG_OK_DONE; 1257 } 1258 else 1259 { 1260 BTIF_TRACE_EVENT("clcc_response: [%d] dir %d state %d mode %d number = %s type = %d", 1261 index, dir, state, mode, number, type); 1262 xx = sprintf (ag_res.str, "%d,%d,%d,%d,%d", 1263 index, dir, state, mode, mpty); 1264 1265 if (number) 1266 { 1267 if ((type == BTHF_CALL_ADDRTYPE_INTERNATIONAL) && (*number != '+')) 1268 sprintf (&ag_res.str[xx], ",\"+%s\",%d", number, type); 1269 else 1270 sprintf (&ag_res.str[xx], ",\"%s\",%d", number, type); 1271 } 1272 } 1273 BTA_AgResult (btif_hf_cb[idx].handle, BTA_AG_CLCC_RES, &ag_res); 1274 1275 return BT_STATUS_SUCCESS; 1276 } 1277 1278 return BT_STATUS_FAIL; 1279} 1280 1281/******************************************************************************* 1282** 1283** Function phone_state_change 1284** 1285** Description notify of a call state change 1286** number & type: valid only for incoming & waiting call 1287** 1288** Returns bt_status_t 1289** 1290*******************************************************************************/ 1291 1292static bt_status_t phone_state_change(int num_active, int num_held, bthf_call_state_t call_setup_state, 1293 const char *number, bthf_call_addrtype_t type) 1294{ 1295 tBTA_AG_RES res = 0xff; 1296 tBTA_AG_RES_DATA ag_res; 1297 bt_status_t status = BT_STATUS_SUCCESS; 1298 BOOLEAN activeCallUpdated = FALSE; 1299 int idx, i; 1300 1301 /* hf_idx is index of connected HS that sent ATA/BLDN, 1302 otherwise index of latest connected HS */ 1303 if (hf_idx != BTIF_HF_INVALID_IDX) 1304 idx = hf_idx; 1305 else 1306 idx = btif_hf_latest_connected_idx(); 1307 1308 BTIF_TRACE_DEBUG("phone_state_change: idx = %d", idx); 1309 1310 /* Check if SLC is connected */ 1311 if (btif_hf_check_if_slc_connected() != BT_STATUS_SUCCESS) 1312 return BT_STATUS_NOT_READY; 1313 1314 BTIF_TRACE_DEBUG("phone_state_change: num_active=%d [prev: %d] num_held=%d[prev: %d]" 1315 " call_setup=%s [prev: %s]", num_active, btif_hf_cb[idx].num_active, 1316 num_held, btif_hf_cb[idx].num_held, dump_hf_call_state(call_setup_state), 1317 dump_hf_call_state(btif_hf_cb[idx].call_setup_state)); 1318 1319 /* if all indicators are 0, send end call and return */ 1320 if (num_active == 0 && num_held == 0 && call_setup_state == BTHF_CALL_STATE_IDLE) 1321 { 1322 BTIF_TRACE_DEBUG("%s: Phone on hook", __FUNCTION__); 1323 1324 /* record call termination timestamp if there was an active/held call or 1325 callsetup state > BTHF_CALL_STATE_IDLE */ 1326 if ((btif_hf_cb[idx].call_setup_state != BTHF_CALL_STATE_IDLE ) || 1327 (btif_hf_cb[idx].num_active) ||(btif_hf_cb[idx].num_held)) 1328 { 1329 BTIF_TRACE_DEBUG("%s: Record call termination timestamp", __FUNCTION__); 1330 clock_gettime(CLOCK_MONOTONIC, &btif_hf_cb[0].call_end_timestamp); 1331 } 1332 BTA_AgResult (BTA_AG_HANDLE_ALL, BTA_AG_END_CALL_RES, NULL); 1333 hf_idx = BTIF_HF_INVALID_IDX; 1334 1335 /* if held call was present, reset that as well */ 1336 if (btif_hf_cb[idx].num_held) 1337 send_indicator_update(BTA_AG_IND_CALLHELD, 0); 1338 1339 goto update_call_states; 1340 } 1341 1342 /* active state can change when: 1343 ** 1. an outgoing/incoming call was answered 1344 ** 2. an held was resumed 1345 ** 3. without callsetup notifications, call became active 1346 ** (3) can happen if call is active and a headset connects to us 1347 ** 1348 ** In the case of (3), we will have to notify the stack of an active 1349 ** call, instead of sending an indicator update. This will also 1350 ** force the SCO to be setup. Handle this special case here prior to 1351 ** call setup handling 1352 */ 1353 if ( ((num_active + num_held) > 0) && (btif_hf_cb[idx].num_active == 0) && (btif_hf_cb[idx].num_held == 0) && 1354 (btif_hf_cb[idx].call_setup_state == BTHF_CALL_STATE_IDLE) ) 1355 { 1356 BTIF_TRACE_DEBUG("%s: Active/Held call notification received without call setup update", 1357 __FUNCTION__); 1358 1359 memset(&ag_res, 0, sizeof(tBTA_AG_RES_DATA)); 1360 ag_res.audio_handle = btif_hf_cb[idx].handle; 1361 /* Addition call setup with the Active call 1362 ** CIND response should have been updated. 1363 ** just open SCO conenction. 1364 */ 1365 if (call_setup_state != BTHF_CALL_STATE_IDLE) 1366 res = BTA_AG_MULTI_CALL_RES; 1367 else 1368 res = BTA_AG_OUT_CALL_CONN_RES; 1369 BTA_AgResult(BTA_AG_HANDLE_ALL, res, &ag_res); 1370 activeCallUpdated = TRUE; 1371 } 1372 1373 /* Ringing call changed? */ 1374 if (call_setup_state != btif_hf_cb[idx].call_setup_state) 1375 { 1376 BTIF_TRACE_DEBUG("%s: Call setup states changed. old: %s new: %s", 1377 __FUNCTION__, dump_hf_call_state(btif_hf_cb[idx].call_setup_state), 1378 dump_hf_call_state(call_setup_state)); 1379 memset(&ag_res, 0, sizeof(tBTA_AG_RES_DATA)); 1380 1381 switch (call_setup_state) 1382 { 1383 case BTHF_CALL_STATE_IDLE: 1384 { 1385 switch (btif_hf_cb[idx].call_setup_state) 1386 { 1387 case BTHF_CALL_STATE_INCOMING: 1388 if (num_active > btif_hf_cb[idx].num_active) 1389 { 1390 res = BTA_AG_IN_CALL_CONN_RES; 1391 ag_res.audio_handle = btif_hf_cb[idx].handle; 1392 } 1393 else if (num_held > btif_hf_cb[idx].num_held) 1394 res = BTA_AG_IN_CALL_HELD_RES; 1395 else 1396 res = BTA_AG_CALL_CANCEL_RES; 1397 break; 1398 case BTHF_CALL_STATE_DIALING: 1399 case BTHF_CALL_STATE_ALERTING: 1400 if (num_active > btif_hf_cb[idx].num_active) 1401 { 1402 ag_res.audio_handle = BTA_AG_HANDLE_SCO_NO_CHANGE; 1403 res = BTA_AG_OUT_CALL_CONN_RES; 1404 } 1405 else 1406 res = BTA_AG_CALL_CANCEL_RES; 1407 break; 1408 default: 1409 BTIF_TRACE_ERROR("%s: Incorrect Call setup state transition", __FUNCTION__); 1410 status = BT_STATUS_PARM_INVALID; 1411 break; 1412 } 1413 } break; 1414 1415 case BTHF_CALL_STATE_INCOMING: 1416 if (num_active || num_held) 1417 res = BTA_AG_CALL_WAIT_RES; 1418 else 1419 res = BTA_AG_IN_CALL_RES; 1420 if (number) 1421 { 1422 int xx = 0; 1423 if ((type == BTHF_CALL_ADDRTYPE_INTERNATIONAL) && (*number != '+')) 1424 xx = sprintf (ag_res.str, "\"+%s\"", number); 1425 else 1426 xx = sprintf (ag_res.str, "\"%s\"", number); 1427 ag_res.num = type; 1428 1429 if (res == BTA_AG_CALL_WAIT_RES) 1430 sprintf(&ag_res.str[xx], ",%d", type); 1431 } 1432 break; 1433 case BTHF_CALL_STATE_DIALING: 1434 if (!(num_active + num_held)) 1435 ag_res.audio_handle = btif_hf_cb[idx].handle; 1436 res = BTA_AG_OUT_CALL_ORIG_RES; 1437 break; 1438 case BTHF_CALL_STATE_ALERTING: 1439 /* if we went from idle->alert, force SCO setup here. dialing usually triggers it */ 1440 if ((btif_hf_cb[idx].call_setup_state == BTHF_CALL_STATE_IDLE) && 1441 !(num_active + num_held)) 1442 ag_res.audio_handle = btif_hf_cb[idx].handle; 1443 res = BTA_AG_OUT_CALL_ALERT_RES; 1444 break; 1445 default: 1446 BTIF_TRACE_ERROR("%s: Incorrect new ringing call state", __FUNCTION__); 1447 status = BT_STATUS_PARM_INVALID; 1448 break; 1449 } 1450 BTIF_TRACE_DEBUG("%s: Call setup state changed. res=%d, audio_handle=%d", __FUNCTION__, res, ag_res.audio_handle); 1451 1452 if (res) 1453 BTA_AgResult(BTA_AG_HANDLE_ALL, res, &ag_res); 1454 1455 /* if call setup is idle, we have already updated call indicator, jump out */ 1456 if (call_setup_state == BTHF_CALL_STATE_IDLE) 1457 { 1458 /* check & update callheld */ 1459 if ((num_held > 0) && (num_active > 0)) 1460 send_indicator_update(BTA_AG_IND_CALLHELD, 1); 1461 goto update_call_states; 1462 } 1463 } 1464 1465 memset(&ag_res, 0, sizeof(tBTA_AG_RES_DATA)); 1466 1467 /* per the errata 2043, call=1 implies atleast one call is in progress (active/held) 1468 ** https://www.bluetooth.org/errata/errata_view.cfm?errata_id=2043 1469 ** Handle call indicator change 1470 **/ 1471 if (!activeCallUpdated && ((num_active + num_held) != 1472 (btif_hf_cb[idx].num_active + btif_hf_cb[idx].num_held)) ) 1473 { 1474 BTIF_TRACE_DEBUG("%s: Active call states changed. old: %d new: %d", __FUNCTION__, btif_hf_cb[idx].num_active, num_active); 1475 send_indicator_update(BTA_AG_IND_CALL, ((num_active + num_held) > 0) ? 1 : 0); 1476 } 1477 1478 /* Held Changed? */ 1479 if (num_held != btif_hf_cb[idx].num_held || 1480 ((num_active == 0) && ((num_held + btif_hf_cb[idx].num_held) > 1))) 1481 { 1482 BTIF_TRACE_DEBUG("%s: Held call states changed. old: %d new: %d", 1483 __FUNCTION__, btif_hf_cb[idx].num_held, num_held); 1484 send_indicator_update(BTA_AG_IND_CALLHELD, ((num_held == 0) ? 0 : ((num_active == 0) ? 2 : 1))); 1485 } 1486 1487 /* Calls Swapped? */ 1488 if ( (call_setup_state == btif_hf_cb[idx].call_setup_state) && 1489 (num_active && num_held) && 1490 (num_active == btif_hf_cb[idx].num_active) && 1491 (num_held == btif_hf_cb[idx].num_held) ) 1492 { 1493 BTIF_TRACE_DEBUG("%s: Calls swapped", __FUNCTION__); 1494 send_indicator_update(BTA_AG_IND_CALLHELD, 1); 1495 } 1496 1497update_call_states: 1498 for (i = 0; i < btif_max_hf_clients; i++) 1499 { 1500 btif_hf_cb[i].num_active = num_active; 1501 btif_hf_cb[i].num_held = num_held; 1502 btif_hf_cb[i].call_setup_state = call_setup_state; 1503 } 1504 return status; 1505} 1506 1507/******************************************************************************* 1508** 1509** Function btif_hf_is_call_idle 1510** 1511** Description returns true if no call is in progress 1512** 1513** Returns bt_status_t 1514** 1515*******************************************************************************/ 1516BOOLEAN btif_hf_is_call_idle() 1517{ 1518 if (bt_hf_callbacks == NULL) 1519 return TRUE; 1520 1521 for (int i = 0; i < btif_max_hf_clients; ++i) 1522 { 1523 if ((btif_hf_cb[i].call_setup_state != BTHF_CALL_STATE_IDLE) 1524 || ((btif_hf_cb[i].num_held + btif_hf_cb[i].num_active) > 0)) 1525 return FALSE; 1526 } 1527 1528 return TRUE; 1529} 1530 1531/******************************************************************************* 1532** 1533** Function btif_hf_call_terminated_recently 1534** 1535** Description Checks if a call has been terminated 1536** 1537** Returns bt_status_t 1538** 1539*******************************************************************************/ 1540BOOLEAN btif_hf_call_terminated_recently() 1541{ 1542 struct timespec now; 1543 1544 clock_gettime(CLOCK_MONOTONIC, &now); 1545 if (now.tv_sec < btif_hf_cb[0].call_end_timestamp.tv_sec + 1546 BTIF_HF_CALL_END_TIMEOUT) 1547 { 1548 return TRUE; 1549 } 1550 else 1551 { 1552 btif_hf_cb[0].call_end_timestamp.tv_sec = 0; 1553 return FALSE; 1554 } 1555} 1556 1557/******************************************************************************* 1558** 1559** Function cleanup 1560** 1561** Description Closes the HF interface 1562** 1563** Returns bt_status_t 1564** 1565*******************************************************************************/ 1566static void cleanup( void ) 1567{ 1568 BTIF_TRACE_EVENT("%s", __FUNCTION__); 1569 1570 if (bt_hf_callbacks) 1571 { 1572 btif_disable_service(BTA_HFP_SERVICE_ID); 1573 bt_hf_callbacks = NULL; 1574 } 1575} 1576 1577/******************************************************************************* 1578** 1579** Function configure_wbs 1580** 1581** Description set to over-ride the current WBS configuration. 1582** It will not send codec setting cmd to the controller now. 1583** It just change the configure. 1584** 1585** Returns bt_status_t 1586** 1587*******************************************************************************/ 1588static bt_status_t configure_wbs( bt_bdaddr_t *bd_addr , bthf_wbs_config_t config ) 1589{ 1590 CHECK_BTHF_INIT(); 1591 1592 int idx = btif_hf_idx_by_bdaddr(bd_addr); 1593 1594 if ((idx < 0) || (idx >= BTIF_HF_NUM_CB)) 1595 { 1596 BTIF_TRACE_ERROR("%s: Invalid index %d", __FUNCTION__, idx); 1597 return BT_STATUS_FAIL; 1598 } 1599 1600 BTIF_TRACE_EVENT("%s config is %d", __FUNCTION__,config); 1601 if (config == BTHF_WBS_YES) 1602 BTA_AgSetCodec(btif_hf_cb[idx].handle,BTA_AG_CODEC_MSBC); 1603 else if(config == BTHF_WBS_NO) 1604 BTA_AgSetCodec(btif_hf_cb[idx].handle,BTA_AG_CODEC_CVSD); 1605 else 1606 BTA_AgSetCodec(btif_hf_cb[idx].handle,BTA_AG_CODEC_NONE); 1607 1608 return BT_STATUS_SUCCESS; 1609} 1610 1611static const bthf_interface_t bthfInterface = { 1612 sizeof(bthfInterface), 1613 init, 1614 connect, 1615 disconnect, 1616 connect_audio, 1617 disconnect_audio, 1618 start_voice_recognition, 1619 stop_voice_recognition, 1620 volume_control, 1621 device_status_notification, 1622 cops_response, 1623 cind_response, 1624 formatted_at_response, 1625 at_response, 1626 clcc_response, 1627 phone_state_change, 1628 cleanup, 1629 configure_wbs, 1630 bind_response, 1631}; 1632 1633/******************************************************************************* 1634** 1635** Function btif_hf_execute_service 1636** 1637** Description Initializes/Shuts down the service 1638** 1639** Returns BT_STATUS_SUCCESS on success, BT_STATUS_FAIL otherwise 1640** 1641*******************************************************************************/ 1642bt_status_t btif_hf_execute_service(BOOLEAN b_enable) 1643{ 1644 char * p_service_names[] = BTIF_HF_SERVICE_NAMES; 1645 int i; 1646 if (b_enable) 1647 { 1648 /* Enable and register with BTA-AG */ 1649 BTA_AgEnable (BTA_AG_PARSE, bte_hf_evt); 1650 for (i = 0; i < btif_max_hf_clients; i++) 1651 { 1652 BTA_AgRegister(BTIF_HF_SERVICES, BTIF_HF_SECURITY, 1653 BTIF_HF_FEATURES, p_service_names, bthf_hf_id[i]); 1654 } 1655 } 1656 else { 1657 /* De-register AG */ 1658 for (i = 0; i < btif_max_hf_clients; i++) 1659 { 1660 BTA_AgDeregister(btif_hf_cb[i].handle); 1661 } 1662 /* Disable AG */ 1663 BTA_AgDisable(); 1664 } 1665 return BT_STATUS_SUCCESS; 1666} 1667 1668/******************************************************************************* 1669** 1670** Function btif_hf_get_interface 1671** 1672** Description Get the hf callback interface 1673** 1674** Returns bthf_interface_t 1675** 1676*******************************************************************************/ 1677const bthf_interface_t *btif_hf_get_interface() 1678{ 1679 BTIF_TRACE_EVENT("%s", __FUNCTION__); 1680 return &bthfInterface; 1681} 1682