sandy
/
PL286
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1 Commit
1 Branch
0 Tags
18 GiB
Tree: 99da0f2c72
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '99da0f2c72'
${ noResults }
PL286/system/bt/bta/hf_client/bta_hf_client_main.cc

948 lines
35 KiB
Raw Blame History

/******************************************************************************
*
* Copyright (c) 2016 The Android Open Source Project
* Copyright (C) 2003-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.
*
******************************************************************************/
#include <base/logging.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "bt_utils.h"
#include "bta_api.h"
#include "bta_hf_client_api.h"
#include "bta_hf_client_int.h"
#include "bta_sys.h"
#include "osi/include/osi.h"
#include "osi/include/properties.h"
#include "utl.h"
static const char* bta_hf_client_evt_str(uint16_t event);
static const char* bta_hf_client_state_str(uint8_t state);
void bta_hf_client_cb_init(tBTA_HF_CLIENT_CB* client_cb, uint16_t handle);
/* state machine states */
enum {
BTA_HF_CLIENT_INIT_ST,
BTA_HF_CLIENT_OPENING_ST,
BTA_HF_CLIENT_OPEN_ST,
BTA_HF_CLIENT_CLOSING_ST
};
/* state machine action enumeration list */
enum {
BTA_HF_CLIENT_RFC_DO_CLOSE,
BTA_HF_CLIENT_START_CLOSE,
BTA_HF_CLIENT_START_OPEN,
BTA_HF_CLIENT_RFC_ACP_OPEN,
BTA_HF_CLIENT_SCO_LISTEN,
BTA_HF_CLIENT_SCO_CONN_OPEN,
BTA_HF_CLIENT_SCO_CONN_CLOSE,
BTA_HF_CLIENT_SCO_OPEN,
BTA_HF_CLIENT_SCO_CLOSE,
BTA_HF_CLIENT_FREE_DB,
BTA_HF_CLIENT_OPEN_FAIL,
BTA_HF_CLIENT_RFC_OPEN,
BTA_HF_CLIENT_RFC_FAIL,
BTA_HF_CLIENT_DISC_INT_RES,
BTA_HF_CLIENT_RFC_DO_OPEN,
BTA_HF_CLIENT_DISC_FAIL,
BTA_HF_CLIENT_RFC_CLOSE,
BTA_HF_CLIENT_RFC_DATA,
BTA_HF_CLIENT_DISC_ACP_RES,
BTA_HF_CLIENT_SVC_CONN_OPEN,
BTA_HF_CLIENT_SEND_AT_CMD,
BTA_HF_CLIENT_NUM_ACTIONS,
};
#define BTA_HF_CLIENT_IGNORE BTA_HF_CLIENT_NUM_ACTIONS
/* type for action functions */
typedef void (*tBTA_HF_CLIENT_ACTION)(tBTA_HF_CLIENT_DATA* p_data);
/* action functions table, indexed with action enum */
const tBTA_HF_CLIENT_ACTION bta_hf_client_action[] = {
/* BTA_HF_CLIENT_RFC_DO_CLOSE */ bta_hf_client_rfc_do_close,
/* BTA_HF_CLIENT_START_CLOSE */ bta_hf_client_start_close,
/* BTA_HF_CLIENT_START_OPEN */ bta_hf_client_start_open,
/* BTA_HF_CLIENT_RFC_ACP_OPEN */ bta_hf_client_rfc_acp_open,
/* BTA_HF_CLIENT_SCO_LISTEN */ NULL,
/* BTA_HF_CLIENT_SCO_CONN_OPEN */ bta_hf_client_sco_conn_open,
/* BTA_HF_CLIENT_SCO_CONN_CLOSE*/ bta_hf_client_sco_conn_close,
/* BTA_HF_CLIENT_SCO_OPEN */ bta_hf_client_sco_open,
/* BTA_HF_CLIENT_SCO_CLOSE */ bta_hf_client_sco_close,
/* BTA_HF_CLIENT_FREE_DB */ bta_hf_client_free_db,
/* BTA_HF_CLIENT_OPEN_FAIL */ bta_hf_client_open_fail,
/* BTA_HF_CLIENT_RFC_OPEN */ bta_hf_client_rfc_open,
/* BTA_HF_CLIENT_RFC_FAIL */ bta_hf_client_rfc_fail,
/* BTA_HF_CLIENT_DISC_INT_RES */ bta_hf_client_disc_int_res,
/* BTA_HF_CLIENT_RFC_DO_OPEN */ bta_hf_client_rfc_do_open,
/* BTA_HF_CLIENT_DISC_FAIL */ bta_hf_client_disc_fail,
/* BTA_HF_CLIENT_RFC_CLOSE */ bta_hf_client_rfc_close,
/* BTA_HF_CLIENT_RFC_DATA */ bta_hf_client_rfc_data,
/* BTA_HF_CLIENT_DISC_ACP_RES */ bta_hf_client_disc_acp_res,
/* BTA_HF_CLIENT_SVC_CONN_OPEN */ bta_hf_client_svc_conn_open,
/* BTA_HF_CLIENT_SEND_AT_CMD */ bta_hf_client_send_at_cmd,
};
/* state table information */
#define BTA_HF_CLIENT_ACTIONS 2 /* number of actions */
#define BTA_HF_CLIENT_NEXT_STATE 2 /* position of next state */
#define BTA_HF_CLIENT_NUM_COLS 3 /* number of columns in state tables */
/* state table for init state */
const uint8_t bta_hf_client_st_init[][BTA_HF_CLIENT_NUM_COLS] = {
/* Event Action 1 Action 2
Next state */
/* API_OPEN_EVT */ {BTA_HF_CLIENT_START_OPEN, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_OPENING_ST},
/* API_CLOSE_EVT */ {BTA_HF_CLIENT_IGNORE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_INIT_ST},
/* API_AUDIO_OPEN_EVT */ {BTA_HF_CLIENT_IGNORE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_INIT_ST},
/* API_AUDIO_CLOSE_EVT */ {BTA_HF_CLIENT_IGNORE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_INIT_ST},
/* RFC_OPEN_EVT */ {BTA_HF_CLIENT_RFC_ACP_OPEN, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_OPEN_ST},
/* RFC_CLOSE_EVT */ {BTA_HF_CLIENT_IGNORE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_INIT_ST},
/* RFC_SRV_CLOSE_EVT */ {BTA_HF_CLIENT_IGNORE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_INIT_ST},
/* RFC_DATA_EVT */ {BTA_HF_CLIENT_IGNORE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_INIT_ST},
/* DISC_ACP_RES_EVT */ {BTA_HF_CLIENT_FREE_DB, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_INIT_ST},
/* DISC_INT_RES_EVT */ {BTA_HF_CLIENT_IGNORE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_INIT_ST},
/* DISC_OK_EVT */ {BTA_HF_CLIENT_IGNORE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_INIT_ST},
/* DISC_FAIL_EVT */ {BTA_HF_CLIENT_IGNORE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_INIT_ST},
/* SCO_OPEN_EVT */ {BTA_HF_CLIENT_IGNORE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_INIT_ST},
/* SCO_CLOSE_EVT */ {BTA_HF_CLIENT_IGNORE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_INIT_ST},
/* SEND_AT_CMD_EVT */ {BTA_HF_CLIENT_IGNORE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_INIT_ST},
};
/* state table for opening state */
const uint8_t bta_hf_client_st_opening[][BTA_HF_CLIENT_NUM_COLS] = {
/* Event Action 1 Action 2
Next state */
/* API_OPEN_EVT */ {BTA_HF_CLIENT_OPEN_FAIL, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_OPENING_ST},
/* API_CLOSE_EVT */ {BTA_HF_CLIENT_RFC_DO_CLOSE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_CLOSING_ST},
/* API_AUDIO_OPEN_EVT */ {BTA_HF_CLIENT_IGNORE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_OPENING_ST},
/* API_AUDIO_CLOSE_EVT */ {BTA_HF_CLIENT_IGNORE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_OPENING_ST},
/* RFC_OPEN_EVT */ {BTA_HF_CLIENT_RFC_OPEN, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_OPEN_ST},
/* RFC_CLOSE_EVT */ {BTA_HF_CLIENT_RFC_FAIL, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_INIT_ST},
/* RFC_SRV_CLOSE_EVT */ {BTA_HF_CLIENT_IGNORE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_OPENING_ST},
/* RFC_DATA_EVT */ {BTA_HF_CLIENT_IGNORE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_OPENING_ST},
/* DISC_ACP_RES_EVT */ {BTA_HF_CLIENT_IGNORE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_OPENING_ST},
/* DISC_INT_RES_EVT */ {BTA_HF_CLIENT_DISC_INT_RES, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_OPENING_ST},
/* DISC_OK_EVT */ {BTA_HF_CLIENT_RFC_DO_OPEN, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_OPENING_ST},
/* DISC_FAIL_EVT */ {BTA_HF_CLIENT_DISC_FAIL, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_INIT_ST},
/* SCO_OPEN_EVT */ {BTA_HF_CLIENT_IGNORE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_OPENING_ST},
/* SCO_CLOSE_EVT */ {BTA_HF_CLIENT_IGNORE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_OPENING_ST},
/* SEND_AT_CMD_EVT */ {BTA_HF_CLIENT_IGNORE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_OPENING_ST},
};
/* state table for open state */
const uint8_t bta_hf_client_st_open[][BTA_HF_CLIENT_NUM_COLS] = {
/* Event Action 1 Action 2
Next state */
/* API_OPEN_EVT */ {BTA_HF_CLIENT_OPEN_FAIL, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_OPEN_ST},
/* API_CLOSE_EVT */ {BTA_HF_CLIENT_START_CLOSE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_CLOSING_ST},
/* API_AUDIO_OPEN_EVT */ {BTA_HF_CLIENT_SCO_OPEN, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_OPEN_ST},
/* API_AUDIO_CLOSE_EVT */ {BTA_HF_CLIENT_SCO_CLOSE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_OPEN_ST},
/* RFC_OPEN_EVT */ {BTA_HF_CLIENT_IGNORE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_OPEN_ST},
/* RFC_CLOSE_EVT */ {BTA_HF_CLIENT_RFC_CLOSE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_INIT_ST},
/* RFC_SRV_CLOSE_EVT */ {BTA_HF_CLIENT_IGNORE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_OPEN_ST},
/* RFC_DATA_EVT */ {BTA_HF_CLIENT_RFC_DATA, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_OPEN_ST},
/* DISC_ACP_RES_EVT */ {BTA_HF_CLIENT_DISC_ACP_RES, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_OPEN_ST},
/* DISC_INT_RES_EVT */ {BTA_HF_CLIENT_IGNORE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_OPEN_ST},
/* DISC_OK_EVT */ {BTA_HF_CLIENT_IGNORE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_OPEN_ST},
/* DISC_FAIL_EVT */ {BTA_HF_CLIENT_IGNORE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_OPEN_ST},
/* SCO_OPEN_EVT */ {BTA_HF_CLIENT_SCO_CONN_OPEN, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_OPEN_ST},
/* SCO_CLOSE_EVT */ {BTA_HF_CLIENT_SCO_CONN_CLOSE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_OPEN_ST},
/* SEND_AT_CMD_EVT */ {BTA_HF_CLIENT_SEND_AT_CMD, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_OPEN_ST},
};
/* state table for closing state */
const uint8_t bta_hf_client_st_closing[][BTA_HF_CLIENT_NUM_COLS] = {
/* Event Action 1 Action 2
Next state */
/* API_OPEN_EVT */ {BTA_HF_CLIENT_OPEN_FAIL, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_CLOSING_ST},
/* API_CLOSE_EVT */ {BTA_HF_CLIENT_IGNORE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_CLOSING_ST},
/* API_AUDIO_OPEN_EVT */ {BTA_HF_CLIENT_IGNORE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_CLOSING_ST},
/* API_AUDIO_CLOSE_EVT */ {BTA_HF_CLIENT_IGNORE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_CLOSING_ST},
/* RFC_OPEN_EVT */ {BTA_HF_CLIENT_IGNORE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_CLOSING_ST},
/* RFC_CLOSE_EVT */ {BTA_HF_CLIENT_RFC_CLOSE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_INIT_ST},
/* RFC_SRV_CLOSE_EVT */ {BTA_HF_CLIENT_IGNORE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_CLOSING_ST},
/* RFC_DATA_EVT */ {BTA_HF_CLIENT_IGNORE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_CLOSING_ST},
/* DISC_ACP_RES_EVT */ {BTA_HF_CLIENT_FREE_DB, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_CLOSING_ST},
/* DISC_INT_RES_EVT */ {BTA_HF_CLIENT_FREE_DB, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_INIT_ST},
/* DISC_OK_EVT */ {BTA_HF_CLIENT_IGNORE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_CLOSING_ST},
/* DISC_FAIL_EVT */ {BTA_HF_CLIENT_IGNORE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_CLOSING_ST},
/* SCO_OPEN_EVT */ {BTA_HF_CLIENT_IGNORE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_CLOSING_ST},
/* SCO_CLOSE_EVT */ {BTA_HF_CLIENT_IGNORE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_CLOSING_ST},
/* SEND_AT_CMD_EVT */ {BTA_HF_CLIENT_IGNORE, BTA_HF_CLIENT_IGNORE,
BTA_HF_CLIENT_CLOSING_ST},
};
/* type for state table */
typedef const uint8_t (*tBTA_HF_CLIENT_ST_TBL)[BTA_HF_CLIENT_NUM_COLS];
/* state table */
const tBTA_HF_CLIENT_ST_TBL bta_hf_client_st_tbl[] = {
bta_hf_client_st_init, bta_hf_client_st_opening, bta_hf_client_st_open,
bta_hf_client_st_closing};
/* HF Client control block */
tBTA_HF_CLIENT_CB_ARR bta_hf_client_cb_arr;
/* Event handler for the state machine */
static const tBTA_SYS_REG bta_hf_client_reg = {bta_hf_client_hdl_event,
BTA_HfClientDisable};
/*******************************************************************************
*
* Function bta_hf_client_cb_arr_init
*
* Description Initialize entire control block array set
*
*
* Returns void
*
******************************************************************************/
void bta_hf_client_cb_arr_init() {
memset(&bta_hf_client_cb_arr, 0, sizeof(tBTA_HF_CLIENT_CB_ARR));
// reset the handles and make the CBs non-allocated
for (int i = 0; i < HF_CLIENT_MAX_DEVICES; i++) {
// Allocate the handles in increasing order of indices
bta_hf_client_cb_init(&(bta_hf_client_cb_arr.cb[i]), i);
bta_hf_client_cb_arr.cb[i].handle = BTA_HF_CLIENT_CB_FIRST_HANDLE + i;
}
}
/*******************************************************************************
*
* Function bta_hf_client_cb_init
*
* Description Initialize an HF_Client service control block. Assign the
* handle to cb->handle.
*
*
*
* Returns void
*
******************************************************************************/
void bta_hf_client_cb_init(tBTA_HF_CLIENT_CB* client_cb, uint16_t handle) {
APPL_TRACE_DEBUG("%s", __func__);
// Free any memory we need to explicity release
alarm_free(client_cb->collision_timer);
// Memset the rest of the block
memset(client_cb, 0, sizeof(tBTA_HF_CLIENT_CB));
// Re allocate any variables required
client_cb->collision_timer = alarm_new("bta_hf_client.scb_collision_timer");
client_cb->handle = handle;
client_cb->sco_idx = BTM_INVALID_SCO_INDEX;
}
/*******************************************************************************
*
* Function bta_hf_client_resume_open
*
* Description Resume opening process.
*
*
* Returns void
*
******************************************************************************/
void bta_hf_client_resume_open(tBTA_HF_CLIENT_CB* client_cb) {
APPL_TRACE_DEBUG("%s", __func__);
/* resume opening process. */
if (client_cb->state == BTA_HF_CLIENT_INIT_ST) {
client_cb->state = BTA_HF_CLIENT_OPENING_ST;
tBTA_HF_CLIENT_DATA msg;
msg.hdr.layer_specific = client_cb->handle;
bta_hf_client_start_open(&msg);
}
}
/*******************************************************************************
*
* Function bta_hf_client_collision_timer_cback
*
* Description HF Client connection collision timer callback
*
*
* Returns void
*
******************************************************************************/
static void bta_hf_client_collision_timer_cback(void* data) {
APPL_TRACE_DEBUG("%s", __func__);
tBTA_HF_CLIENT_CB* client_cb = (tBTA_HF_CLIENT_CB*)data;
/* If the peer haven't opened connection, restart opening process */
bta_hf_client_resume_open(client_cb);
}
/*******************************************************************************
*
* Function bta_hf_client_collision_cback
*
* Description Get notified about collision.
*
*
* Returns void
*
******************************************************************************/
void bta_hf_client_collision_cback(UNUSED_ATTR tBTA_SYS_CONN_STATUS status,
uint8_t id, UNUSED_ATTR uint8_t app_id,
const RawAddress* peer_addr) {
tBTA_HF_CLIENT_CB* client_cb = bta_hf_client_find_cb_by_bda(*peer_addr);
if (client_cb != NULL && client_cb->state == BTA_HF_CLIENT_OPENING_ST) {
if (id == BTA_ID_SYS) /* ACL collision */
{
APPL_TRACE_WARNING("HF Client found collision (ACL) ...");
} else if (id == BTA_ID_HS) /* RFCOMM collision */
{
APPL_TRACE_WARNING("HF Client found collision (RFCOMM) ...");
} else {
APPL_TRACE_WARNING("HF Client found collision (\?\?\?) ...");
}
client_cb->state = BTA_HF_CLIENT_INIT_ST;
/* Cancel SDP if it had been started. */
if (client_cb->p_disc_db) {
(void)SDP_CancelServiceSearch(client_cb->p_disc_db);
bta_hf_client_free_db(NULL);
}
/* reopen registered server */
/* Collision may be detected before or after we close servers. */
// bta_hf_client_start_server();
/* Start timer to handle connection opening restart */
alarm_set_on_mloop(client_cb->collision_timer,
BTA_HF_CLIENT_COLLISION_TIMER_MS,
bta_hf_client_collision_timer_cback, (void*)client_cb);
}
}
/*******************************************************************************
*
* Function bta_hf_client_api_enable
*
* Description Handle an API enable event.
*
*
* Returns void
*
******************************************************************************/
tBTA_STATUS bta_hf_client_api_enable(tBTA_HF_CLIENT_CBACK* p_cback,
tBTA_SEC sec_mask,
tBTA_HF_CLIENT_FEAT features,
const char* p_service_name) {
/* If already registered then return error */
if (bta_sys_is_register(BTA_ID_HS)) {
APPL_TRACE_ERROR("BTA HF Client is already enabled, ignoring ...");
return BTA_FAILURE;
}
/* register with BTA system manager */
bta_sys_register(BTA_ID_HS, &bta_hf_client_reg);
/* reset the control blocks */
bta_hf_client_cb_arr_init();
bta_hf_client_cb_arr.p_cback = p_cback;
bta_hf_client_cb_arr.serv_sec_mask = sec_mask;
bta_hf_client_cb_arr.features = features;
/* create SDP records */
bta_hf_client_create_record(&bta_hf_client_cb_arr, p_service_name);
/* set same setting as AG does */
BTM_WriteVoiceSettings(AG_VOICE_SETTINGS);
bta_sys_collision_register(BTA_ID_HS, bta_hf_client_collision_cback);
/* Set the Audio service class bit */
tBTA_UTL_COD cod;
cod.service = BTM_COD_SERVICE_AUDIO;
utl_set_device_class(&cod, BTA_UTL_SET_COD_SERVICE_CLASS);
/* start RFCOMM server */
bta_hf_client_start_server();
return BTA_SUCCESS;
}
/*******************************************************************************
*
* Function bta_hf_client_find_cb_by_handle
*
* Description Finds the control block by handle provided
*
* handle: Handle as obtained from BTA_HfClientOpen call
*
*
* Returns Control block corresponding to the handle and NULL if
* none exists
*
******************************************************************************/
tBTA_HF_CLIENT_CB* bta_hf_client_find_cb_by_handle(uint16_t handle) {
// Handles are limited from 1 through HF_CLIENT_MAX_DEVICES
if (handle < 1 || handle > HF_CLIENT_MAX_DEVICES) {
APPL_TRACE_ERROR("%s: handle out of range (%d, %d) %d", __func__, 1,
HF_CLIENT_MAX_DEVICES, handle);
return NULL;
}
// Check if the associated index is allocated. Index is (handle - 1).
if (bta_hf_client_cb_arr.cb[handle - 1].is_allocated)
return &(bta_hf_client_cb_arr.cb[handle - 1]);
APPL_TRACE_ERROR("%s: block not found for handle %d", __func__, handle);
return NULL;
}
/*******************************************************************************
*
* Function bta_hf_client_find_cb_by_bda
*
* Description Finds the control block by handle provided
*
* bda: address of the device to find the handle for.
* Since there can only be one HF connection for a device
* we should always find a unique block
*
* Returns Control block corresponding to the address and NULL if
* none exists
*
******************************************************************************/
tBTA_HF_CLIENT_CB* bta_hf_client_find_cb_by_bda(const RawAddress& peer_addr) {
for (int i = 0; i < HF_CLIENT_MAX_DEVICES; i++) {
// Check if the associated index is allocated and that BD ADDR matches
tBTA_HF_CLIENT_CB* client_cb = &bta_hf_client_cb_arr.cb[i];
if (client_cb->is_allocated && peer_addr == client_cb->peer_addr) {
return client_cb;
} else {
APPL_TRACE_WARNING("%s: bdaddr mismatch for handle %d alloc %d", __func__,
i, client_cb->is_allocated);
}
}
APPL_TRACE_ERROR("%s: block not found", __func__);
return NULL;
}
/*******************************************************************************
*
* Function bta_hf_client_find_cb_by_rfc_handle
*
* Description Finds the control block by RFC handle provided.
*
* handle: RFC handle for the established connection
*
*
* Returns Control block corresponding to the handle and NULL if none
* exists
*
******************************************************************************/
tBTA_HF_CLIENT_CB* bta_hf_client_find_cb_by_rfc_handle(uint16_t handle) {
for (int i = 0; i < HF_CLIENT_MAX_DEVICES; i++) {
tBTA_HF_CLIENT_CB* client_cb = &bta_hf_client_cb_arr.cb[i];
bool is_allocated = client_cb->is_allocated;
uint16_t conn_handle = client_cb->conn_handle;
APPL_TRACE_DEBUG("%s: cb rfc_handle %d alloc %d conn_handle %d", __func__,
handle, is_allocated, conn_handle);
if (is_allocated && conn_handle == handle) {
return client_cb;
}
APPL_TRACE_WARNING("%s: no cb yet %d alloc %d conn_handle %d", __func__,
handle, is_allocated, conn_handle);
}
APPL_TRACE_ERROR("%s: no cb found for rfc handle %d", __func__, handle);
return NULL;
}
/*******************************************************************************
*
* Function bta_hf_client_find_cb_by_sco_handle
*
* Description Finds the control block by sco handle provided
*
* handle: sco handle
*
*
* Returns Control block corresponding to the sco handle and
* none if none exists
*
******************************************************************************/
tBTA_HF_CLIENT_CB* bta_hf_client_find_cb_by_sco_handle(uint16_t handle) {
for (int i = 0; i < HF_CLIENT_MAX_DEVICES; i++) {
tBTA_HF_CLIENT_CB* client_cb = &bta_hf_client_cb_arr.cb[i];
if (client_cb->is_allocated && client_cb->sco_idx == handle) {
return client_cb;
}
}
APPL_TRACE_ERROR("%s: block not found for handle %d", __func__, handle);
return NULL;
}
/*******************************************************************************
*
* Function bta_hf_client_allocate_handle
*
* Description Allocates a handle for the new BD ADDR that needs a new RF
* channel for HF connection. If the channel cannot be created
* for a reason then false is returned
*
* bd_addr: Address of the device for which this block is
* being created. Single device can only have one block.
* p_handle: OUT variable to store the outcome of allocate. If
* allocate failed then value is not valid
*
*
* Returns true if the creation of p_handle succeeded, false otherwise
*
******************************************************************************/
bool bta_hf_client_allocate_handle(const RawAddress& bd_addr,
uint16_t* p_handle) {
tBTA_HF_CLIENT_CB* existing_cb = bta_hf_client_find_cb_by_bda(bd_addr);
if (existing_cb != NULL) {
BTIF_TRACE_ERROR("%s: cannot allocate handle since BDADDR already exists",
__func__);
return false;
}
/* Check that we do not have a request to for same device in the control
* blocks */
for (int i = 0; i < HF_CLIENT_MAX_DEVICES; i++) {
tBTA_HF_CLIENT_CB* client_cb = &bta_hf_client_cb_arr.cb[i];
if (client_cb->is_allocated) {
APPL_TRACE_WARNING("%s: control block already used index %d", __func__,
i);
continue;
}
// Reset the client control block
bta_hf_client_cb_init(client_cb, client_cb->handle);
*p_handle = client_cb->handle;
APPL_TRACE_DEBUG("%s: marking CB handle %d to true", __func__,
client_cb->handle);
client_cb->is_allocated = true;
client_cb->peer_addr = bd_addr;
bta_hf_client_at_init(client_cb);
return true;
}
return false;
APPL_TRACE_ERROR("%s: all control blocks in use!", __func__);
}
/*******************************************************************************
*
* Function bta_hf_client_app_callback
*
* Description Calls the application callback
*
*
* Returns Void
*
******************************************************************************/
void bta_hf_client_app_callback(uint16_t event, tBTA_HF_CLIENT* data) {
if (bta_hf_client_cb_arr.p_cback != NULL) {
bta_hf_client_cb_arr.p_cback(event, data);
}
}
/*******************************************************************************
*
* Function bta_hf_client_api_disable
*
* Description Handle an API disable event.
*
*
* Returns void
*
******************************************************************************/
void bta_hf_client_api_disable() {
if (!bta_sys_is_register(BTA_ID_HS)) {
APPL_TRACE_WARNING("BTA HF Client is already disabled, ignoring ...");
return;
}
/* Remove the collision handler */
bta_sys_collision_register(BTA_ID_HS, NULL);
bta_hf_client_cb_arr.deregister = true;
/* remove sdp record */
bta_hf_client_del_record(&bta_hf_client_cb_arr);
/* remove rfcomm server */
bta_hf_client_close_server();
/* reinit the control block */
for (int i = 0; i < HF_CLIENT_MAX_DEVICES; i++) {
if (bta_hf_client_cb_arr.cb[i].is_allocated) {
bta_hf_client_cb_init(&(bta_hf_client_cb_arr.cb[i]), i);
}
}
/* De-register with BTA system manager */
bta_sys_deregister(BTA_ID_HS);
}
/*******************************************************************************
*
* Function bta_hf_client_hdl_event
*
* Description Data HF Client main event handling function.
*
*
* Returns bool
*
******************************************************************************/
bool bta_hf_client_hdl_event(BT_HDR* p_msg) {
APPL_TRACE_DEBUG("%s: %s (0x%x)", __func__,
bta_hf_client_evt_str(p_msg->event), p_msg->event);
bta_hf_client_sm_execute(p_msg->event, (tBTA_HF_CLIENT_DATA*)p_msg);
return true;
}
/*******************************************************************************
*
* Function bta_hf_client_sm_execute
*
* Description State machine event handling function for HF Client
*
*
* Returns void
*
******************************************************************************/
void bta_hf_client_sm_execute(uint16_t event, tBTA_HF_CLIENT_DATA* p_data) {
tBTA_HF_CLIENT_CB* client_cb =
bta_hf_client_find_cb_by_handle(p_data->hdr.layer_specific);
if (client_cb == NULL) {
APPL_TRACE_ERROR("%s: cb not found for handle %d", __func__,
p_data->hdr.layer_specific);
return;
}
tBTA_HF_CLIENT_ST_TBL state_table;
uint8_t action;
int i;
uint16_t in_event = event;
uint8_t in_state = client_cb->state;
/* Ignore displaying of AT results when not connected (Ignored in state
* machine) */
if (client_cb->state == BTA_HF_CLIENT_OPEN_ST) {
APPL_TRACE_EVENT("HF Client evt : State %d (%s), Event 0x%04x (%s)",
client_cb->state,
bta_hf_client_state_str(client_cb->state), event,
bta_hf_client_evt_str(event));
}
event &= 0x00FF;
if (event >= (BTA_HF_CLIENT_MAX_EVT & 0x00FF)) {
APPL_TRACE_ERROR("HF Client evt out of range, ignoring...");
return;
}
/* look up the state table for the current state */
state_table = bta_hf_client_st_tbl[client_cb->state];
/* set next state */
client_cb->state = state_table[event][BTA_HF_CLIENT_NEXT_STATE];
/* execute action functions */
for (i = 0; i < BTA_HF_CLIENT_ACTIONS; i++) {
action = state_table[event][i];
if (action != BTA_HF_CLIENT_IGNORE) {
(*bta_hf_client_action[action])(p_data);
} else {
break;
}
}
/* If the state has changed then notify the app of the corresponding change */
if (in_state != client_cb->state) {
VLOG(1) << __func__ << ": notifying state change to " << in_state << " -> "
<< client_cb->state << " device " << client_cb->peer_addr;
tBTA_HF_CLIENT evt;
memset(&evt, 0, sizeof(evt));
evt.bd_addr = client_cb->peer_addr;
if (client_cb->state == BTA_HF_CLIENT_INIT_ST) {
bta_hf_client_app_callback(BTA_HF_CLIENT_CLOSE_EVT, &evt);
} else if (client_cb->state == BTA_HF_CLIENT_OPEN_ST) {
evt.open.handle = client_cb->handle;
bta_hf_client_app_callback(BTA_HF_CLIENT_OPEN_EVT, &evt);
}
}
/* if the next state is INIT then release the cb for future use */
if (client_cb->state == BTA_HF_CLIENT_INIT_ST) {
APPL_TRACE_DEBUG("%s: marking CB handle %d to false", __func__,
client_cb->handle);
client_cb->is_allocated = false;
}
VLOG(2) << __func__ << ": device " << client_cb->peer_addr
<< "state change: [" << bta_hf_client_state_str(in_state) << "] -> ["
<< bta_hf_client_state_str(client_cb->state) << "] after Event ["
<< bta_hf_client_evt_str(in_event) << "]";
}
static void send_post_slc_cmd(tBTA_HF_CLIENT_CB* client_cb) {
client_cb->at_cb.current_cmd = BTA_HF_CLIENT_AT_NONE;
tBTA_HF_CLIENT_DATA p_data;
p_data.hdr.layer_specific = client_cb->handle;
bta_hf_client_sco_listen(&p_data);
bta_hf_client_send_at_bia(client_cb);
bta_hf_client_send_at_ccwa(client_cb, true);
bta_hf_client_send_at_cmee(client_cb, true);
bta_hf_client_send_at_cops(client_cb, false);
bta_hf_client_send_at_btrh(client_cb, true, 0);
bta_hf_client_send_at_clip(client_cb, true);
}
/*******************************************************************************
*
* Function bta_hf_client_slc_seq
*
* Description Handles AT commands sequence required for SLC creation
*
*
* Returns void
*
******************************************************************************/
void bta_hf_client_slc_seq(tBTA_HF_CLIENT_CB* client_cb, bool error) {
APPL_TRACE_DEBUG("bta_hf_client_slc_seq cmd: %u",
client_cb->at_cb.current_cmd);
if (error) {
/* SLC establishment error, sent close rfcomm event */
APPL_TRACE_ERROR(
"HFPClient: Failed to create SLC due to AT error, disconnecting (%u)",
client_cb->at_cb.current_cmd);
tBTA_HF_CLIENT_DATA msg;
msg.hdr.layer_specific = client_cb->handle;
bta_hf_client_sm_execute(BTA_HF_CLIENT_API_CLOSE_EVT, &msg);
return;
}
if (client_cb->svc_conn) {
APPL_TRACE_WARNING("%s: SLC already connected for CB handle %d", __func__,
client_cb->handle);
return;
}
switch (client_cb->at_cb.current_cmd) {
case BTA_HF_CLIENT_AT_NONE:
bta_hf_client_send_at_brsf(client_cb, bta_hf_client_cb_arr.features);
break;
case BTA_HF_CLIENT_AT_BRSF:
if ((bta_hf_client_cb_arr.features & BTA_HF_CLIENT_FEAT_CODEC) &&
(client_cb->peer_features & BTA_HF_CLIENT_PEER_CODEC)) {
bta_hf_client_send_at_bac(client_cb);
break;
}
bta_hf_client_send_at_cind(client_cb, false);
break;
case BTA_HF_CLIENT_AT_BAC:
bta_hf_client_send_at_cind(client_cb, false);
break;
case BTA_HF_CLIENT_AT_CIND:
bta_hf_client_send_at_cind(client_cb, true);
break;
case BTA_HF_CLIENT_AT_CIND_STATUS:
bta_hf_client_send_at_cmer(client_cb, true);
break;
case BTA_HF_CLIENT_AT_CMER:
if (client_cb->peer_features & BTA_HF_CLIENT_PEER_FEAT_3WAY &&
bta_hf_client_cb_arr.features & BTA_HF_CLIENT_FEAT_3WAY) {
bta_hf_client_send_at_chld(client_cb, '?', 0);
} else {
tBTA_HF_CLIENT_DATA msg;
msg.hdr.layer_specific = client_cb->handle;
bta_hf_client_svc_conn_open(&msg);
send_post_slc_cmd(client_cb);
}
break;
case BTA_HF_CLIENT_AT_CHLD: {
tBTA_HF_CLIENT_DATA msg;
msg.hdr.layer_specific = client_cb->handle;
bta_hf_client_svc_conn_open(&msg);
send_post_slc_cmd(client_cb);
break;
}
default: {
/* If happen there is a bug in SLC creation procedure... */
APPL_TRACE_ERROR(
"HFPClient: Failed to create SLCdue to unexpected AT command, "
"disconnecting (%u)",
client_cb->at_cb.current_cmd);
tBTA_HF_CLIENT_DATA msg;
msg.hdr.layer_specific = client_cb->handle;
bta_hf_client_sm_execute(BTA_HF_CLIENT_API_CLOSE_EVT, &msg);
break;
}
}
}
#ifndef CASE_RETURN_STR
#define CASE_RETURN_STR(const) \
case const: \
return #const;
#endif
static const char* bta_hf_client_evt_str(uint16_t event) {
switch (event) {
CASE_RETURN_STR(BTA_HF_CLIENT_API_OPEN_EVT)
CASE_RETURN_STR(BTA_HF_CLIENT_API_CLOSE_EVT)
CASE_RETURN_STR(BTA_HF_CLIENT_API_AUDIO_OPEN_EVT)
CASE_RETURN_STR(BTA_HF_CLIENT_API_AUDIO_CLOSE_EVT)
CASE_RETURN_STR(BTA_HF_CLIENT_RFC_OPEN_EVT)
CASE_RETURN_STR(BTA_HF_CLIENT_RFC_CLOSE_EVT)
CASE_RETURN_STR(BTA_HF_CLIENT_RFC_SRV_CLOSE_EVT)
CASE_RETURN_STR(BTA_HF_CLIENT_RFC_DATA_EVT)
CASE_RETURN_STR(BTA_HF_CLIENT_DISC_ACP_RES_EVT)
CASE_RETURN_STR(BTA_HF_CLIENT_DISC_INT_RES_EVT)
CASE_RETURN_STR(BTA_HF_CLIENT_DISC_OK_EVT)
CASE_RETURN_STR(BTA_HF_CLIENT_DISC_FAIL_EVT)
CASE_RETURN_STR(BTA_HF_CLIENT_API_ENABLE_EVT)
CASE_RETURN_STR(BTA_HF_CLIENT_API_DISABLE_EVT)
CASE_RETURN_STR(BTA_HF_CLIENT_SCO_OPEN_EVT)
CASE_RETURN_STR(BTA_HF_CLIENT_SCO_CLOSE_EVT)
CASE_RETURN_STR(BTA_HF_CLIENT_SEND_AT_CMD_EVT)
default:
return "Unknown HF Client Event";
}
}
static const char* bta_hf_client_state_str(uint8_t state) {
switch (state) {
CASE_RETURN_STR(BTA_HF_CLIENT_INIT_ST)
CASE_RETURN_STR(BTA_HF_CLIENT_OPENING_ST)
CASE_RETURN_STR(BTA_HF_CLIENT_OPEN_ST)
CASE_RETURN_STR(BTA_HF_CLIENT_CLOSING_ST)
default:
return "Unknown HF Client State";
}
}
void bta_hf_client_dump_statistics(int fd) {
dprintf(fd, "\nBluetooth HF Client BTA Statistics\n");
// We dump statistics for all control blocks
for (int i = 0; i < HF_CLIENT_MAX_DEVICES; i++) {
tBTA_HF_CLIENT_CB* client_cb = &bta_hf_client_cb_arr.cb[i];
if (!client_cb->is_allocated) {
// Skip the blocks which are not allocated
continue;
}
dprintf(fd, " Control block #%d\n", i + 1);
uint8_t* a = client_cb->peer_addr.address;
// Device name
dprintf(fd, " Peer Device: %02x:%02x:%02x:%02x:%02x:%02x\n", a[0], a[1],
a[2], a[3], a[4], a[5]);
// State machine state
dprintf(fd, " State Machine State: %s\n",
bta_hf_client_state_str(client_cb->state));
// Local RFC channelfor communication
dprintf(fd, " RFCOMM Channel (local) %d\n", client_cb->conn_handle);
// BTA Handle shared between BTA and client (ex BTIF)
dprintf(fd, " BTA Generated handle %d\n", client_cb->handle);
}
}