esp_err_t esp_ble_gattc_read_multiple(esp_gatt_if_t gattc_if, uint16_t conn_id, esp_gattc_multi_t *read_multi, esp_gatt_auth_req_t auth_req) { btc_msg_t msg; btc_ble_gattc_args_t arg; ESP_BLUEDROID_STATUS_CHECK(ESP_BLUEDROID_STATUS_ENABLED); if (L2CA_CheckIsCongest(L2CAP_ATT_CID, conn_id)) { LOG_DEBUG("%s, the l2cap chanel is congest.", __func__); return ESP_FAIL; } msg.sig = BTC_SIG_API_CALL; msg.pid = BTC_PID_GATTC; msg.act = BTC_GATTC_ACT_READ_MULTIPLE_CHAR; arg.read_multiple.conn_id = BTC_GATT_CREATE_CONN_ID(gattc_if, conn_id); arg.read_multiple.num_attr = read_multi->num_attr; arg.read_multiple.auth_req = auth_req; if (read_multi->num_attr > 0) { memcpy(arg.read_multiple.handles, read_multi->handles, sizeof(uint16_t)*read_multi->num_attr); } else { LOG_ERROR("%s(), the num_attr should not be 0.", __func__); return ESP_FAIL; } return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_gattc_args_t), NULL) == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL); }
esp_err_t esp_ble_gatts_send_indicate(esp_gatt_if_t gatts_if, uint16_t conn_id, uint16_t attr_handle, uint16_t value_len, uint8_t *value, bool need_confirm) { btc_msg_t msg; btc_ble_gatts_args_t arg; ESP_BLUEDROID_STATUS_CHECK(ESP_BLUEDROID_STATUS_ENABLED); if (L2CA_CheckIsCongest(L2CAP_ATT_CID, conn_id)) { LOG_DEBUG("%s, the l2cap chanel is congest.", __func__); return ESP_FAIL; } msg.sig = BTC_SIG_API_CALL; msg.pid = BTC_PID_GATTS; msg.act = BTC_GATTS_ACT_SEND_INDICATE; arg.send_ind.conn_id = BTC_GATT_CREATE_CONN_ID(gatts_if, conn_id); arg.send_ind.attr_handle = attr_handle; arg.send_ind.need_confirm = need_confirm; arg.send_ind.value_len = value_len; arg.send_ind.value = value; return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_gatts_args_t), btc_gatts_arg_deep_copy) == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL); }
esp_err_t esp_bt_gap_start_discovery(esp_bt_inq_mode_t mode, uint8_t inq_len, uint8_t num_rsps) { btc_msg_t msg; btc_gap_bt_args_t arg; if (esp_bluedroid_get_status() != ESP_BLUEDROID_STATUS_ENABLED) { return ESP_ERR_INVALID_STATE; } if (mode != ESP_BT_INQ_MODE_GENERAL_INQUIRY && mode != ESP_BT_INQ_MODE_LIMITED_INQIURY) { return ESP_ERR_INVALID_ARG; } if (inq_len < ESP_BT_GAP_MIN_INQ_LEN || inq_len > ESP_BT_GAP_MAX_INQ_LEN) { return ESP_ERR_INVALID_ARG; } msg.sig = BTC_SIG_API_CALL; msg.pid = BTC_PID_GAP_BT; msg.act = BTC_GAP_BT_ACT_START_DISCOVERY; arg.start_disc.mode = mode; arg.start_disc.inq_len = inq_len; arg.start_disc.num_rsps = num_rsps; return (btc_transfer_context(&msg, &arg, sizeof(btc_gap_bt_args_t), NULL) == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL); }
esp_err_t esp_ble_gattc_prepare_write_char_descr(esp_gatt_if_t gattc_if, uint16_t conn_id, uint16_t handle, uint16_t offset, uint16_t value_len, uint8_t *value, esp_gatt_auth_req_t auth_req) { btc_msg_t msg; btc_ble_gattc_args_t arg; ESP_BLUEDROID_STATUS_CHECK(ESP_BLUEDROID_STATUS_ENABLED); if (L2CA_CheckIsCongest(L2CAP_ATT_CID, conn_id)) { LOG_DEBUG("%s, the l2cap chanel is congest.", __func__); return ESP_FAIL; } msg.sig = BTC_SIG_API_CALL; msg.pid = BTC_PID_GATTC; msg.act = BTC_GATTC_ACT_PREPARE_WRITE_CHAR_DESCR; arg.prep_write_descr.conn_id = BTC_GATT_CREATE_CONN_ID(gattc_if, conn_id); arg.prep_write_descr.handle = handle; arg.prep_write_descr.offset = offset; arg.prep_write_descr.value_len = value_len > ESP_GATT_MAX_ATTR_LEN ? ESP_GATT_MAX_ATTR_LEN : value_len; // length check ? arg.prep_write_descr.value = value; arg.prep_write_descr.auth_req = auth_req; return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_gattc_args_t), btc_gattc_arg_deep_copy) == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL); }
void btc_dm_sec_evt(tBTA_DM_SEC_EVT event, tBTA_DM_SEC *data) { btc_msg_t msg; msg.sig = BTC_SIG_API_CB; msg.pid = BTC_PID_DM_SEC; msg.act = event; btc_transfer_context(&msg, (btc_dm_sec_args_t *)data, sizeof(btc_dm_sec_args_t), btc_dm_sec_arg_deep_copy); }
esp_err_t esp_ble_gattc_cache_get_addr_list(esp_gatt_if_t gattc_if) { btc_msg_t msg; btc_ble_gattc_args_t arg; ESP_BLUEDROID_STATUS_CHECK(ESP_BLUEDROID_STATUS_ENABLED); msg.sig = BTC_SIG_API_CALL; msg.pid = BTC_PID_GATTC; msg.act = BTC_GATTC_ATC_CACHE_GET_ADDR_LIST; arg.get_addr_list.gattc_if = gattc_if; return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_gattc_args_t), NULL) == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL); }
esp_err_t esp_ble_gatts_stop_service(uint16_t service_handle) { btc_msg_t msg; btc_ble_gatts_args_t arg; ESP_BLUEDROID_STATUS_CHECK(ESP_BLUEDROID_STATUS_ENABLED); msg.sig = BTC_SIG_API_CALL; msg.pid = BTC_PID_GATTS; msg.act = BTC_GATTS_ACT_STOP_SERVICE; arg.stop_srvc.service_handle = service_handle; return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_gatts_args_t), NULL) == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL); }
static void btc_search_callback(tBTA_DM_SEARCH_EVT event, tBTA_DM_SEARCH *p_data) { esp_ble_gap_cb_param_t param; btc_msg_t msg; msg.sig = BTC_SIG_API_CB; msg.pid = BTC_PID_GAP_BLE; msg.act = ESP_GAP_BLE_SCAN_RESULT_EVT; param.scan_rst.search_evt = event; switch (event) { case BTA_DM_INQ_RES_EVT: { bdcpy(param.scan_rst.bda, p_data->inq_res.bd_addr); param.scan_rst.dev_type = p_data->inq_res.device_type; param.scan_rst.rssi = p_data->inq_res.rssi; param.scan_rst.ble_addr_type = p_data->inq_res.ble_addr_type; param.scan_rst.ble_evt_type = p_data->inq_res.ble_evt_type; param.scan_rst.flag = p_data->inq_res.flag; param.scan_rst.num_resps = 1; param.scan_rst.adv_data_len = p_data->inq_res.adv_data_len; param.scan_rst.scan_rsp_len = p_data->inq_res.scan_rsp_len; memcpy(param.scan_rst.ble_adv, p_data->inq_res.p_eir, sizeof(param.scan_rst.ble_adv)); break; } case BTA_DM_INQ_CMPL_EVT: { param.scan_rst.num_resps = p_data->inq_cmpl.num_resps; LOG_ERROR("%s BLE observe complete. Num Resp %d\n", __FUNCTION__, p_data->inq_cmpl.num_resps); break; } case BTA_DM_DISC_RES_EVT: LOG_ERROR("BTA_DM_DISC_RES_EVT\n"); break; case BTA_DM_DISC_BLE_RES_EVT: LOG_ERROR("BTA_DM_DISC_BLE_RES_EVT\n"); break; case BTA_DM_DISC_CMPL_EVT: LOG_ERROR("BTA_DM_DISC_CMPL_EVT\n"); break; case BTA_DM_DI_DISC_CMPL_EVT: LOG_ERROR("BTA_DM_DI_DISC_CMPL_EVT\n"); break; case BTA_DM_SEARCH_CANCEL_CMPL_EVT: LOG_ERROR("BTA_DM_SEARCH_CANCEL_CMPL_EVT\n"); break; default: LOG_ERROR("%s : Unknown event 0x%x\n", __FUNCTION__, event); return; } btc_transfer_context(&msg, ¶m, sizeof(esp_ble_gap_cb_param_t), NULL); }
esp_err_t esp_ble_gattc_app_unregister(esp_gatt_if_t gattc_if) { btc_msg_t msg; btc_ble_gattc_args_t arg; ESP_BLUEDROID_STATUS_CHECK(ESP_BLUEDROID_STATUS_ENABLED); msg.sig = BTC_SIG_API_CALL; msg.pid = BTC_PID_GATTC; msg.act = BTC_GATTC_ACT_APP_UNREGISTER; arg.app_unreg.gattc_if = gattc_if; return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_gattc_args_t), NULL) == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL); }
esp_err_t esp_bt_gap_cancel_discovery(void) { btc_msg_t msg; if (esp_bluedroid_get_status() != ESP_BLUEDROID_STATUS_ENABLED) { return ESP_ERR_INVALID_STATE; } msg.sig = BTC_SIG_API_CALL; msg.pid = BTC_PID_GAP_BT; msg.act = BTC_GAP_BT_ACT_CANCEL_DISCOVERY; return (btc_transfer_context(&msg, NULL, 0, NULL) == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL); }
esp_err_t esp_ble_gattc_close (esp_gatt_if_t gattc_if, uint16_t conn_id) { btc_msg_t msg; btc_ble_gattc_args_t arg; ESP_BLUEDROID_STATUS_CHECK(ESP_BLUEDROID_STATUS_ENABLED); msg.sig = BTC_SIG_API_CALL; msg.pid = BTC_PID_GATTC; msg.act = BTC_GATTC_ACT_CLOSE; arg.close.conn_id = BTC_GATT_CREATE_CONN_ID(gattc_if, conn_id); return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_gattc_args_t), NULL) == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL); }
static void btc_gattc_cback(tBTA_GATTC_EVT event, tBTA_GATTC *p_data) { bt_status_t ret; btc_msg_t msg; msg.sig = BTC_SIG_API_CB; msg.pid = BTC_PID_GATTC; msg.act = (uint8_t) event; ret = btc_transfer_context(&msg, p_data, sizeof(tBTA_GATTC), btc_gattc_copy_req_data); if (ret) { BTC_TRACE_ERROR("%s transfer failed\n", __func__); } }
esp_err_t esp_ble_gattc_cache_refresh(esp_bd_addr_t remote_bda) { btc_msg_t msg; btc_ble_gattc_args_t arg; ESP_BLUEDROID_STATUS_CHECK(ESP_BLUEDROID_STATUS_ENABLED); msg.sig = BTC_SIG_API_CALL; msg.pid = BTC_PID_GATTC; msg.act = BTC_GATTC_ACT_CACHE_REFRESH; memcpy(arg.cache_refresh.remote_bda, remote_bda, sizeof(esp_bd_addr_t)); return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_gattc_args_t), NULL) == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL); }
esp_err_t esp_ble_gattc_execute_write (esp_gatt_if_t gattc_if, uint16_t conn_id, bool is_execute) { btc_msg_t msg; btc_ble_gattc_args_t arg; ESP_BLUEDROID_STATUS_CHECK(ESP_BLUEDROID_STATUS_ENABLED); msg.sig = BTC_SIG_API_CALL; msg.pid = BTC_PID_GATTC; msg.act = BTC_GATTC_ACT_EXECUTE_WRITE; arg.exec_write.conn_id = BTC_GATT_CREATE_CONN_ID(gattc_if, conn_id); arg.exec_write.is_execute = is_execute; return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_gattc_args_t), NULL) == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL); }
static void btc_a2dp_dispatch_datapath_evt(uint32_t dp_evt) { btc_msg_t msg; msg.sig = BTC_SIG_API_CALL; msg.pid = BTC_PID_A2DP; msg.act = BTC_AV_DATAPATH_CTRL_EVT; btc_av_args_t arg; memset(&arg, 0, sizeof(btc_av_args_t)); arg.dp_evt = dp_evt; /* Switch to BTC context */ APPL_TRACE_DEBUG("%s sig %u act %u, dp_evt %u\n", __func__, msg.sig, msg.act, arg.dp_evt); btc_transfer_context(&msg, &arg, sizeof(btc_av_args_t), NULL); }
static void btc_set_local_privacy_callback(UINT8 status) { esp_ble_gap_cb_param_t param; bt_status_t ret; btc_msg_t msg; msg.sig = BTC_SIG_API_CB; msg.pid = BTC_PID_GAP_BLE; msg.act = ESP_GAP_BLE_SET_LOCAL_PRIVACY_COMPLETE_EVT; param.local_privacy_cmpl.status = btc_btm_status_to_esp_status(status); ret = btc_transfer_context(&msg, ¶m, sizeof(esp_ble_gap_cb_param_t), NULL); if (ret != BT_STATUS_SUCCESS) { LOG_ERROR("%s btc_transfer_context failed\n", __func__); } }
esp_err_t esp_ble_gattc_unregister_for_notify (esp_gatt_if_t gattc_if, esp_bd_addr_t server_bda, uint16_t handle) { btc_msg_t msg; btc_ble_gattc_args_t arg; ESP_BLUEDROID_STATUS_CHECK(ESP_BLUEDROID_STATUS_ENABLED); msg.sig = BTC_SIG_API_CALL; msg.pid = BTC_PID_GATTC; msg.act = BTC_GATTC_ACT_UNREG_FOR_NOTIFY; arg.unreg_for_notify.gattc_if = gattc_if; arg.unreg_for_notify.handle = handle; memcpy(arg.unreg_for_notify.remote_bda, server_bda, sizeof(esp_bd_addr_t)); return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_gattc_args_t), NULL) == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL); }
esp_err_t esp_a2d_sink_deinit(void) { if (esp_bluedroid_get_status() != ESP_BLUEDROID_STATUS_ENABLED) { return ESP_ERR_INVALID_STATE; } btc_msg_t msg; msg.sig = BTC_SIG_API_CALL; msg.pid = BTC_PID_A2DP; msg.act = BTC_AV_SINK_API_DEINIT_EVT; /* Switch to BTC context */ bt_status_t stat = btc_transfer_context(&msg, NULL, 0, NULL); return (stat == BT_STATUS_SUCCESS) ? ESP_OK : ESP_FAIL; }
esp_err_t esp_ble_gattc_open(esp_gatt_if_t gattc_if, esp_bd_addr_t remote_bda, bool is_direct) { btc_msg_t msg; btc_ble_gattc_args_t arg; ESP_BLUEDROID_STATUS_CHECK(ESP_BLUEDROID_STATUS_ENABLED); msg.sig = BTC_SIG_API_CALL; msg.pid = BTC_PID_GATTC; msg.act = BTC_GATTC_ACT_OPEN; arg.open.gattc_if = gattc_if; memcpy(arg.open.remote_bda, remote_bda, ESP_BD_ADDR_LEN); arg.open.is_direct = is_direct; return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_gattc_args_t), NULL) == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL); }
esp_err_t esp_bt_gap_get_remote_services(esp_bd_addr_t remote_bda) { btc_msg_t msg; btc_gap_bt_args_t arg; if (esp_bluedroid_get_status() != ESP_BLUEDROID_STATUS_ENABLED) { return ESP_ERR_INVALID_STATE; } msg.sig = BTC_SIG_API_CALL; msg.pid = BTC_PID_GAP_BT; msg.act = BTC_GAP_BT_ACT_GET_REMOTE_SERVICES; memcpy(&arg.bda, remote_bda, sizeof(bt_bdaddr_t)); return (btc_transfer_context(&msg, &arg, sizeof(btc_gap_bt_args_t), NULL) == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL); }
esp_err_t esp_bt_gap_set_scan_mode(esp_bt_scan_mode_t mode) { btc_msg_t msg; btc_gap_bt_args_t arg; if (esp_bluedroid_get_status() != ESP_BLUEDROID_STATUS_ENABLED) { return ESP_ERR_INVALID_STATE; } msg.sig = BTC_SIG_API_CALL; msg.pid = BTC_PID_GAP_BT; msg.act = BTC_GAP_BT_ACT_SET_SCAN_MODE; arg.set_scan_mode.mode = mode; return (btc_transfer_context(&msg, &arg, sizeof(btc_gap_bt_args_t), NULL) == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL); }
esp_err_t esp_ble_gatts_create_service(esp_gatt_if_t gatts_if, esp_gatt_srvc_id_t *service_id, uint16_t num_handle) { btc_msg_t msg; btc_ble_gatts_args_t arg; ESP_BLUEDROID_STATUS_CHECK(ESP_BLUEDROID_STATUS_ENABLED); msg.sig = BTC_SIG_API_CALL; msg.pid = BTC_PID_GATTS; msg.act = BTC_GATTS_ACT_CREATE_SERVICE; arg.create_srvc.gatts_if = gatts_if; arg.create_srvc.num_handle = num_handle; memcpy(&arg.create_srvc.service_id, service_id, sizeof(esp_gatt_srvc_id_t)); return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_gatts_args_t), NULL) == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL); }
static void btc_add_whitelist_complete_callback(UINT8 status, tBTM_WL_OPERATION wl_opration) { esp_ble_gap_cb_param_t param; bt_status_t ret; btc_msg_t msg; msg.sig = BTC_SIG_API_CB; msg.pid = BTC_PID_GAP_BLE; msg.act = ESP_GAP_BLE_UPDATE_WHITELIST_COMPLETE_EVT; param.update_whitelist_cmpl.status = btc_hci_to_esp_status(status); param.update_whitelist_cmpl.wl_opration = wl_opration; ret = btc_transfer_context(&msg, ¶m, sizeof(esp_ble_gap_cb_param_t), NULL); if (ret != BT_STATUS_SUCCESS) { LOG_ERROR("%s btc_transfer_context failed\n", __func__); } }
esp_err_t esp_ble_gattc_cache_assoc(esp_gatt_if_t gattc_if, esp_bd_addr_t src_addr, esp_bd_addr_t assoc_addr, bool is_assoc) { btc_msg_t msg; btc_ble_gattc_args_t arg; ESP_BLUEDROID_STATUS_CHECK(ESP_BLUEDROID_STATUS_ENABLED); msg.sig = BTC_SIG_API_CALL; msg.pid = BTC_PID_GATTC; msg.act = BTC_GATTC_ACT_CACHE_ASSOC; arg.cache_assoc.is_assoc = is_assoc; arg.cache_assoc.gattc_if = gattc_if; memcpy(arg.cache_assoc.src_addr, src_addr, sizeof(esp_bd_addr_t)); memcpy(arg.cache_assoc.assoc_addr, assoc_addr, sizeof(esp_bd_addr_t)); return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_gattc_args_t), NULL) == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL); }
esp_err_t esp_ble_gatts_set_attr_value(uint16_t attr_handle, uint16_t length, const uint8_t *value) { btc_msg_t msg; btc_ble_gatts_args_t arg; ESP_BLUEDROID_STATUS_CHECK(ESP_BLUEDROID_STATUS_ENABLED); msg.sig = BTC_SIG_API_CALL; msg.pid = BTC_PID_GATTS; msg.act = BTC_GATTS_ACT_SET_ATTR_VALUE; arg.set_attr_val.handle = attr_handle; arg.set_attr_val.length = length; arg.set_attr_val.value = (uint8_t *)value; return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_gatts_args_t), btc_gatts_arg_deep_copy) == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL); }
/** * @brief This function is called to set local MTU, * the function is called before BLE connection. * * @param[in] mtu: the size of MTU. * * @return * - ESP_OK: success * - other: failed * */ esp_err_t esp_ble_gatt_set_local_mtu (uint16_t mtu) { btc_msg_t msg; btc_ble_main_args_t arg; ESP_BLUEDROID_STATUS_CHECK(ESP_BLUEDROID_STATUS_ENABLED); if ((mtu < ESP_GATT_DEF_BLE_MTU_SIZE) || (mtu > ESP_GATT_MAX_MTU_SIZE)) { return ESP_ERR_INVALID_SIZE; } msg.sig = BTC_SIG_API_CALL; msg.pid = BTC_PID_MAIN_INIT; msg.act = BTC_GATT_ACT_SET_LOCAL_MTU; arg.set_mtu.mtu = mtu; return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_main_args_t), NULL) == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL); }
esp_err_t esp_ble_gattc_read_char_descr (esp_gatt_if_t gattc_if, uint16_t conn_id, uint16_t handle, esp_gatt_auth_req_t auth_req) { btc_msg_t msg; btc_ble_gattc_args_t arg; ESP_BLUEDROID_STATUS_CHECK(ESP_BLUEDROID_STATUS_ENABLED); msg.sig = BTC_SIG_API_CALL; msg.pid = BTC_PID_GATTC; msg.act = BTC_GATTC_ACT_READ_CHAR_DESCR; arg.read_descr.conn_id = BTC_GATT_CREATE_CONN_ID(gattc_if, conn_id); arg.read_descr.handle = handle; arg.read_descr.auth_req = auth_req; return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_gattc_args_t), NULL) == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL); }
static void btc_set_pkt_length_callback(UINT8 status, tBTM_LE_SET_PKT_DATA_LENGTH_PARAMS *data_len_params) { esp_ble_gap_cb_param_t param; bt_status_t ret; btc_msg_t msg; msg.sig = BTC_SIG_API_CB; msg.pid = BTC_PID_GAP_BLE; msg.act = ESP_GAP_BLE_SET_PKT_LENGTH_COMPLETE_EVT; param.pkt_data_lenth_cmpl.status = btc_btm_status_to_esp_status(status); param.pkt_data_lenth_cmpl.params.rx_len = data_len_params->rx_len; param.pkt_data_lenth_cmpl.params.tx_len = data_len_params->tx_len; ret = btc_transfer_context(&msg, ¶m, sizeof(esp_ble_gap_cb_param_t), NULL); if (ret != BT_STATUS_SUCCESS) { LOG_ERROR("%s btc_transfer_context failed\n", __func__); } }
esp_err_t esp_ble_gattc_app_register(uint16_t app_id) { btc_msg_t msg; btc_ble_gattc_args_t arg; ESP_BLUEDROID_STATUS_CHECK(ESP_BLUEDROID_STATUS_ENABLED); if (app_id > ESP_APP_ID_MAX) { return ESP_ERR_INVALID_ARG; } msg.sig = BTC_SIG_API_CALL; msg.pid = BTC_PID_GATTC; msg.act = BTC_GATTC_ACT_APP_REGISTER; arg.app_reg.app_id = app_id; return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_gattc_args_t), NULL) == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL); }
static void btc_stop_scan_callback(tBTA_STATUS status) { esp_ble_gap_cb_param_t param; bt_status_t ret; btc_msg_t msg; msg.sig = BTC_SIG_API_CB; msg.pid = BTC_PID_GAP_BLE; msg.act = ESP_GAP_BLE_SCAN_STOP_COMPLETE_EVT; param.scan_stop_cmpl.status = status; ret = btc_transfer_context(&msg, ¶m, sizeof(esp_ble_gap_cb_param_t), NULL); if (ret != BT_STATUS_SUCCESS) { LOG_ERROR("%s btc_transfer_context failed\n", __func__); } }