bt_status_t btif_shutdown_bluetooth(void)
{
BTIF_TRACE_DEBUG1("%s", __FUNCTION__);
if (btif_is_enabled())
{
BTIF_TRACE_WARNING0("shutdown while still enabled, initiate disable");
/* shutdown called prior to disabling, initiate disable */
btif_disable_bluetooth();
btif_shutdown_pending = 1;
return BT_STATUS_NOT_READY;
}
btif_shutdown_pending = 0;
GKI_destroy_task(BTIF_TASK);
bte_main_shutdown();
btif_dut_mode = 0;
BTIF_TRACE_DEBUG1("%s done", __FUNCTION__);
return BT_STATUS_SUCCESS;
}
int btpan_tap_send(int tap_fd, const BD_ADDR src, const BD_ADDR dst, UINT16 proto, const char* buf,
UINT16 len, BOOLEAN ext, BOOLEAN forward)
{
if(tap_fd != -1)
{
tETH_HDR eth_hdr;
//if(is_empty_eth_addr(dst))
// memcpy(ð_hdr.h_dest, local_addr, ETH_ADDR_LEN);
//else
memcpy(ð_hdr.h_dest, dst, ETH_ADDR_LEN);
memcpy(ð_hdr.h_src, src, ETH_ADDR_LEN);
eth_hdr.h_proto = htons(proto);
char packet[2000];
memcpy(packet, ð_hdr, sizeof(tETH_HDR));
if(len > 2000)
{
ALOGE("btpan_tap_send eth packet size:%d is exceeded limit!", len);
return -1;
}
memcpy(packet + sizeof(tETH_HDR), buf, len);
/* Send data to network interface */
//btnet_send(btpan_cb.conn[i].sock.sock, &buffer, (len + sizeof(tETH_HDR)));
//dump_bin("packet to network", packet, len + sizeof(tETH_HDR));
int ret = write(tap_fd, packet, len + sizeof(tETH_HDR));
BTIF_TRACE_DEBUG1("ret:%d", ret);
return ret;
}
return -1;
}
static bt_status_t btif_associate_evt(void)
{
BTIF_TRACE_DEBUG1("%s: notify ASSOCIATE_JVM", __FUNCTION__);
HAL_CBACK(bt_hal_cbacks, thread_evt_cb, ASSOCIATE_JVM);
return BT_STATUS_SUCCESS;
}
static inline int should_forward(tETH_HDR* hdr)
{
if(ntohs(hdr->h_proto) == ETH_P_IP || ntohs(hdr->h_proto) == ETH_P_ARP)
return TRUE;
BTIF_TRACE_DEBUG1("unknown proto:%x", ntohs(hdr->h_proto));
return FALSE;
}
void btpan_close_handle(btpan_conn_t *p)
{
BTIF_TRACE_DEBUG1("btpan_close_handle : close handle %d", p->handle);
p->handle = -1;
p->local_role = -1;
p->remote_role = -1;
memset(&p->peer, 0, 6);
}
/*******************************************************************************
**
** Function btif_dut_mode_send
**
** Description Sends a HCI Vendor specific command to the controller
**
** Returns BT_STATUS_SUCCESS on success
**
*******************************************************************************/
bt_status_t btif_dut_mode_send(uint16_t opcode, uint8_t *buf, uint8_t len)
{
/* TODO: Check that opcode is a vendor command group */
BTIF_TRACE_DEBUG1("%s", __FUNCTION__);
BTM_VendorSpecificCommand(opcode, len, buf);
return BT_STATUS_SUCCESS;
}
static bt_status_t btpan_enable(int local_role)
{
int bta_pan_role;
BTIF_TRACE_DEBUG1("local_role:%d", local_role);
bta_pan_role = btpan_role_to_bta(local_role);
BTA_PanSetRole(bta_pan_role, &bta_panu_info, NULL, &bta_pan_nap_info);
btpan_dev_local_role = local_role;
return BT_STATUS_SUCCESS;
}
/***************************************************************************
**
** Function btif_rc_handler
**
** Description RC event handler
**
***************************************************************************/
void btif_rc_handler(tBTA_AV_EVT event, tBTA_AV *p_data)
{
BTIF_TRACE_DEBUG2 ("%s event:%s", __FUNCTION__, dump_rc_event(event));
switch (event)
{
case BTA_AV_RC_OPEN_EVT:
{
BTIF_TRACE_DEBUG1("Peer_features:%x", p_data->rc_open.peer_features);
handle_rc_connect( &(p_data->rc_open) );
}break;
case BTA_AV_RC_CLOSE_EVT:
{
handle_rc_disconnect( &(p_data->rc_close) );
}break;
case BTA_AV_REMOTE_CMD_EVT:
{
BTIF_TRACE_DEBUG2("rc_id:0x%x key_state:%d", p_data->remote_cmd.rc_id,
p_data->remote_cmd.key_state);
handle_rc_passthrough_cmd( (&p_data->remote_cmd) );
}
break;
case BTA_AV_RC_FEAT_EVT:
{
BTIF_TRACE_DEBUG1("Peer_features:%x", p_data->rc_feat.peer_features);
btif_rc_cb.rc_features = p_data->rc_feat.peer_features;
/* TODO Handle RC_FEAT_EVT*/
}
break;
case BTA_AV_META_MSG_EVT:
{
BTIF_TRACE_DEBUG2("BTA_AV_META_MSG_EVT code:%d label:%d", p_data->meta_msg.code,
p_data->meta_msg.label);
BTIF_TRACE_DEBUG3(" company_id:0x%x len:%d handle:%d", p_data->meta_msg.company_id,
p_data->meta_msg.len, p_data->meta_msg.rc_handle);
/* handle the metamsg command */
handle_rc_metamsg_cmd(&(p_data->meta_msg));
}
break;
default:
BTIF_TRACE_DEBUG1("Unhandled RC event : 0x%x", event);
}
}
void close_uinput (void)
{
BTIF_TRACE_DEBUG1("%s", __FUNCTION__);
if (uinput_fd > 0) {
ioctl(uinput_fd, UI_DEV_DESTROY);
close(uinput_fd);
uinput_fd = -1;
}
}
int sock_send_fd(int sock_fd, const uint8_t* buf, int len, int send_fd)
{
ssize_t ret;
struct msghdr msg;
unsigned char *buffer = (unsigned char *)buf;
memset(&msg, 0, sizeof(msg));
struct cmsghdr *cmsg;
char msgbuf[CMSG_SPACE(1)];
asrt(send_fd != -1);
if(sock_fd == -1 || send_fd == -1)
return -1;
// Add any pending outbound file descriptors to the message
// See "man cmsg" really
msg.msg_control = msgbuf;
msg.msg_controllen = sizeof msgbuf;
cmsg = CMSG_FIRSTHDR(&msg);
cmsg->cmsg_level = SOL_SOCKET;
cmsg->cmsg_type = SCM_RIGHTS;
cmsg->cmsg_len = CMSG_LEN(sizeof send_fd);
memcpy(CMSG_DATA(cmsg), &send_fd, sizeof send_fd);
// We only write our msg_control during the first write
int ret_len = len;
while (len > 0) {
struct iovec iv;
memset(&iv, 0, sizeof(iv));
iv.iov_base = buffer;
iv.iov_len = len;
msg.msg_iov = &iv;
msg.msg_iovlen = 1;
do {
ret = sendmsg(sock_fd, &msg, MSG_NOSIGNAL);
} while (ret < 0 && errno == EINTR);
if (ret < 0) {
BTIF_TRACE_ERROR5("fd:%d, send_fd:%d, sendmsg ret:%d, errno:%d, %s",
sock_fd, send_fd, (int)ret, errno, strerror(errno));
ret_len = -1;
break;
}
buffer += ret;
len -= ret;
// Wipes out any msg_control too
memset(&msg, 0, sizeof(msg));
}
BTIF_TRACE_DEBUG1("close fd:%d after sent", send_fd);
close(send_fd);
return ret_len;
}
static bt_status_t btif_disassociate_evt(void)
{
BTIF_TRACE_DEBUG1("%s: notify DISASSOCIATE_JVM", __FUNCTION__);
HAL_CBACK(bt_hal_cbacks, thread_evt_cb, DISASSOCIATE_JVM);
/* shutdown complete, all events notified and we reset HAL callbacks */
bt_hal_cbacks = NULL;
return BT_STATUS_SUCCESS;
}
static int tap_if_up(const char *devname, BD_ADDR addr)
{
struct ifreq ifr;
int sk, err;
sk = socket(AF_INET, SOCK_DGRAM, 0);
//set mac addr
memset(&ifr, 0, sizeof(ifr));
strncpy(ifr.ifr_name, devname, IFNAMSIZ - 1);
err = ioctl(sk, SIOCGIFHWADDR, &ifr);
if(err < 0)
{
BTIF_TRACE_ERROR2("Could not get network hardware for interface:%s, errno:%s", devname, strerror(errno));
close(sk);
return -1;
}
/* debug("found mac address for interface:%s = %02x:%02x:%02x:%02x:%02x:%02x", devname, */
/* ifr.ifr_hwaddr.sa_data[0], ifr.ifr_hwaddr.sa_data[1], ifr.ifr_hwaddr.sa_data[2], */
/* ifr.ifr_hwaddr.sa_data[3], ifr.ifr_hwaddr.sa_data[4], ifr.ifr_hwaddr.sa_data[5]); */
strncpy(ifr.ifr_name, devname, IFNAMSIZ - 1);
memcpy(ifr.ifr_hwaddr.sa_data, addr, 6);
/* debug("setting bt address for interface:%s = %02x:%02x:%02x:%02x:%02x:%02x", devname, */
/* ifr.ifr_hwaddr.sa_data[0], ifr.ifr_hwaddr.sa_data[1], ifr.ifr_hwaddr.sa_data[2], */
/* ifr.ifr_hwaddr.sa_data[3], ifr.ifr_hwaddr.sa_data[4], ifr.ifr_hwaddr.sa_data[5]); */
err = ioctl(sk, SIOCSIFHWADDR, (caddr_t)&ifr);
if (err < 0) {
BTIF_TRACE_ERROR2("Could not set bt address for interface:%s, errno:%s", devname, strerror(errno));
close(sk);
return -1;
}
//bring it up
memset(&ifr, 0, sizeof(ifr));
strncpy(ifr.ifr_name, devname, IF_NAMESIZE - 1);
ifr.ifr_flags |= IFF_UP;
ifr.ifr_flags |= IFF_MULTICAST;
err = ioctl(sk, SIOCSIFFLAGS, (caddr_t) &ifr);
if (err < 0) {
BTIF_TRACE_ERROR2("Could not bring up network interface:%s, errno:%d", devname, errno);
close(sk);
return -1;
}
close(sk);
BTIF_TRACE_DEBUG1("network interface: %s is up", devname);
return 0;
}
static inline int btpan_role_to_bta(int btpan_role)
{
int bta_pan_role = PAN_ROLE_INACTIVE;
BTIF_TRACE_DEBUG1("btpan_role:0x%x", btpan_role);
if(btpan_role & BTPAN_ROLE_PANNAP)
{
bta_pan_role |= PAN_ROLE_NAP_SERVER;
}
if(btpan_role & BTPAN_ROLE_PANU)
{
bta_pan_role |= PAN_ROLE_CLIENT;
}
return bta_pan_role;
}
static inline int bta_role_to_btpan(int bta_pan_role)
{
int btpan_role = 0;
BTIF_TRACE_DEBUG1("bta_pan_role:0x%x", bta_pan_role);
if(bta_pan_role & PAN_ROLE_NAP_SERVER)
{
btpan_role |= BTPAN_ROLE_PANNAP;
}
if(bta_pan_role & PAN_ROLE_CLIENT)
{
btpan_role |= BTPAN_ROLE_PANU;
}
return btpan_role;
}
int init_uinput (void)
{
char *name = "AVRCP";
BTIF_TRACE_DEBUG1("%s", __FUNCTION__);
uinput_fd = uinput_create(name);
if (uinput_fd < 0) {
BTIF_TRACE_ERROR3("%s AVRCP: Failed to initialize uinput for %s (%d)",
__FUNCTION__, name, uinput_fd);
} else {
BTIF_TRACE_DEBUG3("%s AVRCP: Initialized uinput for %s (fd=%d)",
__FUNCTION__, name, uinput_fd);
}
return uinput_fd;
}
static bt_status_t btif_mp_test_evt(void* msg)
{
BT_HDR *p_msg = (BT_HDR *)msg;
UINT8 *p = (UINT8 *)(p_msg + 1) + p_msg->offset;
UINT8 hci_evt_len;
UINT8 hci_evt_code;
STREAM_TO_UINT8 (hci_evt_code, p);
STREAM_TO_UINT8 (hci_evt_len, p);
BTIF_TRACE_DEBUG1("%s: notify btif_mp_test_evt", __FUNCTION__);
if(btif_dut_mode)
{
btif_mp_rx_data_ind(hci_evt_code, (uint8_t*)p, hci_evt_len);
}
return BT_STATUS_SUCCESS;
}
/*******************************************************************************
**
** Function btif_dut_mode_configure
**
** Description Configure Test Mode - 'enable' to 1 puts the device in test mode and 0 exits
** test mode
**
** Returns BT_STATUS_SUCCESS on success
**
*******************************************************************************/
bt_status_t btif_dut_mode_configure(uint8_t enable)
{
BTIF_TRACE_DEBUG1("%s", __FUNCTION__);
if (btif_core_state != BTIF_CORE_STATE_ENABLED) {
BTIF_TRACE_ERROR0("btif_dut_mode_configure : Bluetooth not enabled");
return BT_STATUS_NOT_READY;
}
btif_dut_mode = enable;
if (enable == 1) {
btif_enable_test_mode();
} else {
btif_disable_test_mode();
}
return BT_STATUS_SUCCESS;
}
static void forward_bnep(tETH_HDR* eth_hdr, char * packet, int size)
{
int broadcast = eth_hdr->h_dest[0] & 1;
int i;
for(i = 0; i < MAX_PAN_CONNS; i++)
{
UINT16 handle = btpan_cb.conns[i].handle;
if(handle != (UINT16)-1 &&
(broadcast || memcmp(btpan_cb.conns[i].eth_addr, eth_hdr->h_dest, sizeof(BD_ADDR)) == 0
|| memcmp(btpan_cb.conns[i].peer, eth_hdr->h_dest, sizeof(BD_ADDR)) == 0))
{
BTIF_TRACE_DEBUG1("calling bta_pan_ci_rx_write, handle:%d", handle);
bta_pan_ci_rx_write(handle, eth_hdr->h_dest, eth_hdr->h_src,
ntohs(eth_hdr->h_proto), (UINT8*)packet, size, 0);
break;
}
}
}
btpan_conn_t* btpan_new_conn(int handle, const BD_ADDR addr, int local_role, int remote_role )
{
int i;
for(i = 0; i < MAX_PAN_CONNS; i++)
{
BTIF_TRACE_DEBUG2("conns[%d]:%d", i, btpan_cb.conns[i].handle);
if(btpan_cb.conns[i].handle == -1)
{
BTIF_TRACE_DEBUG3("handle:%d, local_role:%d, remote_role:%d", handle, local_role, remote_role);
btpan_cb.conns[i].handle = handle;
bdcpy(btpan_cb.conns[i].peer, addr);
btpan_cb.conns[i].local_role = local_role;
btpan_cb.conns[i].remote_role = remote_role;
return &btpan_cb.conns[i];
}
}
BTIF_TRACE_DEBUG1("MAX_PAN_CONNS:%d exceeded, return NULL as failed", MAX_PAN_CONNS);
return NULL;
}
/*******************************************************************************
**
** Function bta_hl_co_put_rx_data
**
** Description Put the received data
**
** Parameters app_id - HDP application ID
** mdl_handle - MDL handle
** data_size - the size of the data
** p_data - the data pointer
** evt - the evt to be passed back to the HL in the
** bta_hl_ci_put_rx_data call-in function
**
** Returns Void
**
*******************************************************************************/
void bta_hl_co_put_rx_data (UINT8 app_id, tBTA_HL_MDL_HANDLE mdl_handle,
UINT16 data_size, UINT8 *p_data, UINT16 evt)
{
UINT8 app_idx, mcl_idx, mdl_idx;
btif_hl_mdl_cb_t *p_dcb;
tBTA_HL_STATUS status = BTA_HL_STATUS_FAIL;
int r;
BTIF_TRACE_DEBUG4("%s app_id=%d mdl_handle=0x%x data_size=%d",
__FUNCTION__,app_id, mdl_handle, data_size);
if (btif_hl_find_mdl_idx_using_handle(mdl_handle, &app_idx, &mcl_idx, &mdl_idx))
{
p_dcb = BTIF_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
if ((p_dcb->p_rx_pkt = (UINT8 *)btif_hl_get_buf(data_size)) != NULL)
{
memcpy(p_dcb->p_rx_pkt, p_data, data_size);
if (p_dcb->p_scb)
{
BTIF_TRACE_DEBUG4("app_idx=%d mcl_idx=0x%x mdl_idx=0x%x data_size=%d",
app_idx, mcl_idx, mdl_idx, data_size);
r = send(p_dcb->p_scb->socket_id[1], p_dcb->p_rx_pkt, data_size, 0);
if (r == data_size)
{
BTIF_TRACE_DEBUG1("socket send success data_size=%d", data_size);
status = BTA_HL_STATUS_OK;
}
else
{
BTIF_TRACE_ERROR2("socket send failed r=%d data_size=%d",r, data_size);
}
}
btif_hl_free_buf((void **) &p_dcb->p_rx_pkt);
}
}
bta_hl_ci_put_rx_data(mdl_handle, status, evt);
}
static void btpan_close_conn(btpan_conn_t* conn)
{
BTIF_TRACE_DEBUG1("btpan_close_conn: %p",conn);
if (conn && conn->state == PAN_STATE_OPEN)
{
BTIF_TRACE_DEBUG0("btpan_close_conn: PAN_STATE_OPEN");
conn->state = PAN_STATE_CLOSE;
btpan_cb.open_count--;
if (btpan_cb.open_count == 0)
{
destroy_tap_read_thread();
if (btpan_cb.tap_fd != -1)
{
btpan_tap_close(btpan_cb.tap_fd);
btpan_cb.tap_fd = -1;
}
}
}
}
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;
BOOLEAN activeCallUpdated = FALSE;
CHECK_BTHF_SLC_CONNECTED();
BTIF_TRACE_DEBUG6("phone_state_change: num_active=%d [prev: %d] num_held=%d[prev: %d]"\
" call_setup=%s [prev: %s]", num_active, btif_hf_cb.num_active,
num_held, btif_hf_cb.num_held,
dump_hf_call_state(call_setup_state), dump_hf_call_state(btif_hf_cb.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_DEBUG1("%s: Phone on hook", __FUNCTION__);
/* record call termination timestamp if there was an active/held call or callsetup state > BTHF_CALL_STATE_IDLE */
if ((btif_hf_cb.call_setup_state != BTHF_CALL_STATE_IDLE ) || (btif_hf_cb.num_active) ||(btif_hf_cb.num_held))
{
BTIF_TRACE_DEBUG1("%s: Record call termination timestamp", __FUNCTION__);
clock_gettime(CLOCK_MONOTONIC, &btif_hf_cb.call_end_timestamp);
}
BTA_AgResult (BTA_AG_HANDLE_ALL, BTA_AG_END_CALL_RES, NULL);
/* if held call was present, reset that as well */
if (btif_hf_cb.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 == 1) && (btif_hf_cb.num_active == 0) && (btif_hf_cb.num_held == 0) &&
(btif_hf_cb.call_setup_state == BTHF_CALL_STATE_IDLE) )
{
BTIF_TRACE_DEBUG1("%s: Active call notification received without call setup update",
__FUNCTION__);
memset(&ag_res, 0, sizeof(tBTA_AG_RES_DATA));
ag_res.audio_handle = btif_hf_cb.handle;
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.call_setup_state)
{
BTIF_TRACE_DEBUG3("%s: Call setup states changed. old: %s new: %s",
__FUNCTION__, dump_hf_call_state(btif_hf_cb.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.call_setup_state)
{
case BTHF_CALL_STATE_INCOMING:
if (num_active > btif_hf_cb.num_active)
{
res = BTA_AG_IN_CALL_CONN_RES;
ag_res.audio_handle = btif_hf_cb.handle;
}
else if (num_held > btif_hf_cb.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.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_ERROR1("%s: Incorrect Call setup state transition", __FUNCTION__);
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 = sprintf (ag_res.str, "\"+%s\"", number);
else
xx = sprintf (ag_res.str, "\"%s\"", number);
ag_res.num = type;
if (res == BTA_AG_CALL_WAIT_RES)
sprintf(&ag_res.str[xx], ",%d", type);
}
break;
case BTHF_CALL_STATE_DIALING:
ag_res.audio_handle = btif_hf_cb.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.call_setup_state == BTHF_CALL_STATE_IDLE)
ag_res.audio_handle = btif_hf_cb.handle;
res = BTA_AG_OUT_CALL_ALERT_RES;
break;
default:
BTIF_TRACE_ERROR1("%s: Incorrect new ringing call state", __FUNCTION__);
status = BT_STATUS_PARM_INVALID;
break;
}
BTIF_TRACE_DEBUG3("%s: Call setup state changed. res=%d, audio_handle=%d", __FUNCTION__, 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.num_active + btif_hf_cb.num_held)) )
{
BTIF_TRACE_DEBUG3("%s: Active call states changed. old: %d new: %d", __FUNCTION__, btif_hf_cb.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.num_held)
{
BTIF_TRACE_DEBUG3("%s: Held call states changed. old: %d new: %d", __FUNCTION__, btif_hf_cb.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.call_setup_state) &&
(num_active && num_held) &&
(num_active == btif_hf_cb.num_active) &&
(num_held == btif_hf_cb.num_held) )
{
BTIF_TRACE_DEBUG1("%s: Calls swapped", __FUNCTION__);
send_indicator_update(BTA_AG_IND_CALLHELD, 1);
}
update_call_states:
btif_hf_cb.num_active = num_active;
btif_hf_cb.num_held = num_held;
btif_hf_cb.call_setup_state = call_setup_state;
return status;
}
static int btpan_get_local_role()
{
BTIF_TRACE_DEBUG1("btpan_dev_local_role:%d", btpan_dev_local_role);
return btpan_dev_local_role;
}
