/******************************************************************************
*
* Copyright 2004-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.
*
******************************************************************************/
#define LOG_TAG "bta_ag_cmd"
#include <cctype>
#include <cstdio>
#include <cstring>
#include "bt_common.h"
#include "bt_target.h"
#include "bt_types.h"
#include "bta_ag_api.h"
#include "bta_ag_at.h"
#include "bta_ag_int.h"
#include "bta_api.h"
#include "bta_sys.h"
#include "log/log.h"
#include "osi/include/log.h"
#include "osi/include/osi.h"
#include "port_api.h"
#include "utl.h"
/*****************************************************************************
* Constants
****************************************************************************/
/* Ring timeout */
#define BTA_AG_RING_TIMEOUT_MS (5 * 1000) /* 5 seconds */
#define BTA_AG_CMD_MAX_VAL 32767 /* Maximum value is signed 16-bit value */
/* Invalid Chld command */
#define BTA_AG_INVALID_CHLD 255
#define COLON_IDX_4_VGSVGM 4
/* Local events which will not trigger a higher layer callback */
enum {
BTA_AG_LOCAL_EVT_FIRST = 0x100,
BTA_AG_LOCAL_EVT_CCWA,
BTA_AG_LOCAL_EVT_CLIP,
BTA_AG_LOCAL_EVT_CMER,
BTA_AG_LOCAL_EVT_BRSF,
BTA_AG_LOCAL_EVT_CMEE,
BTA_AG_LOCAL_EVT_BCC,
};
/* AT command interpreter table for HSP */
const tBTA_AG_AT_CMD bta_ag_hsp_cmd[] = {
{"+CKPD", BTA_AG_AT_CKPD_EVT, BTA_AG_AT_SET, BTA_AG_AT_INT, 200, 200},
{"+VGS", BTA_AG_SPK_EVT, BTA_AG_AT_SET, BTA_AG_AT_INT, 0, 15},
{"+VGM", BTA_AG_MIC_EVT, BTA_AG_AT_SET, BTA_AG_AT_INT, 0, 15},
/* End-of-table marker used to stop lookup iteration */
{"", 0, 0, 0, 0, 0}};
/* AT command interpreter table for HFP */
const tBTA_AG_AT_CMD bta_ag_hfp_cmd[] = {
{"A", BTA_AG_AT_A_EVT, BTA_AG_AT_NONE, BTA_AG_AT_STR, 0, 0},
{"D", BTA_AG_AT_D_EVT, BTA_AG_AT_NONE | BTA_AG_AT_FREE, BTA_AG_AT_STR, 0,
0},
{"+VGS", BTA_AG_SPK_EVT, BTA_AG_AT_SET, BTA_AG_AT_INT, 0, 15},
{"+VGM", BTA_AG_MIC_EVT, BTA_AG_AT_SET, BTA_AG_AT_INT, 0, 15},
{"+CCWA", BTA_AG_LOCAL_EVT_CCWA, BTA_AG_AT_SET, BTA_AG_AT_INT, 0, 1},
/* Consider CHLD as str to take care of indexes for ECC */
{"+CHLD", BTA_AG_AT_CHLD_EVT, BTA_AG_AT_SET | BTA_AG_AT_TEST, BTA_AG_AT_STR,
0, 4},
{"+CHUP", BTA_AG_AT_CHUP_EVT, BTA_AG_AT_NONE, BTA_AG_AT_STR, 0, 0},
{"+CIND", BTA_AG_AT_CIND_EVT, BTA_AG_AT_READ | BTA_AG_AT_TEST,
BTA_AG_AT_STR, 0, 0},
{"+CLIP", BTA_AG_LOCAL_EVT_CLIP, BTA_AG_AT_SET, BTA_AG_AT_INT, 0, 1},
{"+CMER", BTA_AG_LOCAL_EVT_CMER, BTA_AG_AT_SET, BTA_AG_AT_STR, 0, 0},
{"+VTS", BTA_AG_AT_VTS_EVT, BTA_AG_AT_SET, BTA_AG_AT_STR, 0, 0},
{"+BINP", BTA_AG_AT_BINP_EVT, BTA_AG_AT_SET, BTA_AG_AT_INT, 1, 1},
{"+BLDN", BTA_AG_AT_BLDN_EVT, BTA_AG_AT_NONE, BTA_AG_AT_STR, 0, 0},
{"+BVRA", BTA_AG_AT_BVRA_EVT, BTA_AG_AT_SET, BTA_AG_AT_INT, 0, 1},
{"+BRSF", BTA_AG_LOCAL_EVT_BRSF, BTA_AG_AT_SET, BTA_AG_AT_INT, 0,
BTA_AG_CMD_MAX_VAL},
{"+NREC", BTA_AG_AT_NREC_EVT, BTA_AG_AT_SET, BTA_AG_AT_INT, 0, 0},
{"+CNUM", BTA_AG_AT_CNUM_EVT, BTA_AG_AT_NONE, BTA_AG_AT_STR, 0, 0},
{"+BTRH", BTA_AG_AT_BTRH_EVT, BTA_AG_AT_READ | BTA_AG_AT_SET, BTA_AG_AT_INT,
0, 2},
{"+CLCC", BTA_AG_AT_CLCC_EVT, BTA_AG_AT_NONE, BTA_AG_AT_STR, 0, 0},
{"+COPS", BTA_AG_AT_COPS_EVT, BTA_AG_AT_READ | BTA_AG_AT_SET, BTA_AG_AT_STR,
0, 0},
{"+CMEE", BTA_AG_LOCAL_EVT_CMEE, BTA_AG_AT_SET, BTA_AG_AT_INT, 0, 1},
{"+BIA", BTA_AG_AT_BIA_EVT, BTA_AG_AT_SET, BTA_AG_AT_STR, 0, 20},
{"+CBC", BTA_AG_AT_CBC_EVT, BTA_AG_AT_SET, BTA_AG_AT_INT, 0, 100},
{"+BCC", BTA_AG_LOCAL_EVT_BCC, BTA_AG_AT_NONE, BTA_AG_AT_STR, 0, 0},
{"+BCS", BTA_AG_AT_BCS_EVT, BTA_AG_AT_SET, BTA_AG_AT_INT, 0,
BTA_AG_CMD_MAX_VAL},
{"+BIND", BTA_AG_AT_BIND_EVT,
BTA_AG_AT_SET | BTA_AG_AT_READ | BTA_AG_AT_TEST, BTA_AG_AT_STR, 0, 0},
{"+BIEV", BTA_AG_AT_BIEV_EVT, BTA_AG_AT_SET, BTA_AG_AT_STR, 0, 0},
{"+BAC", BTA_AG_AT_BAC_EVT, BTA_AG_AT_SET, BTA_AG_AT_STR, 0, 0},
/* End-of-table marker used to stop lookup iteration */
{"", 0, 0, 0, 0, 0}};
/* AT result code table element */
typedef struct {
const char* result_string; /* AT result string */
size_t result_id; /* Local or BTA result id */
uint8_t arg_type; /* whether argument is int or string */
} tBTA_AG_RESULT;
/* AT result code argument types */
enum {
BTA_AG_RES_FMT_NONE, /* no argument */
BTA_AG_RES_FMT_INT, /* integer argument */
BTA_AG_RES_FMT_STR /* string argument */
};
/* Local AT command result codes not defined in bta_ag_api.h */
enum {
BTA_AG_LOCAL_RES_FIRST = 0x0100,
BTA_AG_LOCAL_RES_OK,
BTA_AG_LOCAL_RES_ERROR,
BTA_AG_LOCAL_RES_RING,
BTA_AG_LOCAL_RES_CLIP,
BTA_AG_LOCAL_RES_BRSF,
BTA_AG_LOCAL_RES_CMEE,
BTA_AG_LOCAL_RES_BCS
};
/* AT result code constant table */
const tBTA_AG_RESULT bta_ag_result_tbl[] = {
{"OK", BTA_AG_LOCAL_RES_OK, BTA_AG_RES_FMT_NONE},
{"ERROR", BTA_AG_LOCAL_RES_ERROR, BTA_AG_RES_FMT_NONE},
{"RING", BTA_AG_LOCAL_RES_RING, BTA_AG_RES_FMT_NONE},
{"+VGS: ", BTA_AG_SPK_RES, BTA_AG_RES_FMT_INT},
{"+VGM: ", BTA_AG_MIC_RES, BTA_AG_RES_FMT_INT},
{"+CCWA: ", BTA_AG_CALL_WAIT_RES, BTA_AG_RES_FMT_STR},
{"+CHLD: ", BTA_AG_IN_CALL_HELD_RES, BTA_AG_RES_FMT_STR},
{"+CIND: ", BTA_AG_CIND_RES, BTA_AG_RES_FMT_STR},
{"+CLIP: ", BTA_AG_LOCAL_RES_CLIP, BTA_AG_RES_FMT_STR},
{"+CIEV: ", BTA_AG_IND_RES, BTA_AG_RES_FMT_STR},
{"+BINP: ", BTA_AG_BINP_RES, BTA_AG_RES_FMT_STR},
{"+BVRA: ", BTA_AG_BVRA_RES, BTA_AG_RES_FMT_INT},
{"+BRSF: ", BTA_AG_LOCAL_RES_BRSF, BTA_AG_RES_FMT_INT},
{"+BSIR: ", BTA_AG_INBAND_RING_RES, BTA_AG_RES_FMT_INT},
{"+CNUM: ", BTA_AG_CNUM_RES, BTA_AG_RES_FMT_STR},
{"+BTRH: ", BTA_AG_BTRH_RES, BTA_AG_RES_FMT_INT},
{"+CLCC: ", BTA_AG_CLCC_RES, BTA_AG_RES_FMT_STR},
{"+COPS: ", BTA_AG_COPS_RES, BTA_AG_RES_FMT_STR},
{"+CME ERROR: ", BTA_AG_LOCAL_RES_CMEE, BTA_AG_RES_FMT_INT},
{"+BCS: ", BTA_AG_LOCAL_RES_BCS, BTA_AG_RES_FMT_INT},
{"+BIND: ", BTA_AG_BIND_RES, BTA_AG_RES_FMT_STR},
{"", BTA_AG_UNAT_RES, BTA_AG_RES_FMT_STR}};
static const tBTA_AG_RESULT* bta_ag_result_by_code(size_t code) {
for (size_t i = 0;
i != sizeof(bta_ag_result_tbl) / sizeof(bta_ag_result_tbl[0]); ++i) {
if (code == bta_ag_result_tbl[i].result_id) return &bta_ag_result_tbl[i];
}
return nullptr;
}
const tBTA_AG_AT_CMD* bta_ag_at_tbl[BTA_AG_NUM_IDX] = {bta_ag_hsp_cmd,
bta_ag_hfp_cmd};
typedef struct {
size_t result_code;
size_t indicator;
} tBTA_AG_INDICATOR_MAP;
/* callsetup indicator value lookup table */
const tBTA_AG_INDICATOR_MAP callsetup_indicator_map[] = {
{BTA_AG_IN_CALL_RES, BTA_AG_CALLSETUP_INCOMING},
{BTA_AG_CALL_WAIT_RES, BTA_AG_CALLSETUP_INCOMING},
{BTA_AG_OUT_CALL_ORIG_RES, BTA_AG_CALLSETUP_OUTGOING},
{BTA_AG_OUT_CALL_ALERT_RES, BTA_AG_CALLSETUP_ALERTING}};
static size_t bta_ag_indicator_by_result_code(size_t code) {
for (size_t i = 0;
i !=
sizeof(callsetup_indicator_map) / sizeof(callsetup_indicator_map[0]);
++i) {
if (code == callsetup_indicator_map[i].result_code)
return callsetup_indicator_map[i].indicator;
}
return BTA_AG_CALLSETUP_NONE;
}
/*******************************************************************************
*
* Function bta_ag_send_result
*
* Description Send an AT result code.
*
*
* Returns void
*
******************************************************************************/
static void bta_ag_send_result(tBTA_AG_SCB* p_scb, size_t code,
const char* p_arg, int16_t int_arg) {
const tBTA_AG_RESULT* result = bta_ag_result_by_code(code);
if (result == nullptr) {
LOG_ERROR(LOG_TAG, "%s Unable to lookup result for code %zu", __func__,
code);
return;
}
char buf[BTA_AG_AT_MAX_LEN + 16] = "";
char* p = buf;
/* init with \r\n */
*p++ = '\r';
*p++ = '\n';
/* copy result code string */
strlcpy(p, result->result_string, sizeof(buf) - 2);
if (p_scb->conn_service == BTA_AG_HSP) {
/* If HSP then ":"symbol should be changed as "=" for HSP compatibility */
switch (code) {
case BTA_AG_SPK_RES:
case BTA_AG_MIC_RES:
if (*(p + COLON_IDX_4_VGSVGM) == ':') {
*(p + COLON_IDX_4_VGSVGM) = '=';
}
break;
}
}
p += strlen(result->result_string);
/* copy argument if any */
if (result->arg_type == BTA_AG_RES_FMT_INT) {
p += utl_itoa((uint16_t)int_arg, p);
} else if (result->arg_type == BTA_AG_RES_FMT_STR) {
strcpy(p, p_arg);
p += strlen(p_arg);
}
/* finish with \r\n */
*p++ = '\r';
*p++ = '\n';
/* send to RFCOMM */
uint16_t len = 0;
PORT_WriteData(p_scb->conn_handle, buf, (uint16_t)(p - buf), &len);
}
/*******************************************************************************
*
* Function bta_ag_send_ok
*
* Description Send an OK result code.
*
*
* Returns void
*
******************************************************************************/
static void bta_ag_send_ok(tBTA_AG_SCB* p_scb) {
bta_ag_send_result(p_scb, BTA_AG_LOCAL_RES_OK, nullptr, 0);
}
/*******************************************************************************
*
* Function bta_ag_send_error
*
* Description Send an ERROR result code.
* errcode - used to send verbose errocode
*
*
* Returns void
*
******************************************************************************/
static void bta_ag_send_error(tBTA_AG_SCB* p_scb, int16_t errcode) {
/* If HFP and extended audio gateway error codes are enabled */
if (p_scb->conn_service == BTA_AG_HFP && p_scb->cmee_enabled)
bta_ag_send_result(p_scb, BTA_AG_LOCAL_RES_CMEE, nullptr, errcode);
else
bta_ag_send_result(p_scb, BTA_AG_LOCAL_RES_ERROR, nullptr, 0);
}
/*******************************************************************************
*
* Function bta_ag_send_ind
*
* Description Send an indicator CIEV result code.
*
*
* Returns void
*
******************************************************************************/
static void bta_ag_send_ind(tBTA_AG_SCB* p_scb, uint16_t id, uint16_t value,
bool on_demand) {
char str[12];
char* p = str;
/* If the indicator is masked out, just return */
/* Mandatory indicators can not be masked out. */
if ((p_scb->bia_masked_out & ((uint32_t)1 << id)) &&
((id != BTA_AG_IND_CALL) && (id != BTA_AG_IND_CALLSETUP) &&
(id != BTA_AG_IND_CALLHELD)))
return;
/* Ensure we do not send duplicate indicators if not requested by app */
/* If it was requested by app, transmit CIEV even if it is duplicate. */
if (id == BTA_AG_IND_CALL) {
if ((value == p_scb->call_ind) && (!on_demand)) return;
p_scb->call_ind = (uint8_t)value;
}
if ((id == BTA_AG_IND_CALLSETUP) && (!on_demand)) {
if (value == p_scb->callsetup_ind) return;
p_scb->callsetup_ind = (uint8_t)value;
}
if ((id == BTA_AG_IND_SERVICE) && (!on_demand)) {
if (value == p_scb->service_ind) return;
p_scb->service_ind = (uint8_t)value;
}
if ((id == BTA_AG_IND_SIGNAL) && (!on_demand)) {
if (value == p_scb->signal_ind) return;
p_scb->signal_ind = (uint8_t)value;
}
if ((id == BTA_AG_IND_ROAM) && (!on_demand)) {
if (value == p_scb->roam_ind) return;
p_scb->roam_ind = (uint8_t)value;
}
if ((id == BTA_AG_IND_BATTCHG) && (!on_demand)) {
if (value == p_scb->battchg_ind) return;
p_scb->battchg_ind = (uint8_t)value;
}
if ((id == BTA_AG_IND_CALLHELD) && (!on_demand)) {
/* call swap could result in sending callheld=1 multiple times */
if ((value != 1) && (value == p_scb->callheld_ind)) return;
p_scb->callheld_ind = (uint8_t)value;
}
if (p_scb->cmer_enabled) {
p += utl_itoa(id, p);
*p++ = ',';
utl_itoa(value, p);
bta_ag_send_result(p_scb, BTA_AG_IND_RES, str, 0);
}
}
/*******************************************************************************
*
* Function bta_ag_parse_cmer
*
* Description Parse AT+CMER parameter string.
*
*
* Returns true if parsed ok, false otherwise.
*
******************************************************************************/
static bool bta_ag_parse_cmer(char* p_s, char* p_end, bool* p_enabled) {
int16_t n[4] = {-1, -1, -1, -1};
int i;
char* p;
for (i = 0; i < 4; i++, p_s = p + 1) {
/* skip to comma delimiter */
for (p = p_s; p < p_end && *p != ',' && *p != 0; p++)
;
/* get integer value */
if (p > p_end) {
android_errorWriteLog(0x534e4554, "112860487");
return false;
}
*p = 0;
n[i] = utl_str2int(p_s);
}
/* process values */
if (n[0] < 0 || n[3] < 0) {
return false;
}
if ((n[0] == 3) && ((n[3] == 1) || (n[3] == 0))) {
*p_enabled = (bool)n[3];
}
return true;
}
/*******************************************************************************
*
* Function bta_ag_parse_chld
*
* Description Parse AT+CHLD parameter string.
*
*
* Returns Returns idx (1-7), 0 if ECC not enabled or
BTA_AG_INVALID_CHLD
if idx doesn't exist/1st character of argument is not a
digit
*
******************************************************************************/
static uint8_t bta_ag_parse_chld(UNUSED_ATTR tBTA_AG_SCB* p_scb, char* p_s) {
uint8_t retval = 0;
if (!isdigit(p_s[0])) {
return BTA_AG_INVALID_CHLD;
}
if (p_s[1] != 0) {
/* p_idxstr++; point to beginning of call number */
int16_t idx = utl_str2int(&p_s[1]);
if (idx != -1 && idx < 255) {
retval = (uint8_t)idx;
} else {
retval = BTA_AG_INVALID_CHLD;
}
}
return (retval);
}
/*******************************************************************************
*
* Function bta_ag_parse_bac
*
* Description Parse AT+BAC parameter string.
*
* Returns Returns bitmap of supported codecs.
*
******************************************************************************/
static tBTA_AG_PEER_CODEC bta_ag_parse_bac(tBTA_AG_SCB* p_scb, char* p_s,
char* p_end) {
tBTA_AG_PEER_CODEC retval = BTA_AG_CODEC_NONE;
uint16_t uuid_codec;
char* p;
while (p_s) {
/* skip to comma delimiter */
for (p = p_s; p < p_end && *p != ',' && *p != 0; p++)
;
/* get integer value */
if (p > p_end) {
android_errorWriteLog(0x534e4554, "112860487");
break;
}
bool cont = false; // Continue processing
if (*p != 0) {
*p = 0;
cont = true;
}
uuid_codec = utl_str2int(p_s);
switch (uuid_codec) {
case UUID_CODEC_CVSD:
retval |= BTA_AG_CODEC_CVSD;
break;
case UUID_CODEC_MSBC:
retval |= BTA_AG_CODEC_MSBC;
break;
default:
APPL_TRACE_ERROR("Unknown Codec UUID(%d) received", uuid_codec);
break;
}
if (cont)
p_s = p + 1;
else
break;
}
return (retval);
}
/*******************************************************************************
*
* Function bta_ag_process_unat_res
*
* Description Process the unat response data and remove extra carriage
* return and line feed
*
*
* Returns void
*
******************************************************************************/
static void bta_ag_process_unat_res(char* unat_result) {
uint8_t j = 0;
uint8_t pairs_of_nl_cr;
char trim_data[BTA_AG_AT_MAX_LEN];
uint8_t str_leng = strlen(unat_result);
/* If no extra CR and LF, just return */
if (str_leng < 4) return;
/* Remove the carriage return and left feed */
while (unat_result[0] == '\r' && unat_result[1] == '\n' &&
unat_result[str_leng - 2] == '\r' &&
unat_result[str_leng - 1] == '\n') {
pairs_of_nl_cr = 1;
for (int i = 0; i < (str_leng - 4 * pairs_of_nl_cr); i++) {
trim_data[j++] = unat_result[i + pairs_of_nl_cr * 2];
}
/* Add EOF */
trim_data[j] = '\0';
str_leng = str_leng - 4;
strlcpy(unat_result, trim_data, str_leng + 1);
j = 0;
if (str_leng < 4) return;
}
}
/*******************************************************************************
*
* Function bta_ag_inband_enabled
*
* Description Determine whether in-band ring can be used.
*
*
* Returns void
*
******************************************************************************/
bool bta_ag_inband_enabled(tBTA_AG_SCB* p_scb) {
/* if feature is enabled and no other scbs connected */
return p_scb->inband_enabled && !bta_ag_other_scb_open(p_scb);
}
/*******************************************************************************
*
* Function bta_ag_send_call_inds
*
* Description Send call and callsetup indicators.
*
*
* Returns void
*
******************************************************************************/
void bta_ag_send_call_inds(tBTA_AG_SCB* p_scb, tBTA_AG_RES result) {
uint8_t call;
/* set new call and callsetup values based on BTA_AgResult */
size_t callsetup = bta_ag_indicator_by_result_code(result);
if (result == BTA_AG_END_CALL_RES) {
call = BTA_AG_CALL_INACTIVE;
} else if (result == BTA_AG_IN_CALL_CONN_RES ||
result == BTA_AG_OUT_CALL_CONN_RES ||
result == BTA_AG_IN_CALL_HELD_RES) {
call = BTA_AG_CALL_ACTIVE;
} else {
call = p_scb->call_ind;
}
/* Send indicator function tracks if the values have actually changed */
bta_ag_send_ind(p_scb, BTA_AG_IND_CALL, call, false);
bta_ag_send_ind(p_scb, BTA_AG_IND_CALLSETUP, callsetup, false);
}
/*******************************************************************************
*
* Function bta_ag_at_hsp_cback
*
* Description AT command processing callback for HSP.
*
*
* Returns void
*
******************************************************************************/
void bta_ag_at_hsp_cback(tBTA_AG_SCB* p_scb, uint16_t command_id,
uint8_t arg_type, char* p_arg, char* p_end,
int16_t int_arg) {
APPL_TRACE_DEBUG("AT cmd:%d arg_type:%d arg:%d arg:%s", command_id, arg_type,
int_arg, p_arg);
bta_ag_send_ok(p_scb);
tBTA_AG_VAL val = {};
val.hdr.handle = bta_ag_scb_to_idx(p_scb);
val.hdr.app_id = p_scb->app_id;
val.num = (uint16_t)int_arg;
if ((p_end - p_arg + 1) >= (long)sizeof(val.str)) {
APPL_TRACE_ERROR("%s: p_arg is too long, send error and return", __func__);
bta_ag_send_error(p_scb, BTA_AG_ERR_TEXT_TOO_LONG);
android_errorWriteLog(0x534e4554, "112860487");
return;
}
strlcpy(val.str, p_arg, sizeof(val.str));
/* call callback with event */
(*bta_ag_cb.p_cback)(command_id, (tBTA_AG*)&val);
}
static void remove_spaces(char* str) {
char* dest_str = str;
while (*str) {
if (*str == ' ') {
str++;
} else {
*dest_str++ = *str++;
}
}
*dest_str = '\0';
}
/*******************************************************************************
*
* Function bta_ag_find_empty_hf_ind)
*
* Description This function returns the index of an empty HF indicator
* structure.
*
* Returns int : index of the empty HF indicator structure or
* -1 if no empty indicator
* is available.
*
******************************************************************************/
static int bta_ag_find_empty_hf_ind(tBTA_AG_SCB* p_scb) {
for (int index = 0; index < BTA_AG_MAX_NUM_PEER_HF_IND; index++) {
if (p_scb->peer_hf_indicators[index].ind_id == 0) return index;
}
return -1;
}
/*******************************************************************************
*
* Function bta_ag_find_hf_ind_by_id
*
* Description This function returns the index of the HF indicator
* structure by the indicator id
*
* Returns int : index of the HF indicator structure
* -1 if the indicator
* was not found.
*
******************************************************************************/
static int bta_ag_find_hf_ind_by_id(tBTA_AG_HF_IND* p_hf_ind, int size,
uint32_t ind_id) {
for (int index = 0; index < size; index++) {
if (p_hf_ind[index].ind_id == ind_id) return index;
}
return -1;
}
/*******************************************************************************
*
* Function bta_ag_parse_bind_set
*
* Description Parse AT+BIND set command and save the indicators
*
* Returns true if successful
*
******************************************************************************/
static bool bta_ag_parse_bind_set(tBTA_AG_SCB* p_scb, tBTA_AG_VAL val) {
char* p_token = strtok(val.str, ",");
if (p_token == nullptr) return false;
while (p_token != nullptr) {
uint16_t rcv_ind_id = atoi(p_token);
int index = bta_ag_find_empty_hf_ind(p_scb);
if (index == -1) {
APPL_TRACE_WARNING("%s Can't save more indicators", __func__);
return false;
}
p_scb->peer_hf_indicators[index].ind_id = rcv_ind_id;
APPL_TRACE_DEBUG("%s peer_hf_ind[%d] = %d", __func__, index, rcv_ind_id);
p_token = strtok(nullptr, ",");
}
return true;
}
/*******************************************************************************
*
* Function bta_ag_bind_response
*
* Description Send response for the AT+BIND command (HFP 1.7) received
* from the headset based on the argument types.
*
* Returns Void
*
******************************************************************************/
static void bta_ag_bind_response(tBTA_AG_SCB* p_scb, uint8_t arg_type) {
char buffer[BTA_AG_AT_MAX_LEN] = "";
if (arg_type == BTA_AG_AT_TEST) {
int index = 0;
buffer[index++] = '(';
for (uint32_t i = 0; i < bta_ag_local_hf_ind_cfg[0].ind_id; i++) {
if (bta_ag_local_hf_ind_cfg[i + 1].is_supported) {
/* Add ',' from second indicator */
if (index > 1) buffer[index++] = ',';
snprintf(&buffer[index++], 2, "%d",
bta_ag_local_hf_ind_cfg[i + 1].ind_id);
}
}
buffer[index++] = ')';
bta_ag_send_result(p_scb, BTA_AG_BIND_RES, buffer, 0);
bta_ag_send_ok(p_scb);
} else if (arg_type == BTA_AG_AT_READ) {
char* p = buffer;
/* bta_ag_local_hf_ind_cfg[0].ind_id is used as BTA_AG_NUM_LOCAL_HF_IND */
for (uint32_t i = 0; i < bta_ag_local_hf_ind_cfg[0].ind_id; i++) {
if (i == BTA_AG_MAX_NUM_LOCAL_HF_IND) {
APPL_TRACE_WARNING("%s No space for more HF indicators", __func__);
break;
}
p_scb->local_hf_indicators[i].ind_id =
bta_ag_local_hf_ind_cfg[i + 1].ind_id;
p_scb->local_hf_indicators[i].is_supported =
bta_ag_local_hf_ind_cfg[i + 1].is_supported;
p_scb->local_hf_indicators[i].is_enable =
bta_ag_local_hf_ind_cfg[i + 1].is_enable;
int peer_index = bta_ag_find_hf_ind_by_id(
p_scb->peer_hf_indicators, BTA_AG_MAX_NUM_PEER_HF_IND,
p_scb->local_hf_indicators[i].ind_id);
/* Check whether local and peer sides support this indicator */
if (p_scb->local_hf_indicators[i].is_supported && peer_index != -1) {
/* In the format of ind, state */
p += utl_itoa((uint16_t)p_scb->local_hf_indicators[i].ind_id, p);
*p++ = ',';
p += utl_itoa((uint16_t)p_scb->local_hf_indicators[i].is_enable, p);
bta_ag_send_result(p_scb, BTA_AG_BIND_RES, buffer, 0);
// have to use memset here because assigning to "" will not zero
// initialize the rest of the buffer
memset(buffer, 0, sizeof(buffer));
p = buffer;
} else {
/* If indicator is not supported, also set it to disable */
p_scb->local_hf_indicators[i].is_enable = false;
}
}
bta_ag_send_ok(p_scb);
/* If the service level connection wan't already open, now it's open */
if (!p_scb->svc_conn) {
bta_ag_svc_conn_open(p_scb, tBTA_AG_DATA::kEmpty);
}
}
}
/*******************************************************************************
*
* Function bta_ag_parse_biev_response
*
* Description Send response for AT+BIEV command (HFP 1.7) received from
* the headset based on the argument types.
*
* Returns true if the response was parsed successfully
*
******************************************************************************/
static bool bta_ag_parse_biev_response(tBTA_AG_SCB* p_scb, tBTA_AG_VAL* val) {
char* p_token = strtok(val->str, ",");
if (p_token == nullptr) return false;
uint16_t rcv_ind_id = atoi(p_token);
p_token = strtok(nullptr, ",");
if (p_token == nullptr) return false;
uint16_t rcv_ind_val = atoi(p_token);
APPL_TRACE_DEBUG("%s BIEV indicator id %d, value %d", __func__, rcv_ind_id,
rcv_ind_val);
/* Check whether indicator ID is valid or not */
if (rcv_ind_id > BTA_AG_NUM_LOCAL_HF_IND) {
APPL_TRACE_WARNING("%s received invalid indicator id %d", __func__,
rcv_ind_id);
return false;
}
/* Check this indicator is support or not and enabled or not */
int local_index = bta_ag_find_hf_ind_by_id(
p_scb->local_hf_indicators, BTA_AG_MAX_NUM_LOCAL_HF_IND, rcv_ind_id);
if (local_index == -1 ||
!p_scb->local_hf_indicators[local_index].is_supported ||
!p_scb->local_hf_indicators[local_index].is_enable) {
APPL_TRACE_WARNING("%s indicator id %d not supported or disabled", __func__,
rcv_ind_id);
return false;
}
/* For each indicator ID, check whether the indicator value is in range */
if (rcv_ind_val < bta_ag_local_hf_ind_cfg[rcv_ind_id].ind_min_val ||
rcv_ind_val > bta_ag_local_hf_ind_cfg[rcv_ind_id].ind_max_val) {
APPL_TRACE_WARNING("%s invalid ind_val %d", __func__, rcv_ind_val);
return false;
}
val->lidx = rcv_ind_id;
val->num = rcv_ind_val;
return true;
}
/*******************************************************************************
*
* Function bta_ag_at_hfp_cback
*
* Description AT command processing callback for HFP.
*
*
* Returns void
*
******************************************************************************/
void bta_ag_at_hfp_cback(tBTA_AG_SCB* p_scb, uint16_t cmd, uint8_t arg_type,
char* p_arg, char* p_end, int16_t int_arg) {
tBTA_AG_VAL val = {};
tBTA_AG_SCB* ag_scb;
uint32_t i, ind_id;
uint32_t bia_masked_out;
if (p_arg == nullptr) {
APPL_TRACE_ERROR("%s: p_arg is null, send error and return", __func__);
bta_ag_send_error(p_scb, BTA_AG_ERR_INV_CHAR_IN_TSTR);
return;
}
APPL_TRACE_DEBUG("%s: AT command %d, arg_type %d, int_arg %d, arg %s",
__func__, cmd, arg_type, int_arg, p_arg);
val.hdr.handle = bta_ag_scb_to_idx(p_scb);
val.hdr.app_id = p_scb->app_id;
val.hdr.status = BTA_AG_SUCCESS;
val.num = static_cast<uint32_t>(int_arg);
val.bd_addr = p_scb->peer_addr;
if ((p_end - p_arg + 1) >= (long)sizeof(val.str)) {
APPL_TRACE_ERROR("%s: p_arg is too long, send error and return", __func__);
bta_ag_send_error(p_scb, BTA_AG_ERR_TEXT_TOO_LONG);
android_errorWriteLog(0x534e4554, "112860487");
return;
}
strlcpy(val.str, p_arg, sizeof(val.str));
/**
* Unless this this is a local event, by default we'll forward
* the event code to the application.
* If |event| is 0 at the end of this function, the application
* callback is NOT invoked.
*/
tBTA_AG_EVT event = 0;
if (cmd < BTA_AG_LOCAL_EVT_FIRST) {
event = static_cast<tBTA_AG_EVT>(cmd);
}
switch (cmd) {
case BTA_AG_AT_A_EVT:
case BTA_AG_SPK_EVT:
case BTA_AG_MIC_EVT:
case BTA_AG_AT_CBC_EVT:
/* send OK */
bta_ag_send_ok(p_scb);
break;
case BTA_AG_AT_CHUP_EVT:
if (!bta_ag_sco_is_active_device(p_scb->peer_addr)) {
LOG(WARNING) << __func__ << ": AT+CHUP rejected as " << p_scb->peer_addr
<< " is not the active device";
event = 0;
bta_ag_send_error(p_scb, BTA_AG_ERR_OP_NOT_ALLOWED);
} else {
bta_ag_send_ok(p_scb);
}
break;
case BTA_AG_AT_BLDN_EVT:
/* Do not send OK, App will send error or OK depending on
** last dial number enabled or not */
break;
case BTA_AG_AT_D_EVT:
/* Do not send OK for Dial cmds
** Let application decide whether to send OK or ERROR*/
/* if mem dial cmd, make sure string contains only digits */
if (val.str[0] == '>') {
/* Some car kits may add some unwanted space characters in the
** input string. This workaround will trim the unwanted chars. */
remove_spaces(val.str + 1);
if (!utl_isintstr(val.str + 1)) {
event = 0;
bta_ag_send_error(p_scb, BTA_AG_ERR_INV_CHAR_IN_DSTR);
}
} else if (val.str[0] == 'V') /* ATDV : Dial VoIP Call */
{
/* We do not check string. Code will be added later if needed. */
if (!((p_scb->peer_features & BTA_AG_PEER_FEAT_VOIP) &&
(p_scb->features & BTA_AG_FEAT_VOIP))) {
event = 0;
bta_ag_send_error(p_scb, BTA_AG_ERR_OP_NOT_SUPPORTED);
}
}
/* If dial cmd, make sure string contains only dial digits
** Dial digits are 0-9, A-C, *, #, + */
else {
/* Some car kits may add some unwanted space characters in the
** input string. This workaround will trim the unwanted chars. */
remove_spaces(val.str);
if (!utl_isdialstr(val.str)) {
event = 0;
bta_ag_send_error(p_scb, BTA_AG_ERR_INV_CHAR_IN_DSTR);
}
}
break;
case BTA_AG_LOCAL_EVT_CCWA:
/* store setting */
p_scb->ccwa_enabled = (bool)int_arg;
/* send OK */
bta_ag_send_ok(p_scb);
break;
case BTA_AG_AT_CHLD_EVT:
if (arg_type == BTA_AG_AT_TEST) {
/* don't call callback */
event = 0;
/* send CHLD string */
/* Form string based on supported 1.5 feature */
if ((p_scb->peer_version >= HFP_VERSION_1_5) &&
(p_scb->features & BTA_AG_FEAT_ECC) &&
(p_scb->peer_features & BTA_AG_PEER_FEAT_ECC))
bta_ag_send_result(p_scb, BTA_AG_IN_CALL_HELD_RES,
p_bta_ag_cfg->chld_val_ecc, 0);
else
bta_ag_send_result(p_scb, BTA_AG_IN_CALL_HELD_RES,
p_bta_ag_cfg->chld_val, 0);
/* send OK */
bta_ag_send_ok(p_scb);
/* if service level conn. not already open, now it's open */
bta_ag_svc_conn_open(p_scb, tBTA_AG_DATA::kEmpty);
} else {
val.idx = bta_ag_parse_chld(p_scb, val.str);
if (val.idx == BTA_AG_INVALID_CHLD) {
event = 0;
bta_ag_send_error(p_scb, BTA_AG_ERR_OP_NOT_SUPPORTED);
break;
}
if (val.idx &&
!((p_scb->features & BTA_AG_FEAT_ECC) &&
(p_scb->peer_features & BTA_AG_PEER_FEAT_ECC))) {
/* we do not support ECC, but HF is sending us a CHLD with call
* index*/
event = 0;
bta_ag_send_error(p_scb, BTA_AG_ERR_OP_NOT_SUPPORTED);
} else {
/* If it is swap between calls, set call held indicator to 3(out of
*valid 0-2)
** Application will set it back to 1
** callheld indicator will be sent across to the peer. */
if (val.str[0] == '2') {
for (i = 0, ag_scb = &bta_ag_cb.scb[0]; i < BTA_AG_MAX_NUM_CLIENTS;
i++, ag_scb++) {
if (ag_scb->in_use) {
if ((ag_scb->call_ind == BTA_AG_CALL_ACTIVE) &&
(ag_scb->callsetup_ind == BTA_AG_CALLSETUP_NONE))
ag_scb->callheld_ind = BTA_AG_CALLHELD_NOACTIVE + 1;
}
}
}
}
/* Do not send OK. Let app decide after parsing the val str */
/* bta_ag_send_ok(p_scb); */
}
break;
case BTA_AG_AT_BIND_EVT:
APPL_TRACE_DEBUG("%s BTA_AG_AT_BIND_EVT arg_type: %d", __func__,
arg_type);
if (arg_type == BTA_AG_AT_SET) {
if (bta_ag_parse_bind_set(p_scb, val)) {
bta_ag_send_ok(p_scb);
} else {
event = 0; /* don't call callback */
bta_ag_send_error(p_scb, BTA_AG_ERR_INVALID_INDEX);
}
} else {
bta_ag_bind_response(p_scb, arg_type);
/* Need not pass this command beyond BTIF.*/
/* Stack handles it internally */
event = 0; /* don't call callback */
}
break;
case BTA_AG_AT_BIEV_EVT:
if (bta_ag_parse_biev_response(p_scb, &val)) {
bta_ag_send_ok(p_scb);
} else {
bta_ag_send_error(p_scb, BTA_AG_ERR_INVALID_INDEX);
/* don't call callback receiving invalid indicator */
event = 0;
}
break;
case BTA_AG_AT_CIND_EVT:
if (arg_type == BTA_AG_AT_TEST) {
/* don't call callback */
event = 0;
/* send CIND string, send OK */
bta_ag_send_result(p_scb, BTA_AG_CIND_RES, p_bta_ag_cfg->cind_info, 0);
bta_ag_send_ok(p_scb);
}
break;
case BTA_AG_LOCAL_EVT_CLIP:
/* store setting, send OK */
p_scb->clip_enabled = (bool)int_arg;
bta_ag_send_ok(p_scb);
break;
case BTA_AG_LOCAL_EVT_CMER:
/* if parsed ok store setting, send OK */
if (bta_ag_parse_cmer(p_arg, p_end, &p_scb->cmer_enabled)) {
bta_ag_send_ok(p_scb);
/* if service level conn. not already open and our features and
** peer features do not have 3-way, service level conn. now open
*/
if (!p_scb->svc_conn &&
!((p_scb->features & BTA_AG_FEAT_3WAY) &&
(p_scb->peer_features & BTA_AG_PEER_FEAT_3WAY))) {
bta_ag_svc_conn_open(p_scb, tBTA_AG_DATA::kEmpty);
}
} else {
bta_ag_send_error(p_scb, BTA_AG_ERR_INV_CHAR_IN_TSTR);
}
break;
case BTA_AG_AT_VTS_EVT:
/* check argument */
if (strlen(p_arg) == 1) {
bta_ag_send_ok(p_scb);
} else {
event = 0;
bta_ag_send_error(p_scb, BTA_AG_ERR_INV_CHAR_IN_TSTR);
}
break;
case BTA_AG_AT_BINP_EVT:
/* if feature not set don't call callback, send ERROR */
if (!(p_scb->features & BTA_AG_FEAT_VTAG)) {
event = 0;
bta_ag_send_error(p_scb, BTA_AG_ERR_OP_NOT_SUPPORTED);
}
break;
case BTA_AG_AT_BVRA_EVT:
/* if feature not supported don't call callback, send ERROR. App will send
* OK */
if (!(p_scb->features & BTA_AG_FEAT_VREC)) {
event = 0;
bta_ag_send_error(p_scb, BTA_AG_ERR_OP_NOT_SUPPORTED);
}
break;
case BTA_AG_LOCAL_EVT_BRSF: {
/* store peer features */
p_scb->peer_features = (uint16_t)int_arg;
tBTA_AG_FEAT features = p_scb->features;
if (p_scb->peer_version < HFP_VERSION_1_7) {
features &= HFP_1_6_FEAT_MASK;
}
APPL_TRACE_DEBUG("%s BRSF HF: 0x%x, phone: 0x%x", __func__,
p_scb->peer_features, features);
/* send BRSF, send OK */
bta_ag_send_result(p_scb, BTA_AG_LOCAL_RES_BRSF, nullptr,
(int16_t)features);
bta_ag_send_ok(p_scb);
break;
}
case BTA_AG_AT_NREC_EVT:
/* if feature send OK, else don't call callback, send ERROR */
if (p_scb->features & BTA_AG_FEAT_ECNR) {
bta_ag_send_ok(p_scb);
} else {
event = 0;
bta_ag_send_error(p_scb, BTA_AG_ERR_OP_NOT_SUPPORTED);
}
break;
case BTA_AG_AT_BTRH_EVT:
/* if feature send BTRH, send OK:, else don't call callback, send ERROR */
if (p_scb->features & BTA_AG_FEAT_BTRH) {
/* If set command; send response and notify app */
if (arg_type == BTA_AG_AT_SET) {
for (i = 0, ag_scb = &bta_ag_cb.scb[0]; i < BTA_AG_MAX_NUM_CLIENTS;
i++, ag_scb++) {
if (ag_scb->in_use) {
bta_ag_send_result(ag_scb, BTA_AG_BTRH_RES, nullptr, int_arg);
}
}
bta_ag_send_ok(p_scb);
} else /* Read Command */
{
val.num = BTA_AG_BTRH_READ;
}
} else {
event = 0;
bta_ag_send_error(p_scb, BTA_AG_ERR_OP_NOT_SUPPORTED);
}
break;
case BTA_AG_AT_COPS_EVT:
if (arg_type == BTA_AG_AT_SET) {
/* don't call callback */
event = 0;
/* send OK */
bta_ag_send_ok(p_scb);
}
break;
case BTA_AG_LOCAL_EVT_CMEE:
if (p_scb->features & BTA_AG_FEAT_EXTERR) {
/* store setting */
p_scb->cmee_enabled = (bool)int_arg;
/* send OK */
bta_ag_send_ok(p_scb);
} else {
bta_ag_send_error(p_scb, BTA_AG_ERR_OP_NOT_SUPPORTED);
}
/* don't call callback */
event = 0;
break;
case BTA_AG_AT_BIA_EVT:
bia_masked_out = p_scb->bia_masked_out;
/* Parse the indicator mask */
for (i = 0, ind_id = 1; (val.str[i] != 0) && (ind_id <= 20);
i++, ind_id++) {
if (val.str[i] == ',') {
continue;
}
if (val.str[i] == '0') {
bia_masked_out |= ((uint32_t)1 << ind_id);
} else if (val.str[i] == '1') {
bia_masked_out &= ~((uint32_t)1 << ind_id);
} else {
break;
}
i++;
if (val.str[i] != ',') {
break;
}
}
if (val.str[i] == 0) {
p_scb->bia_masked_out = bia_masked_out;
val.num = bia_masked_out;
bta_ag_send_ok(p_scb);
} else {
event = 0;
bta_ag_send_error(p_scb, BTA_AG_ERR_INVALID_INDEX);
}
break;
case BTA_AG_AT_CNUM_EVT:
break;
case BTA_AG_AT_CLCC_EVT:
if (!(p_scb->features & BTA_AG_FEAT_ECS)) {
event = 0;
bta_ag_send_error(p_scb, BTA_AG_ERR_OP_NOT_SUPPORTED);
}
break;
case BTA_AG_AT_BAC_EVT:
bta_ag_send_ok(p_scb);
p_scb->received_at_bac = true;
/* store available codecs from the peer */
if ((p_scb->peer_features & BTA_AG_PEER_FEAT_CODEC) &&
(p_scb->features & BTA_AG_FEAT_CODEC)) {
p_scb->peer_codecs = bta_ag_parse_bac(p_scb, p_arg, p_end);
p_scb->codec_updated = true;
if (p_scb->peer_codecs & BTA_AG_CODEC_MSBC) {
p_scb->sco_codec = UUID_CODEC_MSBC;
APPL_TRACE_DEBUG("Received AT+BAC, updating sco codec to MSBC");
} else {
p_scb->sco_codec = UUID_CODEC_CVSD;
APPL_TRACE_DEBUG("Received AT+BAC, updating sco codec to CVSD");
}
/* The above logic sets the stack preferred codec based on local and
peer codec
capabilities. This can be overridden by the application depending on its
preference
using the bta_ag_setcodec API. We send the peer_codecs to the
application. */
val.num = p_scb->peer_codecs;
/* Received BAC while in codec negotiation. */
if ((bta_ag_cb.sco.state == BTA_AG_SCO_CODEC_ST) &&
(bta_ag_cb.sco.p_curr_scb == p_scb)) {
bta_ag_codec_negotiate(p_scb);
}
} else {
p_scb->peer_codecs = BTA_AG_CODEC_CVSD;
APPL_TRACE_ERROR(
"Unexpected CMD:AT+BAC, Codec Negotiation is not supported");
}
break;
case BTA_AG_AT_BCS_EVT: {
tBTA_AG_PEER_CODEC codec_type, codec_sent;
bta_ag_send_ok(p_scb);
alarm_cancel(p_scb->codec_negotiation_timer);
switch (int_arg) {
case UUID_CODEC_CVSD:
codec_type = BTA_AG_CODEC_CVSD;
break;
case UUID_CODEC_MSBC:
codec_type = BTA_AG_CODEC_MSBC;
break;
default:
APPL_TRACE_ERROR("Unknown codec_uuid %d", int_arg);
codec_type = 0xFFFF;
break;
}
if (p_scb->codec_fallback)
codec_sent = BTA_AG_CODEC_CVSD;
else
codec_sent = p_scb->sco_codec;
bta_ag_sco_codec_nego(p_scb, codec_type == codec_sent);
/* send final codec info to callback */
val.num = codec_sent;
break;
}
case BTA_AG_LOCAL_EVT_BCC: {
if (!bta_ag_sco_is_active_device(p_scb->peer_addr)) {
LOG(WARNING) << __func__ << ": AT+BCC rejected as " << p_scb->peer_addr
<< " is not the active device";
bta_ag_send_error(p_scb, BTA_AG_ERR_OP_NOT_ALLOWED);
break;
}
bta_ag_send_ok(p_scb);
bta_ag_sco_open(p_scb, tBTA_AG_DATA::kEmpty);
break;
}
default:
bta_ag_send_error(p_scb, BTA_AG_ERR_OP_NOT_SUPPORTED);
break;
}
/* call callback */
if (event != 0) {
(*bta_ag_cb.p_cback)(event, (tBTA_AG*)&val);
}
}
/*******************************************************************************
*
* Function bta_ag_at_err_cback
*
* Description AT command parser error callback.
*
*
* Returns void
*
******************************************************************************/
void bta_ag_at_err_cback(tBTA_AG_SCB* p_scb, bool unknown, const char* p_arg) {
if (unknown && (!strlen(p_arg))) {
APPL_TRACE_DEBUG("Empty AT cmd string received");
bta_ag_send_ok(p_scb);
return;
}
tBTA_AG_VAL val = {};
/* if unknown AT command and configured to pass these to app */
if (unknown && (p_scb->features & BTA_AG_FEAT_UNAT)) {
val.hdr.handle = bta_ag_scb_to_idx(p_scb);
val.hdr.app_id = p_scb->app_id;
val.hdr.status = BTA_AG_SUCCESS;
val.num = 0;
strlcpy(val.str, p_arg, sizeof(val.str));
(*bta_ag_cb.p_cback)(BTA_AG_AT_UNAT_EVT, (tBTA_AG*)&val);
} else {
bta_ag_send_error(p_scb, BTA_AG_ERR_OP_NOT_SUPPORTED);
}
}
/*******************************************************************************
*
* Function bta_ag_hsp_result
*
* Description Handle API result for HSP connections.
*
*
* Returns void
*
******************************************************************************/
void bta_ag_hsp_result(tBTA_AG_SCB* p_scb, const tBTA_AG_API_RESULT& result) {
APPL_TRACE_DEBUG("bta_ag_hsp_result : res = %d", result.result);
switch (result.result) {
case BTA_AG_SPK_RES:
case BTA_AG_MIC_RES:
bta_ag_send_result(p_scb, result.result, nullptr, result.data.num);
break;
case BTA_AG_IN_CALL_RES:
/* tell sys to stop av if any */
bta_sys_sco_use(BTA_ID_AG, p_scb->app_id, p_scb->peer_addr);
/* if sco already opened or no inband ring send ring now */
if (bta_ag_sco_is_open(p_scb) || !bta_ag_inband_enabled(p_scb) ||
(p_scb->features & BTA_AG_FEAT_NOSCO)) {
bta_ag_send_ring(p_scb, tBTA_AG_DATA::kEmpty);
} else {
/* else open sco, send ring after sco opened */
/* HSPv1.2: AG shall not send RING if using in-band ring tone. */
if (p_scb->peer_version >= HSP_VERSION_1_2) {
p_scb->post_sco = BTA_AG_POST_SCO_NONE;
} else {
p_scb->post_sco = BTA_AG_POST_SCO_RING;
}
bta_ag_sco_open(p_scb, tBTA_AG_DATA::kEmpty);
}
break;
case BTA_AG_IN_CALL_CONN_RES:
case BTA_AG_OUT_CALL_ORIG_RES:
/* if incoming call connected stop ring timer */
if (result.result == BTA_AG_IN_CALL_CONN_RES) {
alarm_cancel(p_scb->ring_timer);
}
if (!(p_scb->features & BTA_AG_FEAT_NOSCO)) {
/* if audio connected to this scb AND sco is not opened, open sco */
if (result.data.audio_handle == bta_ag_scb_to_idx(p_scb) &&
!bta_ag_sco_is_open(p_scb)) {
bta_ag_sco_open(p_scb, tBTA_AG_DATA::kEmpty);
} else if (result.data.audio_handle == BTA_AG_HANDLE_NONE &&
bta_ag_sco_is_open(p_scb)) {
/* else if no audio at call close sco */
bta_ag_sco_close(p_scb, tBTA_AG_DATA::kEmpty);
}
}
break;
case BTA_AG_END_CALL_RES:
alarm_cancel(p_scb->ring_timer);
/* close sco */
if ((bta_ag_sco_is_open(p_scb) || bta_ag_sco_is_opening(p_scb)) &&
!(p_scb->features & BTA_AG_FEAT_NOSCO)) {
bta_ag_sco_close(p_scb, tBTA_AG_DATA::kEmpty);
} else {
/* if av got suspended by this call, let it resume. */
bta_sys_sco_unuse(BTA_ID_AG, p_scb->app_id, p_scb->peer_addr);
}
break;
case BTA_AG_INBAND_RING_RES:
p_scb->inband_enabled = result.data.state;
APPL_TRACE_DEBUG("inband_enabled set to %d", p_scb->inband_enabled);
break;
case BTA_AG_UNAT_RES:
if (result.data.ok_flag != BTA_AG_OK_ERROR) {
if (result.data.str[0] != 0) {
bta_ag_send_result(p_scb, result.result, result.data.str, 0);
}
if (result.data.ok_flag == BTA_AG_OK_DONE) bta_ag_send_ok(p_scb);
} else {
bta_ag_send_error(p_scb, BTA_AG_ERR_INV_CHAR_IN_TSTR);
}
break;
default:
/* ignore all others */
break;
}
}
/*******************************************************************************
*
* Function bta_ag_hfp_result
*
* Description Handle API result for HFP connections.
*
*
* Returns void
*
******************************************************************************/
void bta_ag_hfp_result(tBTA_AG_SCB* p_scb, const tBTA_AG_API_RESULT& result) {
APPL_TRACE_DEBUG("bta_ag_hfp_result : res = %d", result.result);
switch (result.result) {
case BTA_AG_SPK_RES:
case BTA_AG_MIC_RES:
bta_ag_send_result(p_scb, result.result, nullptr, result.data.num);
break;
case BTA_AG_IN_CALL_RES: {
/* tell sys to stop av if any */
bta_sys_sco_use(BTA_ID_AG, p_scb->app_id, p_scb->peer_addr);
p_scb->clip[0] = 0;
if (result.data.str[0] != 0) {
snprintf(p_scb->clip, sizeof(p_scb->clip), "%s", result.data.str);
}
/* send callsetup indicator */
if (p_scb->post_sco == BTA_AG_POST_SCO_CALL_END) {
/* Need to sent 2 callsetup IND's(Call End and Incoming call) after SCO
* close. */
p_scb->post_sco = BTA_AG_POST_SCO_CALL_END_INCALL;
} else {
bta_ag_send_call_inds(p_scb, result.result);
/* if sco already opened or no inband ring send ring now */
if (bta_ag_sco_is_open(p_scb) || !bta_ag_inband_enabled(p_scb) ||
(p_scb->features & BTA_AG_FEAT_NOSCO) ||
(result.data.audio_handle != bta_ag_scb_to_idx(p_scb))) {
bta_ag_send_ring(p_scb, tBTA_AG_DATA::kEmpty);
} else {
/* else open sco, send ring after sco opened */
p_scb->post_sco = BTA_AG_POST_SCO_RING;
bta_ag_sco_open(p_scb, tBTA_AG_DATA::kEmpty);
}
}
break;
}
case BTA_AG_IN_CALL_CONN_RES:
alarm_cancel(p_scb->ring_timer);
/* if sco not opened and we need to open it, send indicators first
** then open sco.
*/
bta_ag_send_call_inds(p_scb, result.result);
if (!(p_scb->features & BTA_AG_FEAT_NOSCO)) {
if (result.data.audio_handle == bta_ag_scb_to_idx(p_scb) &&
!bta_ag_sco_is_open(p_scb)) {
bta_ag_sco_open(p_scb, tBTA_AG_DATA::kEmpty);
} else if ((result.data.audio_handle == BTA_AG_HANDLE_NONE) &&
bta_ag_sco_is_open(p_scb)) {
bta_ag_sco_close(p_scb, tBTA_AG_DATA::kEmpty);
}
}
break;
case BTA_AG_IN_CALL_HELD_RES:
alarm_cancel(p_scb->ring_timer);
bta_ag_send_call_inds(p_scb, result.result);
break;
case BTA_AG_OUT_CALL_ORIG_RES:
bta_ag_send_call_inds(p_scb, result.result);
if (result.data.audio_handle == bta_ag_scb_to_idx(p_scb) &&
!(p_scb->features & BTA_AG_FEAT_NOSCO)) {
bta_ag_sco_open(p_scb, tBTA_AG_DATA::kEmpty);
}
break;
case BTA_AG_OUT_CALL_ALERT_RES:
/* send indicators */
bta_ag_send_call_inds(p_scb, result.result);
if (result.data.audio_handle == bta_ag_scb_to_idx(p_scb) &&
!(p_scb->features & BTA_AG_FEAT_NOSCO)) {
bta_ag_sco_open(p_scb, tBTA_AG_DATA::kEmpty);
}
break;
case BTA_AG_MULTI_CALL_RES:
/* open SCO at SLC for this three way call */
APPL_TRACE_DEBUG("Headset Connected in three way call");
if (!(p_scb->features & BTA_AG_FEAT_NOSCO)) {
if (result.data.audio_handle == bta_ag_scb_to_idx(p_scb)) {
bta_ag_sco_open(p_scb, tBTA_AG_DATA::kEmpty);
} else if (result.data.audio_handle == BTA_AG_HANDLE_NONE) {
bta_ag_sco_close(p_scb, tBTA_AG_DATA::kEmpty);
}
}
break;
case BTA_AG_OUT_CALL_CONN_RES:
/* send indicators */
bta_ag_send_call_inds(p_scb, result.result);
/* open or close sco */
if (!(p_scb->features & BTA_AG_FEAT_NOSCO)) {
if (result.data.audio_handle == bta_ag_scb_to_idx(p_scb)) {
bta_ag_sco_open(p_scb, tBTA_AG_DATA::kEmpty);
} else if (result.data.audio_handle == BTA_AG_HANDLE_NONE) {
bta_ag_sco_close(p_scb, tBTA_AG_DATA::kEmpty);
}
}
break;
case BTA_AG_CALL_CANCEL_RES:
/* send indicators */
bta_ag_send_call_inds(p_scb, result.result);
break;
case BTA_AG_END_CALL_RES:
alarm_cancel(p_scb->ring_timer);
/* if sco open, close sco then send indicator values */
if ((bta_ag_sco_is_open(p_scb) || bta_ag_sco_is_opening(p_scb)) &&
!(p_scb->features & BTA_AG_FEAT_NOSCO)) {
p_scb->post_sco = BTA_AG_POST_SCO_CALL_END;
bta_ag_sco_close(p_scb, tBTA_AG_DATA::kEmpty);
} else if (p_scb->post_sco == BTA_AG_POST_SCO_CALL_END_INCALL) {
/* sco closing for outgoing call because of incoming call */
/* Send only callsetup end indicator after sco close */
p_scb->post_sco = BTA_AG_POST_SCO_CALL_END;
} else {
bta_ag_send_call_inds(p_scb, result.result);
/* if av got suspended by this call, let it resume. */
bta_sys_sco_unuse(BTA_ID_AG, p_scb->app_id, p_scb->peer_addr);
}
break;
case BTA_AG_INBAND_RING_RES:
p_scb->inband_enabled = result.data.state;
APPL_TRACE_DEBUG("inband_enabled set to %d", p_scb->inband_enabled);
bta_ag_send_result(p_scb, result.result, nullptr, result.data.state);
break;
case BTA_AG_CIND_RES:
/* store local values */
p_scb->call_ind = result.data.str[0] - '0';
p_scb->callsetup_ind = result.data.str[2] - '0';
p_scb->service_ind = result.data.str[4] - '0';
p_scb->signal_ind = result.data.str[6] - '0';
p_scb->roam_ind = result.data.str[8] - '0';
p_scb->battchg_ind = result.data.str[10] - '0';
p_scb->callheld_ind = result.data.str[12] - '0';
APPL_TRACE_DEBUG("cind call:%d callsetup:%d", p_scb->call_ind,
p_scb->callsetup_ind);
bta_ag_send_result(p_scb, result.result, result.data.str, 0);
bta_ag_send_ok(p_scb);
break;
case BTA_AG_BINP_RES:
case BTA_AG_CNUM_RES:
case BTA_AG_CLCC_RES:
case BTA_AG_COPS_RES:
if (result.data.ok_flag != BTA_AG_OK_ERROR) {
if (result.data.str[0] != 0) {
bta_ag_send_result(p_scb, result.result, result.data.str, 0);
}
if (result.data.ok_flag == BTA_AG_OK_DONE) bta_ag_send_ok(p_scb);
} else {
bta_ag_send_error(p_scb, result.data.errcode);
}
break;
case BTA_AG_UNAT_RES: {
if (result.data.ok_flag != BTA_AG_OK_ERROR) {
if (result.data.str[0] != 0) {
tBTA_AG_API_RESULT result_copy(result);
bta_ag_process_unat_res(result_copy.data.str);
APPL_TRACE_DEBUG("BTA_AG_RES :%s", result_copy.data.str);
bta_ag_send_result(p_scb, result_copy.result, result_copy.data.str,
0);
}
if (result.data.ok_flag == BTA_AG_OK_DONE) {
bta_ag_send_ok(p_scb);
}
} else {
bta_ag_send_error(p_scb, result.data.errcode);
}
break;
}
case BTA_AG_CALL_WAIT_RES:
if (p_scb->ccwa_enabled) {
bta_ag_send_result(p_scb, result.result, result.data.str, 0);
}
bta_ag_send_call_inds(p_scb, result.result);
break;
case BTA_AG_IND_RES:
bta_ag_send_ind(p_scb, result.data.ind.id, result.data.ind.value, false);
break;
case BTA_AG_IND_RES_ON_DEMAND:
bta_ag_send_ind(p_scb, result.data.ind.id, result.data.ind.value, true);
break;
case BTA_AG_BVRA_RES:
bta_ag_send_result(p_scb, result.result, nullptr, result.data.state);
break;
case BTA_AG_BTRH_RES:
if (result.data.ok_flag != BTA_AG_OK_ERROR) {
/* Don't respond to read if not in response & hold state */
if (result.data.num != BTA_AG_BTRH_NO_RESP) {
bta_ag_send_result(p_scb, result.result, nullptr, result.data.num);
}
/* In case of a response to a read request we need to send OK */
if (result.data.ok_flag == BTA_AG_OK_DONE) {
bta_ag_send_ok(p_scb);
}
} else {
bta_ag_send_error(p_scb, result.data.errcode);
}
break;
case BTA_AG_BIND_RES: {
/* Find whether ind_id is supported by local device or not */
int local_index = bta_ag_find_hf_ind_by_id(p_scb->local_hf_indicators,
BTA_AG_MAX_NUM_LOCAL_HF_IND,
result.data.ind.id);
if (local_index == -1) {
APPL_TRACE_WARNING("%s Invalid HF Indicator ID %d", __func__,
result.data.ind.id);
return;
}
/* Find whether ind_id is supported by peer device or not */
int peer_index = bta_ag_find_hf_ind_by_id(p_scb->peer_hf_indicators,
BTA_AG_MAX_NUM_PEER_HF_IND,
result.data.ind.id);
if (peer_index == -1) {
APPL_TRACE_WARNING("%s Invalid HF Indicator ID %d", __func__,
result.data.ind.id);
return;
} else {
/* If the current state is different from the one upper layer request
change current state and send out the result */
if (p_scb->local_hf_indicators[local_index].is_enable !=
result.data.ind.on_demand) {
char buffer[BTA_AG_AT_MAX_LEN] = {0};
char* p = buffer;
p_scb->local_hf_indicators[local_index].is_enable =
result.data.ind.on_demand;
p += utl_itoa(result.data.ind.id, p);
*p++ = ',';
p += utl_itoa(p_scb->local_hf_indicators[local_index].is_enable, p);
bta_ag_send_result(p_scb, result.result, buffer, 0);
} else {
APPL_TRACE_DEBUG(
"%s HF Indicator %d already %s", result.data.ind.id,
(result.data.ind.on_demand) ? "Enabled" : "Disabled");
}
}
break;
}
default:
break;
}
}
/*******************************************************************************
*
* Function bta_ag_result
*
* Description Handle API result.
*
*
* Returns void
*
******************************************************************************/
void bta_ag_result(tBTA_AG_SCB* p_scb, const tBTA_AG_DATA& data) {
if (p_scb->conn_service == BTA_AG_HSP) {
bta_ag_hsp_result(p_scb, data.api_result);
} else {
bta_ag_hfp_result(p_scb, data.api_result);
}
}
/*******************************************************************************
*
* Function bta_ag_send_bcs
*
* Description Send +BCS AT command to peer.
*
* Returns void
*
******************************************************************************/
void bta_ag_send_bcs(tBTA_AG_SCB* p_scb) {
uint16_t codec_uuid;
if (p_scb->codec_fallback) {
codec_uuid = UUID_CODEC_CVSD;
} else {
switch (p_scb->sco_codec) {
case BTA_AG_CODEC_NONE:
codec_uuid = UUID_CODEC_CVSD;
break;
case BTA_AG_CODEC_CVSD:
codec_uuid = UUID_CODEC_CVSD;
break;
case BTA_AG_CODEC_MSBC:
codec_uuid = UUID_CODEC_MSBC;
break;
default:
APPL_TRACE_ERROR("bta_ag_send_bcs: unknown codec %d, use CVSD",
p_scb->sco_codec);
codec_uuid = UUID_CODEC_CVSD;
break;
}
}
/* send +BCS */
APPL_TRACE_DEBUG("send +BCS codec is %d", codec_uuid);
bta_ag_send_result(p_scb, BTA_AG_LOCAL_RES_BCS, nullptr, codec_uuid);
}
/*******************************************************************************
*
* Function bta_ag_send_ring
*
* Description Send RING result code to peer.
*
*
* Returns void
*
******************************************************************************/
void bta_ag_send_ring(tBTA_AG_SCB* p_scb,
UNUSED_ATTR const tBTA_AG_DATA& data) {
if ((p_scb->conn_service == BTA_AG_HFP) &&
p_scb->callsetup_ind != BTA_AG_CALLSETUP_INCOMING) {
LOG(WARNING) << __func__ << ": don't send RING, conn_service="
<< std::to_string(p_scb->conn_service)
<< ", callsetup_ind=" << std::to_string(p_scb->callsetup_ind);
return;
}
/* send RING */
bta_ag_send_result(p_scb, BTA_AG_LOCAL_RES_RING, nullptr, 0);
/* if HFP and clip enabled and clip data send CLIP */
if (p_scb->conn_service == BTA_AG_HFP && p_scb->clip_enabled &&
p_scb->clip[0] != 0) {
bta_ag_send_result(p_scb, BTA_AG_LOCAL_RES_CLIP, p_scb->clip, 0);
}
bta_sys_start_timer(p_scb->ring_timer, BTA_AG_RING_TIMEOUT_MS,
BTA_AG_RING_TIMEOUT_EVT, bta_ag_scb_to_idx(p_scb));
}