You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
594 lines
23 KiB
594 lines
23 KiB
/******************************************************************************
|
|
*
|
|
* Copyright 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 <base/bind.h>
|
|
#include <base/location.h>
|
|
#include <base/logging.h>
|
|
#include <cstdint>
|
|
#include <memory>
|
|
|
|
#include "bt_target.h" // Must be first to define build configuration
|
|
|
|
#include "bta/jv/bta_jv_int.h"
|
|
#include "stack/include/btu.h" // do_in_main_thread
|
|
#include "stack/include/gap_api.h"
|
|
#include "types/bluetooth/uuid.h"
|
|
#include "types/raw_address.h"
|
|
|
|
using base::Bind;
|
|
using bluetooth::Uuid;
|
|
|
|
namespace {
|
|
bool bta_jv_enabled = false;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* 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) {
|
|
if (!p_cback || bta_jv_enabled) {
|
|
LOG(ERROR) << __func__ << ": failure";
|
|
return BTA_JV_FAILURE;
|
|
}
|
|
|
|
VLOG(2) << __func__;
|
|
|
|
memset(&bta_jv_cb, 0, sizeof(tBTA_JV_CB));
|
|
/* set handle to invalid value by default */
|
|
for (int i = 0; i < BTA_JV_PM_MAX_NUM; i++) {
|
|
bta_jv_cb.pm_cb[i].handle = BTA_JV_PM_HANDLE_CLEAR;
|
|
}
|
|
bta_jv_cb.dyn_psm = 0xfff;
|
|
used_l2cap_classic_dynamic_psm = {};
|
|
|
|
bta_jv_enabled = true;
|
|
|
|
do_in_main_thread(FROM_HERE, Bind(&bta_jv_enable, p_cback));
|
|
return BTA_JV_SUCCESS;
|
|
}
|
|
|
|
/** Disable the Java I/F */
|
|
void BTA_JvDisable(void) {
|
|
VLOG(2) << __func__;
|
|
|
|
bta_jv_enabled = false;
|
|
|
|
do_in_main_thread(FROM_HERE, Bind(&bta_jv_disable));
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* 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 void
|
|
*
|
|
******************************************************************************/
|
|
void BTA_JvGetChannelId(int conn_type, uint32_t id, int32_t channel) {
|
|
VLOG(2) << __func__ << ": conn_type=" << conn_type;
|
|
|
|
if (conn_type != BTA_JV_CONN_TYPE_RFCOMM &&
|
|
conn_type != BTA_JV_CONN_TYPE_L2CAP &&
|
|
conn_type != BTA_JV_CONN_TYPE_L2CAP_LE) {
|
|
CHECK(false) << "Invalid conn_type=" << conn_type;
|
|
}
|
|
|
|
do_in_main_thread(FROM_HERE,
|
|
Bind(&bta_jv_get_channel_id, conn_type, channel, id, id));
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* 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_
|
|
*
|
|
* Returns BTA_JV_SUCCESS, if the request is being processed.
|
|
* BTA_JV_FAILURE, otherwise.
|
|
*
|
|
******************************************************************************/
|
|
tBTA_JV_STATUS BTA_JvFreeChannel(uint16_t channel, int conn_type) {
|
|
VLOG(2) << __func__;
|
|
|
|
do_in_main_thread(FROM_HERE, Bind(&bta_jv_free_scn, conn_type, channel));
|
|
return BTA_JV_SUCCESS;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* 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(const RawAddress& bd_addr,
|
|
uint16_t num_uuid, const Uuid* p_uuid_list,
|
|
uint32_t rfcomm_slot_id) {
|
|
VLOG(2) << __func__;
|
|
|
|
Uuid* uuid_list_copy = new Uuid[num_uuid];
|
|
memcpy(uuid_list_copy, p_uuid_list, num_uuid * sizeof(Uuid));
|
|
|
|
do_in_main_thread(FROM_HERE,
|
|
Bind(&bta_jv_start_discovery, bd_addr, num_uuid,
|
|
base::Owned(uuid_list_copy), rfcomm_slot_id));
|
|
return BTA_JV_SUCCESS;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* 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(uint32_t rfcomm_slot_id) {
|
|
VLOG(2) << __func__;
|
|
|
|
do_in_main_thread(FROM_HERE, Bind(&bta_jv_create_record, rfcomm_slot_id));
|
|
return BTA_JV_SUCCESS;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* 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_t handle) {
|
|
VLOG(2) << __func__;
|
|
|
|
do_in_main_thread(FROM_HERE, Bind(&bta_jv_delete_record, handle));
|
|
return BTA_JV_SUCCESS;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* 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
|
|
*
|
|
******************************************************************************/
|
|
void BTA_JvL2capConnect(int conn_type, tBTA_SEC sec_mask, tBTA_JV_ROLE role,
|
|
std::unique_ptr<tL2CAP_ERTM_INFO> ertm_info,
|
|
uint16_t remote_psm, uint16_t rx_mtu,
|
|
std::unique_ptr<tL2CAP_CFG_INFO> cfg,
|
|
const RawAddress& peer_bd_addr,
|
|
tBTA_JV_L2CAP_CBACK* p_cback,
|
|
uint32_t l2cap_socket_id) {
|
|
VLOG(2) << __func__;
|
|
CHECK(p_cback);
|
|
|
|
do_in_main_thread(FROM_HERE,
|
|
Bind(&bta_jv_l2cap_connect, conn_type, sec_mask, role,
|
|
remote_psm, rx_mtu, peer_bd_addr, base::Passed(&cfg),
|
|
base::Passed(&ertm_info), p_cback, l2cap_socket_id));
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* 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_t handle) {
|
|
VLOG(2) << __func__;
|
|
|
|
if (handle >= BTA_JV_MAX_L2C_CONN || !bta_jv_cb.l2c_cb[handle].p_cback)
|
|
return BTA_JV_FAILURE;
|
|
|
|
do_in_main_thread(
|
|
FROM_HERE, Bind(&bta_jv_l2cap_close, handle, &bta_jv_cb.l2c_cb[handle]));
|
|
return BTA_JV_SUCCESS;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* 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 void
|
|
*
|
|
******************************************************************************/
|
|
void BTA_JvL2capStartServer(int conn_type, tBTA_SEC sec_mask, tBTA_JV_ROLE role,
|
|
std::unique_ptr<tL2CAP_ERTM_INFO> ertm_info,
|
|
uint16_t local_psm, uint16_t rx_mtu,
|
|
std::unique_ptr<tL2CAP_CFG_INFO> cfg,
|
|
tBTA_JV_L2CAP_CBACK* p_cback,
|
|
uint32_t l2cap_socket_id) {
|
|
VLOG(2) << __func__;
|
|
CHECK(p_cback);
|
|
|
|
do_in_main_thread(FROM_HERE,
|
|
Bind(&bta_jv_l2cap_start_server, conn_type, sec_mask, role,
|
|
local_psm, rx_mtu, base::Passed(&cfg),
|
|
base::Passed(&ertm_info), p_cback, l2cap_socket_id));
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* 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_t local_psm,
|
|
uint32_t l2cap_socket_id) {
|
|
VLOG(2) << __func__;
|
|
|
|
do_in_main_thread(
|
|
FROM_HERE, Bind(&bta_jv_l2cap_stop_server, local_psm, l2cap_socket_id));
|
|
return BTA_JV_SUCCESS;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function BTA_JvL2capRead
|
|
*
|
|
* Description This function reads data from an L2CAP connection
|
|
* 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_t handle, uint32_t req_id,
|
|
uint8_t* p_data, uint16_t len) {
|
|
VLOG(2) << __func__;
|
|
|
|
if (handle >= BTA_JV_MAX_L2C_CONN || !bta_jv_cb.l2c_cb[handle].p_cback)
|
|
return BTA_JV_FAILURE;
|
|
|
|
tBTA_JV_L2CAP_READ evt_data;
|
|
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_t)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].l2cap_socket_id);
|
|
return BTA_JV_SUCCESS;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* 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_t handle, uint32_t* p_data_size) {
|
|
tBTA_JV_STATUS status = BTA_JV_FAILURE;
|
|
|
|
VLOG(2) << __func__ << ": handle=" << 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_t)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. This function takes ownership of
|
|
* p_data, and will osi_free it. Data length must be smaller
|
|
* than remote maximum SDU size.
|
|
*
|
|
* Returns BTA_JV_SUCCESS, if the request is being processed.
|
|
* BTA_JV_FAILURE, otherwise.
|
|
*
|
|
******************************************************************************/
|
|
tBTA_JV_STATUS BTA_JvL2capWrite(uint32_t handle, uint32_t req_id, BT_HDR* msg,
|
|
uint32_t user_id) {
|
|
VLOG(2) << __func__;
|
|
|
|
if (handle >= BTA_JV_MAX_L2C_CONN || !bta_jv_cb.l2c_cb[handle].p_cback) {
|
|
osi_free(msg);
|
|
return BTA_JV_FAILURE;
|
|
}
|
|
|
|
do_in_main_thread(FROM_HERE, Bind(&bta_jv_l2cap_write, handle, req_id, msg,
|
|
user_id, &bta_jv_cb.l2c_cb[handle]));
|
|
return BTA_JV_SUCCESS;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* 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_t remote_scn,
|
|
const RawAddress& peer_bd_addr,
|
|
tBTA_JV_RFCOMM_CBACK* p_cback,
|
|
uint32_t rfcomm_slot_id) {
|
|
VLOG(2) << __func__;
|
|
|
|
if (!p_cback) return BTA_JV_FAILURE; /* Nothing to do */
|
|
|
|
do_in_main_thread(FROM_HERE,
|
|
Bind(&bta_jv_rfcomm_connect, sec_mask, remote_scn,
|
|
peer_bd_addr, p_cback, rfcomm_slot_id));
|
|
return BTA_JV_SUCCESS;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function BTA_JvRfcommClose
|
|
*
|
|
* Description This function closes an RFCOMM connection
|
|
*
|
|
* Returns BTA_JV_SUCCESS, if the request is being processed.
|
|
* BTA_JV_FAILURE, otherwise.
|
|
*
|
|
******************************************************************************/
|
|
tBTA_JV_STATUS BTA_JvRfcommClose(uint32_t handle, uint32_t rfcomm_slot_id) {
|
|
uint32_t hi = ((handle & BTA_JV_RFC_HDL_MASK) & ~BTA_JV_RFCOMM_MASK) - 1;
|
|
uint32_t si = BTA_JV_RFC_HDL_TO_SIDX(handle);
|
|
|
|
VLOG(2) << __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])
|
|
return BTA_JV_FAILURE;
|
|
|
|
do_in_main_thread(FROM_HERE,
|
|
Bind(&bta_jv_rfcomm_close, handle, rfcomm_slot_id));
|
|
return BTA_JV_SUCCESS;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* 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_t local_scn, uint8_t max_session,
|
|
tBTA_JV_RFCOMM_CBACK* p_cback,
|
|
uint32_t rfcomm_slot_id) {
|
|
VLOG(2) << __func__;
|
|
|
|
if (p_cback == NULL) return BTA_JV_FAILURE; /* Nothing to do */
|
|
|
|
if (max_session == 0) max_session = 1;
|
|
if (max_session > BTA_JV_MAX_RFC_SR_SESSION) {
|
|
LOG(INFO) << __func__ << "max_session is too big. use max "
|
|
<< BTA_JV_MAX_RFC_SR_SESSION;
|
|
max_session = BTA_JV_MAX_RFC_SR_SESSION;
|
|
}
|
|
|
|
do_in_main_thread(FROM_HERE,
|
|
Bind(&bta_jv_rfcomm_start_server, sec_mask, local_scn,
|
|
max_session, p_cback, rfcomm_slot_id));
|
|
return BTA_JV_SUCCESS;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* 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_t handle,
|
|
uint32_t rfcomm_slot_id) {
|
|
VLOG(2) << __func__;
|
|
|
|
do_in_main_thread(FROM_HERE,
|
|
Bind(&bta_jv_rfcomm_stop_server, handle, rfcomm_slot_id));
|
|
return BTA_JV_SUCCESS;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* 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_t BTA_JvRfcommGetPortHdl(uint32_t handle) {
|
|
uint32_t hi = ((handle & BTA_JV_RFC_HDL_MASK) & ~BTA_JV_RFCOMM_MASK) - 1;
|
|
uint32_t 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_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_t handle, uint32_t req_id) {
|
|
uint32_t hi = ((handle & BTA_JV_RFC_HDL_MASK) & ~BTA_JV_RFCOMM_MASK) - 1;
|
|
uint32_t si = BTA_JV_RFC_HDL_TO_SIDX(handle);
|
|
|
|
VLOG(2) << __func__;
|
|
|
|
VLOG(2) << __func__ << "handle=" << loghex(handle) << ", hi=" << hi
|
|
<< ", si=" << 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]) {
|
|
return BTA_JV_FAILURE;
|
|
}
|
|
|
|
VLOG(2) << "write ok";
|
|
|
|
tBTA_JV_RFC_CB* p_cb = &bta_jv_cb.rfc_cb[hi];
|
|
do_in_main_thread(FROM_HERE, Bind(&bta_jv_rfcomm_write, handle, req_id, p_cb,
|
|
&bta_jv_cb.port_cb[p_cb->rfc_hdl[si] - 1]));
|
|
return BTA_JV_SUCCESS;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* 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 implicitly
|
|
* 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_t handle, tBTA_JV_PM_ID app_id,
|
|
tBTA_JV_CONN_STATE init_st) {
|
|
VLOG(2) << __func__ << " handle=" << loghex(handle) << ", app_id:" << app_id;
|
|
|
|
do_in_main_thread(FROM_HERE,
|
|
Bind(&bta_jv_set_pm_profile, handle, app_id, init_st));
|
|
return BTA_JV_SUCCESS;
|
|
}
|