fuquan/allwinner_a64
1
1
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

upload android base code part6

Browse source
This commit is contained in:
August 2018-08-08 17:48:24 +08:00
parent 421e214c7d
commit 4e516ec6ed
35396 changed files with 9188716 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

2377
android/system/bt/bta/hl/bta_hl_act.cc Normal file
View file

File diff suppressed because it is too large Load diff

489
android/system/bt/bta/hl/bta_hl_api.cc Normal file
View file

@ -0,0 +1,489 @@
/******************************************************************************
*
* Copyright (C) 2009-2012 Broadcom Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
******************************************************************************/
/******************************************************************************
*
* This is the implementation of the API for the HeaLth device profile (HL)
* subsystem of BTA, Broadcom Corp's Bluetooth application layer for mobile
* phones.
*
******************************************************************************/
#include <string.h>
#include "bt_target.h"
#if (HL_INCLUDED == TRUE)
#include "bt_common.h"
#include "bta_hl_api.h"
#include "bta_hl_int.h"
/*****************************************************************************
* Constants
****************************************************************************/
static const tBTA_SYS_REG bta_hl_reg = {bta_hl_hdl_event, BTA_HlDisable};
/*******************************************************************************
*
* Function BTA_HlEnable
*
* Description Enable the HL subsystems. This function must be
* called before any other functions in the HL API are called.
* When the enable operation is completed the callback function
* will be called with an BTA_HL_CTRL_ENABLE_CFM_EVT event.
*
* Parameters p_cback - HL event call back function
*
* Returns void
*
******************************************************************************/
void BTA_HlEnable(tBTA_HL_CTRL_CBACK* p_ctrl_cback) {
tBTA_HL_API_ENABLE* p_buf =
(tBTA_HL_API_ENABLE*)osi_malloc(sizeof(tBTA_HL_API_ENABLE));
/* register with BTA system manager */
bta_sys_register(BTA_ID_HL, &bta_hl_reg);
p_buf->hdr.event = BTA_HL_API_ENABLE_EVT;
p_buf->p_cback = p_ctrl_cback;
bta_sys_sendmsg(p_buf);
}
/*******************************************************************************
*
* Function BTA_HlDisable
*
* Description Disable the HL subsystem.
*
* Returns void
*
******************************************************************************/
void BTA_HlDisable(void) {
BT_HDR* p_buf = (BT_HDR*)osi_malloc(sizeof(BT_HDR));
bta_sys_deregister(BTA_ID_HL);
p_buf->event = BTA_HL_API_DISABLE_EVT;
bta_sys_sendmsg(p_buf);
}
/*******************************************************************************
*
* Function BTA_HlUpdate
*
* Description Register an HDP application
*
* Parameters app_id - Application ID
* p_reg_param - non-platform related parameters for the
* HDP application
* p_cback - HL event callback fucntion
*
* Returns void
*
******************************************************************************/
void BTA_HlUpdate(uint8_t app_id, tBTA_HL_REG_PARAM* p_reg_param,
bool is_register, tBTA_HL_CBACK* p_cback) {
tBTA_HL_API_UPDATE* p_buf =
(tBTA_HL_API_UPDATE*)osi_malloc(sizeof(tBTA_HL_API_UPDATE));
APPL_TRACE_DEBUG("%s", __func__);
p_buf->hdr.event = BTA_HL_API_UPDATE_EVT;
p_buf->app_id = app_id;
p_buf->is_register = is_register;
if (is_register) {
p_buf->sec_mask =
(p_reg_param->sec_mask | BTA_SEC_AUTHENTICATE | BTA_SEC_ENCRYPT);
p_buf->p_cback = p_cback;
if (p_reg_param->p_srv_name)
strlcpy(p_buf->srv_name, p_reg_param->p_srv_name, BTA_SERVICE_NAME_LEN);
else
p_buf->srv_name[0] = 0;
if (p_reg_param->p_srv_desp)
strlcpy(p_buf->srv_desp, p_reg_param->p_srv_desp, BTA_SERVICE_DESP_LEN);
else
p_buf->srv_desp[0] = 0;
if (p_reg_param->p_provider_name)
strlcpy(p_buf->provider_name, p_reg_param->p_provider_name,
BTA_PROVIDER_NAME_LEN);
else
p_buf->provider_name[0] = 0;
}
bta_sys_sendmsg(p_buf);
}
/*******************************************************************************
*
* Function BTA_HlRegister
*
* Description Register an HDP application
*
* Parameters app_id - Application ID
* p_reg_param - non-platform related parameters for the
* HDP application
* p_cback - HL event callback fucntion
*
* Returns void
*
******************************************************************************/
void BTA_HlRegister(uint8_t app_id, tBTA_HL_REG_PARAM* p_reg_param,
tBTA_HL_CBACK* p_cback) {
tBTA_HL_API_REGISTER* p_buf =
(tBTA_HL_API_REGISTER*)osi_malloc(sizeof(tBTA_HL_API_REGISTER));
p_buf->hdr.event = BTA_HL_API_REGISTER_EVT;
p_buf->app_id = app_id;
p_buf->sec_mask =
(p_reg_param->sec_mask | BTA_SEC_AUTHENTICATE | BTA_SEC_ENCRYPT);
p_buf->p_cback = p_cback;
if (p_reg_param->p_srv_name)
strlcpy(p_buf->srv_name, p_reg_param->p_srv_name, BTA_SERVICE_NAME_LEN);
else
p_buf->srv_name[0] = 0;
if (p_reg_param->p_srv_desp)
strlcpy(p_buf->srv_desp, p_reg_param->p_srv_desp, BTA_SERVICE_DESP_LEN);
else
p_buf->srv_desp[0] = 0;
if (p_reg_param->p_provider_name)
strlcpy(p_buf->provider_name, p_reg_param->p_provider_name,
BTA_PROVIDER_NAME_LEN);
else
p_buf->provider_name[0] = 0;
bta_sys_sendmsg(p_buf);
}
/*******************************************************************************
*
* Function BTA_HlDeregister
*
* Description Deregister an HDP application
*
* Parameters app_handle - Application handle
*
* Returns void
*
******************************************************************************/
void BTA_HlDeregister(uint8_t app_id, tBTA_HL_APP_HANDLE app_handle) {
tBTA_HL_API_DEREGISTER* p_buf =
(tBTA_HL_API_DEREGISTER*)osi_malloc(sizeof(tBTA_HL_API_DEREGISTER));
p_buf->hdr.event = BTA_HL_API_DEREGISTER_EVT;
p_buf->app_id = app_id;
p_buf->app_handle = app_handle;
bta_sys_sendmsg(p_buf);
}
/*******************************************************************************
*
* Function BTA_HlCchOpen
*
* Description Open a Control channel connection with the specified BD
* address
*
* Parameters app_handle - Application Handle
* p_open_param - parameters for opening a control channel
*
* Returns void
*
* Note: The control PSM value is used to select which
* HDP insatnce should be used in case the peer device support
* multiple HDP instances. Also, if the control PSM value is
* zero then the first HDP instance is used for the control
* channel setup
******************************************************************************/
void BTA_HlCchOpen(uint8_t app_id, tBTA_HL_APP_HANDLE app_handle,
tBTA_HL_CCH_OPEN_PARAM* p_open_param) {
tBTA_HL_API_CCH_OPEN* p_buf =
(tBTA_HL_API_CCH_OPEN*)osi_malloc(sizeof(tBTA_HL_API_CCH_OPEN));
p_buf->hdr.event = BTA_HL_API_CCH_OPEN_EVT;
p_buf->app_id = app_id;
p_buf->app_handle = app_handle;
p_buf->sec_mask =
(p_open_param->sec_mask | BTA_SEC_AUTHENTICATE | BTA_SEC_ENCRYPT);
p_buf->bd_addr = p_open_param->bd_addr;
p_buf->ctrl_psm = p_open_param->ctrl_psm;
bta_sys_sendmsg(p_buf);
}
/*******************************************************************************
*
* Function BTA_HlCchClose
*
* Description Close a Control channel connection with the specified MCL
* handle
*
* Parameters mcl_handle - MCL handle
*
* Returns void
*
******************************************************************************/
void BTA_HlCchClose(tBTA_HL_MCL_HANDLE mcl_handle) {
tBTA_HL_API_CCH_CLOSE* p_buf =
(tBTA_HL_API_CCH_CLOSE*)osi_malloc(sizeof(tBTA_HL_API_CCH_CLOSE));
p_buf->hdr.event = BTA_HL_API_CCH_CLOSE_EVT;
p_buf->mcl_handle = mcl_handle;
bta_sys_sendmsg(p_buf);
}
/*******************************************************************************
*
* Function BTA_HlDchOpen
*
* Description Open a data channel connection with the specified DCH
* parameters
*
* Parameters mcl_handle - MCL handle
* p_open_param - parameters for opening a data channel
*
* Returns void
*
******************************************************************************/
void BTA_HlDchOpen(tBTA_HL_MCL_HANDLE mcl_handle,
tBTA_HL_DCH_OPEN_PARAM* p_open_param) {
tBTA_HL_API_DCH_OPEN* p_buf =
(tBTA_HL_API_DCH_OPEN*)osi_malloc(sizeof(tBTA_HL_API_DCH_OPEN));
p_buf->hdr.event = BTA_HL_API_DCH_OPEN_EVT;
p_buf->mcl_handle = mcl_handle;
p_buf->ctrl_psm = p_open_param->ctrl_psm;
p_buf->local_mdep_id = p_open_param->local_mdep_id;
p_buf->peer_mdep_id = p_open_param->peer_mdep_id;
p_buf->local_cfg = p_open_param->local_cfg;
p_buf->sec_mask =
(p_open_param->sec_mask | BTA_SEC_AUTHENTICATE | BTA_SEC_ENCRYPT);
bta_sys_sendmsg(p_buf);
}
/*******************************************************************************
*
* Function BTA_HlDchReconnect
*
* Description Reconnect a data channel with the specified MDL_ID
*
* Parameters mcl_handle - MCL handle
*8 p_recon_param - parameters for reconnecting a data channel
*
* Returns void
*
******************************************************************************/
void BTA_HlDchReconnect(tBTA_HL_MCL_HANDLE mcl_handle,
tBTA_HL_DCH_RECONNECT_PARAM* p_recon_param) {
tBTA_HL_API_DCH_RECONNECT* p_buf =
(tBTA_HL_API_DCH_RECONNECT*)osi_malloc(sizeof(tBTA_HL_API_DCH_RECONNECT));
p_buf->hdr.event = BTA_HL_API_DCH_RECONNECT_EVT;
p_buf->mcl_handle = mcl_handle;
p_buf->ctrl_psm = p_recon_param->ctrl_psm;
p_buf->mdl_id = p_recon_param->mdl_id;
bta_sys_sendmsg(p_buf);
}
/*******************************************************************************
*
* Function BTA_HlDchClose
*
* Description Close a data channel with the specified MDL handle
*
* Parameters mdl_handle - MDL handle
*
* Returns void
*
******************************************************************************/
void BTA_HlDchClose(tBTA_HL_MDL_HANDLE mdl_handle) {
tBTA_HL_API_DCH_CLOSE* p_buf =
(tBTA_HL_API_DCH_CLOSE*)osi_malloc(sizeof(tBTA_HL_API_DCH_CLOSE));
p_buf->hdr.event = BTA_HL_API_DCH_CLOSE_EVT;
p_buf->mdl_handle = mdl_handle;
bta_sys_sendmsg(p_buf);
}
/*******************************************************************************
*
* Function BTA_HlDchAbort
*
* Description Abort the current data channel setup with the specified MCL
* handle
*
* Parameters mcl_handle - MCL handle
*
*
* Returns void
*
******************************************************************************/
void BTA_HlDchAbort(tBTA_HL_MCL_HANDLE mcl_handle) {
tBTA_HL_API_DCH_ABORT* p_buf =
(tBTA_HL_API_DCH_ABORT*)osi_malloc(sizeof(tBTA_HL_API_DCH_ABORT));
p_buf->hdr.event = BTA_HL_API_DCH_ABORT_EVT;
p_buf->mcl_handle = mcl_handle;
bta_sys_sendmsg(p_buf);
}
/*******************************************************************************
*
* Function BTA_HlSendData
*
* Description Send an APDU to the peer device
*
* Parameters mdl_handle - MDL handle
* pkt_size - size of the data packet to be sent
*
* Returns void
*
******************************************************************************/
void BTA_HlSendData(tBTA_HL_MDL_HANDLE mdl_handle, uint16_t pkt_size) {
tBTA_HL_API_SEND_DATA* p_buf =
(tBTA_HL_API_SEND_DATA*)osi_malloc(sizeof(tBTA_HL_API_SEND_DATA));
p_buf->hdr.event = BTA_HL_API_SEND_DATA_EVT;
p_buf->mdl_handle = mdl_handle;
p_buf->pkt_size = pkt_size;
bta_sys_sendmsg(p_buf);
}
/*******************************************************************************
*
* Function BTA_HlDeleteMdl
*
* Description Delete the specified MDL_ID within the specified MCL handle
*
* Parameters mcl_handle - MCL handle
* mdl_id - MDL ID
*
* Returns void
*
* note: If mdl_id = 0xFFFF then this means to delete all MDLs
* and this value can only be used with DeleteMdl request
* only not other requests
*
******************************************************************************/
void BTA_HlDeleteMdl(tBTA_HL_MCL_HANDLE mcl_handle, tBTA_HL_MDL_ID mdl_id) {
tBTA_HL_API_DELETE_MDL* p_buf =
(tBTA_HL_API_DELETE_MDL*)osi_malloc(sizeof(tBTA_HL_API_DELETE_MDL));
p_buf->hdr.event = BTA_HL_API_DELETE_MDL_EVT;
p_buf->mcl_handle = mcl_handle;
p_buf->mdl_id = mdl_id;
bta_sys_sendmsg(p_buf);
}
/*******************************************************************************
*
* Function BTA_HlDchEchoTest
*
* Description Initiate an echo test with the specified MCL handle
*
* Parameters mcl_handle - MCL handle
*8 p_echo_test_param - parameters for echo testing
*
* Returns void
*
******************************************************************************/
void BTA_HlDchEchoTest(tBTA_HL_MCL_HANDLE mcl_handle,
tBTA_HL_DCH_ECHO_TEST_PARAM* p_echo_test_param) {
tBTA_HL_API_DCH_ECHO_TEST* p_buf =
(tBTA_HL_API_DCH_ECHO_TEST*)osi_malloc(sizeof(tBTA_HL_API_DCH_ECHO_TEST));
p_buf->hdr.event = BTA_HL_API_DCH_ECHO_TEST_EVT;
p_buf->mcl_handle = mcl_handle;
p_buf->ctrl_psm = p_echo_test_param->ctrl_psm;
p_buf->local_cfg = p_echo_test_param->local_cfg;
p_buf->pkt_size = p_echo_test_param->pkt_size;
bta_sys_sendmsg(p_buf);
}
/*******************************************************************************
*
* Function BTA_HlSdpQuery
*
* Description SDP query request for the specified BD address
*
* Parameters app_handle - application handle
* bd_addr - BD address
*
* Returns void
*
******************************************************************************/
void BTA_HlSdpQuery(uint8_t app_id, tBTA_HL_APP_HANDLE app_handle,
const RawAddress& bd_addr) {
tBTA_HL_API_SDP_QUERY* p_buf =
(tBTA_HL_API_SDP_QUERY*)osi_malloc(sizeof(tBTA_HL_API_SDP_QUERY));
p_buf->hdr.event = BTA_HL_API_SDP_QUERY_EVT;
p_buf->app_id = app_id;
p_buf->app_handle = app_handle;
p_buf->bd_addr = bd_addr;
bta_sys_sendmsg(p_buf);
}
/*******************************************************************************
*
* Function BTA_HlDchCreateMdlRsp
*
* Description Set the Response and configuration values for the Create MDL
* request
*
* Parameters mcl_handle - MCL handle
* p_rsp_param - parameters specified whether the request
* should be accepted or not and if it should be
* accepted, then it also specified the
* configuration response value
*
* Returns void
*
******************************************************************************/
void BTA_HlDchCreateRsp(tBTA_HL_MCL_HANDLE mcl_handle,
tBTA_HL_DCH_CREATE_RSP_PARAM* p_rsp_param) {
tBTA_HL_API_DCH_CREATE_RSP* p_buf = (tBTA_HL_API_DCH_CREATE_RSP*)osi_malloc(
sizeof(tBTA_HL_API_DCH_CREATE_RSP));
p_buf->hdr.event = BTA_HL_API_DCH_CREATE_RSP_EVT;
p_buf->mcl_handle = mcl_handle;
p_buf->mdl_id = p_rsp_param->mdl_id;
p_buf->local_mdep_id = p_rsp_param->local_mdep_id;
p_buf->rsp_code = p_rsp_param->rsp_code;
p_buf->cfg_rsp = p_rsp_param->cfg_rsp;
bta_sys_sendmsg(p_buf);
}
#endif /* HL_INCLUDED */

162
android/system/bt/bta/hl/bta_hl_ci.cc Normal file
View file

@ -0,0 +1,162 @@
/******************************************************************************
*
* Copyright (C) 2009-2012 Broadcom Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
******************************************************************************/
/******************************************************************************
*
* This is the implementation file for the HeaLth device profile (HL)
* subsystem call-in functions.
*
******************************************************************************/
#include <stddef.h>
#include "bta_api.h"
#include "bta_hl_api.h"
#include "bta_hl_ci.h"
#include "bta_hl_co.h"
#include "bta_hl_int.h"
#include "bta_sys.h"
#include "btm_api.h"
/*******************************************************************************
*
* Function bta_hl_ci_get_tx_data
*
* Description This function is called in response to the
* bta_hl_co_get_tx_data call-out function.
*
* Parameters mdl_handle -MDL handle
* status - BTA_MA_STATUS_OK if operation is successful
* BTA_MA_STATUS_FAIL if any errors have occurred.
* evt - evt from the call-out function
*
* Returns void
*
******************************************************************************/
void bta_hl_ci_get_tx_data(tBTA_HL_MDL_HANDLE mdl_handle, tBTA_HL_STATUS status,
uint16_t evt) {
tBTA_HL_CI_GET_PUT_DATA* p_evt =
(tBTA_HL_CI_GET_PUT_DATA*)osi_malloc(sizeof(tBTA_HL_CI_GET_PUT_DATA));
#if (BTA_HL_DEBUG == TRUE)
APPL_TRACE_DEBUG("%s mdl_handle=%d status=%d evt=%d\n", __func__, mdl_handle,
status, evt);
#endif
p_evt->hdr.event = evt;
p_evt->mdl_handle = mdl_handle;
p_evt->status = status;
bta_sys_sendmsg(p_evt);
}
/*******************************************************************************
*
* Function bta_hl_ci_put_rx_data
*
* Description This function is called in response to the
* bta_hl_co_put_rx_data call-out function.
*
* Parameters mdl_handle -MDL handle
* status - BTA_MA_STATUS_OK if operation is successful
* BTA_MA_STATUS_FAIL if any errors have occurred.
* evt - evt from the call-out function
*
* Returns void
*
******************************************************************************/
extern void bta_hl_ci_put_rx_data(tBTA_HL_MDL_HANDLE mdl_handle,
tBTA_HL_STATUS status, uint16_t evt) {
tBTA_HL_CI_GET_PUT_DATA* p_evt =
(tBTA_HL_CI_GET_PUT_DATA*)osi_malloc(sizeof(tBTA_HL_CI_GET_PUT_DATA));
#if (BTA_HL_DEBUG == TRUE)
APPL_TRACE_DEBUG("%s mdl_handle=%d status=%d evt=%d\n", __func__, mdl_handle,
status, evt);
#endif
p_evt->hdr.event = evt;
p_evt->mdl_handle = mdl_handle;
p_evt->status = status;
bta_sys_sendmsg(p_evt);
}
/*******************************************************************************
*
* Function bta_hl_ci_get_echo_data
*
* Description This function is called in response to the
* bta_hl_co_get_echo_data call-out function.
*
* Parameters mcl_handle -MCL handle
* status - BTA_MA_STATUS_OK if operation is successful
* BTA_MA_STATUS_FAIL if any errors have occurred.
* evt - evt from the call-out function
*
* Returns void
*
******************************************************************************/
extern void bta_hl_ci_get_echo_data(tBTA_HL_MCL_HANDLE mcl_handle,
tBTA_HL_STATUS status, uint16_t evt) {
tBTA_HL_CI_ECHO_DATA* p_evt =
(tBTA_HL_CI_ECHO_DATA*)osi_malloc(sizeof(tBTA_HL_CI_ECHO_DATA));
#if (BTA_HL_DEBUG == TRUE)
APPL_TRACE_DEBUG("%s mcl_handle=%d status=%d evt=%d\n", __func__, mcl_handle,
status, evt);
#endif
p_evt->hdr.event = evt;
p_evt->mcl_handle = mcl_handle;
p_evt->status = status;
bta_sys_sendmsg(p_evt);
}
/*******************************************************************************
*
* Function bta_hl_ci_put_echo_data
*
* Description This function is called in response to the
* bta_hl_co_put_echo_data call-out function.
*
* Parameters mcl_handle -MCL handle
* status - BTA_MA_STATUS_OK if operation is successful
* BTA_MA_STATUS_FAIL if any errors have occurred.
* evt - evt from the call-out function
*
* Returns void
*
******************************************************************************/
extern void bta_hl_ci_put_echo_data(tBTA_HL_MCL_HANDLE mcl_handle,
tBTA_HL_STATUS status, uint16_t evt) {
tBTA_HL_CI_ECHO_DATA* p_evt =
(tBTA_HL_CI_ECHO_DATA*)osi_malloc(sizeof(tBTA_HL_CI_ECHO_DATA));
#if (BTA_HL_DEBUG == TRUE)
APPL_TRACE_DEBUG("%s mcl_handle=%d status=%d evt=%d\n", __func__, mcl_handle,
status, evt);
#endif
p_evt->hdr.event = evt;
p_evt->mcl_handle = mcl_handle;
p_evt->status = status;
bta_sys_sendmsg(p_evt);
}

856
android/system/bt/bta/hl/bta_hl_int.h Normal file
View file

@ -0,0 +1,856 @@
/******************************************************************************
*
* Copyright (C) 1998-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.
*
******************************************************************************/
/******************************************************************************
*
* This is the private file for the message access equipment (MSE)
* subsystem.
*
******************************************************************************/
#ifndef BTA_HL_INT_H
#define BTA_HL_INT_H
#include "bt_target.h"
#include "bta_hl_api.h"
#include "bta_hl_co.h"
#include "bta_sys.h"
#include "l2cdefs.h"
typedef uint16_t(tBTA_HL_ALLOCATE_PSM)(void);
/*****************************************************************************
* Constants and data types
****************************************************************************/
#ifndef BTA_HL_DISC_SIZE
#define BTA_HL_DISC_SIZE 1600
#endif
#define BTA_HL_NUM_SRCH_ATTR 10
#define BTA_HL_MIN_SDP_MDEP_LEN 7
/* L2CAP defualt parameters */
#define BTA_HL_L2C_TX_WIN_SIZE 10
#define BTA_HL_L2C_MAX_TRANSMIT 32
#define BTA_HL_L2C_RTRANS_TOUT 2000
#define BTA_HL_L2C_MON_TOUT 12000
#define BTA_HL_L2C_MPS 1017
/* L2CAP FCS setting*/
#define BTA_HL_MCA_USE_FCS MCA_FCS_USE
#define BTA_HL_MCA_NO_FCS MCA_FCS_BYPASS
#define BTA_HL_L2C_USE_FCS 1
#define BTA_HL_L2C_NO_FCS 0
#define BTA_HL_DEFAULT_SOURCE_FCS BTA_HL_L2C_USE_FCS
#define BTA_HL_MCA_FCS_USE_MASK MCA_FCS_USE_MASK
/* SDP Operations */
#define BTA_HL_SDP_OP_NONE 0
#define BTA_HL_SDP_OP_CCH_INIT 1
#define BTA_HL_SDP_OP_DCH_OPEN_INIT 2
#define BTA_HL_SDP_OP_DCH_RECONNECT_INIT 3
#define BTA_HL_SDP_OP_SDP_QUERY_NEW 4
#define BTA_HL_SDP_OP_SDP_QUERY_CURRENT 5
typedef uint8_t tBTA_HL_SDP_OPER;
/* CCH Operations */
#define BTA_HL_CCH_OP_NONE 0
#define BTA_HL_CCH_OP_LOCAL_OPEN 1
#define BTA_HL_CCH_OP_REMOTE_OPEN 2
#define BTA_HL_CCH_OP_LOCAL_CLOSE 3
#define BTA_HL_CCH_OP_REMOTE_CLOSE 4
typedef uint8_t tBTA_HL_CCH_OPER;
/* Pending DCH close operations when closing a CCH */
#define BTA_HL_CCH_CLOSE_OP_DCH_NONE 0
#define BTA_HL_CCH_CLOSE_OP_DCH_ABORT 1
#define BTA_HL_CCH_CLOSE_OP_DCH_CLOSE 2
typedef uint8_t tBTA_HL_CCH_CLOSE_DCH_OPER;
/* DCH Operations */
#define BTA_HL_DCH_OP_NONE 0
#define BTA_HL_DCH_OP_REMOTE_CREATE 1
#define BTA_HL_DCH_OP_LOCAL_OPEN 2
#define BTA_HL_DCH_OP_REMOTE_OPEN 3
#define BTA_HL_DCH_OP_LOCAL_CLOSE 4
#define BTA_HL_DCH_OP_REMOTE_CLOSE 5
#define BTA_HL_DCH_OP_LOCAL_DELETE 6
#define BTA_HL_DCH_OP_REMOTE_DELETE 7
#define BTA_HL_DCH_OP_LOCAL_RECONNECT 8
#define BTA_HL_DCH_OP_REMOTE_RECONNECT 9
#define BTA_HL_DCH_OP_LOCAL_CLOSE_ECHO_TEST 10
#define BTA_HL_DCH_OP_LOCAL_CLOSE_RECONNECT 11
typedef uint8_t tBTA_HL_DCH_OPER;
/* Echo test Operations */
#define BTA_HL_ECHO_OP_NONE 0
#define BTA_HL_ECHO_OP_CI_GET_ECHO_DATA 1
#define BTA_HL_ECHO_OP_SDP_INIT 2
#define BTA_HL_ECHO_OP_MDL_CREATE_CFM 3
#define BTA_HL_ECHO_OP_DCH_OPEN_CFM 4
#define BTA_HL_ECHO_OP_LOOP_BACK 5
#define BTA_HL_ECHO_OP_CI_PUT_ECHO_DATA 6
#define BTA_HL_ECHO_OP_DCH_CLOSE_CFM 7
#define BTA_HL_ECHO_OP_OPEN_IND 8
#define BTA_HL_ECHO_OP_ECHO_PKT 9
typedef uint8_t tBTA_HL_ECHO_OPER;
/* abort status mask for abort_oper */
#define BTA_HL_ABORT_NONE_MASK 0x00
#define BTA_HL_ABORT_PENDING_MASK 0x01
#define BTA_HL_ABORT_LOCAL_MASK 0x10
#define BTA_HL_ABORT_REMOTE_MASK 0x20
#define BTA_HL_ABORT_CCH_CLOSE_MASK 0x40
/* call out mask for cout_oper */
#define BTA_HL_CO_NONE_MASK 0x00
#define BTA_HL_CO_GET_TX_DATA_MASK 0x01
#define BTA_HL_CO_PUT_RX_DATA_MASK 0x02
#define BTA_HL_CO_GET_ECHO_DATA_MASK 0x04
#define BTA_HL_CO_PUT_ECHO_DATA_MASK 0x08
typedef struct {
uint16_t mtu;
uint8_t fcs; /* '0' No FCS, otherwise '1' */
} tBTA_HL_L2CAP_CFG_INFO;
/* State Machine Events */
enum {
/* these events are handled by the state machine */
BTA_HL_CCH_OPEN_EVT = BTA_SYS_EVT_START(BTA_ID_HL),
BTA_HL_CCH_SDP_OK_EVT,
BTA_HL_CCH_SDP_FAIL_EVT,
BTA_HL_MCA_CONNECT_IND_EVT,
BTA_HL_MCA_DISCONNECT_IND_EVT,
BTA_HL_CCH_CLOSE_EVT,
BTA_HL_CCH_CLOSE_CMPL_EVT,
BTA_HL_MCA_RSP_TOUT_IND_EVT,
/* DCH EVENT */
BTA_HL_DCH_SDP_INIT_EVT,
BTA_HL_DCH_OPEN_EVT,
BTA_HL_MCA_CREATE_IND_EVT,
BTA_HL_MCA_CREATE_CFM_EVT,
BTA_HL_MCA_OPEN_IND_EVT,
BTA_HL_MCA_OPEN_CFM_EVT,
BTA_HL_DCH_CLOSE_EVT,
BTA_HL_MCA_CLOSE_IND_EVT,
BTA_HL_MCA_CLOSE_CFM_EVT,
BTA_HL_API_SEND_DATA_EVT,
BTA_HL_MCA_RCV_DATA_EVT,
BTA_HL_DCH_CLOSE_CMPL_EVT,
BTA_HL_DCH_RECONNECT_EVT,
BTA_HL_DCH_SDP_FAIL_EVT,
BTA_HL_MCA_RECONNECT_IND_EVT,
BTA_HL_MCA_RECONNECT_CFM_EVT,
BTA_HL_DCH_CLOSE_ECHO_TEST_EVT,
BTA_HL_API_DCH_CREATE_RSP_EVT,
BTA_HL_DCH_ABORT_EVT,
BTA_HL_MCA_ABORT_IND_EVT,
BTA_HL_MCA_ABORT_CFM_EVT,
BTA_HL_MCA_CONG_CHG_EVT,
BTA_HL_CI_GET_TX_DATA_EVT,
BTA_HL_CI_PUT_RX_DATA_EVT,
BTA_HL_CI_GET_ECHO_DATA_EVT,
BTA_HL_DCH_ECHO_TEST_EVT,
BTA_HL_CI_PUT_ECHO_DATA_EVT,
/* these events are handled outside the state machine */
BTA_HL_API_ENABLE_EVT,
BTA_HL_API_DISABLE_EVT,
BTA_HL_API_UPDATE_EVT,
BTA_HL_API_REGISTER_EVT,
BTA_HL_API_DEREGISTER_EVT,
BTA_HL_API_CCH_OPEN_EVT,
BTA_HL_API_CCH_CLOSE_EVT,
BTA_HL_API_DCH_OPEN_EVT,
BTA_HL_API_DCH_RECONNECT_EVT,
BTA_HL_API_DCH_CLOSE_EVT,
BTA_HL_API_DELETE_MDL_EVT,
BTA_HL_API_DCH_ABORT_EVT,
BTA_HL_API_DCH_ECHO_TEST_EVT,
BTA_HL_API_SDP_QUERY_EVT,
BTA_HL_SDP_QUERY_OK_EVT,
BTA_HL_SDP_QUERY_FAIL_EVT,
BTA_HL_MCA_DELETE_IND_EVT,
BTA_HL_MCA_DELETE_CFM_EVT
};
typedef uint16_t tBTA_HL_INT_EVT;
#define BTA_HL_DCH_EVT_MIN BTA_HL_DCH_SDP_INIT_EVT
#define BTA_HL_DCH_EVT_MAX 0xFFFF
/* state machine states */
enum {
BTA_HL_CCH_IDLE_ST = 0, /* Idle */
BTA_HL_CCH_OPENING_ST, /* Opening a connection*/
BTA_HL_CCH_OPEN_ST, /* Connection is open */
BTA_HL_CCH_CLOSING_ST /* Closing is in progress */
};
typedef uint8_t tBTA_HL_CCH_STATE;
enum {
BTA_HL_DCH_IDLE_ST = 0, /* Idle */
BTA_HL_DCH_OPENING_ST, /* Opening a connection*/
BTA_HL_DCH_OPEN_ST, /* Connection is open */
BTA_HL_DCH_CLOSING_ST /* Closing is in progress */
};
typedef uint8_t tBTA_HL_DCH_STATE;
typedef struct {
BT_HDR hdr;
tBTA_HL_CTRL_CBACK* p_cback; /* pointer to control callback function */
} tBTA_HL_API_ENABLE;
typedef struct {
BT_HDR hdr;
uint8_t app_id;
bool is_register; /* Update HL application due to register or deregister */
tBTA_HL_CBACK* p_cback; /* pointer to application callback function */
tBTA_HL_DEVICE_TYPE dev_type; /* sink, source or dual roles */
tBTA_SEC sec_mask; /* security mask for accepting conenction*/
char srv_name[BTA_SERVICE_NAME_LEN +
1]; /* service name to be used in the SDP; null terminated*/
char srv_desp[BTA_SERVICE_DESP_LEN + 1]; /* service description to be used in
the SDP; null terminated */
char provider_name[BTA_PROVIDER_NAME_LEN + 1]; /* provide name to be used in
the SDP; null terminated */
} tBTA_HL_API_UPDATE;
typedef struct {
BT_HDR hdr;
uint8_t app_id;
tBTA_HL_CBACK* p_cback; /* pointer to application callback function */
tBTA_HL_DEVICE_TYPE dev_type; /* sink, source or dual roles */
tBTA_SEC sec_mask; /* security mask for accepting conenction*/
char srv_name[BTA_SERVICE_NAME_LEN +
1]; /* service name to be used in the SDP; null terminated*/
char srv_desp[BTA_SERVICE_DESP_LEN + 1]; /* service description to be used in
the SDP; null terminated */
char provider_name[BTA_PROVIDER_NAME_LEN + 1]; /* provide name to be used in
the SDP; null terminated */
} tBTA_HL_API_REGISTER;
typedef struct {
BT_HDR hdr;
uint8_t app_id;
tBTA_HL_CBACK* p_cback; /* pointer to application callback function */
tBTA_HL_APP_HANDLE app_handle;
} tBTA_HL_API_DEREGISTER;
typedef struct {
BT_HDR hdr;
uint8_t app_id;
tBTA_HL_APP_HANDLE app_handle;
uint16_t ctrl_psm;
RawAddress bd_addr; /* Address of peer device */
tBTA_SEC sec_mask; /* security mask for initiating connection*/
} tBTA_HL_API_CCH_OPEN;
typedef struct {
BT_HDR hdr;
tBTA_HL_MCL_HANDLE mcl_handle;
} tBTA_HL_API_CCH_CLOSE;
typedef struct {
BT_HDR hdr;
tBTA_HL_MCL_HANDLE mcl_handle;
uint16_t ctrl_psm;
tBTA_HL_MDEP_ID local_mdep_id; /* local MDEP ID */
tBTA_HL_MDEP_ID peer_mdep_id; /* peer mdep id */
tBTA_HL_DCH_CFG local_cfg;
tBTA_SEC sec_mask; /* security mask for initiating connection*/
} tBTA_HL_API_DCH_OPEN;
typedef struct {
BT_HDR hdr;
tBTA_HL_MCL_HANDLE mcl_handle;
uint16_t ctrl_psm;
tBTA_HL_MDL_ID mdl_id;
} tBTA_HL_API_DCH_RECONNECT;
typedef struct {
BT_HDR hdr;
tBTA_HL_MDL_HANDLE mdl_handle;
} tBTA_HL_API_DCH_CLOSE;
typedef struct {
BT_HDR hdr;
tBTA_HL_MCL_HANDLE mcl_handle;
tBTA_HL_MDL_ID mdl_id;
} tBTA_HL_API_DELETE_MDL;
typedef struct {
BT_HDR hdr;
tBTA_HL_MCL_HANDLE mcl_handle;
} tBTA_HL_API_DCH_ABORT;
typedef struct {
BT_HDR hdr;
tBTA_HL_MDL_HANDLE mdl_handle;
uint16_t pkt_size;
} tBTA_HL_API_SEND_DATA;
typedef struct {
BT_HDR hdr;
tBTA_HL_MCL_HANDLE mcl_handle;
uint16_t ctrl_psm;
uint16_t pkt_size;
tBTA_HL_DCH_CFG local_cfg;
} tBTA_HL_API_DCH_ECHO_TEST;
typedef struct {
BT_HDR hdr;
uint8_t app_idx;
uint8_t mcl_idx;
bool release_mcl_cb;
} tBTA_HL_CCH_SDP;
/* MCA callback event parameters. */
typedef struct {
BT_HDR hdr;
tBTA_HL_APP_HANDLE app_handle;
tBTA_HL_MCL_HANDLE mcl_handle;
tMCA_CTRL mca_data;
} tBTA_HL_MCA_EVT;
/* MCA callback event parameters. */
typedef struct {
BT_HDR hdr;
uint8_t app_idx;
uint8_t mcl_idx;
uint8_t mdl_idx;
BT_HDR* p_pkt;
} tBTA_HL_MCA_RCV_DATA_EVT;
typedef struct {
BT_HDR hdr;
uint8_t app_idx;
uint8_t mcl_idx;
uint8_t mdl_idx;
} tBTA_HL_DCH_SDP;
typedef struct {
BT_HDR hdr;
tBTA_HL_APP_HANDLE app_handle;
uint8_t app_id;
RawAddress bd_addr; /* Address of peer device */
} tBTA_HL_API_SDP_QUERY;
typedef struct {
BT_HDR hdr;
tBTA_HL_MCL_HANDLE mcl_handle;
tBTA_HL_MDL_ID mdl_id;
tBTA_HL_MDEP_ID local_mdep_id;
tBTA_HL_DCH_CREATE_RSP rsp_code;
tBTA_HL_DCH_CFG cfg_rsp;
} tBTA_HL_API_DCH_CREATE_RSP;
typedef struct {
BT_HDR hdr;
tBTA_HL_MDL_HANDLE mdl_handle;
tBTA_HL_STATUS status;
} tBTA_HL_CI_GET_PUT_DATA;
typedef struct {
BT_HDR hdr;
tBTA_HL_MCL_HANDLE mcl_handle;
tBTA_HL_STATUS status;
} tBTA_HL_CI_ECHO_DATA;
/* union of all state machine event data types */
typedef union {
BT_HDR hdr;
tBTA_HL_API_ENABLE api_enable; /* data for BTA_MSE_API_ENABLE_EVT */
tBTA_HL_API_UPDATE api_update;
tBTA_HL_API_REGISTER api_reg;
tBTA_HL_API_DEREGISTER api_dereg;
tBTA_HL_API_CCH_OPEN api_cch_open;
tBTA_HL_API_CCH_CLOSE api_cch_close;
tBTA_HL_API_DCH_CREATE_RSP api_dch_create_rsp;
tBTA_HL_API_DCH_OPEN api_dch_open;
tBTA_HL_API_DCH_RECONNECT api_dch_reconnect;
tBTA_HL_API_DCH_CLOSE api_dch_close;
tBTA_HL_API_DELETE_MDL api_delete_mdl;
tBTA_HL_API_DCH_ABORT api_dch_abort;
tBTA_HL_API_SEND_DATA api_send_data;
tBTA_HL_API_DCH_ECHO_TEST api_dch_echo_test;
tBTA_HL_API_SDP_QUERY api_sdp_query;
tBTA_HL_CCH_SDP cch_sdp;
tBTA_HL_MCA_EVT mca_evt;
tBTA_HL_MCA_RCV_DATA_EVT mca_rcv_data_evt;
tBTA_HL_DCH_SDP dch_sdp; /* for DCH_OPEN_EVT and DCH_RECONNECT_EVT */
tBTA_HL_CI_GET_PUT_DATA ci_get_put_data;
tBTA_HL_CI_ECHO_DATA ci_get_put_echo_data;
} tBTA_HL_DATA;
typedef struct {
bool in_use;
uint16_t mdl_id;
tBTA_HL_MDL_HANDLE mdl_handle;
tBTA_HL_DCH_OPER dch_oper;
bool intentional_close;
tBTA_HL_DCH_STATE dch_state;
uint8_t abort_oper;
uint16_t req_data_psm;
uint16_t max_rx_apdu_size;
uint16_t max_tx_apdu_size;
BT_HDR* p_tx_pkt;
BT_HDR* p_rx_pkt;
tBTA_HL_MDEP_ID local_mdep_id;
uint8_t local_mdep_cfg_idx;
tBTA_HL_DCH_CFG local_cfg;
tBTA_HL_DCH_CFG remote_cfg;
tBTA_HL_MDEP_ID peer_mdep_id;
uint16_t peer_data_type;
tBTA_HL_MDEP_ROLE peer_mdep_role;
tBTA_HL_DCH_MODE dch_mode;
tBTA_SEC sec_mask;
bool is_the_first_reliable;
bool delete_mdl;
uint16_t mtu;
tMCA_CHNL_CFG chnl_cfg;
bool mdl_cfg_idx_included;
uint8_t mdl_cfg_idx;
uint8_t echo_oper;
bool cong;
bool close_pending;
uint8_t cout_oper;
BT_HDR* p_echo_tx_pkt;
BT_HDR* p_echo_rx_pkt;
tBTA_HL_STATUS ci_put_echo_data_status;
} tBTA_HL_MDL_CB;
typedef struct {
tBTA_HL_MDL_CB mdl[BTA_HL_NUM_MDLS_PER_MCL];
tBTA_HL_DELETE_MDL delete_mdl;
bool in_use;
tBTA_HL_CCH_STATE cch_state;
uint16_t req_ctrl_psm;
uint16_t ctrl_psm;
uint16_t data_psm;
RawAddress bd_addr;
uint16_t cch_mtu;
uint16_t sec_mask;
tBTA_HL_MCL_HANDLE mcl_handle;
tSDP_DISCOVERY_DB* p_db; /* pointer to discovery database */
tSDP_DISC_CMPL_CB* sdp_cback;
tBTA_HL_SDP_OPER sdp_oper;
bool close_pending;
uint8_t sdp_mdl_idx;
tBTA_HL_SDP sdp;
uint8_t cch_oper;
uint8_t force_close_local_cch_opening;
bool intentional_close;
bool rsp_tout;
uint8_t timer_oper;
bool echo_test;
uint8_t echo_mdl_idx;
uint8_t cch_close_dch_oper;
uint8_t app_id;
} tBTA_HL_MCL_CB;
typedef struct {
tBTA_HL_MCL_CB mcb[BTA_HL_NUM_MCLS]; /* application Control Blocks */
tBTA_HL_CBACK* p_cback; /* pointer to control callback function */
bool in_use; /* this CB is in use*/
bool deregistering;
uint8_t app_id;
uint32_t sdp_handle; /* SDP record handle */
tBTA_HL_SUP_FEATURE sup_feature;
tBTA_HL_MDL_CFG mdl_cfg[BTA_HL_NUM_MDL_CFGS];
tBTA_HL_DEVICE_TYPE dev_type;
tBTA_HL_APP_HANDLE app_handle;
uint16_t ctrl_psm; /* L2CAP PSM for the MCAP control channel */
uint16_t data_psm; /* L2CAP PSM for the MCAP data channel */
uint16_t sec_mask; /* Security mask for BTM_SetSecurityLevel() */
char srv_name[BTA_SERVICE_NAME_LEN +
1]; /* service name to be used in the SDP; null terminated*/
char srv_desp[BTA_SERVICE_DESP_LEN + 1]; /* service description to be used in
the SDP; null terminated */
char provider_name[BTA_PROVIDER_NAME_LEN + 1]; /* provide name to be used in
the SDP; null terminated */
tMCA_CTRL_CBACK* p_mcap_cback; /* pointer to MCAP callback function */
tMCA_DATA_CBACK* p_data_cback;
} tBTA_HL_APP_CB;
typedef struct {
bool in_use;
tBTA_HL_SDP_OPER sdp_oper;
uint8_t app_idx;
uint8_t mcl_idx;
uint8_t mdl_idx;
} tBTA_HL_SDP_CB;
typedef struct {
bool in_use;
uint8_t app_idx;
uint8_t mcl_idx;
} tBTA_HL_TIMER_CB;
typedef struct {
tBTA_HL_APP_CB acb[BTA_HL_NUM_APPS]; /* HL Control Blocks */
tBTA_HL_CTRL_CBACK* p_ctrl_cback; /* pointer to control callback function */
bool enable;
bool disabling;
tBTA_HL_SDP_CB scb[BTA_HL_NUM_SDP_CBACKS];
tBTA_HL_TIMER_CB tcb[BTA_HL_NUM_TIMERS];
bool enable_random_psm;
tBTA_HL_ALLOCATE_PSM* p_alloc_psm;
} tBTA_HL_CB;
/******************************************************************************
* Configuration Definitions
******************************************************************************/
/* Configuration structure */
/*****************************************************************************
* Global data
****************************************************************************/
/* HL control block */
extern tBTA_HL_CB bta_hl_cb;
#define BTA_HL_GET_CB_PTR() &(bta_hl_cb)
#define BTA_HL_GET_APP_CB_PTR(app_idx) &(bta_hl_cb.acb[(app_idx)])
#define BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx) \
&(bta_hl_cb.acb[(app_idx)].mcb[(mcl_idx)])
#define BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx) \
&(bta_hl_cb.acb[(app_idx)].mcb[(mcl_idx)].mdl[(mdl_idx)])
#define BTA_HL_GET_MDL_CFG_PTR(app_idx, item_idx) \
&(bta_hl_cb.acb[(app_idx)].mdl_cfg[(item_idx)])
#define BTA_HL_GET_ECHO_CFG_PTR(app_idx) \
&(bta_hl_cb.acb[(app_idx)].sup_feature.echo_cfg)
#define BTA_HL_GET_MDEP_CFG_PTR(app_idx, mdep_cfg_idx) \
&(bta_hl_cb.acb[(app_idx)].sup_feature.mdep[(mdep_cfg_idx)].mdep_cfg)
#define BTA_HL_GET_DATA_CFG_PTR(app_idx, mdep_cfg_idx, data_cfg_idx) \
&(bta_hl_cb.acb[(app_idx)] \
.sup_feature.mdep[(mdep_cfg_idx)] \
.mdep_cfg.data_cfg[(data_cfg_idx)])
#define BTA_HL_GET_BUF_PTR(p_pkt) \
((uint8_t*)((uint8_t*)((p_pkt) + 1) + (p_pkt)->offset))
/*****************************************************************************
* Function prototypes
****************************************************************************/
/* main */
extern bool bta_hl_hdl_event(BT_HDR* p_msg);
/* sdp */
extern bool bta_hl_fill_sup_feature_list(const tSDP_DISC_ATTR* p_attr,
tBTA_HL_SUP_FEATURE_LIST_ELEM* p_list);
extern tBTA_HL_STATUS bta_hl_sdp_update(uint8_t app_id);
extern tBTA_HL_STATUS bta_hl_sdp_register(uint8_t app_idx);
extern tSDP_DISC_REC* bta_hl_find_sink_or_src_srv_class_in_db(
const tSDP_DISCOVERY_DB* p_db, const tSDP_DISC_REC* p_start_rec);
/* action routines */
extern void bta_hl_dch_ci_get_tx_data(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdl_idx, tBTA_HL_DATA* p_data);
extern void bta_hl_dch_ci_put_rx_data(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdl_idx, tBTA_HL_DATA* p_data);
extern void bta_hl_dch_ci_get_echo_data(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdl_idx, tBTA_HL_DATA* p_data);
extern void bta_hl_dch_echo_test(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdl_idx, tBTA_HL_DATA* p_data);
extern void bta_hl_dch_ci_put_echo_data(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdl_idx, tBTA_HL_DATA* p_data);
extern void bta_hl_dch_send_data(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdl_idx, tBTA_HL_DATA* p_data);
extern void bta_hl_dch_sdp_fail(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdl_idx, tBTA_HL_DATA* p_data);
extern void bta_hl_dch_mca_cong_change(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdl_idx, tBTA_HL_DATA* p_data);
extern void bta_hl_dch_mca_reconnect_ind(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdl_idx, tBTA_HL_DATA* p_data);
extern void bta_hl_dch_mca_reconnect_cfm(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdl_idx, tBTA_HL_DATA* p_data);
extern void bta_hl_dch_mca_reconnect(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdl_idx, tBTA_HL_DATA* p_data);
extern void bta_hl_dch_sdp_init(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdl_idx, tBTA_HL_DATA* p_data);
extern void bta_hl_dch_close_echo_test(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdl_idx, tBTA_HL_DATA* p_data);
extern void bta_hl_dch_create_rsp(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdl_idx, tBTA_HL_DATA* p_data);
extern void bta_hl_dch_mca_rcv_data(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdl_idx, tBTA_HL_DATA* p_data);
extern void bta_hl_dch_close_cmpl(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdl_idx, tBTA_HL_DATA* p_data);
extern void bta_hl_dch_mca_close_cfm(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdl_idx, tBTA_HL_DATA* p_data);
extern void bta_hl_dch_mca_close_ind(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdl_idx, tBTA_HL_DATA* p_data);
extern void bta_hl_dch_mca_close(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdl_idx, tBTA_HL_DATA* p_data);
extern void bta_hl_dch_mca_delete_ind(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdl_idx, tBTA_HL_DATA* p_data);
extern void bta_hl_dch_mca_delete_cfm(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdl_idx, tBTA_HL_DATA* p_data);
extern void bta_hl_dch_mca_delete(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdl_idx, tBTA_HL_DATA* p_data);
extern void bta_hl_dch_mca_abort_ind(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdl_idx, tBTA_HL_DATA* p_data);
extern void bta_hl_dch_mca_abort_cfm(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdl_idx, tBTA_HL_DATA* p_data);
extern void bta_hl_dch_mca_abort(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdl_idx, tBTA_HL_DATA* p_data);
extern void bta_hl_dch_mca_open_ind(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdl_idx, tBTA_HL_DATA* p_data);
extern void bta_hl_dch_mca_open_cfm(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdl_idx, tBTA_HL_DATA* p_data);
extern void bta_hl_dch_mca_create_ind(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdl_idx, tBTA_HL_DATA* p_data);
extern void bta_hl_dch_mca_create_cfm(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdl_idx, tBTA_HL_DATA* p_data);
extern void bta_hl_dch_mca_create(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdl_idx, tBTA_HL_DATA* p_data);
extern void bta_hl_deallocate_spd_cback(uint8_t sdp_cback_idx);
extern tSDP_DISC_CMPL_CB* bta_hl_allocate_spd_cback(tBTA_HL_SDP_OPER sdp_oper,
uint8_t app_idx,
uint8_t mcl_idx,
uint8_t mdl_idx,
uint8_t* p_sdp_cback_idx);
extern tBTA_HL_STATUS bta_hl_init_sdp(tBTA_HL_SDP_OPER sdp_oper,
uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdl_idx);
extern void bta_hl_cch_sdp_init(uint8_t app_idx, uint8_t mcl_idx,
tBTA_HL_DATA* p_data);
extern void bta_hl_cch_mca_open(uint8_t app_idx, uint8_t mcl_idx,
tBTA_HL_DATA* p_data);
extern void bta_hl_cch_mca_close(uint8_t app_idx, uint8_t mcl_idx,
tBTA_HL_DATA* p_data);
extern void bta_hl_cch_close_cmpl(uint8_t app_idx, uint8_t mcl_idx,
tBTA_HL_DATA* p_data);
extern void bta_hl_cch_mca_disconnect(uint8_t app_idx, uint8_t mcl_idx,
tBTA_HL_DATA* p_data);
extern void bta_hl_cch_mca_disc_open(uint8_t app_idx, uint8_t mcl_idx,
tBTA_HL_DATA* p_data);
extern void bta_hl_cch_mca_rsp_tout(uint8_t app_idx, uint8_t mcl_idx,
tBTA_HL_DATA* p_data);
extern void bta_hl_cch_mca_connect(uint8_t app_idx, uint8_t mcl_idx,
tBTA_HL_DATA* p_data);
/* State machine drivers */
extern void bta_hl_cch_sm_execute(uint8_t inst_idx, uint8_t mcl_idx,
uint16_t event, tBTA_HL_DATA* p_data);
extern void bta_hl_dch_sm_execute(uint8_t inst_idx, uint8_t mcl_idx,
uint8_t mdl_idx, uint16_t event,
tBTA_HL_DATA* p_data);
/* MCAP callback functions */
extern void bta_hl_mcap_ctrl_cback(tMCA_HANDLE handle, tMCA_CL mcl,
uint8_t event, tMCA_CTRL* p_data);
extern void bta_hl_mcap_data_cback(tMCA_DL mdl, BT_HDR* p_pkt);
/* utility functions */
extern bool bta_hl_set_ctrl_psm_for_dch(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdl_idx, uint16_t ctrl_psm);
extern bool bta_hl_find_sdp_idx_using_ctrl_psm(tBTA_HL_SDP* p_sdp,
uint16_t ctrl_psm,
uint8_t* p_sdp_idx);
extern uint16_t bta_hl_set_user_tx_buf_size(uint16_t max_tx_size);
extern uint16_t bta_hl_set_user_rx_buf_size(uint16_t mtu);
extern uint8_t bta_hl_set_tx_win_size(uint16_t mtu, uint16_t mps);
extern uint16_t bta_hl_set_mps(uint16_t mtu);
extern void bta_hl_clean_mdl_cb(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdl_idx);
extern BT_HDR* bta_hl_get_buf(uint16_t data_size, bool fcs_use);
extern bool bta_hl_find_service_in_db(uint8_t app_idx, uint8_t mcl_idx,
uint16_t service_uuid,
tSDP_DISC_REC** pp_rec);
extern uint16_t bta_hl_get_service_uuids(uint8_t sdp_oper, uint8_t app_idx,
uint8_t mcl_idx, uint8_t mdl_idx);
extern bool bta_hl_find_echo_cfg_rsp(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdep_idx, uint8_t cfg,
uint8_t* p_cfg_rsp);
extern bool bta_hl_validate_cfg(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdl_idx, uint8_t cfg);
extern bool bta_hl_find_cch_cb_indexes(tBTA_HL_DATA* p_msg, uint8_t* p_app_idx,
uint8_t* p_mcl_idx);
extern bool bta_hl_find_dch_cb_indexes(tBTA_HL_DATA* p_msg, uint8_t* p_app_idx,
uint8_t* p_mcl_idx, uint8_t* p_mdl_idx);
extern uint16_t bta_hl_allocate_mdl_id(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdl_idx);
extern bool bta_hl_find_mdl_idx_using_handle(tBTA_HL_MDL_HANDLE mdl_handle,
uint8_t* p_app_idx,
uint8_t* p_mcl_idx,
uint8_t* p_mdl_idx);
extern bool bta_hl_find_mdl_idx(uint8_t app_idx, uint8_t mcl_idx,
uint16_t mdl_id, uint8_t* p_mdl_idx);
extern bool bta_hl_find_an_active_mdl_idx(uint8_t app_idx, uint8_t mcl_idx,
uint8_t* p_mdl_idx);
extern bool bta_hl_find_dch_setup_mdl_idx(uint8_t app_idx, uint8_t mcl_idx,
uint8_t* p_mdl_idx);
extern bool bta_hl_find_an_in_use_mcl_idx(uint8_t app_idx, uint8_t* p_mcl_idx);
extern bool bta_hl_find_an_in_use_app_idx(uint8_t* p_app_idx);
extern bool bta_hl_find_app_idx(uint8_t app_id, uint8_t* p_app_idx);
extern bool bta_hl_find_app_idx_using_handle(tBTA_HL_APP_HANDLE app_handle,
uint8_t* p_app_idx);
extern bool bta_hl_find_mcl_idx_using_handle(tBTA_HL_MCL_HANDLE mcl_handle,
uint8_t* p_app_idx,
uint8_t* p_mcl_idx);
extern bool bta_hl_find_mcl_idx(uint8_t app_idx, const RawAddress& p_bd_addr,
uint8_t* p_mcl_idx);
extern bool bta_hl_is_the_first_reliable_existed(uint8_t app_idx,
uint8_t mcl_idx);
extern bool bta_hl_find_non_active_mdl_cfg(uint8_t app_idx,
uint8_t start_mdl_cfg_idx,
uint8_t* p_mdl_cfg_idx);
extern bool bta_hl_find_avail_mdl_cfg_idx(uint8_t app_idx, uint8_t mcl_idx,
uint8_t* p_mdl_cfg_idx);
extern bool bta_hl_find_mdl_cfg_idx(uint8_t app_idx, uint8_t mcl_idx,
tBTA_HL_MDL_ID mdl_id,
uint8_t* p_mdl_cfg_idx);
extern bool bta_hl_get_cur_time(uint8_t app_idx, uint8_t* p_cur_time);
extern void bta_hl_sort_cfg_time_idx(uint8_t app_idx, uint8_t* a, uint8_t n);
extern void bta_hl_compact_mdl_cfg_time(uint8_t app_idx, uint8_t mdep_id);
extern bool bta_hl_is_mdl_exsit_in_mcl(uint8_t app_idx,
const RawAddress& bd_addr,
tBTA_HL_MDL_ID mdl_id);
extern bool bta_hl_delete_mdl_cfg(uint8_t app_idx, const RawAddress& bd_addr,
tBTA_HL_MDL_ID mdl_id);
extern bool bta_hl_is_mdl_value_valid(tBTA_HL_MDL_ID mdl_id);
extern bool bta_hl_find_mdep_cfg_idx(uint8_t app_idx,
tBTA_HL_MDEP_ID local_mdep_id,
uint8_t* p_mdep_cfg_idx);
extern void bta_hl_find_rxtx_apdu_size(uint8_t app_idx, uint8_t mdep_cfg_idx,
uint16_t* p_rx_apu_size,
uint16_t* p_tx_apu_size);
extern bool bta_hl_validate_peer_cfg(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdl_idx,
tBTA_HL_MDEP_ID peer_mdep_id,
tBTA_HL_MDEP_ROLE peer_mdep_role,
uint8_t sdp_idx);
extern tBTA_HL_STATUS bta_hl_chk_local_cfg(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdep_cfg_idx,
tBTA_HL_DCH_CFG local_cfg);
extern bool bta_hl_validate_reconnect_params(
uint8_t app_idx, uint8_t mcl_idx, tBTA_HL_API_DCH_RECONNECT* p_reconnect,
uint8_t* p_mdep_cfg_idx, uint8_t* p_mdl_cfg_idx);
extern bool bta_hl_find_avail_mcl_idx(uint8_t app_idx, uint8_t* p_mcl_idx);
extern bool bta_hl_find_avail_mdl_idx(uint8_t app_idx, uint8_t mcl_idx,
uint8_t* p_mdl_idx);
extern bool bta_hl_is_a_duplicate_id(uint8_t app_id);
extern bool bta_hl_find_avail_app_idx(uint8_t* p_idx);
extern tBTA_HL_STATUS bta_hl_app_update(uint8_t app_id, bool is_register);
extern tBTA_HL_STATUS bta_hl_app_registration(uint8_t app_idx);
extern void bta_hl_discard_data(uint16_t event, tBTA_HL_DATA* p_data);
extern void bta_hl_save_mdl_cfg(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdl_idx);
extern void bta_hl_set_dch_chan_cfg(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdl_idx, tBTA_HL_DATA* p_data);
extern bool bta_hl_get_l2cap_cfg(tBTA_HL_MDL_HANDLE mdl_hnd,
tBTA_HL_L2CAP_CFG_INFO* p_cfg);
extern bool bta_hl_validate_chan_cfg(uint8_t app_idx, uint8_t mcl_idx,
uint8_t mdl_idx);
extern bool bta_hl_is_cong_on(uint8_t app_id, const RawAddress& bd_addr,
tBTA_HL_MDL_ID mdl_id);
extern void bta_hl_check_cch_close(uint8_t app_idx, uint8_t mcl_idx,
tBTA_HL_DATA* p_data, bool check_dch_setup);
extern void bta_hl_clean_app(uint8_t app_idx);
extern void bta_hl_check_deregistration(uint8_t app_idx, tBTA_HL_DATA* p_data);
extern void bta_hl_check_disable(tBTA_HL_DATA* p_data);
extern void bta_hl_build_abort_ind(tBTA_HL* p_evt_data,
tBTA_HL_APP_HANDLE app_handle,
tBTA_HL_MCL_HANDLE mcl_handle);
extern void bta_hl_build_abort_cfm(tBTA_HL* p_evt_data,
tBTA_HL_APP_HANDLE app_handle,
tBTA_HL_MCL_HANDLE mcl_handle,
tBTA_HL_STATUS status);
extern void bta_hl_build_dch_close_cfm(tBTA_HL* p_evt_data,
tBTA_HL_APP_HANDLE app_handle,
tBTA_HL_MCL_HANDLE mcl_handle,
tBTA_HL_MDL_HANDLE mdl_handle,
tBTA_HL_STATUS status);
extern void bta_hl_build_dch_close_ind(tBTA_HL* p_evt_data,
tBTA_HL_APP_HANDLE app_handle,
tBTA_HL_MCL_HANDLE mcl_handle,
tBTA_HL_MDL_HANDLE mdl_handle,
bool intentional);
extern void bta_hl_build_send_data_cfm(tBTA_HL* p_evt_data,
tBTA_HL_APP_HANDLE app_handle,
tBTA_HL_MCL_HANDLE mcl_handle,
tBTA_HL_MDL_HANDLE mdl_handle,
tBTA_HL_STATUS status);
extern void bta_hl_build_rcv_data_ind(tBTA_HL* p_evt_data,
tBTA_HL_APP_HANDLE app_handle,
tBTA_HL_MCL_HANDLE mcl_handle,
tBTA_HL_MDL_HANDLE mdl_handle);
extern void bta_hl_build_cch_open_cfm(tBTA_HL* p_evt_data, uint8_t app_id,
tBTA_HL_APP_HANDLE app_handle,
tBTA_HL_MCL_HANDLE mcl_handle,
const RawAddress& bd_addr,
tBTA_HL_STATUS status);
extern void bta_hl_build_cch_open_ind(tBTA_HL* p_evt_data,
tBTA_HL_APP_HANDLE app_handle,
tBTA_HL_MCL_HANDLE mcl_handle,
const RawAddress& bd_addr);
extern void bta_hl_build_cch_close_cfm(tBTA_HL* p_evt_data,
tBTA_HL_APP_HANDLE app_handle,
tBTA_HL_MCL_HANDLE mcl_handle,
tBTA_HL_STATUS status);
extern void bta_hl_build_cch_close_ind(tBTA_HL* p_evt_data,
tBTA_HL_APP_HANDLE app_handle,
tBTA_HL_MCL_HANDLE mcl_handle,
bool intentional);
extern void bta_hl_build_dch_open_cfm(
tBTA_HL* p_evt_data, tBTA_HL_APP_HANDLE app_handle,
tBTA_HL_MCL_HANDLE mcl_handle, tBTA_HL_MDL_HANDLE mdl_handle,
tBTA_HL_MDEP_ID local_mdep_id, tBTA_HL_MDL_ID mdl_id,
tBTA_HL_DCH_MODE dch_mode, bool first_reliable, uint16_t mtu,
tBTA_HL_STATUS status);
extern void bta_hl_build_delete_mdl_cfm(tBTA_HL* p_evt_data,
tBTA_HL_APP_HANDLE app_handle,
tBTA_HL_MCL_HANDLE mcl_handle,
tBTA_HL_MDL_ID mdl_id,
tBTA_HL_STATUS status);
extern void bta_hl_build_echo_test_cfm(tBTA_HL* p_evt_data,
tBTA_HL_APP_HANDLE app_handle,
tBTA_HL_MCL_HANDLE mcl_handle,
tBTA_HL_STATUS status);
extern void bta_hl_build_sdp_query_cfm(tBTA_HL* p_evt_data, uint8_t app_id,
tBTA_HL_APP_HANDLE app_handle,
const RawAddress& bd_addr,
tBTA_HL_SDP* p_sdp,
tBTA_HL_STATUS status);
#if (BTA_HL_DEBUG == TRUE)
extern const char* bta_hl_status_code(tBTA_HL_STATUS status);
extern const char* bta_hl_evt_code(tBTA_HL_INT_EVT evt_code);
#endif
#endif /* BTA_MSE_INT_H */

1872
android/system/bt/bta/hl/bta_hl_main.cc Normal file
View file

File diff suppressed because it is too large Load diff

574
android/system/bt/bta/hl/bta_hl_sdp.cc Normal file
View file

@ -0,0 +1,574 @@
/******************************************************************************
*
* Copyright (C) 1998-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 <string.h>
#include "bt_target.h"
#if (HL_INCLUDED == TRUE)
#include "bta_hl_int.h"
#include "osi/include/osi.h"
#include "sdp_api.h"
#include "utl.h"
/*******************************************************************************
*
* Function bta_hl_fill_sup_feature_list
*
* Description Fill the supported features from teh SDP record
*
* Returns true if found, false if not
* If found, the passed protocol list element is filled in.
*
******************************************************************************/
bool bta_hl_fill_sup_feature_list(const tSDP_DISC_ATTR* p_attr,
tBTA_HL_SUP_FEATURE_LIST_ELEM* p_list) {
tSDP_DISC_ATTR* p_sattr;
uint8_t item_cnt;
uint8_t list_cnt = 0;
bool status = true;
for (p_attr = p_attr->attr_value.v.p_sub_attr; p_attr;
p_attr = p_attr->p_next_attr) {
/* mdep sequence */
if (SDP_DISC_ATTR_TYPE(p_attr->attr_len_type) != DATA_ELE_SEQ_DESC_TYPE) {
return (false);
}
item_cnt = 0;
for (p_sattr = p_attr->attr_value.v.p_sub_attr; p_sattr && (item_cnt < 4);
p_sattr = p_sattr->p_next_attr) {
/* for each mdep list */
p_list->list_elem[list_cnt].p_mdep_desp = NULL;
switch (item_cnt) {
case 0:
p_list->list_elem[list_cnt].mdep_id = p_sattr->attr_value.v.u8;
break;
case 1:
p_list->list_elem[list_cnt].data_type = p_sattr->attr_value.v.u16;
break;
case 2:
p_list->list_elem[list_cnt].mdep_role =
(tBTA_HL_MDEP_ROLE)p_sattr->attr_value.v.u8;
break;
case 3:
p_list->list_elem[list_cnt].p_mdep_desp =
(char*)p_sattr->attr_value.v.array;
break;
}
item_cnt++;
}
list_cnt++;
}
p_list->num_elems = list_cnt;
return (status);
}
/*******************************************************************************
*
* Function bta_hl_compose_supported_feature_list
*
* Description This function is called to compose a data sequence from
* the supported feature element list struct pointer
*
* Returns the length of the data sequence
*
******************************************************************************/
int bta_hl_compose_supported_feature_list(
uint8_t* p, uint16_t num_elem,
const tBTA_HL_SUP_FEATURE_ELEM* p_elem_list) {
uint16_t xx, str_len, seq_len;
uint8_t* p_head = p;
for (xx = 0; xx < num_elem; xx++, p_elem_list++) {
UINT8_TO_BE_STREAM(p, (DATA_ELE_SEQ_DESC_TYPE << 3) | SIZE_IN_NEXT_BYTE);
seq_len = 7;
str_len = 0;
if (p_elem_list->p_mdep_desp) {
str_len = strlen(p_elem_list->p_mdep_desp) + 1;
seq_len += str_len + 2; /* todo add a # symbol for 2 */
}
*p++ = (uint8_t)seq_len;
UINT8_TO_BE_STREAM(p, (UINT_DESC_TYPE << 3) | SIZE_ONE_BYTE);
UINT8_TO_BE_STREAM(p, p_elem_list->mdep_id);
UINT8_TO_BE_STREAM(p, (UINT_DESC_TYPE << 3) | SIZE_TWO_BYTES);
UINT16_TO_BE_STREAM(p, p_elem_list->data_type);
UINT8_TO_BE_STREAM(p, (UINT_DESC_TYPE << 3) | SIZE_ONE_BYTE);
UINT8_TO_BE_STREAM(p, p_elem_list->mdep_role);
if (str_len) {
UINT8_TO_BE_STREAM(p, (TEXT_STR_DESC_TYPE << 3) | SIZE_IN_NEXT_BYTE);
UINT8_TO_BE_STREAM(p, str_len);
ARRAY_TO_BE_STREAM(p, p_elem_list->p_mdep_desp, str_len);
}
}
return (p - p_head);
}
/*******************************************************************************
*
* Function bta_hl_add_sup_feature_list
*
* Description This function is called to add a protocol descriptor list to
* a record. This would be through the SDP database maintenance
* API. If the protocol list already exists in the record, it
* is replaced with the new list.
*
* Returns true if added OK, else false
*
******************************************************************************/
bool bta_hl_add_sup_feature_list(uint32_t handle, uint16_t num_elem,
const tBTA_HL_SUP_FEATURE_ELEM* p_elem_list) {
int offset;
bool result;
uint8_t* p_buf = (uint8_t*)osi_malloc(BTA_HL_SUP_FEATURE_SDP_BUF_SIZE);
offset = bta_hl_compose_supported_feature_list(p_buf, num_elem, p_elem_list);
result = SDP_AddAttribute(handle, ATTR_ID_HDP_SUP_FEAT_LIST,
DATA_ELE_SEQ_DESC_TYPE, (uint32_t)offset, p_buf);
osi_free(p_buf);
return result;
}
/*****************************************************************************
*
* Function: bta_hl_sdp_update
*
* Purpose: Register an HDP application with SDP
*
* Parameters:
*
* Returns: void
*
****************************************************************************/
tBTA_HL_STATUS bta_hl_sdp_update(UNUSED_ATTR uint8_t app_id) {
uint16_t svc_class_id_list[BTA_HL_NUM_SVC_ELEMS];
tSDP_PROTOCOL_ELEM proto_elem_list[BTA_HL_NUM_PROTO_ELEMS];
tSDP_PROTO_LIST_ELEM add_proto_list;
tBTA_HL_SUP_FEATURE_LIST_ELEM sup_feature_list;
uint16_t browse_list[] = {UUID_SERVCLASS_PUBLIC_BROWSE_GROUP};
uint8_t i, j, cnt, mdep_id, mdep_role;
uint8_t data_exchange_spec = BTA_HL_SDP_IEEE_11073_20601;
uint8_t mcap_sup_proc = BTA_HL_MCAP_SUP_PROC_MASK;
uint16_t profile_uuid = UUID_SERVCLASS_HDP_PROFILE;
uint16_t version = BTA_HL_VERSION;
uint8_t num_services = 1;
tBTA_HL_APP_CB* p_cb = BTA_HL_GET_APP_CB_PTR(0);
bool result = true;
tBTA_HL_STATUS status = BTA_HL_STATUS_OK;
if ((p_cb->sup_feature.app_role_mask == BTA_HL_MDEP_ROLE_MASK_SOURCE) &&
(!p_cb->sup_feature.advertize_source_sdp)) {
return BTA_HL_STATUS_OK;
}
num_services = 1;
svc_class_id_list[0] = UUID_SERVCLASS_HDP_SOURCE;
if (p_cb->sup_feature.app_role_mask == BTA_HL_MDEP_ROLE_MASK_SINK) {
svc_class_id_list[0] = UUID_SERVCLASS_HDP_SINK;
} else {
if (p_cb->sup_feature.app_role_mask != BTA_HL_MDEP_ROLE_MASK_SOURCE) {
/* dual role */
num_services = 2;
svc_class_id_list[1] = UUID_SERVCLASS_HDP_SINK;
}
}
result &= SDP_AddServiceClassIdList(p_cb->sdp_handle, num_services,
svc_class_id_list);
if (result) {
/* add the protocol element sequence */
proto_elem_list[0].protocol_uuid = UUID_PROTOCOL_L2CAP;
proto_elem_list[0].num_params = 1;
proto_elem_list[0].params[0] = p_cb->ctrl_psm;
proto_elem_list[1].protocol_uuid = UUID_PROTOCOL_MCAP_CTRL;
proto_elem_list[1].num_params = 1;
proto_elem_list[1].params[0] = version;
result &= SDP_AddProtocolList(p_cb->sdp_handle, BTA_HL_NUM_PROTO_ELEMS,
proto_elem_list);
result &=
SDP_AddProfileDescriptorList(p_cb->sdp_handle, profile_uuid, version);
}
if (result) {
add_proto_list.num_elems = BTA_HL_NUM_ADD_PROTO_ELEMS;
add_proto_list.list_elem[0].protocol_uuid = UUID_PROTOCOL_L2CAP;
add_proto_list.list_elem[0].num_params = 1;
add_proto_list.list_elem[0].params[0] = p_cb->data_psm;
add_proto_list.list_elem[1].protocol_uuid = UUID_PROTOCOL_MCAP_DATA;
add_proto_list.list_elem[1].num_params = 0;
result &=
SDP_AddAdditionProtoLists(p_cb->sdp_handle, BTA_HL_NUM_ADD_PROTO_LISTS,
(tSDP_PROTO_LIST_ELEM*)&add_proto_list);
}
if (result) {
if (p_cb->srv_name[0]) {
result &= SDP_AddAttribute(
p_cb->sdp_handle, (uint16_t)ATTR_ID_SERVICE_NAME,
(uint8_t)TEXT_STR_DESC_TYPE, (uint32_t)(strlen(p_cb->srv_name) + 1),
(uint8_t*)p_cb->srv_name);
} /* end of setting optional service name */
}
if (result) {
if (p_cb->srv_desp[0]) {
result &= SDP_AddAttribute(
p_cb->sdp_handle, (uint16_t)ATTR_ID_SERVICE_DESCRIPTION,
(uint8_t)TEXT_STR_DESC_TYPE, (uint32_t)(strlen(p_cb->srv_desp) + 1),
(uint8_t*)p_cb->srv_desp);
} /* end of setting optional service description */
}
if (result) {
if (p_cb->provider_name[0]) {
result &=
SDP_AddAttribute(p_cb->sdp_handle, (uint16_t)ATTR_ID_PROVIDER_NAME,
(uint8_t)TEXT_STR_DESC_TYPE,
(uint32_t)(strlen(p_cb->provider_name) + 1),
(uint8_t*)p_cb->provider_name);
} /* end of setting optional provider name */
}
/* add supported feture list */
if (result) {
cnt = 0;
for (i = 1; i < BTA_HL_NUM_MDEPS; i++) {
if (p_cb->sup_feature.mdep[i].mdep_id) {
mdep_id = (uint8_t)p_cb->sup_feature.mdep[i].mdep_id;
mdep_role = (uint8_t)p_cb->sup_feature.mdep[i].mdep_cfg.mdep_role;
APPL_TRACE_DEBUG(
"num_of_mdep_data_types %d ",
p_cb->sup_feature.mdep[i].mdep_cfg.num_of_mdep_data_types);
for (j = 0;
j < p_cb->sup_feature.mdep[i].mdep_cfg.num_of_mdep_data_types;
j++) {
sup_feature_list.list_elem[cnt].mdep_id = mdep_id;
sup_feature_list.list_elem[cnt].mdep_role = mdep_role;
sup_feature_list.list_elem[cnt].data_type =
p_cb->sup_feature.mdep[i].mdep_cfg.data_cfg[j].data_type;
if (p_cb->sup_feature.mdep[i].mdep_cfg.data_cfg[j].desp[0] != '\0') {
sup_feature_list.list_elem[cnt].p_mdep_desp =
p_cb->sup_feature.mdep[i].mdep_cfg.data_cfg[j].desp;
} else {
sup_feature_list.list_elem[cnt].p_mdep_desp = NULL;
}
cnt++;
if (cnt == BTA_HL_NUM_SUP_FEATURE_ELEMS) {
result = false;
break;
}
}
}
}
sup_feature_list.num_elems = cnt;
result &= bta_hl_add_sup_feature_list(p_cb->sdp_handle,
sup_feature_list.num_elems,
sup_feature_list.list_elem);
}
if (result) {
result &= SDP_AddAttribute(p_cb->sdp_handle, ATTR_ID_HDP_DATA_EXCH_SPEC,
UINT_DESC_TYPE, (uint32_t)1,
(uint8_t*)&data_exchange_spec);
}
if (result) {
result &=
SDP_AddAttribute(p_cb->sdp_handle, ATTR_ID_HDP_MCAP_SUP_PROC,
UINT_DESC_TYPE, (uint32_t)1, (uint8_t*)&mcap_sup_proc);
}
if (result) {
result &= SDP_AddUuidSequence(p_cb->sdp_handle, ATTR_ID_BROWSE_GROUP_LIST,
1, browse_list);
}
if (result) {
for (i = 0; i < num_services; i++) {
bta_sys_add_uuid(svc_class_id_list[i]);
APPL_TRACE_DEBUG("dbg bta_sys_add_uuid i=%d uuid=0x%x", i,
svc_class_id_list[i]); // todo
}
} else {
if (p_cb->sdp_handle) {
SDP_DeleteRecord(p_cb->sdp_handle);
p_cb->sdp_handle = 0;
}
status = BTA_HL_STATUS_SDP_FAIL;
}
#if (BTA_HL_DEBUG == TRUE)
APPL_TRACE_DEBUG("bta_hl_sdp_update status=%s", bta_hl_status_code(status));
#endif
return status;
}
/*****************************************************************************
*
* Function: bta_hl_sdp_register
*
* Purpose: Register an HDP application with SDP
*
* Parameters: p_cb - Pointer to MA instance control block
* p_service_name - MA server name
* inst_id - MAS instance ID
* msg_type - Supported message type(s)
*
*
* Returns: void
*
****************************************************************************/
tBTA_HL_STATUS bta_hl_sdp_register(uint8_t app_idx) {
uint16_t svc_class_id_list[BTA_HL_NUM_SVC_ELEMS];
tSDP_PROTOCOL_ELEM proto_elem_list[BTA_HL_NUM_PROTO_ELEMS];
tSDP_PROTO_LIST_ELEM add_proto_list;
tBTA_HL_SUP_FEATURE_LIST_ELEM sup_feature_list;
uint16_t browse_list[] = {UUID_SERVCLASS_PUBLIC_BROWSE_GROUP};
uint8_t i, j, cnt, mdep_id, mdep_role;
uint8_t data_exchange_spec = BTA_HL_SDP_IEEE_11073_20601;
uint8_t mcap_sup_proc = BTA_HL_MCAP_SUP_PROC_MASK;
uint16_t profile_uuid = UUID_SERVCLASS_HDP_PROFILE;
uint16_t version = BTA_HL_VERSION;
uint8_t num_services = 1;
tBTA_HL_APP_CB* p_cb = BTA_HL_GET_APP_CB_PTR(app_idx);
bool result = true;
tBTA_HL_STATUS status = BTA_HL_STATUS_OK;
#if (BTA_HL_DEBUG == TRUE)
APPL_TRACE_DEBUG("bta_hl_sdp_register app_idx=%d", app_idx);
#endif
if ((p_cb->sup_feature.app_role_mask == BTA_HL_MDEP_ROLE_MASK_SOURCE) &&
(!p_cb->sup_feature.advertize_source_sdp)) {
return BTA_HL_STATUS_OK;
}
p_cb->sdp_handle = SDP_CreateRecord();
if (p_cb->sdp_handle == 0) {
return BTA_HL_STATUS_SDP_NO_RESOURCE;
}
num_services = 1;
svc_class_id_list[0] = UUID_SERVCLASS_HDP_SOURCE;
if (p_cb->sup_feature.app_role_mask == BTA_HL_MDEP_ROLE_MASK_SINK) {
svc_class_id_list[0] = UUID_SERVCLASS_HDP_SINK;
} else {
if (p_cb->sup_feature.app_role_mask != BTA_HL_MDEP_ROLE_MASK_SOURCE) {
/* dual role */
num_services = 2;
svc_class_id_list[1] = UUID_SERVCLASS_HDP_SINK;
}
}
result &= SDP_AddServiceClassIdList(p_cb->sdp_handle, num_services,
svc_class_id_list);
if (result) {
/* add the protocol element sequence */
proto_elem_list[0].protocol_uuid = UUID_PROTOCOL_L2CAP;
proto_elem_list[0].num_params = 1;
proto_elem_list[0].params[0] = p_cb->ctrl_psm;
proto_elem_list[1].protocol_uuid = UUID_PROTOCOL_MCAP_CTRL;
proto_elem_list[1].num_params = 1;
proto_elem_list[1].params[0] = version;
result &= SDP_AddProtocolList(p_cb->sdp_handle, BTA_HL_NUM_PROTO_ELEMS,
proto_elem_list);
result &=
SDP_AddProfileDescriptorList(p_cb->sdp_handle, profile_uuid, version);
}
if (result) {
add_proto_list.num_elems = BTA_HL_NUM_ADD_PROTO_ELEMS;
add_proto_list.list_elem[0].protocol_uuid = UUID_PROTOCOL_L2CAP;
add_proto_list.list_elem[0].num_params = 1;
add_proto_list.list_elem[0].params[0] = p_cb->data_psm;
add_proto_list.list_elem[1].protocol_uuid = UUID_PROTOCOL_MCAP_DATA;
add_proto_list.list_elem[1].num_params = 0;
result &=
SDP_AddAdditionProtoLists(p_cb->sdp_handle, BTA_HL_NUM_ADD_PROTO_LISTS,
(tSDP_PROTO_LIST_ELEM*)&add_proto_list);
}
if (result) {
if (p_cb->srv_name[0]) {
result &= SDP_AddAttribute(
p_cb->sdp_handle, (uint16_t)ATTR_ID_SERVICE_NAME,
(uint8_t)TEXT_STR_DESC_TYPE, (uint32_t)(strlen(p_cb->srv_name) + 1),
(uint8_t*)p_cb->srv_name);
} /* end of setting optional service name */
}
if (result) {
if (p_cb->srv_desp[0]) {
result &= SDP_AddAttribute(
p_cb->sdp_handle, (uint16_t)ATTR_ID_SERVICE_DESCRIPTION,
(uint8_t)TEXT_STR_DESC_TYPE, (uint32_t)(strlen(p_cb->srv_desp) + 1),
(uint8_t*)p_cb->srv_desp);
} /* end of setting optional service description */
}
if (result) {
if (p_cb->provider_name[0]) {
result &=
SDP_AddAttribute(p_cb->sdp_handle, (uint16_t)ATTR_ID_PROVIDER_NAME,
(uint8_t)TEXT_STR_DESC_TYPE,
(uint32_t)(strlen(p_cb->provider_name) + 1),
(uint8_t*)p_cb->provider_name);
} /* end of setting optional provider name */
}
/* add supported feture list */
if (result) {
cnt = 0;
for (i = 1; i <= p_cb->sup_feature.num_of_mdeps; i++) {
mdep_id = (uint8_t)p_cb->sup_feature.mdep[i].mdep_id;
mdep_role = (uint8_t)p_cb->sup_feature.mdep[i].mdep_cfg.mdep_role;
for (j = 0; j < p_cb->sup_feature.mdep[i].mdep_cfg.num_of_mdep_data_types;
j++) {
sup_feature_list.list_elem[cnt].mdep_id = mdep_id;
sup_feature_list.list_elem[cnt].mdep_role = mdep_role;
sup_feature_list.list_elem[cnt].data_type =
p_cb->sup_feature.mdep[i].mdep_cfg.data_cfg[j].data_type;
if (p_cb->sup_feature.mdep[i].mdep_cfg.data_cfg[j].desp[0] != '\0') {
sup_feature_list.list_elem[cnt].p_mdep_desp =
p_cb->sup_feature.mdep[i].mdep_cfg.data_cfg[j].desp;
} else {
sup_feature_list.list_elem[cnt].p_mdep_desp = NULL;
}
cnt++;
if (cnt == BTA_HL_NUM_SUP_FEATURE_ELEMS) {
result = false;
break;
}
}
}
sup_feature_list.num_elems = cnt;
result &= bta_hl_add_sup_feature_list(p_cb->sdp_handle,
sup_feature_list.num_elems,
sup_feature_list.list_elem);
}
if (result) {
result &= SDP_AddAttribute(p_cb->sdp_handle, ATTR_ID_HDP_DATA_EXCH_SPEC,
UINT_DESC_TYPE, (uint32_t)1,
(uint8_t*)&data_exchange_spec);
}
if (result) {
result &=
SDP_AddAttribute(p_cb->sdp_handle, ATTR_ID_HDP_MCAP_SUP_PROC,
UINT_DESC_TYPE, (uint32_t)1, (uint8_t*)&mcap_sup_proc);
}
if (result) {
result &= SDP_AddUuidSequence(p_cb->sdp_handle, ATTR_ID_BROWSE_GROUP_LIST,
1, browse_list);
}
if (result) {
for (i = 0; i < num_services; i++) {
bta_sys_add_uuid(svc_class_id_list[i]);
APPL_TRACE_DEBUG("dbg bta_sys_add_uuid i=%d uuid=0x%x", i,
svc_class_id_list[i]); // todo
}
} else {
if (p_cb->sdp_handle) {
SDP_DeleteRecord(p_cb->sdp_handle);
p_cb->sdp_handle = 0;
}
status = BTA_HL_STATUS_SDP_FAIL;
}
#if (BTA_HL_DEBUG == TRUE)
APPL_TRACE_DEBUG("bta_hl_sdp_register status=%s", bta_hl_status_code(status));
#endif
return status;
}
/*******************************************************************************
*
* Function bta_hl_find_sink_or_src_srv_class_in_db
*
* Description This function queries an SDP database for either a HDP Sink
* or Source service class ID.
* If the p_start_rec pointer is NULL, it looks from the
* beginning of the database, else it continues from the next
* record after p_start_rec.
*
* Returns Pointer to record containing service class, or NULL
*
******************************************************************************/
tSDP_DISC_REC* bta_hl_find_sink_or_src_srv_class_in_db(
const tSDP_DISCOVERY_DB* p_db, const tSDP_DISC_REC* p_start_rec) {
tSDP_DISC_REC* p_rec;
tSDP_DISC_ATTR *p_attr, *p_sattr;
/* Must have a valid database */
if (p_db == NULL) return (NULL);
if (!p_start_rec) {
p_rec = p_db->p_first_rec;
} else {
p_rec = p_start_rec->p_next_rec;
}
while (p_rec) {
p_attr = p_rec->p_first_attr;
while (p_attr) {
if ((p_attr->attr_id == ATTR_ID_SERVICE_CLASS_ID_LIST) &&
(SDP_DISC_ATTR_TYPE(p_attr->attr_len_type) ==
DATA_ELE_SEQ_DESC_TYPE)) {
for (p_sattr = p_attr->attr_value.v.p_sub_attr; p_sattr;
p_sattr = p_sattr->p_next_attr) {
if ((SDP_DISC_ATTR_TYPE(p_sattr->attr_len_type) == UUID_DESC_TYPE) &&
(SDP_DISC_ATTR_LEN(p_sattr->attr_len_type) == 2) &&
((p_sattr->attr_value.v.u16 == UUID_SERVCLASS_HDP_SINK) ||
(p_sattr->attr_value.v.u16 == UUID_SERVCLASS_HDP_SOURCE))) {
return (p_rec);
}
}
break;
}
p_attr = p_attr->p_next_attr;
}
p_rec = p_rec->p_next_rec;
}
/* If here, no matching UUID found */
#if (BTA_HL_DEBUG == TRUE)
APPL_TRACE_DEBUG("bta_hl_find_sink_or_src_srv_class_in_db failed");
#endif
return (NULL);
}
#endif /* HL_INCLUDED */

3083
android/system/bt/bta/hl/bta_hl_utils.cc Normal file
View file

File diff suppressed because it is too large Load diff