mirror of
https://github.com/espressif/esp-idf.git
synced 2024-10-05 20:47:46 -04:00
7e772d2195
1. Add logs for SPP not enabled successfully 2. Add information to Applicatioin layer that the A2DP is connecting to peer device Regular BTC and BTU Task name & Add BTC Init protection 1. Regular the BTC Task Name to Close a Github issue Closes https://github.com/espressif/esp-idf/issues/4966 2. Add BTC Init failure protection 3. Regular BTU Task Name with BTC 4. Correct the comment of a. SDP_ServiceSearchRequest and SDP_ServiceSearchRequest2 b. l2cu_create_conn_after_switch 5. Correct comment of esp_bt_hf_vra(); 6. Fix cpp compilier region
1179 lines
43 KiB
C
1179 lines
43 KiB
C
/******************************************************************************
|
|
*
|
|
* Copyright (C) 2006-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 JAVA API for Bluetooth Wireless
|
|
* Technology (JABWT) as specified by the JSR82 specificiation
|
|
*
|
|
******************************************************************************/
|
|
|
|
#include "bta/bta_api.h"
|
|
#include "bta/bta_sys.h"
|
|
#include "bta/bta_jv_api.h"
|
|
#include "bta_jv_int.h"
|
|
#include "osi/allocator.h"
|
|
#include <string.h>
|
|
#include "stack/port_api.h"
|
|
#include "stack/sdp_api.h"
|
|
#include "bta/utl.h"
|
|
#include "stack/gap_api.h"
|
|
|
|
#include "common/bt_target.h"
|
|
#include "stack/sdp_api.h"
|
|
|
|
|
|
#if (defined BTA_JV_INCLUDED && BTA_JV_INCLUDED == TRUE)
|
|
/*****************************************************************************
|
|
** Constants
|
|
*****************************************************************************/
|
|
|
|
static const tBTA_SYS_REG bta_jv_reg = {
|
|
bta_jv_sm_execute,
|
|
NULL
|
|
};
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTA_JvEnable
|
|
**
|
|
** Description Enable the Java I/F service. When the enable
|
|
** operation is complete the callback function will be
|
|
** called with a BTA_JV_ENABLE_EVT. This function must
|
|
** be called before other function in the JV API are
|
|
** called.
|
|
**
|
|
** Returns BTA_JV_SUCCESS if successful.
|
|
** BTA_JV_FAIL if internal failure.
|
|
**
|
|
*******************************************************************************/
|
|
tBTA_JV_STATUS BTA_JvEnable(tBTA_JV_DM_CBACK *p_cback)
|
|
{
|
|
tBTA_JV_STATUS status = BTA_JV_FAILURE;
|
|
tBTA_JV_API_ENABLE *p_buf;
|
|
int i;
|
|
APPL_TRACE_API( "BTA_JvEnable");
|
|
|
|
#if BTA_DYNAMIC_MEMORY == TRUE
|
|
/* Malloc buffer for JV configuration structure */
|
|
p_bta_jv_cfg->p_sdp_raw_data = (UINT8 *)osi_malloc(p_bta_jv_cfg->sdp_raw_size);
|
|
p_bta_jv_cfg->p_sdp_db = (tSDP_DISCOVERY_DB *)osi_malloc(p_bta_jv_cfg->sdp_db_size);
|
|
if (p_bta_jv_cfg->p_sdp_raw_data == NULL || p_bta_jv_cfg->p_sdp_db == NULL) {
|
|
return BTA_JV_NO_DATA;
|
|
}
|
|
#endif
|
|
|
|
if (p_cback && FALSE == bta_sys_is_register(BTA_ID_JV)) {
|
|
memset(&bta_jv_cb, 0, sizeof(tBTA_JV_CB));
|
|
/* set handle to invalid value by default */
|
|
for (i = 0; i < BTA_JV_PM_MAX_NUM; i++) {
|
|
bta_jv_cb.pm_cb[i].handle = BTA_JV_PM_HANDLE_CLEAR;
|
|
}
|
|
|
|
/* register with BTA system manager */
|
|
bta_sys_register(BTA_ID_JV, &bta_jv_reg);
|
|
|
|
if (p_cback && (p_buf = (tBTA_JV_API_ENABLE *) osi_malloc(sizeof(tBTA_JV_API_ENABLE))) != NULL) {
|
|
p_buf->hdr.event = BTA_JV_API_ENABLE_EVT;
|
|
p_buf->p_cback = p_cback;
|
|
bta_sys_sendmsg(p_buf);
|
|
status = BTA_JV_SUCCESS;
|
|
}
|
|
} else if (p_cback == NULL) {
|
|
APPL_TRACE_ERROR("No p_cback.");
|
|
} else {
|
|
APPL_TRACE_WARNING("No need to Init again.");
|
|
// status = BTA_JV_SUCCESS;
|
|
}
|
|
return (status);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTA_JvDisable
|
|
**
|
|
** Description Disable the Java I/F
|
|
**
|
|
** Returns void
|
|
**
|
|
*******************************************************************************/
|
|
void BTA_JvDisable(tBTA_JV_RFCOMM_CBACK *p_cback)
|
|
{
|
|
tBTA_JV_API_DISABLE *p_buf;
|
|
|
|
APPL_TRACE_API( "BTA_JvDisable");
|
|
bta_sys_deregister(BTA_ID_JV);
|
|
if ((p_buf = (tBTA_JV_API_DISABLE *) osi_malloc(sizeof(tBTA_JV_API_DISABLE))) != NULL) {
|
|
p_buf->hdr.event = BTA_JV_API_DISABLE_EVT;
|
|
p_buf->p_cback = p_cback;
|
|
bta_sys_sendmsg(p_buf);
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTA_JvFree
|
|
**
|
|
** Description Free JV configuration
|
|
**
|
|
** Returns void
|
|
**
|
|
*******************************************************************************/
|
|
void BTA_JvFree(void)
|
|
{
|
|
#if BTA_DYNAMIC_MEMORY == TRUE
|
|
/* Free buffer for JV configuration structure */
|
|
osi_free(p_bta_jv_cfg->p_sdp_raw_data);
|
|
osi_free(p_bta_jv_cfg->p_sdp_db);
|
|
p_bta_jv_cfg->p_sdp_raw_data = NULL;
|
|
p_bta_jv_cfg->p_sdp_db = NULL;
|
|
#endif
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTA_JvIsEnable
|
|
**
|
|
** Description Get the JV registration status.
|
|
**
|
|
** Returns TRUE, if registered
|
|
**
|
|
*******************************************************************************/
|
|
BOOLEAN BTA_JvIsEnable(void)
|
|
{
|
|
return bta_sys_is_register(BTA_ID_JV);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTA_JvIsEncrypted
|
|
**
|
|
** Description This function checks if the link to peer device is encrypted
|
|
**
|
|
** Returns TRUE if encrypted.
|
|
** FALSE if not.
|
|
**
|
|
*******************************************************************************/
|
|
BOOLEAN BTA_JvIsEncrypted(BD_ADDR bd_addr)
|
|
{
|
|
BOOLEAN is_encrypted = FALSE;
|
|
UINT8 sec_flags, le_flags;
|
|
|
|
if (BTM_GetSecurityFlags(bd_addr, &sec_flags) &&
|
|
BTM_GetSecurityFlagsByTransport(bd_addr, &le_flags, BT_TRANSPORT_LE)) {
|
|
if (sec_flags & BTM_SEC_FLAG_ENCRYPTED ||
|
|
le_flags & BTM_SEC_FLAG_ENCRYPTED) {
|
|
is_encrypted = TRUE;
|
|
}
|
|
}
|
|
return is_encrypted;
|
|
}
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTA_JvGetChannelId
|
|
**
|
|
** Description This function reserves a SCN (server channel number) for
|
|
** applications running over RFCOMM, L2CAP of L2CAP_LE.
|
|
** It is primarily called by server profiles/applications to
|
|
** register their SCN into the SDP database. The SCN is reported
|
|
** by the tBTA_JV_DM_CBACK callback with a BTA_JV_GET_SCN_EVT
|
|
** for RFCOMM channels and BTA_JV_GET_PSM_EVT for L2CAP and LE.
|
|
** If the SCN/PSM reported is 0, that means all resources are
|
|
** exhausted.
|
|
** Parameters
|
|
** conn_type one of BTA_JV_CONN_TYPE_
|
|
** user_data Any uservalue - will be returned in the resulting event.
|
|
** channel Only used for RFCOMM - to try to allocate a specific RFCOMM
|
|
** channel.
|
|
**
|
|
** Returns BTA_JV_SUCCESS, if the request is being processed.
|
|
** BTA_JV_FAILURE, otherwise.
|
|
**
|
|
*******************************************************************************/
|
|
tBTA_JV_STATUS BTA_JvGetChannelId(int conn_type, void *user_data, INT32 channel)
|
|
{
|
|
tBTA_JV_STATUS status = BTA_JV_FAILURE;
|
|
tBTA_JV_API_ALLOC_CHANNEL *p_msg;
|
|
|
|
APPL_TRACE_API( "%s", __func__);
|
|
if ((p_msg = (tBTA_JV_API_ALLOC_CHANNEL *)osi_malloc(sizeof(tBTA_JV_API_ALLOC_CHANNEL))) != NULL) {
|
|
p_msg->hdr.event = BTA_JV_API_GET_CHANNEL_EVT;
|
|
p_msg->type = conn_type;
|
|
p_msg->channel = channel;
|
|
p_msg->user_data = user_data;
|
|
bta_sys_sendmsg(p_msg);
|
|
status = BTA_JV_SUCCESS;
|
|
}
|
|
|
|
return (status);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTA_JvFreeChannel
|
|
**
|
|
** Description This function frees a server channel number that was used
|
|
** by an application running over RFCOMM.
|
|
** Parameters
|
|
** channel The channel to free
|
|
** conn_type one of BTA_JV_CONN_TYPE_
|
|
** p_cback tBTA_JV_RFCOMM_CBACK is called with when server
|
|
** user_data indicate the RFCOMM server status
|
|
**
|
|
** Returns BTA_JV_SUCCESS, if the request is being processed.
|
|
** BTA_JV_FAILURE, otherwise.
|
|
**
|
|
*******************************************************************************/
|
|
tBTA_JV_STATUS BTA_JvFreeChannel(UINT16 channel, int conn_type, tBTA_JV_RFCOMM_CBACK *p_cback, void *user_data)
|
|
{
|
|
tBTA_JV_STATUS status = BTA_JV_FAILURE;
|
|
tBTA_JV_API_FREE_CHANNEL *p_msg;
|
|
|
|
APPL_TRACE_API( "%s", __func__);
|
|
if ((p_msg = (tBTA_JV_API_FREE_CHANNEL *)osi_malloc(sizeof(tBTA_JV_API_FREE_CHANNEL))) != NULL) {
|
|
p_msg->hdr.event = BTA_JV_API_FREE_SCN_EVT;
|
|
p_msg->scn = channel;
|
|
p_msg->type = conn_type;
|
|
p_msg->p_cback = p_cback;
|
|
p_msg->user_data = user_data;
|
|
bta_sys_sendmsg(p_msg);
|
|
status = BTA_JV_SUCCESS;
|
|
}
|
|
|
|
return (status);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTA_JvStartDiscovery
|
|
**
|
|
** Description This function performs service discovery for the services
|
|
** provided by the given peer device. When the operation is
|
|
** complete the tBTA_JV_DM_CBACK callback function will be
|
|
** called with a BTA_JV_DISCOVERY_COMP_EVT.
|
|
**
|
|
** Returns BTA_JV_SUCCESS, if the request is being processed.
|
|
** BTA_JV_FAILURE, otherwise.
|
|
**
|
|
*******************************************************************************/
|
|
tBTA_JV_STATUS BTA_JvStartDiscovery(BD_ADDR bd_addr, UINT16 num_uuid,
|
|
tSDP_UUID *p_uuid_list, void *user_data)
|
|
{
|
|
tBTA_JV_STATUS status = BTA_JV_FAILURE;
|
|
tBTA_JV_API_START_DISCOVERY *p_msg;
|
|
|
|
APPL_TRACE_API( "BTA_JvStartDiscovery");
|
|
if ((p_msg = (tBTA_JV_API_START_DISCOVERY *)osi_malloc(sizeof(tBTA_JV_API_START_DISCOVERY))) != NULL) {
|
|
p_msg->hdr.event = BTA_JV_API_START_DISCOVERY_EVT;
|
|
bdcpy(p_msg->bd_addr, bd_addr);
|
|
p_msg->num_uuid = num_uuid;
|
|
memcpy(p_msg->uuid_list, p_uuid_list, num_uuid * sizeof(tSDP_UUID));
|
|
p_msg->num_attr = 0;
|
|
p_msg->user_data = user_data;
|
|
bta_sys_sendmsg(p_msg);
|
|
status = BTA_JV_SUCCESS;
|
|
}
|
|
|
|
return (status);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTA_JvCreateRecord
|
|
**
|
|
** Description Create a service record in the local SDP database.
|
|
** When the operation is complete the tBTA_JV_DM_CBACK callback
|
|
** function will be called with a BTA_JV_CREATE_RECORD_EVT.
|
|
**
|
|
** Returns BTA_JV_SUCCESS, if the request is being processed.
|
|
** BTA_JV_FAILURE, otherwise.
|
|
**
|
|
*******************************************************************************/
|
|
tBTA_JV_STATUS BTA_JvCreateRecordByUser(const char *name, UINT32 channel, void *user_data)
|
|
{
|
|
tBTA_JV_STATUS status = BTA_JV_FAILURE;
|
|
tBTA_JV_API_CREATE_RECORD *p_msg;
|
|
|
|
APPL_TRACE_API( "BTA_JvCreateRecordByUser");
|
|
if ((p_msg = (tBTA_JV_API_CREATE_RECORD *)osi_malloc(sizeof(tBTA_JV_API_CREATE_RECORD))) != NULL) {
|
|
p_msg->hdr.event = BTA_JV_API_CREATE_RECORD_EVT;
|
|
p_msg->user_data = user_data;
|
|
strcpy(p_msg->name, name);
|
|
p_msg->channel = channel;
|
|
bta_sys_sendmsg(p_msg);
|
|
status = BTA_JV_SUCCESS;
|
|
}
|
|
|
|
return (status);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTA_JvDeleteRecord
|
|
**
|
|
** Description Delete a service record in the local SDP database.
|
|
**
|
|
** Returns BTA_JV_SUCCESS, if the request is being processed.
|
|
** BTA_JV_FAILURE, otherwise.
|
|
**
|
|
*******************************************************************************/
|
|
tBTA_JV_STATUS BTA_JvDeleteRecord(UINT32 handle)
|
|
{
|
|
tBTA_JV_STATUS status = BTA_JV_FAILURE;
|
|
tBTA_JV_API_ADD_ATTRIBUTE *p_msg;
|
|
|
|
APPL_TRACE_API( "BTA_JvDeleteRecord");
|
|
if ((p_msg = (tBTA_JV_API_ADD_ATTRIBUTE *)osi_malloc(sizeof(tBTA_JV_API_ADD_ATTRIBUTE))) != NULL) {
|
|
p_msg->hdr.event = BTA_JV_API_DELETE_RECORD_EVT;
|
|
p_msg->handle = handle;
|
|
bta_sys_sendmsg(p_msg);
|
|
status = BTA_JV_SUCCESS;
|
|
}
|
|
return (status);
|
|
}
|
|
|
|
#if BTA_JV_L2CAP_INCLUDED
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTA_JvL2capConnectLE
|
|
**
|
|
** Description Initiate an LE connection as a L2CAP client to the given BD
|
|
** Address.
|
|
** When the connection is initiated or failed to initiate,
|
|
** tBTA_JV_L2CAP_CBACK is called with BTA_JV_L2CAP_CL_INIT_EVT
|
|
** When the connection is established or failed,
|
|
** tBTA_JV_L2CAP_CBACK is called with BTA_JV_L2CAP_OPEN_EVT
|
|
**
|
|
** Returns BTA_JV_SUCCESS, if the request is being processed.
|
|
** BTA_JV_FAILURE, otherwise.
|
|
**
|
|
*******************************************************************************/
|
|
tBTA_JV_STATUS BTA_JvL2capConnectLE(tBTA_SEC sec_mask, tBTA_JV_ROLE role,
|
|
const tL2CAP_ERTM_INFO *ertm_info, UINT16 remote_chan,
|
|
UINT16 rx_mtu, tL2CAP_CFG_INFO *cfg,
|
|
BD_ADDR peer_bd_addr, tBTA_JV_L2CAP_CBACK *p_cback, void *user_data)
|
|
{
|
|
tBTA_JV_STATUS status = BTA_JV_FAILURE;
|
|
tBTA_JV_API_L2CAP_CONNECT *p_msg;
|
|
|
|
APPL_TRACE_API( "%s", __func__);
|
|
|
|
if (p_cback &&
|
|
(p_msg =
|
|
(tBTA_JV_API_L2CAP_CONNECT *)osi_malloc(sizeof(tBTA_JV_API_L2CAP_CONNECT))) != NULL) {
|
|
p_msg->hdr.event = BTA_JV_API_L2CAP_CONNECT_LE_EVT;
|
|
p_msg->sec_mask = sec_mask;
|
|
p_msg->role = role;
|
|
p_msg->remote_chan = remote_chan;
|
|
p_msg->rx_mtu = rx_mtu;
|
|
if (cfg != NULL) {
|
|
p_msg->has_cfg = TRUE;
|
|
p_msg->cfg = *cfg;
|
|
} else {
|
|
p_msg->has_cfg = FALSE;
|
|
}
|
|
if (ertm_info != NULL) {
|
|
p_msg->has_ertm_info = TRUE;
|
|
p_msg->ertm_info = *ertm_info;
|
|
} else {
|
|
p_msg->has_ertm_info = FALSE;
|
|
}
|
|
memcpy(p_msg->peer_bd_addr, peer_bd_addr, sizeof(BD_ADDR));
|
|
p_msg->p_cback = p_cback;
|
|
p_msg->user_data = user_data;
|
|
bta_sys_sendmsg(p_msg);
|
|
status = BTA_JV_SUCCESS;
|
|
}
|
|
|
|
return (status);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTA_JvL2capConnect
|
|
**
|
|
** Description Initiate a connection as a L2CAP client to the given BD
|
|
** Address.
|
|
** When the connection is initiated or failed to initiate,
|
|
** tBTA_JV_L2CAP_CBACK is called with BTA_JV_L2CAP_CL_INIT_EVT
|
|
** When the connection is established or failed,
|
|
** tBTA_JV_L2CAP_CBACK is called with BTA_JV_L2CAP_OPEN_EVT
|
|
**
|
|
** Returns BTA_JV_SUCCESS, if the request is being processed.
|
|
** BTA_JV_FAILURE, otherwise.
|
|
**
|
|
*******************************************************************************/
|
|
tBTA_JV_STATUS BTA_JvL2capConnect(tBTA_SEC sec_mask, tBTA_JV_ROLE role,
|
|
const tL2CAP_ERTM_INFO *ertm_info, UINT16 remote_psm,
|
|
UINT16 rx_mtu, tL2CAP_CFG_INFO *cfg,
|
|
BD_ADDR peer_bd_addr, tBTA_JV_L2CAP_CBACK *p_cback, void *user_data)
|
|
{
|
|
tBTA_JV_STATUS status = BTA_JV_FAILURE;
|
|
tBTA_JV_API_L2CAP_CONNECT *p_msg;
|
|
|
|
APPL_TRACE_API( "%s", __func__);
|
|
|
|
if (p_cback &&
|
|
(p_msg = (tBTA_JV_API_L2CAP_CONNECT *)osi_malloc(sizeof(tBTA_JV_API_L2CAP_CONNECT))) != NULL) {
|
|
p_msg->hdr.event = BTA_JV_API_L2CAP_CONNECT_EVT;
|
|
p_msg->sec_mask = sec_mask;
|
|
p_msg->role = role;
|
|
p_msg->remote_psm = remote_psm;
|
|
p_msg->rx_mtu = rx_mtu;
|
|
if (cfg != NULL) {
|
|
p_msg->has_cfg = TRUE;
|
|
p_msg->cfg = *cfg;
|
|
} else {
|
|
p_msg->has_cfg = FALSE;
|
|
}
|
|
if (ertm_info != NULL) {
|
|
p_msg->has_ertm_info = TRUE;
|
|
p_msg->ertm_info = *ertm_info;
|
|
} else {
|
|
p_msg->has_ertm_info = FALSE;
|
|
}
|
|
memcpy(p_msg->peer_bd_addr, peer_bd_addr, sizeof(BD_ADDR));
|
|
p_msg->p_cback = p_cback;
|
|
p_msg->user_data = user_data;
|
|
bta_sys_sendmsg(p_msg);
|
|
status = BTA_JV_SUCCESS;
|
|
}
|
|
|
|
return (status);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTA_JvL2capClose
|
|
**
|
|
** Description This function closes an L2CAP client connection
|
|
**
|
|
** Returns BTA_JV_SUCCESS, if the request is being processed.
|
|
** BTA_JV_FAILURE, otherwise.
|
|
**
|
|
*******************************************************************************/
|
|
tBTA_JV_STATUS BTA_JvL2capClose(UINT32 handle)
|
|
{
|
|
tBTA_JV_STATUS status = BTA_JV_FAILURE;
|
|
tBTA_JV_API_L2CAP_CLOSE *p_msg;
|
|
|
|
APPL_TRACE_API( "%s", __func__);
|
|
|
|
if (handle < BTA_JV_MAX_L2C_CONN && bta_jv_cb.l2c_cb[handle].p_cback &&
|
|
(p_msg = (tBTA_JV_API_L2CAP_CLOSE *)osi_malloc(sizeof(tBTA_JV_API_L2CAP_CLOSE))) != NULL) {
|
|
p_msg->hdr.event = BTA_JV_API_L2CAP_CLOSE_EVT;
|
|
p_msg->handle = handle;
|
|
p_msg->p_cb = &bta_jv_cb.l2c_cb[handle];
|
|
bta_sys_sendmsg(p_msg);
|
|
status = BTA_JV_SUCCESS;
|
|
}
|
|
|
|
return (status);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTA_JvL2capCloseLE
|
|
**
|
|
** Description This function closes an L2CAP client connection for Fixed Channels
|
|
** Function is idempotent and no callbacks are called!
|
|
**
|
|
** Returns BTA_JV_SUCCESS, if the request is being processed.
|
|
** BTA_JV_FAILURE, otherwise.
|
|
**
|
|
*******************************************************************************/
|
|
tBTA_JV_STATUS BTA_JvL2capCloseLE(UINT32 handle)
|
|
{
|
|
tBTA_JV_STATUS status = BTA_JV_FAILURE;
|
|
tBTA_JV_API_L2CAP_CLOSE *p_msg;
|
|
|
|
APPL_TRACE_API( "%s", __func__);
|
|
|
|
if ((p_msg = (tBTA_JV_API_L2CAP_CLOSE *)osi_malloc(sizeof(tBTA_JV_API_L2CAP_CLOSE))) != NULL) {
|
|
p_msg->hdr.event = BTA_JV_API_L2CAP_CLOSE_FIXED_EVT;
|
|
p_msg->handle = handle;
|
|
bta_sys_sendmsg(p_msg);
|
|
status = BTA_JV_SUCCESS;
|
|
}
|
|
|
|
return (status);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTA_JvL2capStartServer
|
|
**
|
|
** Description This function starts an L2CAP server and listens for an L2CAP
|
|
** connection from a remote Bluetooth device. When the server
|
|
** is started successfully, tBTA_JV_L2CAP_CBACK is called with
|
|
** BTA_JV_L2CAP_START_EVT. When the connection is established,
|
|
** tBTA_JV_L2CAP_CBACK is called with BTA_JV_L2CAP_OPEN_EVT.
|
|
**
|
|
** Returns BTA_JV_SUCCESS, if the request is being processed.
|
|
** BTA_JV_FAILURE, otherwise.
|
|
**
|
|
*******************************************************************************/
|
|
tBTA_JV_STATUS BTA_JvL2capStartServer(tBTA_SEC sec_mask, tBTA_JV_ROLE role,
|
|
const tL2CAP_ERTM_INFO *ertm_info, UINT16 local_psm, UINT16 rx_mtu, tL2CAP_CFG_INFO *cfg,
|
|
tBTA_JV_L2CAP_CBACK *p_cback, void *user_data)
|
|
{
|
|
tBTA_JV_STATUS status = BTA_JV_FAILURE;
|
|
tBTA_JV_API_L2CAP_SERVER *p_msg;
|
|
|
|
APPL_TRACE_API( "%s", __func__);
|
|
|
|
if (p_cback &&
|
|
(p_msg = (tBTA_JV_API_L2CAP_SERVER *)osi_malloc(sizeof(tBTA_JV_API_L2CAP_SERVER))) != NULL) {
|
|
p_msg->hdr.event = BTA_JV_API_L2CAP_START_SERVER_EVT;
|
|
p_msg->sec_mask = sec_mask;
|
|
p_msg->role = role;
|
|
p_msg->local_psm = local_psm;
|
|
p_msg->rx_mtu = rx_mtu;
|
|
if (cfg != NULL) {
|
|
p_msg->has_cfg = TRUE;
|
|
p_msg->cfg = *cfg;
|
|
} else {
|
|
p_msg->has_cfg = FALSE;
|
|
}
|
|
if (ertm_info != NULL) {
|
|
p_msg->has_ertm_info = TRUE;
|
|
p_msg->ertm_info = *ertm_info;
|
|
} else {
|
|
p_msg->has_ertm_info = FALSE;
|
|
}
|
|
p_msg->p_cback = p_cback;
|
|
p_msg->user_data = user_data;
|
|
bta_sys_sendmsg(p_msg);
|
|
status = BTA_JV_SUCCESS;
|
|
}
|
|
|
|
return (status);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTA_JvL2capStartServerLE
|
|
**
|
|
** Description This function starts an LE L2CAP server and listens for an L2CAP
|
|
** connection from a remote Bluetooth device. When the server
|
|
** is started successfully, tBTA_JV_L2CAP_CBACK is called with
|
|
** BTA_JV_L2CAP_START_EVT. When the connection is established,
|
|
** tBTA_JV_L2CAP_CBACK is called with BTA_JV_L2CAP_OPEN_EVT.
|
|
**
|
|
** Returns BTA_JV_SUCCESS, if the request is being processed.
|
|
** BTA_JV_FAILURE, otherwise.
|
|
**
|
|
*******************************************************************************/
|
|
tBTA_JV_STATUS BTA_JvL2capStartServerLE(tBTA_SEC sec_mask, tBTA_JV_ROLE role,
|
|
const tL2CAP_ERTM_INFO *ertm_info, UINT16 local_chan, UINT16 rx_mtu, tL2CAP_CFG_INFO *cfg,
|
|
tBTA_JV_L2CAP_CBACK *p_cback, void *user_data)
|
|
{
|
|
tBTA_JV_STATUS status = BTA_JV_FAILURE;
|
|
tBTA_JV_API_L2CAP_SERVER *p_msg;
|
|
|
|
APPL_TRACE_API( "%s", __func__);
|
|
|
|
if (p_cback &&
|
|
(p_msg = (tBTA_JV_API_L2CAP_SERVER *)osi_malloc(sizeof(tBTA_JV_API_L2CAP_SERVER))) != NULL) {
|
|
p_msg->hdr.event = BTA_JV_API_L2CAP_START_SERVER_LE_EVT;
|
|
p_msg->sec_mask = sec_mask;
|
|
p_msg->role = role;
|
|
p_msg->local_chan = local_chan;
|
|
p_msg->rx_mtu = rx_mtu;
|
|
if (cfg != NULL) {
|
|
p_msg->has_cfg = TRUE;
|
|
p_msg->cfg = *cfg;
|
|
} else {
|
|
p_msg->has_cfg = FALSE;
|
|
}
|
|
if (ertm_info != NULL) {
|
|
p_msg->has_ertm_info = TRUE;
|
|
p_msg->ertm_info = *ertm_info;
|
|
} else {
|
|
p_msg->has_ertm_info = FALSE;
|
|
}
|
|
p_msg->p_cback = p_cback;
|
|
p_msg->user_data = user_data;
|
|
bta_sys_sendmsg(p_msg);
|
|
status = BTA_JV_SUCCESS;
|
|
}
|
|
|
|
return (status);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTA_JvL2capStopServer
|
|
**
|
|
** Description This function stops the L2CAP server. If the server has an
|
|
** active connection, it would be closed.
|
|
**
|
|
** Returns BTA_JV_SUCCESS, if the request is being processed.
|
|
** BTA_JV_FAILURE, otherwise.
|
|
**
|
|
*******************************************************************************/
|
|
tBTA_JV_STATUS BTA_JvL2capStopServer(UINT16 local_psm, void *user_data)
|
|
{
|
|
tBTA_JV_STATUS status = BTA_JV_FAILURE;
|
|
tBTA_JV_API_L2CAP_SERVER *p_msg;
|
|
|
|
APPL_TRACE_API( "%s", __func__);
|
|
|
|
if ((p_msg = (tBTA_JV_API_L2CAP_SERVER *)osi_malloc(sizeof(tBTA_JV_API_L2CAP_SERVER))) != NULL) {
|
|
p_msg->hdr.event = BTA_JV_API_L2CAP_STOP_SERVER_EVT;
|
|
p_msg->local_psm = local_psm;
|
|
p_msg->user_data = user_data;
|
|
bta_sys_sendmsg(p_msg);
|
|
status = BTA_JV_SUCCESS;
|
|
}
|
|
|
|
return (status);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTA_JvL2capStopServerLE
|
|
**
|
|
** Description This function stops the LE L2CAP server. If the server has an
|
|
** active connection, it would be closed.
|
|
**
|
|
** Returns BTA_JV_SUCCESS, if the request is being processed.
|
|
** BTA_JV_FAILURE, otherwise.
|
|
**
|
|
*******************************************************************************/
|
|
tBTA_JV_STATUS BTA_JvL2capStopServerLE(UINT16 local_chan, void *user_data)
|
|
{
|
|
tBTA_JV_STATUS status = BTA_JV_FAILURE;
|
|
tBTA_JV_API_L2CAP_SERVER *p_msg;
|
|
|
|
APPL_TRACE_API( "%s", __func__);
|
|
|
|
if ((p_msg = (tBTA_JV_API_L2CAP_SERVER *)osi_malloc(sizeof(tBTA_JV_API_L2CAP_SERVER))) != NULL) {
|
|
p_msg->hdr.event = BTA_JV_API_L2CAP_STOP_SERVER_LE_EVT;
|
|
p_msg->local_chan = local_chan;
|
|
p_msg->user_data = user_data;
|
|
bta_sys_sendmsg(p_msg);
|
|
status = BTA_JV_SUCCESS;
|
|
}
|
|
|
|
return (status);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTA_JvL2capRead
|
|
**
|
|
** Description This function reads data from an L2CAP connecti;
|
|
tBTA_JV_RFC_CB *p_cb = rc->p_cb;
|
|
on
|
|
** When the operation is complete, tBTA_JV_L2CAP_CBACK is
|
|
** called with BTA_JV_L2CAP_READ_EVT.
|
|
**
|
|
** Returns BTA_JV_SUCCESS, if the request is being processed.
|
|
** BTA_JV_FAILURE, otherwise.
|
|
**
|
|
*******************************************************************************/
|
|
tBTA_JV_STATUS BTA_JvL2capRead(UINT32 handle, UINT32 req_id, UINT8 *p_data, UINT16 len)
|
|
{
|
|
tBTA_JV_STATUS status = BTA_JV_FAILURE;
|
|
tBTA_JV_L2CAP_READ evt_data;
|
|
|
|
APPL_TRACE_API( "%s", __func__);
|
|
|
|
|
|
if (handle < BTA_JV_MAX_L2C_CONN && bta_jv_cb.l2c_cb[handle].p_cback) {
|
|
status = BTA_JV_SUCCESS;
|
|
evt_data.status = BTA_JV_FAILURE;
|
|
evt_data.handle = handle;
|
|
evt_data.req_id = req_id;
|
|
evt_data.p_data = p_data;
|
|
evt_data.len = 0;
|
|
|
|
if (BT_PASS == GAP_ConnReadData((UINT16)handle, p_data, len, &evt_data.len)) {
|
|
evt_data.status = BTA_JV_SUCCESS;
|
|
}
|
|
bta_jv_cb.l2c_cb[handle].p_cback(
|
|
BTA_JV_L2CAP_READ_EVT, (tBTA_JV *)&evt_data, bta_jv_cb.l2c_cb[handle].user_data);
|
|
}
|
|
|
|
return (status);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTA_JvL2capReceive
|
|
**
|
|
** Description This function reads data from an L2CAP connection
|
|
** When the operation is complete, tBTA_JV_L2CAP_CBACK is
|
|
** called with BTA_JV_L2CAP_RECEIVE_EVT.
|
|
** If there are more data queued in L2CAP than len, the extra data will be discarded.
|
|
**
|
|
** Returns BTA_JV_SUCCESS, if the request is being processed.
|
|
** BTA_JV_FAILURE, otherwise.
|
|
**
|
|
*******************************************************************************/
|
|
tBTA_JV_STATUS BTA_JvL2capReceive(UINT32 handle, UINT32 req_id, UINT8 *p_data, UINT16 len)
|
|
{
|
|
tBTA_JV_STATUS status = BTA_JV_FAILURE;
|
|
tBTA_JV_L2CAP_RECEIVE evt_data;
|
|
UINT32 left_over = 0;
|
|
UINT16 max_len, read_len;
|
|
|
|
APPL_TRACE_API( "%s", __func__);
|
|
|
|
|
|
if (handle < BTA_JV_MAX_L2C_CONN && bta_jv_cb.l2c_cb[handle].p_cback) {
|
|
status = BTA_JV_SUCCESS;
|
|
evt_data.status = BTA_JV_FAILURE;
|
|
evt_data.handle = handle;
|
|
evt_data.req_id = req_id;
|
|
evt_data.p_data = p_data;
|
|
evt_data.len = 0;
|
|
|
|
if (BT_PASS == GAP_ConnReadData((UINT16)handle, p_data, len, &evt_data.len)) {
|
|
evt_data.status = BTA_JV_SUCCESS;
|
|
GAP_GetRxQueueCnt ((UINT16)handle, &left_over);
|
|
while (left_over) {
|
|
max_len = (left_over > 0xFFFF) ? 0xFFFF : left_over;
|
|
GAP_ConnReadData ((UINT16)handle, NULL, max_len, &read_len);
|
|
left_over -= read_len;
|
|
}
|
|
}
|
|
bta_jv_cb.l2c_cb[handle].p_cback(
|
|
BTA_JV_L2CAP_RECEIVE_EVT, (tBTA_JV *)&evt_data, bta_jv_cb.l2c_cb[handle].user_data);
|
|
}
|
|
|
|
return (status);
|
|
}
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTA_JvL2capReady
|
|
**
|
|
** Description This function determined if there is data to read from
|
|
** an L2CAP connection
|
|
**
|
|
** Returns BTA_JV_SUCCESS, if data queue size is in *p_data_size.
|
|
** BTA_JV_FAILURE, if error.
|
|
**
|
|
*******************************************************************************/
|
|
tBTA_JV_STATUS BTA_JvL2capReady(UINT32 handle, UINT32 *p_data_size)
|
|
{
|
|
tBTA_JV_STATUS status = BTA_JV_FAILURE;
|
|
|
|
APPL_TRACE_API( "%s: %d", __func__, handle);
|
|
if (p_data_size && handle < BTA_JV_MAX_L2C_CONN && bta_jv_cb.l2c_cb[handle].p_cback) {
|
|
*p_data_size = 0;
|
|
if (BT_PASS == GAP_GetRxQueueCnt((UINT16)handle, p_data_size) ) {
|
|
status = BTA_JV_SUCCESS;
|
|
}
|
|
}
|
|
|
|
return (status);
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTA_JvL2capWrite
|
|
**
|
|
** Description This function writes data to an L2CAP connection
|
|
** When the operation is complete, tBTA_JV_L2CAP_CBACK is
|
|
** called with BTA_JV_L2CAP_WRITE_EVT. Works for
|
|
** PSM-based connections
|
|
**
|
|
** Returns BTA_JV_SUCCESS, if the request is being processed.
|
|
** BTA_JV_FAILURE, otherwise.
|
|
**
|
|
*******************************************************************************/
|
|
tBTA_JV_STATUS BTA_JvL2capWrite(UINT32 handle, UINT32 req_id, UINT8 *p_data,
|
|
UINT16 len, void *user_data)
|
|
{
|
|
tBTA_JV_STATUS status = BTA_JV_FAILURE;
|
|
tBTA_JV_API_L2CAP_WRITE *p_msg;
|
|
|
|
APPL_TRACE_API( "%s", __func__);
|
|
|
|
if (handle < BTA_JV_MAX_L2C_CONN && bta_jv_cb.l2c_cb[handle].p_cback &&
|
|
(p_msg = (tBTA_JV_API_L2CAP_WRITE *)osi_malloc(sizeof(tBTA_JV_API_L2CAP_WRITE))) != NULL) {
|
|
p_msg->hdr.event = BTA_JV_API_L2CAP_WRITE_EVT;
|
|
p_msg->handle = handle;
|
|
p_msg->req_id = req_id;
|
|
p_msg->p_data = p_data;
|
|
p_msg->p_cb = &bta_jv_cb.l2c_cb[handle];
|
|
p_msg->len = len;
|
|
p_msg->user_data = user_data;
|
|
bta_sys_sendmsg(p_msg);
|
|
status = BTA_JV_SUCCESS;
|
|
}
|
|
|
|
return (status);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTA_JvL2capWriteFixed
|
|
**
|
|
** Description This function writes data to an L2CAP connection
|
|
** When the operation is complete, tBTA_JV_L2CAP_CBACK is
|
|
** called with BTA_JV_L2CAP_WRITE_EVT. Works for
|
|
** fixed-channel connections
|
|
**
|
|
** Returns BTA_JV_SUCCESS, if the request is being processed.
|
|
** BTA_JV_FAILURE, otherwise.
|
|
**
|
|
*******************************************************************************/
|
|
tBTA_JV_STATUS BTA_JvL2capWriteFixed(UINT16 channel, BD_ADDR *addr, UINT32 req_id,
|
|
tBTA_JV_L2CAP_CBACK *p_cback, UINT8 *p_data, UINT16 len, void *user_data)
|
|
{
|
|
tBTA_JV_STATUS status = BTA_JV_FAILURE;
|
|
tBTA_JV_API_L2CAP_WRITE_FIXED *p_msg;
|
|
|
|
APPL_TRACE_API( "%s", __func__);
|
|
|
|
if ((p_msg =
|
|
(tBTA_JV_API_L2CAP_WRITE_FIXED *)osi_malloc(sizeof(tBTA_JV_API_L2CAP_WRITE_FIXED))) != NULL) {
|
|
p_msg->hdr.event = BTA_JV_API_L2CAP_WRITE_FIXED_EVT;
|
|
p_msg->channel = channel;
|
|
memcpy(p_msg->addr, addr, sizeof(p_msg->addr));
|
|
p_msg->req_id = req_id;
|
|
p_msg->p_data = p_data;
|
|
p_msg->p_cback = p_cback;
|
|
p_msg->len = len;
|
|
p_msg->user_data = user_data;
|
|
bta_sys_sendmsg(p_msg);
|
|
status = BTA_JV_SUCCESS;
|
|
}
|
|
|
|
return (status);
|
|
}
|
|
#endif /* BTA_JV_L2CAP_INCLUDED */
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTA_JvRfcommConnect
|
|
**
|
|
** Description This function makes an RFCOMM conection to a remote BD
|
|
** Address.
|
|
** When the connection is initiated or failed to initiate,
|
|
** tBTA_JV_RFCOMM_CBACK is called with BTA_JV_RFCOMM_CL_INIT_EVT
|
|
** When the connection is established or failed,
|
|
** tBTA_JV_RFCOMM_CBACK is called with BTA_JV_RFCOMM_OPEN_EVT
|
|
**
|
|
** Returns BTA_JV_SUCCESS, if the request is being processed.
|
|
** BTA_JV_FAILURE, otherwise.
|
|
**
|
|
*******************************************************************************/
|
|
tBTA_JV_STATUS BTA_JvRfcommConnect(tBTA_SEC sec_mask,
|
|
tBTA_JV_ROLE role, UINT8 remote_scn, BD_ADDR peer_bd_addr,
|
|
tBTA_JV_RFCOMM_CBACK *p_cback, void *user_data)
|
|
{
|
|
tBTA_JV_STATUS status = BTA_JV_FAILURE;
|
|
tBTA_JV_API_RFCOMM_CONNECT *p_msg;
|
|
|
|
APPL_TRACE_API( "BTA_JvRfcommConnect");
|
|
if (p_cback &&
|
|
(p_msg = (tBTA_JV_API_RFCOMM_CONNECT *)osi_malloc(sizeof(tBTA_JV_API_RFCOMM_CONNECT))) != NULL) {
|
|
p_msg->hdr.event = BTA_JV_API_RFCOMM_CONNECT_EVT;
|
|
p_msg->sec_mask = sec_mask;
|
|
p_msg->role = role;
|
|
p_msg->remote_scn = remote_scn;
|
|
memcpy(p_msg->peer_bd_addr, peer_bd_addr, sizeof(BD_ADDR));
|
|
p_msg->p_cback = p_cback;
|
|
p_msg->user_data = user_data;
|
|
bta_sys_sendmsg(p_msg);
|
|
status = BTA_JV_SUCCESS;
|
|
}
|
|
|
|
return (status);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTA_JvRfcommClose
|
|
**
|
|
** Description This function closes an RFCOMM connection
|
|
** When the connection is established or failed,
|
|
** tBTA_JV_RFCOMM_CBACK is called with BTA_JV_RFCOMM_CLOSE_EVT
|
|
** Returns BTA_JV_SUCCESS, if the request is being processed.
|
|
** BTA_JV_FAILURE, otherwise.
|
|
**
|
|
*******************************************************************************/
|
|
tBTA_JV_STATUS BTA_JvRfcommClose(UINT32 handle, tBTA_JV_RFCOMM_CBACK *p_cback, void *user_data)
|
|
{
|
|
tBTA_JV_STATUS status = BTA_JV_FAILURE;
|
|
tBTA_JV_API_RFCOMM_CLOSE *p_msg;
|
|
UINT32 hi = ((handle & BTA_JV_RFC_HDL_MASK) & ~BTA_JV_RFCOMM_MASK) - 1;
|
|
UINT32 si = BTA_JV_RFC_HDL_TO_SIDX(handle);
|
|
|
|
APPL_TRACE_API( "%s", __func__);
|
|
if (hi < BTA_JV_MAX_RFC_CONN && bta_jv_cb.rfc_cb[hi].p_cback &&
|
|
si < BTA_JV_MAX_RFC_SR_SESSION && bta_jv_cb.rfc_cb[hi].rfc_hdl[si] &&
|
|
(p_msg = (tBTA_JV_API_RFCOMM_CLOSE *)osi_malloc(sizeof(tBTA_JV_API_RFCOMM_CLOSE))) != NULL) {
|
|
p_msg->hdr.event = BTA_JV_API_RFCOMM_CLOSE_EVT;
|
|
p_msg->handle = handle;
|
|
p_msg->p_cb = &bta_jv_cb.rfc_cb[hi];
|
|
p_msg->p_pcb = &bta_jv_cb.port_cb[p_msg->p_cb->rfc_hdl[si] - 1];
|
|
p_msg->p_cback = p_cback;
|
|
p_msg->user_data = user_data;
|
|
bta_sys_sendmsg(p_msg);
|
|
status = BTA_JV_SUCCESS;
|
|
}
|
|
|
|
return (status);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTA_JvRfcommStartServer
|
|
**
|
|
** Description This function starts listening for an RFCOMM connection
|
|
** request from a remote Bluetooth device. When the server is
|
|
** started successfully, tBTA_JV_RFCOMM_CBACK is called
|
|
** with BTA_JV_RFCOMM_START_EVT.
|
|
** When the connection is established, tBTA_JV_RFCOMM_CBACK
|
|
** is called with BTA_JV_RFCOMM_OPEN_EVT.
|
|
**
|
|
** Returns BTA_JV_SUCCESS, if the request is being processed.
|
|
** BTA_JV_FAILURE, otherwise.
|
|
**
|
|
*******************************************************************************/
|
|
tBTA_JV_STATUS BTA_JvRfcommStartServer(tBTA_SEC sec_mask,
|
|
tBTA_JV_ROLE role, UINT8 local_scn, UINT8 max_session,
|
|
tBTA_JV_RFCOMM_CBACK *p_cback, void *user_data)
|
|
{
|
|
tBTA_JV_STATUS status = BTA_JV_FAILURE;
|
|
tBTA_JV_API_RFCOMM_SERVER *p_msg;
|
|
|
|
APPL_TRACE_API( "BTA_JvRfcommStartServer");
|
|
if (p_cback &&
|
|
(p_msg = (tBTA_JV_API_RFCOMM_SERVER *)osi_malloc(sizeof(tBTA_JV_API_RFCOMM_SERVER))) != NULL) {
|
|
if (max_session == 0) {
|
|
max_session = 1;
|
|
}
|
|
if (max_session > BTA_JV_MAX_RFC_SR_SESSION) {
|
|
APPL_TRACE_DEBUG( "max_session (%d) is too big. use max (%d)", max_session, BTA_JV_MAX_RFC_SR_SESSION);
|
|
max_session = BTA_JV_MAX_RFC_SR_SESSION;
|
|
}
|
|
p_msg->hdr.event = BTA_JV_API_RFCOMM_START_SERVER_EVT;
|
|
p_msg->sec_mask = sec_mask;
|
|
p_msg->role = role;
|
|
p_msg->local_scn = local_scn;
|
|
p_msg->max_session = max_session;
|
|
p_msg->p_cback = p_cback;
|
|
p_msg->user_data = user_data; //caller's private data
|
|
bta_sys_sendmsg(p_msg);
|
|
status = BTA_JV_SUCCESS;
|
|
}
|
|
|
|
return (status);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTA_JvRfcommStopServer
|
|
**
|
|
** Description This function stops the RFCOMM server. If the server has an
|
|
** active connection, it would be closed.
|
|
**
|
|
** Returns BTA_JV_SUCCESS, if the request is being processed.
|
|
** BTA_JV_FAILURE, otherwise.
|
|
**
|
|
*******************************************************************************/
|
|
tBTA_JV_STATUS BTA_JvRfcommStopServer(UINT32 handle, void *user_data)
|
|
{
|
|
tBTA_JV_STATUS status = BTA_JV_FAILURE;
|
|
tBTA_JV_API_RFCOMM_SERVER *p_msg;
|
|
APPL_TRACE_API( "BTA_JvRfcommStopServer");
|
|
if ((p_msg = (tBTA_JV_API_RFCOMM_SERVER *)osi_malloc(sizeof(tBTA_JV_API_RFCOMM_SERVER))) != NULL) {
|
|
p_msg->hdr.event = BTA_JV_API_RFCOMM_STOP_SERVER_EVT;
|
|
p_msg->handle = handle;
|
|
p_msg->user_data = user_data; //caller's private data
|
|
bta_sys_sendmsg(p_msg);
|
|
status = BTA_JV_SUCCESS;
|
|
}
|
|
|
|
return (status);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTA_JvRfcommRead
|
|
**
|
|
** Description This function reads data from an RFCOMM connection
|
|
** The actual size of data read is returned in p_len.
|
|
**
|
|
** Returns BTA_JV_SUCCESS, if the request is being processed.
|
|
** BTA_JV_FAILURE, otherwise.
|
|
**
|
|
*******************************************************************************/
|
|
tBTA_JV_STATUS BTA_JvRfcommRead(UINT32 handle, UINT32 req_id, UINT8 *p_data, UINT16 len)
|
|
{
|
|
tBTA_JV_STATUS status = BTA_JV_FAILURE;
|
|
tBTA_JV_API_RFCOMM_READ *p_msg;
|
|
UINT32 hi = ((handle & BTA_JV_RFC_HDL_MASK) & ~BTA_JV_RFCOMM_MASK) - 1;
|
|
UINT32 si = BTA_JV_RFC_HDL_TO_SIDX(handle);
|
|
|
|
APPL_TRACE_API( "BTA_JvRfcommRead");
|
|
if (hi < BTA_JV_MAX_RFC_CONN && bta_jv_cb.rfc_cb[hi].p_cback &&
|
|
si < BTA_JV_MAX_RFC_SR_SESSION && bta_jv_cb.rfc_cb[hi].rfc_hdl[si] &&
|
|
(p_msg = (tBTA_JV_API_RFCOMM_READ *)osi_malloc(sizeof(tBTA_JV_API_RFCOMM_READ))) != NULL) {
|
|
p_msg->hdr.event = BTA_JV_API_RFCOMM_READ_EVT;
|
|
p_msg->handle = handle;
|
|
p_msg->req_id = req_id;
|
|
p_msg->p_data = p_data;
|
|
p_msg->len = len;
|
|
p_msg->p_cb = &bta_jv_cb.rfc_cb[hi];
|
|
p_msg->p_pcb = &bta_jv_cb.port_cb[p_msg->p_cb->rfc_hdl[si] - 1];
|
|
bta_sys_sendmsg(p_msg);
|
|
status = BTA_JV_SUCCESS;
|
|
}
|
|
|
|
return (status);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTA_JvRfcommGetPortHdl
|
|
**
|
|
** Description This function fetches the rfcomm port handle
|
|
**
|
|
** Returns BTA_JV_SUCCESS, if the request is being processed.
|
|
** BTA_JV_FAILURE, otherwise.
|
|
**
|
|
*******************************************************************************/
|
|
UINT16 BTA_JvRfcommGetPortHdl(UINT32 handle)
|
|
{
|
|
UINT32 hi = ((handle & BTA_JV_RFC_HDL_MASK) & ~BTA_JV_RFCOMM_MASK) - 1;
|
|
UINT32 si = BTA_JV_RFC_HDL_TO_SIDX(handle);
|
|
|
|
if (hi < BTA_JV_MAX_RFC_CONN &&
|
|
si < BTA_JV_MAX_RFC_SR_SESSION && bta_jv_cb.rfc_cb[hi].rfc_hdl[si]) {
|
|
return bta_jv_cb.port_cb[bta_jv_cb.rfc_cb[hi].rfc_hdl[si] - 1].port_handle;
|
|
} else {
|
|
return 0xffff;
|
|
}
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTA_JvRfcommReady
|
|
**
|
|
** Description This function determined if there is data to read from
|
|
** an RFCOMM connection
|
|
**
|
|
** Returns BTA_JV_SUCCESS, if data queue size is in *p_data_size.
|
|
** BTA_JV_FAILURE, if error.
|
|
**
|
|
*******************************************************************************/
|
|
tBTA_JV_STATUS BTA_JvRfcommReady(UINT32 handle, UINT32 *p_data_size)
|
|
{
|
|
tBTA_JV_STATUS status = BTA_JV_FAILURE;
|
|
UINT16 size = 0;
|
|
UINT32 hi = ((handle & BTA_JV_RFC_HDL_MASK) & ~BTA_JV_RFCOMM_MASK) - 1;
|
|
UINT32 si = BTA_JV_RFC_HDL_TO_SIDX(handle);
|
|
|
|
APPL_TRACE_API( "BTA_JvRfcommReady");
|
|
if (hi < BTA_JV_MAX_RFC_CONN && bta_jv_cb.rfc_cb[hi].p_cback &&
|
|
si < BTA_JV_MAX_RFC_SR_SESSION && bta_jv_cb.rfc_cb[hi].rfc_hdl[si]) {
|
|
if (PORT_GetRxQueueCnt(bta_jv_cb.rfc_cb[hi].rfc_hdl[si], &size) == PORT_SUCCESS) {
|
|
status = BTA_JV_SUCCESS;
|
|
}
|
|
}
|
|
*p_data_size = size;
|
|
return (status);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTA_JvRfcommWrite
|
|
**
|
|
** Description This function writes data to an RFCOMM connection
|
|
**
|
|
** Returns BTA_JV_SUCCESS, if the request is being processed.
|
|
** BTA_JV_FAILURE, otherwise.
|
|
**
|
|
*******************************************************************************/
|
|
|
|
tBTA_JV_STATUS BTA_JvRfcommWrite(UINT32 handle, UINT32 req_id, int len, UINT8 *p_data)
|
|
{
|
|
tBTA_JV_STATUS status = BTA_JV_FAILURE;
|
|
tBTA_JV_API_RFCOMM_WRITE *p_msg;
|
|
UINT32 hi = ((handle & BTA_JV_RFC_HDL_MASK) & ~BTA_JV_RFCOMM_MASK) - 1;
|
|
UINT32 si = BTA_JV_RFC_HDL_TO_SIDX(handle);
|
|
|
|
APPL_TRACE_API( "BTA_JvRfcommWrite");
|
|
APPL_TRACE_DEBUG( "handle:0x%x, hi:%d, si:%d", handle, hi, si);
|
|
if (hi < BTA_JV_MAX_RFC_CONN && bta_jv_cb.rfc_cb[hi].p_cback &&
|
|
si < BTA_JV_MAX_RFC_SR_SESSION && bta_jv_cb.rfc_cb[hi].rfc_hdl[si] &&
|
|
(p_msg = (tBTA_JV_API_RFCOMM_WRITE *)osi_malloc(sizeof(tBTA_JV_API_RFCOMM_WRITE))) != NULL) {
|
|
p_msg->hdr.event = BTA_JV_API_RFCOMM_WRITE_EVT;
|
|
p_msg->handle = handle;
|
|
p_msg->req_id = req_id;
|
|
p_msg->p_cb = &bta_jv_cb.rfc_cb[hi];
|
|
p_msg->p_pcb = &bta_jv_cb.port_cb[p_msg->p_cb->rfc_hdl[si] - 1];
|
|
p_msg->p_data = p_data;
|
|
p_msg->len = len;
|
|
APPL_TRACE_API( "write ok");
|
|
bta_sys_sendmsg(p_msg);
|
|
status = BTA_JV_SUCCESS;
|
|
}
|
|
return (status);
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTA_JVSetPmProfile
|
|
**
|
|
** Description This function set or free power mode profile for different JV application
|
|
**
|
|
** Parameters: handle, JV handle from RFCOMM or L2CAP
|
|
** app_id: app specific pm ID, can be BTA_JV_PM_ALL, see bta_dm_cfg.c for details
|
|
** BTA_JV_PM_ID_CLEAR: removes pm management on the handle. init_st is ignored and
|
|
** BTA_JV_CONN_CLOSE is called implicitely
|
|
** init_st: state after calling this API. typically it should be BTA_JV_CONN_OPEN
|
|
**
|
|
** Returns BTA_JV_SUCCESS, if the request is being processed.
|
|
** BTA_JV_FAILURE, otherwise.
|
|
**
|
|
** NOTE: BTA_JV_PM_ID_CLEAR: In general no need to be called as jv pm calls automatically
|
|
** BTA_JV_CONN_CLOSE to remove in case of connection close!
|
|
**
|
|
*******************************************************************************/
|
|
tBTA_JV_STATUS BTA_JvSetPmProfile(UINT32 handle, tBTA_JV_PM_ID app_id, tBTA_JV_CONN_STATE init_st)
|
|
{
|
|
tBTA_JV_STATUS status = BTA_JV_FAILURE;
|
|
tBTA_JV_API_SET_PM_PROFILE *p_msg;
|
|
|
|
APPL_TRACE_API("BTA_JVSetPmProfile handle:0x%x, app_id:%d", handle, app_id);
|
|
if ((p_msg = (tBTA_JV_API_SET_PM_PROFILE *)osi_malloc(sizeof(tBTA_JV_API_SET_PM_PROFILE)))
|
|
!= NULL) {
|
|
p_msg->hdr.event = BTA_JV_API_SET_PM_PROFILE_EVT;
|
|
p_msg->handle = handle;
|
|
p_msg->app_id = app_id;
|
|
p_msg->init_st = init_st;
|
|
bta_sys_sendmsg(p_msg);
|
|
status = BTA_JV_SUCCESS;
|
|
}
|
|
|
|
return (status);
|
|
}
|
|
|
|
#endif ///defined BTA_JV_INCLUDED && BTA_JV_INCLUDED == TRUE
|