typedef void(tBTA_JV_DM_CBACK)(tBTA_JV_EVT event, tBTA_JV* p_data, uint32_t id);
/* JAVA RFCOMM interface callback */
-typedef void*(tBTA_JV_RFCOMM_CBACK)(tBTA_JV_EVT event, tBTA_JV* p_data,
- void* user_data);
+typedef uint32_t(tBTA_JV_RFCOMM_CBACK)(tBTA_JV_EVT event, tBTA_JV* p_data,
+ uint32_t rfcomm_slot_id);
/* JAVA L2CAP interface callback */
typedef void(tBTA_JV_L2CAP_CBACK)(tBTA_JV_EVT event, tBTA_JV* p_data,
* BTA_JV_FAILURE, otherwise.
*
******************************************************************************/
-tBTA_JV_STATUS BTA_JvCreateRecordByUser(void* user_data);
+tBTA_JV_STATUS BTA_JvCreateRecordByUser(uint32_t rfcomm_slot_id);
/*******************************************************************************
*
tBTA_JV_STATUS BTA_JvRfcommConnect(tBTA_SEC sec_mask, tBTA_JV_ROLE role,
uint8_t remote_scn, BD_ADDR peer_bd_addr,
tBTA_JV_RFCOMM_CBACK* p_cback,
- void* user_data);
+ uint32_t rfcomm_slot_id);
/*******************************************************************************
*
* BTA_JV_FAILURE, otherwise.
*
******************************************************************************/
-tBTA_JV_STATUS BTA_JvRfcommClose(uint32_t handle, void* user_data);
+tBTA_JV_STATUS BTA_JvRfcommClose(uint32_t handle, uint32_t rfcomm_slot_id);
/*******************************************************************************
*
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,
- void* user_data);
+ uint32_t rfcomm_slot_id);
/*******************************************************************************
*
* BTA_JV_FAILURE, otherwise.
*
******************************************************************************/
-tBTA_JV_STATUS BTA_JvRfcommStopServer(uint32_t handle, void* user_data);
+tBTA_JV_STATUS BTA_JvRfcommStopServer(uint32_t handle, uint32_t rfcomm_slot_id);
/*******************************************************************************
*
*
******************************************************************************/
-extern int bta_co_rfc_data_incoming(void* user_data, BT_HDR* p_buf);
-extern int bta_co_rfc_data_outgoing_size(void* user_data, int* size);
-extern int bta_co_rfc_data_outgoing(void* user_data, uint8_t* buf,
+extern int bta_co_rfc_data_incoming(uint32_t rfcomm_slot_id, BT_HDR* p_buf);
+extern int bta_co_rfc_data_outgoing_size(uint32_t rfcomm_slot_id, int* size);
+extern int bta_co_rfc_data_outgoing(uint32_t rfcomm_slot_id, uint8_t* buf,
uint16_t size);
extern int bta_co_l2cap_data_incoming(void* user_data, BT_HDR* p_buf);
APPL_TRACE_DEBUG(
"bta_jv_free_sr_rfc_cb: max_sess:%d, curr_sess:%d, p_pcb:%p, user:"
"%p, state:%d, jv handle: 0x%x",
- p_cb->max_sess, p_cb->curr_sess, p_pcb, p_pcb->user_data, p_pcb->state,
- p_pcb->handle);
+ p_cb->max_sess, p_cb->curr_sess, p_pcb, p_pcb->rfcomm_slot_id,
+ p_pcb->state, p_pcb->handle);
if (p_cb->curr_sess <= 0) return BTA_JV_SUCCESS;
APPL_TRACE_WARNING(
"bta_jv_free_sr_rfc_cb: return on closing, port state:%d, "
"scn:%d, p_pcb:%p, user_data:%p",
- p_pcb->state, p_cb->scn, p_pcb, p_pcb->user_data);
+ p_pcb->state, p_cb->scn, p_pcb, p_pcb->rfcomm_slot_id);
status = BTA_JV_FAILURE;
return status;
case BTA_JV_ST_CL_OPEN:
APPL_TRACE_DEBUG(
"bta_jv_free_sr_rfc_cb: state: %d, scn:%d,"
" user_data:%p",
- p_pcb->state, p_cb->scn, p_pcb->user_data);
+ p_pcb->state, p_cb->scn, p_pcb->rfcomm_slot_id);
p_pcb->state = BTA_JV_ST_CL_CLOSING;
break;
case BTA_JV_ST_SR_LISTEN:
APPL_TRACE_DEBUG(
"bta_jv_free_sr_rfc_cb: state: BTA_JV_ST_SR_LISTEN, scn:%d,"
" user_data:%p",
- p_cb->scn, p_pcb->user_data);
+ p_cb->scn, p_pcb->rfcomm_slot_id);
break;
case BTA_JV_ST_SR_OPEN:
p_pcb->state = BTA_JV_ST_SR_CLOSING;
APPL_TRACE_DEBUG(
"bta_jv_free_sr_rfc_cb: state: BTA_JV_ST_SR_OPEN, scn:%d,"
" user_data:%p",
- p_cb->scn, p_pcb->user_data);
+ p_cb->scn, p_pcb->rfcomm_slot_id);
break;
default:
APPL_TRACE_WARNING(
"bta_jv_free_sr_rfc_cb():failed, ignore port state:%d, scn:"
"%d, p_pcb:%p, jv handle: 0x%x, port_handle: %d, user_data:%p",
p_pcb->state, p_cb->scn, p_pcb, p_pcb->handle, p_pcb->port_handle,
- p_pcb->user_data);
+ p_pcb->rfcomm_slot_id);
status = BTA_JV_FAILURE;
break;
}
// Initialize congestion flags
p_pcb->cong = false;
- p_pcb->user_data = 0;
+ p_pcb->rfcomm_slot_id = 0;
int si = BTA_JV_RFC_HDL_TO_SIDX(p_pcb->handle);
if (0 <= si && si < BTA_JV_MAX_RFC_SR_SESSION) p_cb->rfc_hdl[si] = 0;
p_pcb->handle = 0;
* Returns void
*
******************************************************************************/
-static void bta_jv_start_discovery_cback(uint16_t result,
- void* rfcomm_slot_id) {
+static void bta_jv_start_discovery_cback(uint16_t result, void* user_data) {
tBTA_JV_STATUS status;
+ uint32_t* p_rfcomm_slot_id = static_cast<uint32_t*>(user_data);
APPL_TRACE_DEBUG("bta_jv_start_discovery_cback res: 0x%x", result);
dcomp.status = status;
bta_jv_cb.p_dm_cback(BTA_JV_DISCOVERY_COMP_EVT, (tBTA_JV*)&dcomp,
- PTR_TO_UINT(rfcomm_slot_id));
+ *p_rfcomm_slot_id);
+ osi_free(p_rfcomm_slot_id);
}
}
bta_jv_cb.uuid = p_data->start_discovery.uuid_list[0];
bta_jv_cb.sdp_active = BTA_JV_SDP_ACT_YES;
+
+ uint32_t* rfcomm_slot_id = (uint32_t*)osi_malloc(sizeof(uint32_t));
+ *rfcomm_slot_id = p_data->start_discovery.rfcomm_slot_id;
+
if (!SDP_ServiceSearchAttributeRequest2(
p_data->start_discovery.bd_addr, p_bta_jv_cfg->p_sdp_db,
- bta_jv_start_discovery_cback,
- UINT_TO_PTR(p_data->start_discovery.rfcomm_slot_id))) {
+ bta_jv_start_discovery_cback, (void*)rfcomm_slot_id)) {
bta_jv_cb.sdp_active = BTA_JV_SDP_ACT_NONE;
/* failed to start SDP. report the failure right away */
if (bta_jv_cb.p_dm_cback)
// callback user immediately to create his own sdp record in stack thread
// context
bta_jv_cb.p_dm_cback(BTA_JV_CREATE_RECORD_EVT, (tBTA_JV*)&evt_data,
- PTR_TO_UINT(cr->user_data));
+ cr->rfcomm_slot_id);
}
/*******************************************************************************
if (p_pcb != NULL) {
switch (type) {
case DATA_CO_CALLBACK_TYPE_INCOMING:
- return bta_co_rfc_data_incoming(p_pcb->user_data, (BT_HDR*)buf);
+ return bta_co_rfc_data_incoming(p_pcb->rfcomm_slot_id, (BT_HDR*)buf);
case DATA_CO_CALLBACK_TYPE_OUTGOING_SIZE:
- return bta_co_rfc_data_outgoing_size(p_pcb->user_data, (int*)buf);
+ return bta_co_rfc_data_outgoing_size(p_pcb->rfcomm_slot_id, (int*)buf);
case DATA_CO_CALLBACK_TYPE_OUTGOING:
- return bta_co_rfc_data_outgoing(p_pcb->user_data, buf, len);
+ return bta_co_rfc_data_outgoing(p_pcb->rfcomm_slot_id, buf, len);
default:
APPL_TRACE_ERROR("unknown callout type:%d", type);
break;
evt_data.rfc_open.status = BTA_JV_SUCCESS;
bdcpy(evt_data.rfc_open.rem_bda, rem_bda);
p_pcb->state = BTA_JV_ST_CL_OPEN;
- p_cb->p_cback(BTA_JV_RFCOMM_OPEN_EVT, &evt_data, p_pcb->user_data);
+ p_cb->p_cback(BTA_JV_RFCOMM_OPEN_EVT, &evt_data, p_pcb->rfcomm_slot_id);
} else {
evt_data.rfc_close.handle = p_cb->handle;
evt_data.rfc_close.status = BTA_JV_FAILURE;
// p_pcb->state = BTA_JV_ST_NONE;
// p_pcb->cong = false;
p_cback = p_cb->p_cback;
- p_cback(BTA_JV_RFCOMM_CLOSE_EVT, &evt_data, p_pcb->user_data);
+ p_cback(BTA_JV_RFCOMM_CLOSE_EVT, &evt_data, p_pcb->rfcomm_slot_id);
// bta_jv_free_rfc_cb(p_cb, p_pcb);
}
}
port_handle, p_cb->handle);
if (code & PORT_EV_RXCHAR) {
evt_data.data_ind.handle = p_cb->handle;
- p_cb->p_cback(BTA_JV_RFCOMM_DATA_IND_EVT, &evt_data, p_pcb->user_data);
+ p_cb->p_cback(BTA_JV_RFCOMM_DATA_IND_EVT, &evt_data, p_pcb->rfcomm_slot_id);
}
if (code & PORT_EV_FC) {
evt_data.rfc_cong.cong = p_pcb->cong;
evt_data.rfc_cong.handle = p_cb->handle;
evt_data.rfc_cong.status = BTA_JV_SUCCESS;
- p_cb->p_cback(BTA_JV_RFCOMM_CONG_EVT, &evt_data, p_pcb->user_data);
+ p_cb->p_cback(BTA_JV_RFCOMM_CONG_EVT, &evt_data, p_pcb->rfcomm_slot_id);
}
if (code & PORT_EV_TXEMPTY) {
p_cb->sec_id = sec_id;
p_cb->scn = 0;
p_pcb->state = BTA_JV_ST_CL_OPENING;
- p_pcb->user_data = cc->user_data;
+ p_pcb->rfcomm_slot_id = cc->rfcomm_slot_id;
evt_data.use_co = true;
PORT_SetEventCallback(handle, bta_jv_port_event_cl_cback);
APPL_TRACE_ERROR("run out of rfc control block");
}
}
- cc->p_cback(BTA_JV_RFCOMM_CL_INIT_EVT, (tBTA_JV*)&evt_data, cc->user_data);
+ cc->p_cback(BTA_JV_RFCOMM_CL_INIT_EVT, (tBTA_JV*)&evt_data,
+ cc->rfcomm_slot_id);
if (evt_data.status == BTA_JV_FAILURE) {
if (sec_id) bta_jv_free_sec_id(&sec_id);
if (handle) RFCOMM_RemoveConnection(handle);
}
}
-static int find_rfc_pcb(void* user_data, tBTA_JV_RFC_CB** cb,
+static int find_rfc_pcb(uint32_t rfcomm_slot_id, tBTA_JV_RFC_CB** cb,
tBTA_JV_PCB** pcb) {
*cb = NULL;
*pcb = NULL;
for (i = 0; i < MAX_RFC_PORTS; i++) {
uint32_t rfc_handle = bta_jv_cb.port_cb[i].handle & BTA_JV_RFC_HDL_MASK;
rfc_handle &= ~BTA_JV_RFCOMM_MASK;
- if (rfc_handle && bta_jv_cb.port_cb[i].user_data == user_data) {
+ if (rfc_handle && bta_jv_cb.port_cb[i].rfcomm_slot_id == rfcomm_slot_id) {
*pcb = &bta_jv_cb.port_cb[i];
*cb = &bta_jv_cb.rfc_cb[rfc_handle - 1];
APPL_TRACE_DEBUG(
}
}
APPL_TRACE_DEBUG("find_rfc_pcb: cannot find rfc_cb from user data: %u",
- PTR_TO_UINT(user_data));
+ rfcomm_slot_id);
return 0;
}
return;
}
- void* user_data = cc->user_data;
- if (!find_rfc_pcb(user_data, &p_cb, &p_pcb)) return;
+ if (!find_rfc_pcb(cc->rfcomm_slot_id, &p_cb, &p_pcb)) return;
bta_jv_free_rfc_cb(p_cb, p_pcb);
APPL_TRACE_DEBUG("bta_jv_rfcomm_close: sec id in use:%d, rfc_cb in use:%d",
get_sec_id_used(), get_rfc_cb_used());
p_cb, p_cb ? p_cb->p_cback : NULL);
return;
}
- void* user_data = p_pcb->user_data;
+ uint32_t rfcomm_slot_id = p_pcb->rfcomm_slot_id;
APPL_TRACE_DEBUG(
"bta_jv_port_mgmt_sr_cback code=%d port_handle:0x%x handle:0x%x, "
"p_pcb:%p, user:%d",
- code, port_handle, p_cb->handle, p_pcb, p_pcb->user_data);
+ code, port_handle, p_cb->handle, p_pcb, p_pcb->rfcomm_slot_id);
PORT_CheckConnection(port_handle, rem_bda, &lcid);
int failed = true;
tBTA_JV_PCB* p_pcb_new_listen = bta_jv_add_rfc_port(p_cb, p_pcb);
if (p_pcb_new_listen) {
evt_data.rfc_srv_open.new_listen_handle = p_pcb_new_listen->handle;
- p_pcb_new_listen->user_data =
- p_cb->p_cback(BTA_JV_RFCOMM_SRV_OPEN_EVT, &evt_data, user_data);
+ p_pcb_new_listen->rfcomm_slot_id =
+ p_cb->p_cback(BTA_JV_RFCOMM_SRV_OPEN_EVT, &evt_data, rfcomm_slot_id);
APPL_TRACE_DEBUG("PORT_SUCCESS: curr_sess:%d, max_sess:%d",
p_cb->curr_sess, p_cb->max_sess);
failed = false;
evt_data.rfc_close.status = BTA_JV_SUCCESS;
}
// p_pcb->state = BTA_JV_ST_NONE;
- p_cback(BTA_JV_RFCOMM_CLOSE_EVT, &evt_data, user_data);
+ p_cback(BTA_JV_RFCOMM_CLOSE_EVT, &evt_data, rfcomm_slot_id);
// bta_jv_free_rfc_cb(p_cb, p_pcb);
APPL_TRACE_DEBUG(
"bta_jv_port_event_sr_cback code=x%x port_handle:%d handle:%d", code,
port_handle, p_cb->handle);
- void* user_data = p_pcb->user_data;
+ uint32_t user_data = p_pcb->rfcomm_slot_id;
if (code & PORT_EV_RXCHAR) {
evt_data.data_ind.handle = p_cb->handle;
p_cb->p_cback(BTA_JV_RFCOMM_DATA_IND_EVT, &evt_data, user_data);
p_pcb = &bta_jv_cb.port_cb[p_cb->rfc_hdl[si] - 1];
p_pcb->state = BTA_JV_ST_SR_LISTEN;
p_pcb->port_handle = p_cb->rfc_hdl[si];
- p_pcb->user_data = p_pcb_open->user_data;
+ p_pcb->rfcomm_slot_id = p_pcb_open->rfcomm_slot_id;
PORT_ClearKeepHandleFlag(p_pcb->port_handle);
PORT_SetEventCallback(p_pcb->port_handle, bta_jv_port_event_sr_cback);
p_cb->sec_id = sec_id;
p_cb->scn = rs->local_scn;
p_pcb->state = BTA_JV_ST_SR_LISTEN;
- p_pcb->user_data = rs->user_data;
+ p_pcb->rfcomm_slot_id = rs->rfcomm_slot_id;
evt_data.status = BTA_JV_SUCCESS;
evt_data.handle = p_cb->handle;
evt_data.sec_id = sec_id;
PORT_SetState(handle, &port_state);
} while (0);
- rs->p_cback(BTA_JV_RFCOMM_START_EVT, (tBTA_JV*)&evt_data, rs->user_data);
+ rs->p_cback(BTA_JV_RFCOMM_START_EVT, (tBTA_JV*)&evt_data, rs->rfcomm_slot_id);
if (evt_data.status == BTA_JV_SUCCESS) {
PORT_SetDataCOCallback(handle, bta_jv_port_data_co_cback);
} else {
APPL_TRACE_ERROR("bta_jv_rfcomm_stop_server, jv handle is null");
return;
}
- void* user_data = ls->user_data;
- if (!find_rfc_pcb(user_data, &p_cb, &p_pcb)) return;
+
+ if (!find_rfc_pcb(ls->rfcomm_slot_id, &p_cb, &p_pcb)) return;
APPL_TRACE_DEBUG("bta_jv_rfcomm_stop_server: p_pcb:%p, p_pcb->port_handle:%d",
p_pcb, p_pcb->port_handle);
bta_jv_free_rfc_cb(p_cb, p_pcb);
if (p_cb->p_cback) {
p_cb->p_cback(BTA_JV_RFCOMM_WRITE_EVT, (tBTA_JV*)&evt_data,
- p_pcb->user_data);
+ p_pcb->rfcomm_slot_id);
} else {
APPL_TRACE_ERROR("%s No JV callback set", __func__);
}
* BTA_JV_FAILURE, otherwise.
*
******************************************************************************/
-tBTA_JV_STATUS BTA_JvCreateRecordByUser(void* user_data) {
+tBTA_JV_STATUS BTA_JvCreateRecordByUser(uint32_t rfcomm_slot_id) {
tBTA_JV_API_CREATE_RECORD* p_msg =
(tBTA_JV_API_CREATE_RECORD*)osi_malloc(sizeof(tBTA_JV_API_CREATE_RECORD));
APPL_TRACE_API("%s", __func__);
p_msg->hdr.event = BTA_JV_API_CREATE_RECORD_EVT;
- p_msg->user_data = user_data;
+ p_msg->rfcomm_slot_id = rfcomm_slot_id;
bta_sys_sendmsg(p_msg);
tBTA_JV_STATUS BTA_JvRfcommConnect(tBTA_SEC sec_mask, tBTA_JV_ROLE role,
uint8_t remote_scn, BD_ADDR peer_bd_addr,
tBTA_JV_RFCOMM_CBACK* p_cback,
- void* user_data) {
+ uint32_t rfcomm_slot_id) {
APPL_TRACE_API("%s", __func__);
if (p_cback == NULL) return BTA_JV_FAILURE; /* Nothing to do */
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;
+ p_msg->rfcomm_slot_id = rfcomm_slot_id;
bta_sys_sendmsg(p_msg);
* BTA_JV_FAILURE, otherwise.
*
******************************************************************************/
-tBTA_JV_STATUS BTA_JvRfcommClose(uint32_t handle, void* user_data) {
+tBTA_JV_STATUS BTA_JvRfcommClose(uint32_t handle, uint32_t rfcomm_slot_id) {
tBTA_JV_STATUS status = BTA_JV_FAILURE;
uint32_t hi = ((handle & BTA_JV_RFC_HDL_MASK) & ~BTA_JV_RFCOMM_MASK) - 1;
uint32_t si = BTA_JV_RFC_HDL_TO_SIDX(handle);
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->user_data = user_data;
+ p_msg->rfcomm_slot_id = rfcomm_slot_id;
bta_sys_sendmsg(p_msg);
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,
- void* user_data) {
+ uint32_t rfcomm_slot_id) {
APPL_TRACE_API("%s", __func__);
if (p_cback == NULL) return BTA_JV_FAILURE; /* Nothing to do */
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
+ p_msg->rfcomm_slot_id = rfcomm_slot_id; // caller's private data
bta_sys_sendmsg(p_msg);
* BTA_JV_FAILURE, otherwise.
*
******************************************************************************/
-tBTA_JV_STATUS BTA_JvRfcommStopServer(uint32_t handle, void* user_data) {
+tBTA_JV_STATUS BTA_JvRfcommStopServer(uint32_t handle,
+ uint32_t rfcomm_slot_id) {
tBTA_JV_API_RFCOMM_SERVER* p_msg =
(tBTA_JV_API_RFCOMM_SERVER*)osi_malloc(sizeof(tBTA_JV_API_RFCOMM_SERVER));
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
+ p_msg->rfcomm_slot_id = rfcomm_slot_id; // caller's private data
bta_sys_sendmsg(p_msg);
/* port control block */
typedef struct {
- uint32_t handle; /* the rfcomm session handle at jv */
- uint16_t port_handle; /* port handle */
- tBTA_JV_STATE state; /* the state of this control block */
- uint8_t max_sess; /* max sessions */
- void* user_data; /* piggyback caller's private data*/
+ uint32_t handle; /* the rfcomm session handle at jv */
+ uint16_t port_handle; /* port handle */
+ tBTA_JV_STATE state; /* the state of this control block */
+ uint8_t max_sess; /* max sessions */
+ uint32_t rfcomm_slot_id;
bool cong; /* true, if congested */
tBTA_JV_PM_CB* p_pm_cb; /* ptr to pm control block, NULL: unused */
} tBTA_JV_PCB;
uint8_t remote_scn;
BD_ADDR peer_bd_addr;
tBTA_JV_RFCOMM_CBACK* p_cback;
- void* user_data;
+ uint32_t rfcomm_slot_id;
} tBTA_JV_API_RFCOMM_CONNECT;
/* data type for BTA_JV_API_RFCOMM_SERVER_EVT */
uint8_t max_session;
uint32_t handle;
tBTA_JV_RFCOMM_CBACK* p_cback;
- void* user_data;
+ uint32_t rfcomm_slot_id;
} tBTA_JV_API_RFCOMM_SERVER;
/* data type for BTA_JV_API_SET_PM_PROFILE_EVT */
uint32_t handle;
tBTA_JV_RFC_CB* p_cb;
tBTA_JV_PCB* p_pcb;
- void* user_data;
+ uint32_t rfcomm_slot_id;
} tBTA_JV_API_RFCOMM_CLOSE;
/* data type for BTA_JV_API_CREATE_RECORD_EVT */
typedef struct {
BT_HDR hdr;
- void* user_data;
+ uint32_t rfcomm_slot_id;
} tBTA_JV_API_CREATE_RECORD;
/* data type for BTA_JV_API_ADD_ATTRIBUTE_EVT */
static rfc_slot_t* find_free_slot(void);
static void cleanup_rfc_slot(rfc_slot_t* rs);
static void jv_dm_cback(tBTA_JV_EVT event, tBTA_JV* p_data, uint32_t id);
-static void* rfcomm_cback(tBTA_JV_EVT event, tBTA_JV* p_data, void* user_data);
+static uint32_t rfcomm_cback(tBTA_JV_EVT event, tBTA_JV* p_data,
+ uint32_t rfcomm_slot_id);
static bool send_app_scn(rfc_slot_t* rs);
static bool is_init_done(void) { return pth != -1; }
}
if (is_uuid_empty(service_uuid)) {
- tBTA_JV_STATUS ret = BTA_JvRfcommConnect(
- slot->security, slot->role, slot->scn, slot->addr.address, rfcomm_cback,
- (void*)(uintptr_t)slot->id);
+ tBTA_JV_STATUS ret =
+ BTA_JvRfcommConnect(slot->security, slot->role, slot->scn,
+ slot->addr.address, rfcomm_cback, slot->id);
if (ret != BTA_JV_SUCCESS) {
LOG_ERROR(LOG_TAG, "%s unable to initiate RFCOMM connection: %d",
__func__, ret);
if (slot->scn <= 0) return;
if (slot->f.server && !slot->f.closing && slot->rfc_handle) {
- BTA_JvRfcommStopServer(slot->rfc_handle, (void*)(uintptr_t)slot->id);
+ BTA_JvRfcommStopServer(slot->rfc_handle, slot->id);
slot->rfc_handle = 0;
}
}
if (slot->rfc_handle && !slot->f.closing && !slot->f.server) {
- BTA_JvRfcommClose(slot->rfc_handle, (void*)(uintptr_t)slot->id);
+ BTA_JvRfcommClose(slot->rfc_handle, slot->id);
slot->rfc_handle = 0;
}
}
}
-static void* rfcomm_cback(tBTA_JV_EVT event, tBTA_JV* p_data, void* user_data) {
- void* new_user_data = NULL;
+static uint32_t rfcomm_cback(tBTA_JV_EVT event, tBTA_JV* p_data,
+ uint32_t rfcomm_slot_id) {
+ uint32_t id = 0;
switch (event) {
case BTA_JV_RFCOMM_START_EVT:
- on_srv_rfc_listen_started(&p_data->rfc_start, (uintptr_t)user_data);
+ on_srv_rfc_listen_started(&p_data->rfc_start, rfcomm_slot_id);
break;
case BTA_JV_RFCOMM_CL_INIT_EVT:
- on_cl_rfc_init(&p_data->rfc_cl_init, (uintptr_t)user_data);
+ on_cl_rfc_init(&p_data->rfc_cl_init, rfcomm_slot_id);
break;
case BTA_JV_RFCOMM_OPEN_EVT:
BTA_JvSetPmProfile(p_data->rfc_open.handle, BTA_JV_PM_ID_1,
BTA_JV_CONN_OPEN);
- on_cli_rfc_connect(&p_data->rfc_open, (uintptr_t)user_data);
+ on_cli_rfc_connect(&p_data->rfc_open, rfcomm_slot_id);
break;
case BTA_JV_RFCOMM_SRV_OPEN_EVT:
BTA_JvSetPmProfile(p_data->rfc_srv_open.handle, BTA_JV_PM_ALL,
BTA_JV_CONN_OPEN);
- new_user_data = (void*)(uintptr_t)on_srv_rfc_connect(
- &p_data->rfc_srv_open, (uintptr_t)user_data);
+ id = on_srv_rfc_connect(&p_data->rfc_srv_open, rfcomm_slot_id);
break;
case BTA_JV_RFCOMM_CLOSE_EVT:
- APPL_TRACE_DEBUG("BTA_JV_RFCOMM_CLOSE_EVT: user_data:%d",
- (uintptr_t)user_data);
- on_rfc_close(&p_data->rfc_close, (uintptr_t)user_data);
+ APPL_TRACE_DEBUG("BTA_JV_RFCOMM_CLOSE_EVT: rfcomm_slot_id:%d",
+ rfcomm_slot_id);
+ on_rfc_close(&p_data->rfc_close, rfcomm_slot_id);
break;
case BTA_JV_RFCOMM_WRITE_EVT:
- on_rfc_write_done(&p_data->rfc_write, (uintptr_t)user_data);
+ on_rfc_write_done(&p_data->rfc_write, rfcomm_slot_id);
break;
case BTA_JV_RFCOMM_CONG_EVT:
- on_rfc_outgoing_congest(&p_data->rfc_cong, (uintptr_t)user_data);
+ on_rfc_outgoing_congest(&p_data->rfc_cong, rfcomm_slot_id);
break;
case BTA_JV_RFCOMM_DATA_IND_EVT:
default:
LOG_ERROR(LOG_TAG, "%s unhandled event %d, slot id: %zi", __func__, event,
- (uintptr_t)user_data);
+ rfcomm_slot_id);
break;
}
- return new_user_data;
+ return id;
}
static void jv_dm_cback(tBTA_JV_EVT event, tBTA_JV* p_data, uint32_t id) {
if (rs->is_service_uuid_valid == true) {
// We already have data for SDP record, create it (RFC-only
// profiles)
- BTA_JvCreateRecordByUser(UINT_TO_PTR(rs->id));
+ BTA_JvCreateRecordByUser(rs->id);
} else {
APPL_TRACE_DEBUG(
"is_service_uuid_valid==false - don't set SDP-record, "
rs->id);
// now start the rfcomm server after sdp & channel # assigned
BTA_JvRfcommStartServer(rs->security, rs->role, rs->scn,
- MAX_RFC_SESSION, rfcomm_cback,
- UINT_TO_PTR(rs->id));
+ MAX_RFC_SESSION, rfcomm_cback, rs->id);
}
}
} else if (rs) {
if (slot && create_server_sdp_record(slot)) {
// Start the rfcomm server after sdp & channel # assigned.
BTA_JvRfcommStartServer(slot->security, slot->role, slot->scn,
- MAX_RFC_SESSION, rfcomm_cback,
- (void*)(uintptr_t)slot->id);
+ MAX_RFC_SESSION, rfcomm_cback, slot->id);
} else if (slot) {
APPL_TRACE_ERROR("jv_dm_cback: cannot start server, slot found:%p",
slot);
// number to connect to.
if (BTA_JvRfcommConnect(slot->security, slot->role,
p_data->disc_comp.scn, slot->addr.address,
- rfcomm_cback, (void*)(uintptr_t)slot->id) ==
- BTA_JV_SUCCESS) {
+ rfcomm_cback, slot->id) == BTA_JV_SUCCESS) {
slot->scn = p_data->disc_comp.scn;
slot->f.doing_sdp_request = false;
if (!send_app_scn(slot)) cleanup_rfc_slot(slot);
}
}
-int bta_co_rfc_data_incoming(void* user_data, BT_HDR* p_buf) {
+int bta_co_rfc_data_incoming(uint32_t id, BT_HDR* p_buf) {
int app_uid = -1;
uint64_t bytes_rx = 0;
int ret = 0;
- uint32_t id = (uintptr_t)user_data;
std::unique_lock<std::recursive_mutex> lock(slot_lock);
rfc_slot_t* slot = find_rfc_slot_by_id(id);
if (!slot) return 0;
return ret; // Return 0 to disable data flow.
}
-int bta_co_rfc_data_outgoing_size(void* user_data, int* size) {
- uint32_t id = (uintptr_t)user_data;
+int bta_co_rfc_data_outgoing_size(uint32_t id, int* size) {
*size = 0;
std::unique_lock<std::recursive_mutex> lock(slot_lock);
rfc_slot_t* slot = find_rfc_slot_by_id(id);
return true;
}
-int bta_co_rfc_data_outgoing(void* user_data, uint8_t* buf, uint16_t size) {
+int bta_co_rfc_data_outgoing(uint32_t id, uint8_t* buf, uint16_t size) {
std::unique_lock<std::recursive_mutex> lock(slot_lock);
- uint32_t id = (uintptr_t)user_data;
rfc_slot_t* slot = find_rfc_slot_by_id(id);
if (!slot) return false;
OSDN Git Service
