void bta_hf_client_send_at_clip(BOOLEAN activate) { char *buf; APPL_TRACE_DEBUG1("%s", __FUNCTION__); if (activate) buf = "AT+CLIP=1\r"; else buf = "AT+CLIP=0\r"; bta_hf_client_send_at(BTA_HF_CLIENT_AT_CLIP, buf, strlen(buf)); }
static void *sock_poll_thread(void *arg) { struct pollfd pfds[MAX_POLL]; memset(pfds, 0, sizeof(pfds)); int h = (int)arg; for(;;) { prepare_poll_fds(h, pfds); int ret = poll(pfds, ts[h].poll_count, -1); if(ret == -1) { APPL_TRACE_ERROR2("poll ret -1, exit the thread, errno:%d, err:%s", errno, strerror(errno)); break; } if(ret != 0) { int need_process_data_fd = TRUE; if(pfds[0].revents) //cmd fd always is the first one { asrt(pfds[0].fd == ts[h].cmd_fdr); if(!process_cmd_sock(h)) { APPL_TRACE_DEBUG1("h:%d, process_cmd_sock return false, exit...", h); break; } if(ret == 1) need_process_data_fd = FALSE; else ret--; //exclude the cmd fd } if(need_process_data_fd) process_data_sock(h, pfds, ret); } else {APPL_TRACE_DEBUG1("no data, select ret: %d", ret)}; } ts[h].thread_id = -1; APPL_TRACE_DEBUG1("socket poll thread exiting, h:%d", h); return 0; }
void bta_av_conn_cback(UINT8 handle, BD_ADDR bd_addr, UINT8 event, tAVDT_CTRL *p_data) { tBTA_AV_STR_MSG *p_msg; UINT16 evt = 0; tBTA_AV_SCB *p_scb = NULL; #if( defined BTA_AR_INCLUDED ) && (BTA_AR_INCLUDED == TRUE) if (event == BTA_AR_AVDT_CONN_EVT || event == AVDT_CONNECT_IND_EVT || event == AVDT_DISCONNECT_IND_EVT) #else if (event == AVDT_CONNECT_IND_EVT || event == AVDT_DISCONNECT_IND_EVT) #endif { evt = BTA_AV_SIG_CHG_EVT; if(AVDT_DISCONNECT_IND_EVT == event) p_scb = bta_av_addr_to_scb(bd_addr); #if (defined(BTA_AV_DEBUG) && BTA_AV_DEBUG == TRUE) else if (AVDT_CONNECT_IND_EVT == event) { APPL_TRACE_DEBUG1("CONN_IND is ACP:%d", p_data->hdr.err_param); } #endif if (/*((p_scb && (p_scb->role & BTA_AV_ROLE_AD_ACP)) || //(AVDT_CONNECT_IND_EVT == event && AVDT_ACP == p_data->hdr.err_param)) (AVDT_CONNECT_IND_EVT == event))&& */ (p_msg = (tBTA_AV_STR_MSG *) GKI_getbuf((UINT16) (sizeof(tBTA_AV_STR_MSG)))) != NULL) { p_msg->hdr.event = evt; p_msg->hdr.layer_specific = event; p_msg->hdr.offset = p_data->hdr.err_param; bdcpy(p_msg->bd_addr, bd_addr); #if (defined(BTA_AV_DEBUG) && BTA_AV_DEBUG == TRUE) if(p_scb) { APPL_TRACE_DEBUG2("scb hndl x%x, role x%x", p_scb->hndl, p_scb->role); } #endif APPL_TRACE_DEBUG6("conn_cback bd_addr:%02x-%02x-%02x-%02x-%02x-%02x", bd_addr[0], bd_addr[1], bd_addr[2], bd_addr[3], bd_addr[4], bd_addr[5]); bta_sys_sendmsg(p_msg); } } }
void bta_hf_client_send_at_cnum(void) { char *buf; APPL_TRACE_DEBUG1("%s", __FUNCTION__); if (!service_availability) { APPL_TRACE_DEBUG0("Skip AT+CNUM no Service"); return; } buf = "AT+CNUM\r"; bta_hf_client_send_at(BTA_HF_CLIENT_AT_CNUM, buf, strlen(buf)); }
static void bta_hf_client_start_at_hold_timer(void) { TIMER_LIST_ENT *timer = &bta_hf_client_cb.scb.at_cb.hold_timer; APPL_TRACE_DEBUG1("%s", __FUNCTION__); if (bta_hf_client_cb.scb.at_cb.hold_timer_on) { bta_sys_stop_timer (timer); } timer->p_cback = (TIMER_CBACK*)&bta_hf_client_at_hold_timer_cback; bta_sys_start_timer(timer, 0, BTA_HF_CLIENT_AT_HOLD_TIMEOUT); bta_hf_client_cb.scb.at_cb.hold_timer_on = TRUE; }
void bta_hf_client_send_at_brsf(void) { char buf[BTA_HF_CLIENT_AT_MAX_LEN]; int at_len; APPL_TRACE_DEBUG1("%s", __FUNCTION__); at_len = snprintf(buf, sizeof(buf), "AT+BRSF=%lu\r", bta_hf_client_cb.scb.features); if (at_len < 0) { APPL_TRACE_ERROR0("HFPClient: AT command Framing error"); return; } bta_hf_client_send_at(BTA_HF_CLIENT_AT_BRSF , buf, at_len); }
void bta_hf_client_send_at_binp(UINT32 action) { char buf[BTA_HF_CLIENT_AT_MAX_LEN]; int at_len; APPL_TRACE_DEBUG1("%s", __FUNCTION__); at_len = snprintf(buf, sizeof(buf), "AT+BINP=%lu\r", action); if (at_len < 0) { APPL_TRACE_ERROR0("HFPClient: AT command Framing error"); return; } bta_hf_client_send_at(BTA_HF_CLIENT_AT_BINP, buf, at_len); }
void bta_hf_client_send_at_vts(char code) { char buf[BTA_HF_CLIENT_AT_MAX_LEN]; int at_len; APPL_TRACE_DEBUG1("%s", __FUNCTION__); at_len = snprintf(buf, sizeof(buf), "AT+VTS=%c\r", code); if (at_len < 0) { APPL_TRACE_ERROR0("HFPClient: AT command Framing error"); return; } bta_hf_client_send_at(BTA_HF_CLIENT_AT_VTS, buf, at_len); }
/****************************************************************************** ** ** Function bte_main_enable ** ** Description BTE MAIN API - Creates all the BTE tasks. Should be called ** part of the Bluetooth stack enable sequence ** ** Returns None ** ******************************************************************************/ void bte_main_enable() { APPL_TRACE_DEBUG1("%s", __FUNCTION__); /* Initialize BTE control block */ BTE_Init(); lpm_enabled = FALSE; GKI_create_task((TASKPTR)btu_task, BTU_TASK, BTE_BTU_TASK_STR, (UINT16 *) ((UINT8 *)bte_btu_stack + BTE_BTU_STACK_SIZE), sizeof(bte_btu_stack)); bte_hci_enable(); GKI_run(0); }
static inline int create_server_socket(const char* name) { int s = socket(AF_LOCAL, SOCK_STREAM, 0); APPL_TRACE_DEBUG1("covert name to android abstract name:%s", name); if(socket_local_server_bind(s, name, ANDROID_SOCKET_NAMESPACE_ABSTRACT) >= 0) { if(listen(s, 5) == 0) { APPL_TRACE_DEBUG2("listen to local socket:%s, fd:%d", name, s); return s; } else APPL_TRACE_ERROR3("listen to local socket:%s, fd:%d failed, errno:%d", name, s, errno); } else APPL_TRACE_ERROR3("create local socket:%s fd:%d, failed, errno:%d", name, s, errno); close(s); return -1; }
void bta_hf_client_send_at_bac(void) { char *buf; APPL_TRACE_DEBUG1("%s", __FUNCTION__); if (bta_hf_client_cb.msbc_enabled) { buf = "AT+BAC=1,2\r"; } else { buf = "AT+BAC=1\r"; } bta_hf_client_send_at(BTA_HF_CLIENT_AT_BAC, buf, strlen(buf)); }
static void bta_hf_client_at_parse_start(void) { char *buf = bta_hf_client_cb.scb.at_cb.buf; APPL_TRACE_DEBUG1("%s", __FUNCTION__); #ifdef BTA_HF_CLIENT_AT_DUMP bta_hf_client_dump_at(); #endif while(*buf != '\0') { int i; char *tmp = NULL; for(i = 0; i < bta_hf_client_psraser_cb_count; i++) { tmp = bta_hf_client_parser_cb[i](buf); if (tmp == NULL) { APPL_TRACE_ERROR0("HFPCient: AT event/reply parsing failed, skipping"); tmp = bta_hf_client_skip_unknown(buf); break; } /* matched or unknown skipped, if unknown failed tmp is NULL so this is also handled */ if (tmp != buf) { buf = tmp; break; } } /* could not skip unknown (received garbage?)... disconnect */ if (tmp == NULL) { APPL_TRACE_ERROR0("HFPCient: could not skip unknown AT event, disconnecting"); bta_hf_client_at_reset(); bta_hf_client_sm_execute(BTA_HF_CLIENT_API_CLOSE_EVT, NULL); return; } buf = tmp; } }
/******************************************************************************* ** ** Function bta_ag_resume_open ** ** Description Resume opening process. ** ** ** Returns void ** *******************************************************************************/ void bta_ag_resume_open (tBTA_AG_SCB *p_scb) { if (p_scb) { APPL_TRACE_DEBUG1 ("bta_ag_resume_open, Handle(%d)", bta_ag_scb_to_idx(p_scb)); /* resume opening process. */ if (p_scb->state == BTA_AG_INIT_ST) { p_scb->state = BTA_AG_OPENING_ST; bta_ag_start_open (p_scb, NULL); } } else { APPL_TRACE_ERROR0 ("bta_ag_resume_open, Null p_scb"); } }
void bta_hf_client_send_at_cops(BOOLEAN query) { char *buf; APPL_TRACE_DEBUG1("%s", __FUNCTION__); if (!service_availability) { APPL_TRACE_DEBUG0("Skip AT+COPS no service"); return; } if (query) buf = "AT+COPS?\r"; else buf = "AT+COPS=3,0\r"; bta_hf_client_send_at(BTA_HF_CLIENT_AT_COPS, buf, strlen(buf)); }
static void bta_hf_client_send_queued_at(void) { tBTA_HF_CLIENT_AT_QCMD *cur = bta_hf_client_cb.scb.at_cb.queued_cmd; tBTA_HF_CLIENT_AT_QCMD *next; APPL_TRACE_DEBUG1("%s", __FUNCTION__); if (cur != NULL) { next = cur->next; bta_hf_client_send_at(cur->cmd, cur->buf, cur->buf_len); GKI_freebuf(cur); bta_hf_client_cb.scb.at_cb.queued_cmd = next; } }
/******************************************************************************* ** ** Function bta_av_co_audio_init ** ** Description This callout function is executed by AV when it is ** started by calling BTA_AvRegister(). This function can be ** used by the phone to initialize audio paths or for other ** initialization purposes. ** ** ** Returns Stream codec and content protection capabilities info. ** *******************************************************************************/ BOOLEAN bta_av_co_audio_init(UINT8 *p_codec_type, UINT8 *p_codec_info, UINT8 *p_num_protect, UINT8 *p_protect_info, UINT8 index) { FUNC_TRACE(); APPL_TRACE_DEBUG1("bta_av_co_audio_init: %d", index); #if defined(BTA_AV_CO_CP_SCMS_T) && (BTA_AV_CO_CP_SCMS_T == TRUE) { UINT8 *p = p_protect_info; /* Content protection info - support SCMS-T */ *p_num_protect = 1; *p++ = BTA_AV_CP_LOSC; UINT16_TO_STREAM(p, BTA_AV_CP_SCMS_T_ID); } #else /* By default - no content protection info */ *p_num_protect = 0; *p_protect_info = 0; #endif /* reset remote preference through setconfig */ bta_av_co_cb.codec_cfg_setconfig.id = BTIF_AV_CODEC_NONE; switch (index) { case BTIF_SV_AV_AA_SBC_INDEX: /* Set up for SBC codec */ *p_codec_type = BTA_AV_CODEC_SBC; /* This should not fail because we are using constants for parameters */ A2D_BldSbcInfo(AVDT_MEDIA_AUDIO, (tA2D_SBC_CIE *) &bta_av_co_sbc_caps, p_codec_info); /* Codec is valid */ return TRUE; default: /* Not valid */ return FALSE; } }
void bta_hf_client_send_at_chld(char cmd, UINT32 idx) { char buf[BTA_HF_CLIENT_AT_MAX_LEN]; int at_len; APPL_TRACE_DEBUG1("%s", __FUNCTION__); if (idx > 0) at_len = snprintf(buf, sizeof(buf), "AT+CHLD=%c%lu\r", cmd, idx); else at_len = snprintf(buf, sizeof(buf), "AT+CHLD=%c\r", cmd); if (at_len < 0) { APPL_TRACE_ERROR0("HFPClient: AT command Framing error"); return; } bta_hf_client_send_at(BTA_HF_CLIENT_AT_CHLD, buf, at_len); }
/******************************************************************************* ** ** Function bta_hf_client_sco_conn_open ** ** Description ** ** ** Returns void ** *******************************************************************************/ void bta_hf_client_sco_conn_open(tBTA_HF_CLIENT_DATA *p_data) { APPL_TRACE_DEBUG1("%s", __FUNCTION__); bta_hf_client_sco_event(BTA_HF_CLIENT_SCO_CONN_OPEN_E); bta_sys_sco_open(BTA_ID_HS, 1, bta_hf_client_cb.scb.peer_addr); if (bta_hf_client_cb.scb.negotiated_codec == BTM_SCO_CODEC_MSBC) { bta_hf_client_cback_sco(BTA_HF_CLIENT_AUDIO_MSBC_OPEN_EVT); } else { bta_hf_client_cback_sco(BTA_HF_CLIENT_AUDIO_OPEN_EVT); } bta_hf_client_cb.scb.retry_with_sco_only = FALSE; }
static void bta_hf_client_handle_ok() { APPL_TRACE_DEBUG1("%s", __FUNCTION__); bta_hf_client_stop_at_resp_timer(); if (!bta_hf_client_cb.scb.svc_conn) { bta_hf_client_slc_seq(FALSE); return; } switch(bta_hf_client_cb.scb.at_cb.current_cmd) { case BTA_HF_CLIENT_AT_BIA: case BTA_HF_CLIENT_AT_BCC: break; case BTA_HF_CLIENT_AT_BCS: bta_hf_client_start_at_hold_timer(); bta_hf_client_cb.scb.at_cb.current_cmd = BTA_HF_CLIENT_AT_NONE; return; case BTA_HF_CLIENT_AT_CLIP: //last cmd is post slc seq if (bta_hf_client_cb.scb.send_at_reply == FALSE) { bta_hf_client_cb.scb.send_at_reply = TRUE; } break; case BTA_HF_CLIENT_AT_NONE: bta_hf_client_stop_at_hold_timer(); break; default: if (bta_hf_client_cb.scb.send_at_reply) { bta_hf_client_at_result(BTA_HF_CLIENT_AT_RESULT_OK, 0); } break; } bta_hf_client_cb.scb.at_cb.current_cmd = BTA_HF_CLIENT_AT_NONE; bta_hf_client_send_queued_at(); }
void bta_hf_client_send_at_cind(BOOLEAN status) { char *buf; tBTA_HF_CLIENT_AT_CMD cmd; APPL_TRACE_DEBUG1("%s", __FUNCTION__); if (status) { buf = "AT+CIND?\r"; cmd = BTA_HF_CLIENT_AT_CIND_STATUS; } else { buf = "AT+CIND=?\r"; cmd = BTA_HF_CLIENT_AT_CIND; } bta_hf_client_send_at(cmd, buf, strlen(buf)); }
/******************************************************************************* ** ** Function bta_av_restore_switch ** ** Description assume that the caller of this function already makes ** sure that there's only one ACL connection left ** ** Returns void ** *******************************************************************************/ void bta_av_restore_switch (void) { tBTA_AV_CB *p_cb = &bta_av_cb; int i; UINT8 mask; APPL_TRACE_DEBUG1("reg_audio: 0x%x",bta_av_cb.reg_audio); for(i=0; i<BTA_AV_NUM_STRS; i++) { mask = BTA_AV_HNDL_TO_MSK(i); if (p_cb->conn_audio == mask) { if (p_cb->p_scb[i]) { bta_sys_set_policy(BTA_ID_AV, HCI_ENABLE_MASTER_SLAVE_SWITCH, p_cb->p_scb[i]->peer_addr); } break; } } }
int btsock_thread_init() { static int initialized; APPL_TRACE_DEBUG1("in initialized:%d", initialized); if(!initialized) { initialized = 1; init_slot_lock(&thread_slot_lock); int h; for(h = 0; h < MAX_THREAD; h++) { ts[h].cmd_fdr = ts[h].cmd_fdw = -1; ts[h].used = 0; ts[h].thread_id = -1; ts[h].poll_count = 0; ts[h].callback = NULL; ts[h].cmd_callback = NULL; } } return TRUE; }
/******************************************************************************* ** ** Function bta_ag_scb_by_idx ** ** Description Given an scb index return pointer to scb. ** ** ** Returns Pointer to scb or NULL if not allocated. ** *******************************************************************************/ tBTA_AG_SCB *bta_ag_scb_by_idx(UINT16 idx) { tBTA_AG_SCB *p_scb; /* verify index */ if (idx > 0 && idx <= BTA_AG_NUM_SCB) { p_scb = &bta_ag_cb.scb[idx - 1]; if (!p_scb->in_use) { p_scb = NULL; APPL_TRACE_WARNING1("ag scb idx %d not allocated", idx); } } else { p_scb = NULL; APPL_TRACE_DEBUG1("ag scb idx %d out of range", idx); } return p_scb; }
/******************************************************************************* ** ** Function bta_ag_del_records ** ** Description Delete SDP records for any registered services. ** ** ** Returns void ** *******************************************************************************/ void bta_ag_del_records(tBTA_AG_SCB *p_scb, tBTA_AG_DATA *p_data) { tBTA_AG_SCB *p = &bta_ag_cb.scb[0]; tBTA_SERVICE_MASK services; tBTA_SERVICE_MASK others = 0; int i; /* get services of all other registered servers */ for (i = 0; i < BTA_AG_NUM_IDX; i++, p++) { if (p_scb == p) { continue; } if (p->in_use && p->dealloc == FALSE) { others |= p->reg_services; } } others >>= BTA_HSP_SERVICE_ID; services = p_scb->reg_services >> BTA_HSP_SERVICE_ID; for (i = 0; i < BTA_AG_NUM_IDX && services != 0; i++, services >>= 1, others >>= 1) { /* if service registered for this scb and not registered for any other scb */ if (((services & 1) == 1) && ((others & 1) == 0)) { APPL_TRACE_DEBUG1("bta_ag_del_records %d", i); if (bta_ag_cb.profile[i].sdp_handle != 0) { SDP_DeleteRecord(bta_ag_cb.profile[i].sdp_handle); bta_ag_cb.profile[i].sdp_handle = 0; } BTM_FreeSCN(bta_ag_cb.profile[i].scn); BTM_SecClrService(bta_ag_sec_id[i]); bta_sys_remove_uuid(bta_ag_uuid[i]); } } }
static void on_srv_rfc_listen_started(tBTA_JV_RFCOMM_START *p_start, uint32_t id) { lock_slot(&slot_lock); rfc_slot_t* rs = find_rfc_slot_by_id(id); if(rs) { if (p_start->status != BTA_JV_SUCCESS) cleanup_rfc_slot(rs); else { rs->rfc_handle = p_start->handle; if(!send_app_scn(rs)) { //closed APPL_TRACE_DEBUG1("send_app_scn() failed, close rs->id:%d", rs->id); cleanup_rfc_slot(rs); } } } unlock_slot(&slot_lock); }
void bta_hf_client_send_at_atd(char *number, UINT32 memory) { char buf[BTA_HF_CLIENT_AT_MAX_LEN]; int at_len; APPL_TRACE_DEBUG1("%s", __FUNCTION__); if (number[0] != '\0') { at_len = snprintf(buf, sizeof(buf), "ATD%s;\r", number); } else { at_len = snprintf(buf, sizeof(buf), "ATD>%lu;\r", memory); } if (at_len < 0) { APPL_TRACE_ERROR0("HFPClient: AT command Framing error"); return; } bta_hf_client_send_at(BTA_HF_CLIENT_AT_ATD, buf, at_len); }
void bta_hf_client_send_at_btrh(BOOLEAN query, UINT32 val) { char buf[BTA_HF_CLIENT_AT_MAX_LEN]; int at_len; APPL_TRACE_DEBUG1("%s", __FUNCTION__); if (query == TRUE) { at_len = snprintf(buf, sizeof(buf), "AT+BTRH?\r"); } else { at_len = snprintf(buf, sizeof(buf), "AT+BTRH=%lu\r", val); } if (at_len < 0) { APPL_TRACE_ERROR0("HFPClient: AT command Framing error"); return; } bta_hf_client_send_at(BTA_HF_CLIENT_AT_BTRH, buf, at_len); }
/******************************************************************************* ** ** Function bta_pan_scb_alloc ** ** Description Allocate a PAN server control block. ** ** ** Returns pointer to the scb, or NULL if none could be allocated. ** *******************************************************************************/ tBTA_PAN_SCB *bta_pan_scb_alloc(void) { tBTA_PAN_SCB *p_scb = &bta_pan_cb.scb[0]; int i; for (i = 0; i < BTA_PAN_NUM_CONN; i++, p_scb++) { if (!p_scb->in_use) { p_scb->in_use = TRUE; APPL_TRACE_DEBUG1("bta_pan_scb_alloc %d", i); break; } } if (i == BTA_PAN_NUM_CONN) { /* out of scbs */ p_scb = NULL; APPL_TRACE_WARNING0("Out of scbs"); } return p_scb; }
/******************************************************************************* ** ** Function bta_ag_scb_dealloc ** ** Description Deallocate a service control block. ** ** ** Returns void ** *******************************************************************************/ void bta_ag_scb_dealloc(tBTA_AG_SCB *p_scb) { UINT8 idx; BOOLEAN allocated = FALSE; APPL_TRACE_DEBUG1("bta_ag_scb_dealloc %d", bta_ag_scb_to_idx(p_scb)); /* stop timers */ bta_sys_stop_timer(&p_scb->act_timer); #if (BTM_WBS_INCLUDED == TRUE) bta_sys_stop_timer(&p_scb->cn_timer); #endif /* initialize control block */ memset(p_scb, 0, sizeof(tBTA_AG_SCB)); p_scb->sco_idx = BTM_INVALID_SCO_INDEX; /* If all scbs are deallocated, callback with disable event */ if (!bta_sys_is_register (BTA_ID_AG)) { for (idx = 0; idx < BTA_AG_NUM_SCB; idx++) { if (bta_ag_cb.scb[idx].in_use) { allocated = TRUE; break; } } if (!allocated) { (*bta_ag_cb.p_cback)(BTA_AG_DISABLE_EVT, NULL); } } }
/******************************************************************************* ** ** Function bta_gattc_hdl_event ** ** Description GATT client main event handling function. ** ** ** Returns void ** *******************************************************************************/ BOOLEAN bta_gattc_hdl_event(BT_HDR *p_msg) { tBTA_GATTC_CB *p_cb = &bta_gattc_cb; tBTA_GATTC_CLCB *p_clcb = NULL; tBTA_GATTC_RCB *p_clreg; #if BTA_GATT_DEBUG == TRUE APPL_TRACE_DEBUG1("bta_gattc_hdl_event: Event [%s]", gattc_evt_code(p_msg->event)); #endif switch (p_msg->event) { case BTA_GATTC_API_DISABLE_EVT: bta_gattc_disable(p_cb); break; case BTA_GATTC_API_REG_EVT: bta_gattc_register(p_cb, (tBTA_GATTC_DATA *) p_msg); break; case BTA_GATTC_INT_START_IF_EVT: bta_gattc_start_if(p_cb, (tBTA_GATTC_DATA *) p_msg); break; case BTA_GATTC_API_DEREG_EVT: p_clreg = bta_gattc_cl_get_regcb(((tBTA_GATTC_DATA *)p_msg)->api_dereg.client_if); bta_gattc_deregister(p_cb, p_clreg); break; case BTA_GATTC_API_OPEN_EVT: bta_gattc_process_api_open(p_cb, (tBTA_GATTC_DATA *) p_msg); break; case BTA_GATTC_API_CANCEL_OPEN_EVT: bta_gattc_process_api_open_cancel(p_cb, (tBTA_GATTC_DATA *) p_msg); break; case BTA_GATTC_API_REFRESH_EVT: bta_gattc_process_api_refresh(p_cb, (tBTA_GATTC_DATA *) p_msg); break; #if BLE_INCLUDED == TRUE case BTA_GATTC_API_LISTEN_EVT: bta_gattc_listen(p_cb, (tBTA_GATTC_DATA *) p_msg); break; case BTA_GATTC_API_BROADCAST_EVT: bta_gattc_broadcast(p_cb, (tBTA_GATTC_DATA *) p_msg); break; #endif case BTA_GATTC_ENC_CMPL_EVT: bta_gattc_process_enc_cmpl(p_cb, (tBTA_GATTC_DATA *) p_msg); break; default: if (p_msg->event == BTA_GATTC_INT_CONN_EVT) p_clcb = bta_gattc_find_int_conn_clcb((tBTA_GATTC_DATA *) p_msg); else if (p_msg->event == BTA_GATTC_INT_DISCONN_EVT) p_clcb = bta_gattc_find_int_disconn_clcb((tBTA_GATTC_DATA *) p_msg); else p_clcb = bta_gattc_find_clcb_by_conn_id(p_msg->layer_specific); if (p_clcb != NULL) { bta_gattc_sm_execute(p_clcb, p_msg->event, (tBTA_GATTC_DATA *) p_msg); } else { APPL_TRACE_DEBUG1("Ignore unknown conn ID: %d", p_msg->layer_specific); } break; } return(TRUE); }