/******************************************************************************
*
* Copyright (C) 2009-2012 Broadcom Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
******************************************************************************/
/*******************************************************************************
*
* Filename: btif_hf.c
*
* Description: Handsfree Profile Bluetooth Interface
*
*
******************************************************************************/
#define LOG_TAG "bt_btif_hf"
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <hardware/bluetooth.h>
#include <hardware/bt_hf.h>
#include "bta/include/utl.h"
#include "bta_ag_api.h"
#include "btcore/include/bdaddr.h"
#include "btif_common.h"
#include "btif_hf.h"
#include "btif_profile_queue.h"
#include "btif_util.h"
#include "osi/include/properties.h"
/*******************************************************************************
* Constants & Macros
******************************************************************************/
#ifndef BTIF_HSAG_SERVICE_NAME
#define BTIF_HSAG_SERVICE_NAME ("Headset Gateway")
#endif
#ifndef BTIF_HFAG_SERVICE_NAME
#define BTIF_HFAG_SERVICE_NAME ("Handsfree Gateway")
#endif
#ifndef BTIF_HF_SERVICES
#define BTIF_HF_SERVICES (BTA_HSP_SERVICE_MASK | BTA_HFP_SERVICE_MASK)
#endif
#ifndef BTIF_HF_SERVICE_NAMES
#define BTIF_HF_SERVICE_NAMES \
{ BTIF_HSAG_SERVICE_NAME, BTIF_HFAG_SERVICE_NAME }
#endif
#ifndef BTIF_HF_SECURITY
#define BTIF_HF_SECURITY (BTA_SEC_AUTHENTICATE | BTA_SEC_ENCRYPT)
#endif
#ifndef BTIF_HF_FEATURES
#define BTIF_HF_FEATURES \
(BTA_AG_FEAT_3WAY | BTA_AG_FEAT_ECNR | BTA_AG_FEAT_REJECT | \
BTA_AG_FEAT_ECS | BTA_AG_FEAT_EXTERR | BTA_AG_FEAT_VREC | \
BTA_AG_FEAT_CODEC | BTA_AG_FEAT_HF_IND | BTA_AG_FEAT_ESCO | \
BTA_AG_FEAT_UNAT)
#endif
/* HF features supported at runtime */
static uint32_t btif_hf_features = BTIF_HF_FEATURES;
#define BTIF_HF_CALL_END_TIMEOUT 6
#define BTIF_HF_INVALID_IDX (-1)
/* Number of BTIF-HF control blocks */
#define BTIF_HF_NUM_CB 2
/* Max HF clients supported from App */
uint16_t btif_max_hf_clients = 1;
/* HF app ids for service registration */
typedef enum {
BTIF_HF_ID_1 = 0,
BTIF_HF_ID_2,
#if (BTIF_HF_NUM_CB == 3)
BTIF_HF_ID_3
#endif
} bthf_hf_id_t;
uint16_t bthf_hf_id[BTIF_HF_NUM_CB] = {BTIF_HF_ID_1, BTIF_HF_ID_2,
#if (BTIF_HF_NUM_CB == 3)
BTIF_HF_ID_3
#endif
};
/*******************************************************************************
* Local type definitions
******************************************************************************/
/*******************************************************************************
* Static variables
******************************************************************************/
static bthf_callbacks_t* bt_hf_callbacks = NULL;
static int hf_idx = BTIF_HF_INVALID_IDX;
#define CHECK_BTHF_INIT() \
do { \
if (bt_hf_callbacks == NULL) { \
BTIF_TRACE_WARNING("BTHF: %s: BTHF not initialized", __func__); \
return BT_STATUS_NOT_READY; \
} else { \
BTIF_TRACE_EVENT("BTHF: %s", __func__); \
} \
} while (0)
/* BTIF-HF control block to map bdaddr to BTA handle */
typedef struct _btif_hf_cb {
uint16_t handle;
bt_bdaddr_t connected_bda;
bthf_connection_state_t state;
bthf_vr_state_t vr_state;
tBTA_AG_PEER_FEAT peer_feat;
int num_active;
int num_held;
struct timespec call_end_timestamp;
struct timespec connected_timestamp;
bthf_call_state_t call_setup_state;
} btif_hf_cb_t;
static btif_hf_cb_t btif_hf_cb[BTIF_HF_NUM_CB];
/*******************************************************************************
* Static functions
******************************************************************************/
/*******************************************************************************
* Externs
******************************************************************************/
/* By default, even though codec negotiation is enabled, we will not use WBS as
* the default
* codec unless this variable is set to true.
*/
#ifndef BTIF_HF_WBS_PREFERRED
#define BTIF_HF_WBS_PREFERRED false
#endif
bool btif_conf_hf_force_wbs = BTIF_HF_WBS_PREFERRED;
/*******************************************************************************
* Functions
******************************************************************************/
/*******************************************************************************
*
* Function is_connected
*
* Description Internal function to check if HF is connected
*
* Returns true if connected
*
******************************************************************************/
static bool is_connected(bt_bdaddr_t* bd_addr) {
int i;
for (i = 0; i < btif_max_hf_clients; ++i) {
if (((btif_hf_cb[i].state == BTHF_CONNECTION_STATE_CONNECTED) ||
(btif_hf_cb[i].state == BTHF_CONNECTION_STATE_SLC_CONNECTED)) &&
((bd_addr == NULL) ||
(bdcmp(bd_addr->address, btif_hf_cb[i].connected_bda.address) == 0)))
return true;
}
return false;
}
/*******************************************************************************
*
* Function btif_hf_idx_by_bdaddr
*
* Description Internal function to get idx by bdaddr
*
* Returns idx
*
******************************************************************************/
static int btif_hf_idx_by_bdaddr(bt_bdaddr_t* bd_addr) {
int i;
for (i = 0; i < btif_max_hf_clients; ++i) {
if ((bdcmp(bd_addr->address, btif_hf_cb[i].connected_bda.address) == 0))
return i;
}
return BTIF_HF_INVALID_IDX;
}
/*******************************************************************************
*
* Function callstate_to_callsetup
*
* Description Converts HAL call state to BTA call setup indicator value
*
* Returns BTA call indicator value
*
******************************************************************************/
static uint8_t callstate_to_callsetup(bthf_call_state_t call_state) {
uint8_t call_setup = 0;
if (call_state == BTHF_CALL_STATE_INCOMING) call_setup = 1;
if (call_state == BTHF_CALL_STATE_DIALING) call_setup = 2;
if (call_state == BTHF_CALL_STATE_ALERTING) call_setup = 3;
return call_setup;
}
/*******************************************************************************
*
* Function send_at_result
*
* Description Send AT result code (OK/ERROR)
*
* Returns void
*
******************************************************************************/
static void send_at_result(uint8_t ok_flag, uint16_t errcode, int idx) {
tBTA_AG_RES_DATA ag_res;
memset(&ag_res, 0, sizeof(ag_res));
ag_res.ok_flag = ok_flag;
if (ok_flag == BTA_AG_OK_ERROR) {
ag_res.errcode = errcode;
}
BTA_AgResult(btif_hf_cb[idx].handle, BTA_AG_UNAT_RES, &ag_res);
}
/*******************************************************************************
*
* Function send_indicator_update
*
* Description Send indicator update (CIEV)
*
* Returns void
*
******************************************************************************/
static void send_indicator_update(uint16_t indicator, uint16_t value) {
tBTA_AG_RES_DATA ag_res;
memset(&ag_res, 0, sizeof(tBTA_AG_RES_DATA));
ag_res.ind.id = indicator;
ag_res.ind.value = value;
BTA_AgResult(BTA_AG_HANDLE_ALL, BTA_AG_IND_RES, &ag_res);
}
void clear_phone_state_multihf(int idx) {
btif_hf_cb[idx].call_setup_state = BTHF_CALL_STATE_IDLE;
btif_hf_cb[idx].num_active = btif_hf_cb[idx].num_held = 0;
}
/*******************************************************************************
*
* Function btif_hf_latest_connected_idx
*
* Description Returns idx for latest connected HF
*
* Returns int
*
******************************************************************************/
static int btif_hf_latest_connected_idx() {
struct timespec now, conn_time_delta;
int latest_conn_idx = BTIF_HF_INVALID_IDX, i;
clock_gettime(CLOCK_MONOTONIC, &now);
conn_time_delta.tv_sec = now.tv_sec;
for (i = 0; i < btif_max_hf_clients; i++) {
if (btif_hf_cb[i].state == BTHF_CONNECTION_STATE_SLC_CONNECTED) {
if ((now.tv_sec - btif_hf_cb[i].connected_timestamp.tv_sec) <
conn_time_delta.tv_sec) {
conn_time_delta.tv_sec =
now.tv_sec - btif_hf_cb[i].connected_timestamp.tv_sec;
latest_conn_idx = i;
}
}
}
return latest_conn_idx;
}
/*******************************************************************************
*
* Function btif_hf_check_if_slc_connected
*
* Description Returns BT_STATUS_SUCCESS if SLC is up for any HF
*
* Returns bt_status_t
*
******************************************************************************/
static bt_status_t btif_hf_check_if_slc_connected() {
if (bt_hf_callbacks == NULL) {
BTIF_TRACE_WARNING("BTHF: %s: BTHF not initialized", __func__);
return BT_STATUS_NOT_READY;
} else {
int i;
for (i = 0; i < btif_max_hf_clients; i++) {
if (btif_hf_cb[i].state == BTHF_CONNECTION_STATE_SLC_CONNECTED) {
BTIF_TRACE_EVENT("BTHF: %s: slc connected for idx = %d", __func__, i);
return BT_STATUS_SUCCESS;
}
}
BTIF_TRACE_WARNING("BTHF: %s: No SLC connection up", __func__);
return BT_STATUS_NOT_READY;
}
}
/*****************************************************************************
* Section name (Group of functions)
****************************************************************************/
/*****************************************************************************
*
* btif hf api functions (no context switch)
*
****************************************************************************/
/*******************************************************************************
*
* Function btif_hf_upstreams_evt
*
* Description Executes HF UPSTREAMS events in btif context
*
* Returns void
*
******************************************************************************/
static void btif_hf_upstreams_evt(uint16_t event, char* p_param) {
tBTA_AG* p_data = (tBTA_AG*)p_param;
bdstr_t bdstr;
int idx = p_data->hdr.handle - 1;
BTIF_TRACE_DEBUG("%s: event=%s", __func__, dump_hf_event(event));
if ((idx < 0) || (idx >= BTIF_HF_NUM_CB)) {
BTIF_TRACE_ERROR("%s: Invalid index %d", __func__, idx);
return;
}
switch (event) {
case BTA_AG_ENABLE_EVT:
case BTA_AG_DISABLE_EVT:
break;
case BTA_AG_REGISTER_EVT:
btif_hf_cb[idx].handle = p_data->reg.hdr.handle;
BTIF_TRACE_DEBUG(
"%s: BTA_AG_REGISTER_EVT,"
"btif_hf_cb.handle = %d",
__func__, btif_hf_cb[idx].handle);
break;
case BTA_AG_OPEN_EVT:
if (p_data->open.status == BTA_AG_SUCCESS) {
bdcpy(btif_hf_cb[idx].connected_bda.address, p_data->open.bd_addr);
btif_hf_cb[idx].state = BTHF_CONNECTION_STATE_CONNECTED;
btif_hf_cb[idx].peer_feat = 0;
clear_phone_state_multihf(idx);
} else if (btif_hf_cb[idx].state == BTHF_CONNECTION_STATE_CONNECTING) {
btif_hf_cb[idx].state = BTHF_CONNECTION_STATE_DISCONNECTED;
} else {
BTIF_TRACE_WARNING(
"%s: AG open failed, but another device connected. status=%d "
"state=%d connected device=%s",
__func__, p_data->open.status, btif_hf_cb[idx].state,
bdaddr_to_string(&btif_hf_cb[idx].connected_bda, bdstr,
sizeof(bdstr)));
break;
}
HAL_CBACK(bt_hf_callbacks, connection_state_cb, btif_hf_cb[idx].state,
&btif_hf_cb[idx].connected_bda);
if (btif_hf_cb[idx].state == BTHF_CONNECTION_STATE_DISCONNECTED)
bdsetany(btif_hf_cb[idx].connected_bda.address);
if (p_data->open.status != BTA_AG_SUCCESS) btif_queue_advance();
break;
case BTA_AG_CLOSE_EVT:
btif_hf_cb[idx].connected_timestamp.tv_sec = 0;
btif_hf_cb[idx].state = BTHF_CONNECTION_STATE_DISCONNECTED;
BTIF_TRACE_DEBUG(
"%s: BTA_AG_CLOSE_EVT,"
"idx = %d, btif_hf_cb.handle = %d",
__func__, idx, btif_hf_cb[idx].handle);
HAL_CBACK(bt_hf_callbacks, connection_state_cb, btif_hf_cb[idx].state,
&btif_hf_cb[idx].connected_bda);
bdsetany(btif_hf_cb[idx].connected_bda.address);
btif_hf_cb[idx].peer_feat = 0;
clear_phone_state_multihf(idx);
hf_idx = btif_hf_latest_connected_idx();
/* If AG_OPEN was received but SLC was not setup in a specified time (10
*seconds),
** then AG_CLOSE may be received. We need to advance the queue here
*/
btif_queue_advance();
break;
case BTA_AG_CONN_EVT:
clock_gettime(CLOCK_MONOTONIC, &btif_hf_cb[idx].connected_timestamp);
BTIF_TRACE_DEBUG("%s: BTA_AG_CONN_EVT, idx = %d ", __func__, idx);
btif_hf_cb[idx].peer_feat = p_data->conn.peer_feat;
btif_hf_cb[idx].state = BTHF_CONNECTION_STATE_SLC_CONNECTED;
hf_idx = btif_hf_latest_connected_idx();
HAL_CBACK(bt_hf_callbacks, connection_state_cb, btif_hf_cb[idx].state,
&btif_hf_cb[idx].connected_bda);
btif_queue_advance();
break;
case BTA_AG_AUDIO_OPEN_EVT:
hf_idx = idx;
HAL_CBACK(bt_hf_callbacks, audio_state_cb, BTHF_AUDIO_STATE_CONNECTED,
&btif_hf_cb[idx].connected_bda);
break;
case BTA_AG_AUDIO_CLOSE_EVT:
HAL_CBACK(bt_hf_callbacks, audio_state_cb, BTHF_AUDIO_STATE_DISCONNECTED,
&btif_hf_cb[idx].connected_bda);
break;
/* BTA auto-responds, silently discard */
case BTA_AG_SPK_EVT:
case BTA_AG_MIC_EVT:
HAL_CBACK(bt_hf_callbacks, volume_cmd_cb,
(event == BTA_AG_SPK_EVT) ? BTHF_VOLUME_TYPE_SPK
: BTHF_VOLUME_TYPE_MIC,
p_data->val.num, &btif_hf_cb[idx].connected_bda);
break;
case BTA_AG_AT_A_EVT:
if ((btif_hf_cb[0].num_held + btif_hf_cb[0].num_active) == 0)
hf_idx = idx;
else
BTIF_TRACE_DEBUG("Donot set hf_idx for ATA since already in a call");
HAL_CBACK(bt_hf_callbacks, answer_call_cmd_cb,
&btif_hf_cb[idx].connected_bda);
break;
/* Java needs to send OK/ERROR for these commands */
case BTA_AG_AT_BLDN_EVT:
case BTA_AG_AT_D_EVT:
if ((btif_hf_cb[0].num_held + btif_hf_cb[0].num_active) == 0)
hf_idx = idx;
else
BTIF_TRACE_DEBUG("Donot set hf_idx for BLDN/D since already in a call");
HAL_CBACK(bt_hf_callbacks, dial_call_cmd_cb,
(event == BTA_AG_AT_D_EVT) ? p_data->val.str : NULL,
&btif_hf_cb[idx].connected_bda);
break;
case BTA_AG_AT_CHUP_EVT:
HAL_CBACK(bt_hf_callbacks, hangup_call_cmd_cb,
&btif_hf_cb[idx].connected_bda);
break;
case BTA_AG_AT_CIND_EVT:
HAL_CBACK(bt_hf_callbacks, cind_cmd_cb, &btif_hf_cb[idx].connected_bda);
break;
case BTA_AG_AT_VTS_EVT:
HAL_CBACK(bt_hf_callbacks, dtmf_cmd_cb, p_data->val.str[0],
&btif_hf_cb[idx].connected_bda);
break;
case BTA_AG_AT_BVRA_EVT:
HAL_CBACK(bt_hf_callbacks, vr_cmd_cb,
(p_data->val.num == 1) ? BTHF_VR_STATE_STARTED
: BTHF_VR_STATE_STOPPED,
&btif_hf_cb[idx].connected_bda);
break;
case BTA_AG_AT_NREC_EVT:
HAL_CBACK(bt_hf_callbacks, nrec_cmd_cb,
(p_data->val.num == 1) ? BTHF_NREC_START : BTHF_NREC_STOP,
&btif_hf_cb[idx].connected_bda);
break;
/* TODO: Add a callback for CBC */
case BTA_AG_AT_CBC_EVT:
break;
case BTA_AG_AT_CKPD_EVT:
HAL_CBACK(bt_hf_callbacks, key_pressed_cmd_cb,
&btif_hf_cb[idx].connected_bda);
break;
case BTA_AG_WBS_EVT:
BTIF_TRACE_DEBUG(
"BTA_AG_WBS_EVT Set codec status %d codec %d 1=CVSD 2=MSBC",
p_data->val.hdr.status, p_data->val.num);
if (p_data->val.num == BTA_AG_CODEC_CVSD) {
HAL_CBACK(bt_hf_callbacks, wbs_cb, BTHF_WBS_NO,
&btif_hf_cb[idx].connected_bda);
} else if (p_data->val.num == BTA_AG_CODEC_MSBC) {
HAL_CBACK(bt_hf_callbacks, wbs_cb, BTHF_WBS_YES,
&btif_hf_cb[idx].connected_bda);
} else {
HAL_CBACK(bt_hf_callbacks, wbs_cb, BTHF_WBS_NONE,
&btif_hf_cb[idx].connected_bda);
}
break;
/* Java needs to send OK/ERROR for these commands */
case BTA_AG_AT_CHLD_EVT:
HAL_CBACK(bt_hf_callbacks, chld_cmd_cb,
(bthf_chld_type_t)atoi(p_data->val.str),
&btif_hf_cb[idx].connected_bda);
break;
case BTA_AG_AT_CLCC_EVT:
HAL_CBACK(bt_hf_callbacks, clcc_cmd_cb, &btif_hf_cb[idx].connected_bda);
break;
case BTA_AG_AT_COPS_EVT:
HAL_CBACK(bt_hf_callbacks, cops_cmd_cb, &btif_hf_cb[idx].connected_bda);
break;
case BTA_AG_AT_UNAT_EVT:
HAL_CBACK(bt_hf_callbacks, unknown_at_cmd_cb, p_data->val.str,
&btif_hf_cb[idx].connected_bda);
break;
case BTA_AG_AT_CNUM_EVT:
HAL_CBACK(bt_hf_callbacks, cnum_cmd_cb, &btif_hf_cb[idx].connected_bda);
break;
/* TODO: Some of these commands may need to be sent to app. For now respond
* with error */
case BTA_AG_AT_BINP_EVT:
case BTA_AG_AT_BTRH_EVT:
send_at_result(BTA_AG_OK_ERROR, BTA_AG_ERR_OP_NOT_SUPPORTED, idx);
break;
case BTA_AG_AT_BAC_EVT:
BTIF_TRACE_DEBUG("AG Bitmap of peer-codecs %d", p_data->val.num);
/* If the peer supports mSBC and the BTIF preferred codec is also mSBC,
then
we should set the BTA AG Codec to mSBC. This would trigger a +BCS to mSBC
at the time
of SCO connection establishment */
if ((btif_conf_hf_force_wbs == true) &&
(p_data->val.num & BTA_AG_CODEC_MSBC)) {
BTIF_TRACE_EVENT("%s: btif_hf override-Preferred Codec to MSBC",
__func__);
BTA_AgSetCodec(btif_hf_cb[idx].handle, BTA_AG_CODEC_MSBC);
} else {
BTIF_TRACE_EVENT("%s btif_hf override-Preferred Codec to CVSD",
__func__);
BTA_AgSetCodec(btif_hf_cb[idx].handle, BTA_AG_CODEC_CVSD);
}
break;
case BTA_AG_AT_BCS_EVT:
BTIF_TRACE_DEBUG("%s: AG final selected codec is 0x%02x 1=CVSD 2=MSBC",
__func__, p_data->val.num);
/* No BTHF_WBS_NONE case, because HF1.6 supported device can send BCS */
/* Only CVSD is considered narrow band speech */
HAL_CBACK(
bt_hf_callbacks, wbs_cb,
(p_data->val.num == BTA_AG_CODEC_CVSD) ? BTHF_WBS_NO : BTHF_WBS_YES,
&btif_hf_cb[idx].connected_bda);
break;
case BTA_AG_AT_BIND_EVT:
if (p_data->val.hdr.status == BTA_AG_SUCCESS) {
HAL_CBACK(bt_hf_callbacks, bind_cb, p_data->val.str,
&btif_hf_cb[idx].connected_bda);
}
break;
case BTA_AG_AT_BIEV_EVT:
if (p_data->val.hdr.status == BTA_AG_SUCCESS) {
HAL_CBACK(bt_hf_callbacks, biev_cb,
(bthf_hf_ind_type_t)p_data->val.lidx, (int)p_data->val.num,
&btif_hf_cb[idx].connected_bda);
}
break;
default:
BTIF_TRACE_WARNING("%s: Unhandled event: %d", __func__, event);
break;
}
}
/*******************************************************************************
*
* Function bte_hf_evt
*
* Description Switches context from BTE to BTIF for all HF events
*
* Returns void
*
******************************************************************************/
static void bte_hf_evt(tBTA_AG_EVT event, tBTA_AG* p_data) {
bt_status_t status;
int param_len = 0;
/* TODO: BTA sends the union members and not tBTA_AG. If using
* param_len=sizeof(tBTA_AG), we get a crash on memcpy */
if (BTA_AG_REGISTER_EVT == event)
param_len = sizeof(tBTA_AG_REGISTER);
else if (BTA_AG_OPEN_EVT == event)
param_len = sizeof(tBTA_AG_OPEN);
else if (BTA_AG_CONN_EVT == event)
param_len = sizeof(tBTA_AG_CONN);
else if ((BTA_AG_CLOSE_EVT == event) || (BTA_AG_AUDIO_OPEN_EVT == event) ||
(BTA_AG_AUDIO_CLOSE_EVT == event))
param_len = sizeof(tBTA_AG_HDR);
else if (p_data)
param_len = sizeof(tBTA_AG_VAL);
/* switch context to btif task context (copy full union size for convenience)
*/
status = btif_transfer_context(btif_hf_upstreams_evt, (uint16_t)event,
(char*)p_data, param_len, NULL);
/* catch any failed context transfers */
ASSERTC(status == BT_STATUS_SUCCESS, "context transfer failed", status);
}
/*******************************************************************************
*
* Function btif_in_hf_generic_evt
*
* Description Processes generic events to be sent to JNI that are not
* triggered from the BTA.
* Always runs in BTIF context
*
* Returns void
*
******************************************************************************/
static void btif_in_hf_generic_evt(uint16_t event, char* p_param) {
int idx = btif_hf_idx_by_bdaddr((bt_bdaddr_t*)p_param);
BTIF_TRACE_EVENT("%s: event=%d", __func__, event);
if ((idx < 0) || (idx >= BTIF_HF_NUM_CB)) {
BTIF_TRACE_ERROR("%s: Invalid index %d", __func__, idx);
return;
}
switch (event) {
case BTIF_HFP_CB_AUDIO_CONNECTING: {
HAL_CBACK(bt_hf_callbacks, audio_state_cb, BTHF_AUDIO_STATE_CONNECTING,
&btif_hf_cb[idx].connected_bda);
} break;
default: {
BTIF_TRACE_WARNING("%s : Unknown event 0x%x", __func__, event);
} break;
}
}
static bool inband_ringing_property_enabled() {
char inband_ringing_flag[PROPERTY_VALUE_MAX] = {0};
osi_property_get("persist.bluetooth.enableinbandringing", inband_ringing_flag,
"false");
if (strncmp(inband_ringing_flag, "true", 4) == 0) {
BTIF_TRACE_DEBUG("%s: In-band ringing enabled by property", __func__);
return true;
}
return false;
}
/*******************************************************************************
*
* Function btif_hf_init
*
* Description initializes the hf interface
*
* Returns bt_status_t
*
******************************************************************************/
static bt_status_t init(bthf_callbacks_t* callbacks, int max_hf_clients,
bool inband_ringing_supported) {
bool inband_ringing_property_enable = inband_ringing_property_enabled();
if (inband_ringing_supported && inband_ringing_property_enable) {
btif_hf_features |= BTA_AG_FEAT_INBAND;
} else {
btif_hf_features &= ~BTA_AG_FEAT_INBAND;
}
btif_max_hf_clients = max_hf_clients;
BTIF_TRACE_DEBUG(
"%s: btif_hf_features=%zu, max_hf_clients=%d, "
"inband_ringing=[supported=%d, enabled=%d]",
__func__, btif_hf_features, btif_max_hf_clients, inband_ringing_supported,
inband_ringing_property_enable);
bt_hf_callbacks = callbacks;
memset(&btif_hf_cb, 0, sizeof(btif_hf_cb));
/* Invoke the enable service API to the core to set the appropriate service_id
* Internally, the HSP_SERVICE_ID shall also be enabled if HFP is enabled
* (phone)
* othwerwise only HSP is enabled (tablet)
*/
#if (defined(BTIF_HF_SERVICES) && (BTIF_HF_SERVICES & BTA_HFP_SERVICE_MASK))
btif_enable_service(BTA_HFP_SERVICE_ID);
#else
btif_enable_service(BTA_HSP_SERVICE_ID);
#endif
for (int i = 0; i < btif_max_hf_clients; i++) clear_phone_state_multihf(i);
return BT_STATUS_SUCCESS;
}
/*******************************************************************************
*
* Function connect
*
* Description connect to headset
*
* Returns bt_status_t
*
******************************************************************************/
static bt_status_t connect_int(bt_bdaddr_t* bd_addr, uint16_t uuid) {
CHECK_BTHF_INIT();
int i;
for (i = 0; i < btif_max_hf_clients;) {
if (((btif_hf_cb[i].state == BTHF_CONNECTION_STATE_CONNECTED) ||
(btif_hf_cb[i].state == BTHF_CONNECTION_STATE_SLC_CONNECTED)))
i++;
else
break;
}
if (i == btif_max_hf_clients) return BT_STATUS_BUSY;
if (!is_connected(bd_addr)) {
btif_hf_cb[i].state = BTHF_CONNECTION_STATE_CONNECTING;
bdcpy(btif_hf_cb[i].connected_bda.address, bd_addr->address);
BTA_AgOpen(btif_hf_cb[i].handle, btif_hf_cb[i].connected_bda.address,
BTIF_HF_SECURITY, BTIF_HF_SERVICES);
return BT_STATUS_SUCCESS;
}
return BT_STATUS_BUSY;
}
static bt_status_t connect(bt_bdaddr_t* bd_addr) {
CHECK_BTHF_INIT();
return btif_queue_connect(UUID_SERVCLASS_AG_HANDSFREE, bd_addr, connect_int);
}
/*******************************************************************************
*
* Function disconnect
*
* Description disconnect from headset
*
* Returns bt_status_t
*
******************************************************************************/
static bt_status_t disconnect(bt_bdaddr_t* bd_addr) {
CHECK_BTHF_INIT();
int idx = btif_hf_idx_by_bdaddr(bd_addr);
if ((idx < 0) || (idx >= BTIF_HF_NUM_CB)) {
BTIF_TRACE_ERROR("%s: Invalid index %d", __func__, idx);
return BT_STATUS_FAIL;
}
if (is_connected(bd_addr) && (idx != BTIF_HF_INVALID_IDX)) {
BTA_AgClose(btif_hf_cb[idx].handle);
return BT_STATUS_SUCCESS;
}
return BT_STATUS_FAIL;
}
/*******************************************************************************
*
* Function connect_audio
*
* Description create an audio connection
*
* Returns bt_status_t
*
******************************************************************************/
static bt_status_t connect_audio(bt_bdaddr_t* bd_addr) {
CHECK_BTHF_INIT();
int idx = btif_hf_idx_by_bdaddr(bd_addr);
if ((idx < 0) || (idx >= BTIF_HF_NUM_CB)) {
BTIF_TRACE_ERROR("%s: Invalid index %d", __func__, idx);
return BT_STATUS_FAIL;
}
/* Check if SLC is connected */
if (btif_hf_check_if_slc_connected() != BT_STATUS_SUCCESS)
return BT_STATUS_NOT_READY;
if (is_connected(bd_addr) && (idx != BTIF_HF_INVALID_IDX)) {
BTA_AgAudioOpen(btif_hf_cb[idx].handle);
/* Inform the application that the audio connection has been initiated
* successfully */
btif_transfer_context(btif_in_hf_generic_evt, BTIF_HFP_CB_AUDIO_CONNECTING,
(char*)bd_addr, sizeof(bt_bdaddr_t), NULL);
return BT_STATUS_SUCCESS;
}
return BT_STATUS_FAIL;
}
/*******************************************************************************
*
* Function disconnect_audio
*
* Description close the audio connection
*
* Returns bt_status_t
*
******************************************************************************/
static bt_status_t disconnect_audio(bt_bdaddr_t* bd_addr) {
CHECK_BTHF_INIT();
int idx = btif_hf_idx_by_bdaddr(bd_addr);
if ((idx < 0) || (idx >= BTIF_HF_NUM_CB)) {
BTIF_TRACE_ERROR("%s: Invalid index %d", __func__, idx);
return BT_STATUS_FAIL;
}
if (is_connected(bd_addr) && (idx != BTIF_HF_INVALID_IDX)) {
BTA_AgAudioClose(btif_hf_cb[idx].handle);
return BT_STATUS_SUCCESS;
}
return BT_STATUS_FAIL;
}
/*******************************************************************************
*
* Function start_voice_recognition
*
* Description start voice recognition
*
* Returns bt_status_t
*
******************************************************************************/
static bt_status_t start_voice_recognition(bt_bdaddr_t* bd_addr) {
CHECK_BTHF_INIT();
int idx = btif_hf_idx_by_bdaddr(bd_addr);
if ((idx < 0) || (idx >= BTIF_HF_NUM_CB)) {
BTIF_TRACE_ERROR("%s: Invalid index %d", __func__, idx);
return BT_STATUS_FAIL;
}
if (is_connected(bd_addr) && (idx != BTIF_HF_INVALID_IDX)) {
if (btif_hf_cb[idx].peer_feat & BTA_AG_PEER_FEAT_VREC) {
tBTA_AG_RES_DATA ag_res;
memset(&ag_res, 0, sizeof(ag_res));
ag_res.state = 1;
BTA_AgResult(btif_hf_cb[idx].handle, BTA_AG_BVRA_RES, &ag_res);
return BT_STATUS_SUCCESS;
} else {
return BT_STATUS_UNSUPPORTED;
}
}
return BT_STATUS_NOT_READY;
}
/*******************************************************************************
*
* Function stop_voice_recognition
*
* Description stop voice recognition
*
* Returns bt_status_t
*
******************************************************************************/
static bt_status_t stop_voice_recognition(bt_bdaddr_t* bd_addr) {
CHECK_BTHF_INIT();
int idx = btif_hf_idx_by_bdaddr(bd_addr);
if ((idx < 0) || (idx >= BTIF_HF_NUM_CB)) {
BTIF_TRACE_ERROR("%s: Invalid index %d", __func__, idx);
return BT_STATUS_FAIL;
}
if (is_connected(bd_addr) && (idx != BTIF_HF_INVALID_IDX)) {
if (btif_hf_cb[idx].peer_feat & BTA_AG_PEER_FEAT_VREC) {
tBTA_AG_RES_DATA ag_res;
memset(&ag_res, 0, sizeof(ag_res));
ag_res.state = 0;
BTA_AgResult(btif_hf_cb[idx].handle, BTA_AG_BVRA_RES, &ag_res);
return BT_STATUS_SUCCESS;
} else {
return BT_STATUS_UNSUPPORTED;
}
}
return BT_STATUS_NOT_READY;
}
/*******************************************************************************
*
* Function volume_control
*
* Description volume control
*
* Returns bt_status_t
*
******************************************************************************/
static bt_status_t volume_control(bthf_volume_type_t type, int volume,
bt_bdaddr_t* bd_addr) {
CHECK_BTHF_INIT();
int idx = btif_hf_idx_by_bdaddr(bd_addr);
if ((idx < 0) || (idx >= BTIF_HF_NUM_CB)) {
BTIF_TRACE_ERROR("%s: Invalid index %d", __func__, idx);
return BT_STATUS_FAIL;
}
tBTA_AG_RES_DATA ag_res;
memset(&ag_res, 0, sizeof(tBTA_AG_RES_DATA));
if (is_connected(bd_addr) && (idx != BTIF_HF_INVALID_IDX)) {
ag_res.num = volume;
BTA_AgResult(
btif_hf_cb[idx].handle,
(type == BTHF_VOLUME_TYPE_SPK) ? BTA_AG_SPK_RES : BTA_AG_MIC_RES,
&ag_res);
return BT_STATUS_SUCCESS;
}
return BT_STATUS_FAIL;
}
/*******************************************************************************
*
* Function device_status_notification
*
* Description Combined device status change notification
*
* Returns bt_status_t
*
******************************************************************************/
static bt_status_t device_status_notification(bthf_network_state_t ntk_state,
bthf_service_type_t svc_type,
int signal, int batt_chg) {
CHECK_BTHF_INIT();
if (is_connected(NULL)) {
/* send all indicators to BTA.
** BTA will make sure no duplicates are sent out
*/
send_indicator_update(BTA_AG_IND_SERVICE,
(ntk_state == BTHF_NETWORK_STATE_AVAILABLE) ? 1 : 0);
send_indicator_update(BTA_AG_IND_ROAM,
(svc_type == BTHF_SERVICE_TYPE_HOME) ? 0 : 1);
send_indicator_update(BTA_AG_IND_SIGNAL, signal);
send_indicator_update(BTA_AG_IND_BATTCHG, batt_chg);
return BT_STATUS_SUCCESS;
}
return BT_STATUS_SUCCESS;
}
/*******************************************************************************
*
* Function cops_response
*
* Description Response for COPS command
*
* Returns bt_status_t
*
******************************************************************************/
static bt_status_t cops_response(const char* cops, bt_bdaddr_t* bd_addr) {
CHECK_BTHF_INIT();
int idx = btif_hf_idx_by_bdaddr(bd_addr);
if ((idx < 0) || (idx >= BTIF_HF_NUM_CB)) {
BTIF_TRACE_ERROR("%s: Invalid index %d", __func__, idx);
return BT_STATUS_FAIL;
}
if (is_connected(bd_addr) && (idx != BTIF_HF_INVALID_IDX)) {
tBTA_AG_RES_DATA ag_res;
/* Format the response */
snprintf(ag_res.str, sizeof(ag_res.str), "0,0,\"%.16s\"", cops);
ag_res.ok_flag = BTA_AG_OK_DONE;
BTA_AgResult(btif_hf_cb[idx].handle, BTA_AG_COPS_RES, &ag_res);
return BT_STATUS_SUCCESS;
}
return BT_STATUS_FAIL;
}
/*******************************************************************************
*
* Function cind_response
*
* Description Response for CIND command
*
* Returns bt_status_t
*
******************************************************************************/
static bt_status_t cind_response(int svc, int num_active, int num_held,
bthf_call_state_t call_setup_state, int signal,
int roam, int batt_chg, bt_bdaddr_t* bd_addr) {
CHECK_BTHF_INIT();
int idx = btif_hf_idx_by_bdaddr(bd_addr);
if ((idx < 0) || (idx >= BTIF_HF_NUM_CB)) {
BTIF_TRACE_ERROR("%s: Invalid index %d", __func__, idx);
return BT_STATUS_FAIL;
}
if (is_connected(bd_addr) && (idx != BTIF_HF_INVALID_IDX)) {
tBTA_AG_RES_DATA ag_res;
memset(&ag_res, 0, sizeof(ag_res));
/* per the errata 2043, call=1 implies atleast one call is in progress
*(active/held)
** https://www.bluetooth.org/errata/errata_view.cfm?errata_id=2043
**/
snprintf(
ag_res.str, sizeof(ag_res.str), "%d,%d,%d,%d,%d,%d,%d",
(num_active + num_held) ? 1 : 0, /* Call state */
callstate_to_callsetup(call_setup_state), /* Callsetup state */
svc, /* network service */
signal, /* Signal strength */
roam, /* Roaming indicator */
batt_chg, /* Battery level */
((num_held == 0) ? 0 : ((num_active == 0) ? 2 : 1))); /* Call held */
BTA_AgResult(btif_hf_cb[idx].handle, BTA_AG_CIND_RES, &ag_res);
return BT_STATUS_SUCCESS;
}
return BT_STATUS_FAIL;
}
/*******************************************************************************
*
* Function bind_response
*
* Description Send +BIND response
*
* Returns bt_status_t
*
******************************************************************************/
static bt_status_t bind_response(bthf_hf_ind_type_t ind_id,
bthf_hf_ind_status_t ind_status,
bt_bdaddr_t* bd_addr) {
CHECK_BTHF_INIT();
int index = btif_hf_idx_by_bdaddr(bd_addr);
if (!is_connected(bd_addr) || index == BTIF_HF_INVALID_IDX)
return BT_STATUS_FAIL;
tBTA_AG_RES_DATA ag_res;
memset(&ag_res, 0, sizeof(ag_res));
ag_res.ind.id = ind_id;
ag_res.ind.on_demand = (ind_status == BTHF_HF_IND_ENABLED);
BTA_AgResult(btif_hf_cb[index].handle, BTA_AG_BIND_RES, &ag_res);
return BT_STATUS_SUCCESS;
}
/*******************************************************************************
*
* Function formatted_at_response
*
* Description Pre-formatted AT response, typically in response to unknown
* AT cmd
*
* Returns bt_status_t
*
******************************************************************************/
static bt_status_t formatted_at_response(const char* rsp,
bt_bdaddr_t* bd_addr) {
CHECK_BTHF_INIT();
tBTA_AG_RES_DATA ag_res;
int idx = btif_hf_idx_by_bdaddr(bd_addr);
if ((idx < 0) || (idx >= BTIF_HF_NUM_CB)) {
BTIF_TRACE_ERROR("%s: Invalid index %d", __func__, idx);
return BT_STATUS_FAIL;
}
if (is_connected(bd_addr) && (idx != BTIF_HF_INVALID_IDX)) {
/* Format the response and send */
memset(&ag_res, 0, sizeof(ag_res));
strncpy(ag_res.str, rsp, BTA_AG_AT_MAX_LEN);
BTA_AgResult(btif_hf_cb[idx].handle, BTA_AG_UNAT_RES, &ag_res);
return BT_STATUS_SUCCESS;
}
return BT_STATUS_FAIL;
}
/*******************************************************************************
*
* Function at_response
*
* Description ok/error response
*
* Returns bt_status_t
*
******************************************************************************/
static bt_status_t at_response(bthf_at_response_t response_code, int error_code,
bt_bdaddr_t* bd_addr) {
CHECK_BTHF_INIT();
int idx = btif_hf_idx_by_bdaddr(bd_addr);
if ((idx < 0) || (idx >= BTIF_HF_NUM_CB)) {
BTIF_TRACE_ERROR("%s: Invalid index %d", __func__, idx);
return BT_STATUS_FAIL;
}
if (is_connected(bd_addr) && (idx != BTIF_HF_INVALID_IDX)) {
send_at_result((response_code == BTHF_AT_RESPONSE_OK) ? BTA_AG_OK_DONE
: BTA_AG_OK_ERROR,
error_code, idx);
return BT_STATUS_SUCCESS;
}
return BT_STATUS_FAIL;
}
/*******************************************************************************
*
* Function clcc_response
*
* Description response for CLCC command
* Can be iteratively called for each call index. Call index
* of 0 will be treated as NULL termination (Completes
* response)
*
* Returns bt_status_t
*
******************************************************************************/
static bt_status_t clcc_response(int index, bthf_call_direction_t dir,
bthf_call_state_t state, bthf_call_mode_t mode,
bthf_call_mpty_type_t mpty, const char* number,
bthf_call_addrtype_t type,
bt_bdaddr_t* bd_addr) {
CHECK_BTHF_INIT();
int idx = btif_hf_idx_by_bdaddr(bd_addr);
if ((idx < 0) || (idx >= BTIF_HF_NUM_CB)) {
BTIF_TRACE_ERROR("%s: Invalid index %d", __func__, idx);
return BT_STATUS_FAIL;
}
if (is_connected(bd_addr) && (idx != BTIF_HF_INVALID_IDX)) {
tBTA_AG_RES_DATA ag_res;
memset(&ag_res, 0, sizeof(ag_res));
/* Format the response */
if (index == 0) {
ag_res.ok_flag = BTA_AG_OK_DONE;
} else {
BTIF_TRACE_EVENT(
"clcc_response: [%d] dir %d state %d mode %d number = %s type = %d",
index, dir, state, mode, number, type);
int res_strlen =
snprintf(ag_res.str, sizeof(ag_res.str), "%d,%d,%d,%d,%d", index, dir,
state, mode, mpty);
if (number) {
size_t rem_bytes = sizeof(ag_res.str) - res_strlen;
char dialnum[sizeof(ag_res.str)];
size_t newidx = 0;
if (type == BTHF_CALL_ADDRTYPE_INTERNATIONAL && *number != '+') {
dialnum[newidx++] = '+';
}
for (size_t i = 0; number[i] != 0; i++) {
if (utl_isdialchar(number[i])) {
dialnum[newidx++] = number[i];
}
}
dialnum[newidx] = 0;
snprintf(&ag_res.str[res_strlen], rem_bytes, ",\"%s\",%d", dialnum,
type);
}
}
BTA_AgResult(btif_hf_cb[idx].handle, BTA_AG_CLCC_RES, &ag_res);
return BT_STATUS_SUCCESS;
}
return BT_STATUS_FAIL;
}
/*******************************************************************************
*
* Function phone_state_change
*
* Description notify of a call state change
* number & type: valid only for incoming & waiting call
*
* Returns bt_status_t
*
******************************************************************************/
static bt_status_t phone_state_change(int num_active, int num_held,
bthf_call_state_t call_setup_state,
const char* number,
bthf_call_addrtype_t type) {
tBTA_AG_RES res = 0xff;
tBTA_AG_RES_DATA ag_res;
bt_status_t status = BT_STATUS_SUCCESS;
bool activeCallUpdated = false;
int idx, i;
/* hf_idx is index of connected HS that sent ATA/BLDN,
otherwise index of latest connected HS */
if (hf_idx != BTIF_HF_INVALID_IDX)
idx = hf_idx;
else
idx = btif_hf_latest_connected_idx();
BTIF_TRACE_DEBUG("phone_state_change: idx = %d", idx);
/* Check if SLC is connected */
if (btif_hf_check_if_slc_connected() != BT_STATUS_SUCCESS)
return BT_STATUS_NOT_READY;
BTIF_TRACE_DEBUG(
"phone_state_change: num_active=%d [prev: %d] num_held=%d[prev: %d]"
" call_setup=%s [prev: %s]",
num_active, btif_hf_cb[idx].num_active, num_held,
btif_hf_cb[idx].num_held, dump_hf_call_state(call_setup_state),
dump_hf_call_state(btif_hf_cb[idx].call_setup_state));
/* if all indicators are 0, send end call and return */
if (num_active == 0 && num_held == 0 &&
call_setup_state == BTHF_CALL_STATE_IDLE) {
BTIF_TRACE_DEBUG("%s: Phone on hook", __func__);
/* record call termination timestamp if there was an active/held call or
callsetup state > BTHF_CALL_STATE_IDLE */
if ((btif_hf_cb[idx].call_setup_state != BTHF_CALL_STATE_IDLE) ||
(btif_hf_cb[idx].num_active) || (btif_hf_cb[idx].num_held)) {
BTIF_TRACE_DEBUG("%s: Record call termination timestamp", __func__);
clock_gettime(CLOCK_MONOTONIC, &btif_hf_cb[0].call_end_timestamp);
}
BTA_AgResult(BTA_AG_HANDLE_ALL, BTA_AG_END_CALL_RES, NULL);
hf_idx = BTIF_HF_INVALID_IDX;
/* if held call was present, reset that as well */
if (btif_hf_cb[idx].num_held) send_indicator_update(BTA_AG_IND_CALLHELD, 0);
goto update_call_states;
}
/* active state can change when:
** 1. an outgoing/incoming call was answered
** 2. an held was resumed
** 3. without callsetup notifications, call became active
** (3) can happen if call is active and a headset connects to us
**
** In the case of (3), we will have to notify the stack of an active
** call, instead of sending an indicator update. This will also
** force the SCO to be setup. Handle this special case here prior to
** call setup handling
*/
if (((num_active + num_held) > 0) && (btif_hf_cb[idx].num_active == 0) &&
(btif_hf_cb[idx].num_held == 0) &&
(btif_hf_cb[idx].call_setup_state == BTHF_CALL_STATE_IDLE)) {
BTIF_TRACE_DEBUG(
"%s: Active/Held call notification received without call setup update",
__func__);
memset(&ag_res, 0, sizeof(tBTA_AG_RES_DATA));
ag_res.audio_handle = BTA_AG_HANDLE_SCO_NO_CHANGE;
/* Addition call setup with the Active call
** CIND response should have been updated.
** just open SCO connection.
*/
if (call_setup_state != BTHF_CALL_STATE_IDLE)
res = BTA_AG_MULTI_CALL_RES;
else
res = BTA_AG_OUT_CALL_CONN_RES;
BTA_AgResult(BTA_AG_HANDLE_ALL, res, &ag_res);
activeCallUpdated = true;
}
/* Ringing call changed? */
if (call_setup_state != btif_hf_cb[idx].call_setup_state) {
BTIF_TRACE_DEBUG("%s: Call setup states changed. old: %s new: %s", __func__,
dump_hf_call_state(btif_hf_cb[idx].call_setup_state),
dump_hf_call_state(call_setup_state));
memset(&ag_res, 0, sizeof(tBTA_AG_RES_DATA));
switch (call_setup_state) {
case BTHF_CALL_STATE_IDLE: {
switch (btif_hf_cb[idx].call_setup_state) {
case BTHF_CALL_STATE_INCOMING:
if (num_active > btif_hf_cb[idx].num_active) {
res = BTA_AG_IN_CALL_CONN_RES;
ag_res.audio_handle = btif_hf_cb[idx].handle;
} else if (num_held > btif_hf_cb[idx].num_held)
res = BTA_AG_IN_CALL_HELD_RES;
else
res = BTA_AG_CALL_CANCEL_RES;
break;
case BTHF_CALL_STATE_DIALING:
case BTHF_CALL_STATE_ALERTING:
if (num_active > btif_hf_cb[idx].num_active) {
ag_res.audio_handle = BTA_AG_HANDLE_SCO_NO_CHANGE;
res = BTA_AG_OUT_CALL_CONN_RES;
} else
res = BTA_AG_CALL_CANCEL_RES;
break;
default:
BTIF_TRACE_ERROR("%s: Incorrect Call setup state transition",
__func__);
status = BT_STATUS_PARM_INVALID;
break;
}
} break;
case BTHF_CALL_STATE_INCOMING:
if (num_active || num_held) {
res = BTA_AG_CALL_WAIT_RES;
} else {
res = BTA_AG_IN_CALL_RES;
}
if (number) {
int xx = 0;
if ((type == BTHF_CALL_ADDRTYPE_INTERNATIONAL) && (*number != '+'))
xx = snprintf(ag_res.str, sizeof(ag_res.str), "\"+%s\"", number);
else
xx = snprintf(ag_res.str, sizeof(ag_res.str), "\"%s\"", number);
ag_res.num = type;
if (res == BTA_AG_CALL_WAIT_RES)
snprintf(&ag_res.str[xx], sizeof(ag_res.str) - xx, ",%d", type);
}
break;
case BTHF_CALL_STATE_DIALING:
if (!(num_active + num_held))
ag_res.audio_handle = btif_hf_cb[idx].handle;
res = BTA_AG_OUT_CALL_ORIG_RES;
break;
case BTHF_CALL_STATE_ALERTING:
/* if we went from idle->alert, force SCO setup here. dialing usually
* triggers it */
if ((btif_hf_cb[idx].call_setup_state == BTHF_CALL_STATE_IDLE) &&
!(num_active + num_held))
ag_res.audio_handle = btif_hf_cb[idx].handle;
res = BTA_AG_OUT_CALL_ALERT_RES;
break;
default:
BTIF_TRACE_ERROR("%s: Incorrect new ringing call state", __func__);
status = BT_STATUS_PARM_INVALID;
break;
}
BTIF_TRACE_DEBUG("%s: Call setup state changed. res=%d, audio_handle=%d",
__func__, res, ag_res.audio_handle);
if (res) BTA_AgResult(BTA_AG_HANDLE_ALL, res, &ag_res);
/* if call setup is idle, we have already updated call indicator, jump out
*/
if (call_setup_state == BTHF_CALL_STATE_IDLE) {
/* check & update callheld */
if ((num_held > 0) && (num_active > 0))
send_indicator_update(BTA_AG_IND_CALLHELD, 1);
goto update_call_states;
}
}
memset(&ag_res, 0, sizeof(tBTA_AG_RES_DATA));
/* per the errata 2043, call=1 implies atleast one call is in progress
*(active/held)
** https://www.bluetooth.org/errata/errata_view.cfm?errata_id=2043
** Handle call indicator change
**/
if (!activeCallUpdated &&
((num_active + num_held) !=
(btif_hf_cb[idx].num_active + btif_hf_cb[idx].num_held))) {
BTIF_TRACE_DEBUG("%s: Active call states changed. old: %d new: %d",
__func__, btif_hf_cb[idx].num_active, num_active);
send_indicator_update(BTA_AG_IND_CALL,
((num_active + num_held) > 0) ? 1 : 0);
}
/* Held Changed? */
if (num_held != btif_hf_cb[idx].num_held ||
((num_active == 0) && ((num_held + btif_hf_cb[idx].num_held) > 1))) {
BTIF_TRACE_DEBUG("%s: Held call states changed. old: %d new: %d", __func__,
btif_hf_cb[idx].num_held, num_held);
send_indicator_update(BTA_AG_IND_CALLHELD,
((num_held == 0) ? 0 : ((num_active == 0) ? 2 : 1)));
}
/* Calls Swapped? */
if ((call_setup_state == btif_hf_cb[idx].call_setup_state) &&
(num_active && num_held) && (num_active == btif_hf_cb[idx].num_active) &&
(num_held == btif_hf_cb[idx].num_held)) {
BTIF_TRACE_DEBUG("%s: Calls swapped", __func__);
send_indicator_update(BTA_AG_IND_CALLHELD, 1);
}
update_call_states:
for (i = 0; i < btif_max_hf_clients; i++) {
if (btif_hf_cb[i].state == BTHF_CONNECTION_STATE_SLC_CONNECTED) {
btif_hf_cb[i].num_active = num_active;
btif_hf_cb[i].num_held = num_held;
btif_hf_cb[i].call_setup_state = call_setup_state;
}
}
return status;
}
/*******************************************************************************
*
* Function btif_hf_is_call_idle
*
* Description returns true if no call is in progress
*
* Returns bt_status_t
*
******************************************************************************/
bool btif_hf_is_call_idle(void) {
if (bt_hf_callbacks == NULL) return true;
for (int i = 0; i < btif_max_hf_clients; ++i) {
if ((btif_hf_cb[i].call_setup_state != BTHF_CALL_STATE_IDLE) ||
((btif_hf_cb[i].num_held + btif_hf_cb[i].num_active) > 0))
return false;
}
return true;
}
/*******************************************************************************
*
* Function btif_hf_call_terminated_recently
*
* Description Checks if a call has been terminated
*
* Returns bt_status_t
*
******************************************************************************/
bool btif_hf_call_terminated_recently() {
struct timespec now;
clock_gettime(CLOCK_MONOTONIC, &now);
if (now.tv_sec <
btif_hf_cb[0].call_end_timestamp.tv_sec + BTIF_HF_CALL_END_TIMEOUT) {
return true;
} else {
btif_hf_cb[0].call_end_timestamp.tv_sec = 0;
return false;
}
}
/*******************************************************************************
*
* Function cleanup
*
* Description Closes the HF interface
*
* Returns bt_status_t
*
******************************************************************************/
static void cleanup(void) {
BTIF_TRACE_EVENT("%s", __func__);
if (bt_hf_callbacks) {
#if (defined(BTIF_HF_SERVICES) && (BTIF_HF_SERVICES & BTA_HFP_SERVICE_MASK))
btif_disable_service(BTA_HFP_SERVICE_ID);
#else
btif_disable_service(BTA_HSP_SERVICE_ID);
#endif
bt_hf_callbacks = NULL;
}
}
/*******************************************************************************
*
* Function configure_wbs
*
* Description set to over-ride the current WBS configuration.
* It will not send codec setting cmd to the controller now.
* It just change the configure.
*
* Returns bt_status_t
*
******************************************************************************/
static bt_status_t configure_wbs(bt_bdaddr_t* bd_addr,
bthf_wbs_config_t config) {
CHECK_BTHF_INIT();
int idx = btif_hf_idx_by_bdaddr(bd_addr);
if ((idx < 0) || (idx >= BTIF_HF_NUM_CB)) {
BTIF_TRACE_ERROR("%s: Invalid index %d", __func__, idx);
return BT_STATUS_FAIL;
}
BTIF_TRACE_EVENT("%s config is %d", __func__, config);
if (config == BTHF_WBS_YES)
BTA_AgSetCodec(btif_hf_cb[idx].handle, BTA_AG_CODEC_MSBC);
else if (config == BTHF_WBS_NO)
BTA_AgSetCodec(btif_hf_cb[idx].handle, BTA_AG_CODEC_CVSD);
else
BTA_AgSetCodec(btif_hf_cb[idx].handle, BTA_AG_CODEC_NONE);
return BT_STATUS_SUCCESS;
}
static const bthf_interface_t bthfInterface = {
sizeof(bthfInterface),
init,
connect,
disconnect,
connect_audio,
disconnect_audio,
start_voice_recognition,
stop_voice_recognition,
volume_control,
device_status_notification,
cops_response,
cind_response,
formatted_at_response,
at_response,
clcc_response,
phone_state_change,
cleanup,
configure_wbs,
bind_response,
};
/*******************************************************************************
*
* Function btif_hf_execute_service
*
* Description Initializes/Shuts down the service
*
* Returns BT_STATUS_SUCCESS on success, BT_STATUS_FAIL otherwise
*
******************************************************************************/
bt_status_t btif_hf_execute_service(bool b_enable) {
const char* p_service_names[] = BTIF_HF_SERVICE_NAMES;
int i;
if (b_enable) {
/* Enable and register with BTA-AG */
BTA_AgEnable(BTA_AG_PARSE, bte_hf_evt);
for (i = 0; i < btif_max_hf_clients; i++) {
BTA_AgRegister(BTIF_HF_SERVICES, BTIF_HF_SECURITY, btif_hf_features,
p_service_names, bthf_hf_id[i]);
}
} else {
/* De-register AG */
for (i = 0; i < btif_max_hf_clients; i++) {
BTA_AgDeregister(btif_hf_cb[i].handle);
}
/* Disable AG */
BTA_AgDisable();
}
return BT_STATUS_SUCCESS;
}
/*******************************************************************************
*
* Function btif_hf_get_interface
*
* Description Get the hf callback interface
*
* Returns bthf_interface_t
*
******************************************************************************/
const bthf_interface_t* btif_hf_get_interface() {
BTIF_TRACE_EVENT("%s", __func__);
return &bthfInterface;
}