bt_status_t btsock_l2c_listen(const char* service_name, const uint8_t* service_uuid, int channel,
int* sock_fd, int flags)
{
int status = BT_STATUS_FAIL;
APPL_TRACE_DEBUG("btsock_l2c_listen, service_name:%s", service_name);
/* TODO find the available psm list for obex */
if(sock_fd == NULL || (service_uuid == NULL))
{
APPL_TRACE_ERROR("invalid sock_fd:%p, uuid:%p", sock_fd, service_uuid);
return BT_STATUS_PARM_INVALID;
}
*sock_fd = -1;
if(!is_init_done())
return BT_STATUS_NOT_READY;
/* validate it for FTP and OPP */
//Check the service_uuid. overwrite the channel # if reserved
int reserved_channel = get_reserved_l2c_channel(service_uuid);
if(reserved_channel > 0)
{
channel = reserved_channel;
}
else
{
return BT_STATUS_FAIL;
}
lock_slot(&slot_lock);
l2c_slot_t* ls = alloc_l2c_slot(NULL, service_name, service_uuid, channel, flags, TRUE);
if(ls)
{
APPL_TRACE_DEBUG("BTA_JvCreateRecordByUser:%s", service_name);
BTA_JvCreateRecordByUser((void *)(ls->id));
APPL_TRACE_DEBUG("BTA_JvCreateRecordByUser userdata :%d", service_name);
*sock_fd = ls->app_fd;
ls->app_fd = -1; //the fd ownelship is transferred to app
status = BT_STATUS_SUCCESS;
btsock_thread_add_fd(pth, ls->fd, BTSOCK_L2CAP, SOCK_THREAD_FD_EXCEPTION, ls->id);
}
unlock_slot(&slot_lock);
return status;
}
bt_status_t btsock_rfc_listen(const char* service_name, const uint8_t* service_uuid, int channel,
int* sock_fd, int flags)
{
APPL_TRACE_DEBUG1("btsock_rfc_listen, service_name:%s", service_name);
if(sock_fd == NULL || (service_uuid == NULL && (channel < 1 || channel > 30)))
{
APPL_TRACE_ERROR3("invalid rfc channel:%d or sock_fd:%p, uuid:%p", channel, sock_fd, service_uuid);
return BT_STATUS_PARM_INVALID;
}
*sock_fd = -1;
if(!is_init_done())
return BT_STATUS_NOT_READY;
if(is_uuid_empty(service_uuid))
service_uuid = UUID_SPP; //use serial port profile to listen to specified channel
else
{
//Check the service_uuid. overwrite the channel # if reserved
int reserved_channel = get_reserved_rfc_channel(service_uuid);
if(reserved_channel > 0)
{
channel = reserved_channel;
}
}
int status = BT_STATUS_FAIL;
lock_slot(&slot_lock);
rfc_slot_t* rs = alloc_rfc_slot(NULL, service_name, service_uuid, channel, flags, TRUE);
if(rs)
{
APPL_TRACE_DEBUG1("BTA_JvCreateRecordByUser:%s", service_name);
BTA_JvCreateRecordByUser((void *)rs->id);
*sock_fd = rs->app_fd;
rs->app_fd = -1; //the fd ownership is transferred to app
status = BT_STATUS_SUCCESS;
btsock_thread_add_fd(pth, rs->fd, BTSOCK_RFCOMM, SOCK_THREAD_FD_EXCEPTION, rs->id);
}
unlock_slot(&slot_lock);
return status;
}
static void jv_dm_cback(tBTA_JV_EVT event, tBTA_JV *p_data, void *user_data) {
uint32_t id = PTR_TO_UINT(user_data);
switch(event) {
case BTA_JV_GET_SCN_EVT:
{
pthread_mutex_lock(&slot_lock);
rfc_slot_t* rs = find_rfc_slot_by_id(id);
int new_scn = p_data->scn;
if(rs && (new_scn != 0))
{
rs->scn = new_scn;
/* BTA_JvCreateRecordByUser will only create a record if a UUID is specified,
* else it just allocate a RFC channel and start the RFCOMM thread - needed
* for the java
* layer to get a RFCOMM channel.
* If uuid is null the create_sdp_record() will be called from Java when it
* has received the RFCOMM and L2CAP channel numbers through the sockets.*/
// Send channel ID to java layer
if(!send_app_scn(rs)){
//closed
APPL_TRACE_DEBUG("send_app_scn() failed, close rs->id:%d", rs->id);
cleanup_rfc_slot(rs);
} else {
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));
} else {
APPL_TRACE_DEBUG("is_service_uuid_valid==false - don't set SDP-record, "
"just start the RFCOMM server", 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));
}
}
} else if(rs) {
APPL_TRACE_ERROR("jv_dm_cback: Error: allocate channel %d, slot found:%p", rs->scn, rs);
cleanup_rfc_slot(rs);
}
pthread_mutex_unlock(&slot_lock);
break;
}
case BTA_JV_GET_PSM_EVT:
{
APPL_TRACE_DEBUG("Received PSM: 0x%04x", p_data->psm);
on_l2cap_psm_assigned(id, p_data->psm);
break;
}
case BTA_JV_CREATE_RECORD_EVT: {
pthread_mutex_lock(&slot_lock);
rfc_slot_t *slot = find_rfc_slot_by_id(id);
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);
} else if(slot) {
APPL_TRACE_ERROR("jv_dm_cback: cannot start server, slot found:%p", slot);
cleanup_rfc_slot(slot);
}
pthread_mutex_unlock(&slot_lock);
break;
}
case BTA_JV_DISCOVERY_COMP_EVT: {
pthread_mutex_lock(&slot_lock);
rfc_slot_t *slot = find_rfc_slot_by_id(id);
if (p_data->disc_comp.status == BTA_JV_SUCCESS && p_data->disc_comp.scn) {
if (slot && slot->f.doing_sdp_request) {
// Establish the connection if we successfully looked up a channel 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) {
slot->scn = p_data->disc_comp.scn;
slot->f.doing_sdp_request = false;
if (!send_app_scn(slot))
cleanup_rfc_slot(slot);
} else {
cleanup_rfc_slot(slot);
}
} else if (slot) {
// TODO(sharvil): this is really a logic error and we should probably assert.
LOG_ERROR(LOG_TAG, "%s SDP response returned but RFCOMM slot %d did not request SDP record.", __func__, id);
}
} else if (slot) {
cleanup_rfc_slot(slot);
}
// Find the next slot that needs to perform an SDP request and service it.
slot = find_rfc_slot_by_pending_sdp();
if (slot) {
tSDP_UUID sdp_uuid;
sdp_uuid.len = 16;
memcpy(sdp_uuid.uu.uuid128, slot->service_uuid, sizeof(sdp_uuid.uu.uuid128));
BTA_JvStartDiscovery((uint8_t *)slot->addr.address, 1, &sdp_uuid, (void *)(uintptr_t)slot->id);
slot->f.pending_sdp_request = false;
slot->f.doing_sdp_request = true;
}
pthread_mutex_unlock(&slot_lock);
break;
}
default:
APPL_TRACE_DEBUG("unhandled event:%d, slot id:%d", event, id);
break;
}
}