component/bt: change MACRO to inline function when invoking callbacks

diff --git a/components/bt/bluedroid/btc/profile/esp/blufi/blufi_prf.c b/components/bt/bluedroid/btc/profile/esp/blufi/blufi_prf.c
index 85be60b7b2269416ac76502d4cede1c2c931c089..e88c775f5ff79759e3f8d01114b4676cf736932b 100644 (file)
--- a/components/bt/bluedroid/btc/profile/esp/blufi/blufi_prf.c
+++ b/components/bt/bluedroid/btc/profile/esp/blufi/blufi_prf.c
@@ -35,13 +35,6 @@
 
 #include "esp_blufi_api.h"
 
-#define BTC_BLUFI_CB_TO_APP(event, param)     do { \
-        esp_blufi_event_cb_t btc_blufi_cb = (esp_blufi_event_cb_t)btc_profile_cb_get(BTC_PID_BLUFI); \
-        if (btc_blufi_cb) { \
-            btc_blufi_cb(event, param); \
-        } \
-    } while (0)
-
 #define BT_BD_ADDR_STR         "%02x:%02x:%02x:%02x:%02x:%02x"
 #define BT_BD_ADDR_HEX(addr)   addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]
 
@@ -71,6 +64,14 @@ static void blufi_profile_cb(tBTA_GATTS_EVT event,  tBTA_GATTS *p_data);
 static void btc_blufi_recv_handler(uint8_t *data, int len);
 static void btc_blufi_send_ack(uint8_t seq);
 
+static inline void btc_blufi_cb_to_app(esp_blufi_cb_event_t event, esp_blufi_cb_param_t *param)
+{
+    esp_blufi_event_cb_t btc_blufi_cb = (esp_blufi_event_cb_t)btc_profile_cb_get(BTC_PID_BLUFI);
+    if (btc_blufi_cb) {
+       btc_blufi_cb(event, param);
+    }
+}
+
 static void blufi_create_service(void)
 {
     if (!blufi_env.enabled) {
@@ -682,75 +683,75 @@ void btc_blufi_cb_handler(btc_msg_t *msg)
 
     switch (msg->act) {
     case ESP_BLUFI_EVENT_INIT_FINISH: {
-        BTC_BLUFI_CB_TO_APP(ESP_BLUFI_EVENT_INIT_FINISH, param);
+        btc_blufi_cb_to_app(ESP_BLUFI_EVENT_INIT_FINISH, param);
         break;
     }
     case ESP_BLUFI_EVENT_DEINIT_FINISH: {
-        BTC_BLUFI_CB_TO_APP(ESP_BLUFI_EVENT_DEINIT_FINISH, param);
+        btc_blufi_cb_to_app(ESP_BLUFI_EVENT_DEINIT_FINISH, param);
         break;
     }
     case ESP_BLUFI_EVENT_BLE_CONNECT:
-        BTC_BLUFI_CB_TO_APP(ESP_BLUFI_EVENT_BLE_CONNECT, param);
+        btc_blufi_cb_to_app(ESP_BLUFI_EVENT_BLE_CONNECT, param);
         break;
     case ESP_BLUFI_EVENT_BLE_DISCONNECT:
-        BTC_BLUFI_CB_TO_APP(ESP_BLUFI_EVENT_BLE_DISCONNECT, param);
+        btc_blufi_cb_to_app(ESP_BLUFI_EVENT_BLE_DISCONNECT, param);
         break;
     case ESP_BLUFI_EVENT_SET_WIFI_OPMODE:
-        BTC_BLUFI_CB_TO_APP(ESP_BLUFI_EVENT_SET_WIFI_OPMODE, param);
+        btc_blufi_cb_to_app(ESP_BLUFI_EVENT_SET_WIFI_OPMODE, param);
         break;
     case ESP_BLUFI_EVENT_REQ_CONNECT_TO_AP:
-        BTC_BLUFI_CB_TO_APP(ESP_BLUFI_EVENT_REQ_CONNECT_TO_AP, NULL);
+        btc_blufi_cb_to_app(ESP_BLUFI_EVENT_REQ_CONNECT_TO_AP, NULL);
         break;
     case ESP_BLUFI_EVENT_REQ_DISCONNECT_FROM_AP:
-        BTC_BLUFI_CB_TO_APP(ESP_BLUFI_EVENT_REQ_DISCONNECT_FROM_AP, NULL);
+        btc_blufi_cb_to_app(ESP_BLUFI_EVENT_REQ_DISCONNECT_FROM_AP, NULL);
         break;
     case ESP_BLUFI_EVENT_GET_WIFI_STATUS:
-        BTC_BLUFI_CB_TO_APP(ESP_BLUFI_EVENT_GET_WIFI_STATUS, NULL);
+        btc_blufi_cb_to_app(ESP_BLUFI_EVENT_GET_WIFI_STATUS, NULL);
         break;
     case ESP_BLUFI_EVENT_DEAUTHENTICATE_STA:
-        BTC_BLUFI_CB_TO_APP(ESP_BLUFI_EVENT_DEAUTHENTICATE_STA, NULL);
+        btc_blufi_cb_to_app(ESP_BLUFI_EVENT_DEAUTHENTICATE_STA, NULL);
         break;
     case ESP_BLUFI_EVENT_RECV_STA_BSSID:
-        BTC_BLUFI_CB_TO_APP(ESP_BLUFI_EVENT_RECV_STA_BSSID, param);
+        btc_blufi_cb_to_app(ESP_BLUFI_EVENT_RECV_STA_BSSID, param);
         break;
     case ESP_BLUFI_EVENT_RECV_STA_SSID:
-        BTC_BLUFI_CB_TO_APP(ESP_BLUFI_EVENT_RECV_STA_SSID, param);
+        btc_blufi_cb_to_app(ESP_BLUFI_EVENT_RECV_STA_SSID, param);
         break;
     case ESP_BLUFI_EVENT_RECV_STA_PASSWD:
-        BTC_BLUFI_CB_TO_APP(ESP_BLUFI_EVENT_RECV_STA_PASSWD, param);
+        btc_blufi_cb_to_app(ESP_BLUFI_EVENT_RECV_STA_PASSWD, param);
         break;
     case ESP_BLUFI_EVENT_RECV_SOFTAP_SSID:
-        BTC_BLUFI_CB_TO_APP(ESP_BLUFI_EVENT_RECV_SOFTAP_SSID, param);
+        btc_blufi_cb_to_app(ESP_BLUFI_EVENT_RECV_SOFTAP_SSID, param);
         break;
     case ESP_BLUFI_EVENT_RECV_SOFTAP_PASSWD:
-        BTC_BLUFI_CB_TO_APP(ESP_BLUFI_EVENT_RECV_SOFTAP_PASSWD, param);
+        btc_blufi_cb_to_app(ESP_BLUFI_EVENT_RECV_SOFTAP_PASSWD, param);
         break;
     case ESP_BLUFI_EVENT_RECV_SOFTAP_MAX_CONN_NUM:
-        BTC_BLUFI_CB_TO_APP(ESP_BLUFI_EVENT_RECV_SOFTAP_MAX_CONN_NUM, param);
+        btc_blufi_cb_to_app(ESP_BLUFI_EVENT_RECV_SOFTAP_MAX_CONN_NUM, param);
         break;
     case ESP_BLUFI_EVENT_RECV_SOFTAP_AUTH_MODE:
-        BTC_BLUFI_CB_TO_APP(ESP_BLUFI_EVENT_RECV_SOFTAP_AUTH_MODE, param);
+        btc_blufi_cb_to_app(ESP_BLUFI_EVENT_RECV_SOFTAP_AUTH_MODE, param);
         break;
     case ESP_BLUFI_EVENT_RECV_SOFTAP_CHANNEL:
-        BTC_BLUFI_CB_TO_APP(ESP_BLUFI_EVENT_RECV_SOFTAP_CHANNEL, param);
+        btc_blufi_cb_to_app(ESP_BLUFI_EVENT_RECV_SOFTAP_CHANNEL, param);
         break;
     case ESP_BLUFI_EVENT_RECV_USERNAME:
-        BTC_BLUFI_CB_TO_APP(ESP_BLUFI_EVENT_RECV_USERNAME, param);
+        btc_blufi_cb_to_app(ESP_BLUFI_EVENT_RECV_USERNAME, param);
         break;
     case ESP_BLUFI_EVENT_RECV_CA_CERT:
-        BTC_BLUFI_CB_TO_APP(ESP_BLUFI_EVENT_RECV_CA_CERT, param);
+        btc_blufi_cb_to_app(ESP_BLUFI_EVENT_RECV_CA_CERT, param);
         break;
     case ESP_BLUFI_EVENT_RECV_CLIENT_CERT:
-        BTC_BLUFI_CB_TO_APP(ESP_BLUFI_EVENT_RECV_CLIENT_CERT, param);
+        btc_blufi_cb_to_app(ESP_BLUFI_EVENT_RECV_CLIENT_CERT, param);
         break;
     case ESP_BLUFI_EVENT_RECV_SERVER_CERT:
-        BTC_BLUFI_CB_TO_APP(ESP_BLUFI_EVENT_RECV_SERVER_CERT, param);
+        btc_blufi_cb_to_app(ESP_BLUFI_EVENT_RECV_SERVER_CERT, param);
         break;
     case ESP_BLUFI_EVENT_RECV_CLIENT_PRIV_KEY:
-        BTC_BLUFI_CB_TO_APP(ESP_BLUFI_EVENT_RECV_CLIENT_PRIV_KEY, param);
+        btc_blufi_cb_to_app(ESP_BLUFI_EVENT_RECV_CLIENT_PRIV_KEY, param);
         break;
     case ESP_BLUFI_EVENT_RECV_SERVER_PRIV_KEY:
-        BTC_BLUFI_CB_TO_APP(ESP_BLUFI_EVENT_RECV_SERVER_PRIV_KEY, param);
+        btc_blufi_cb_to_app(ESP_BLUFI_EVENT_RECV_SERVER_PRIV_KEY, param);
         break;
     default:
         LOG_ERROR("%s UNKNOWN %d\n", __func__, msg->act);

diff --git a/components/bt/bluedroid/btc/profile/std/gap/btc_gap_ble.c b/components/bt/bluedroid/btc/profile/std/gap/btc_gap_ble.c
index e2f4815087c405c55c1f477ab447dc7e4a8d0b7f..4161567538682ee70b577b19cc27ae90ed4c5933 100644 (file)
--- a/components/bt/bluedroid/btc/profile/std/gap/btc_gap_ble.c
+++ b/components/bt/bluedroid/btc/profile/std/gap/btc_gap_ble.c
@@ -26,12 +26,13 @@
 static tBTA_BLE_ADV_DATA gl_bta_adv_data;
 static tBTA_BLE_ADV_DATA gl_bta_scan_rsp_data;
 
-#define BTC_GAP_BLE_CB_TO_APP(event, param)      do { \
-        esp_gap_ble_cb_t btc_gap_ble_cb = (esp_gap_ble_cb_t)btc_profile_cb_get(BTC_PID_GAP_BLE); \
-        if (btc_gap_ble_cb) { \
-            btc_gap_ble_cb(event, param); \
-        } \
-    } while (0)
+static inline void btc_gap_ble_cb_to_app(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param)
+{
+    esp_gap_ble_cb_t btc_gap_ble_cb = (esp_gap_ble_cb_t)btc_profile_cb_get(BTC_PID_GAP_BLE);
+    if (btc_gap_ble_cb) {
+       btc_gap_ble_cb(event, param);
+    }
+}
 
 static void btc_gap_adv_point_cleanup(void **buf)
 {
@@ -508,16 +509,16 @@ void btc_gap_ble_cb_handler(btc_msg_t *msg)
 
     switch (msg->act) {
     case ESP_GAP_BLE_ADV_DATA_SET_COMPLETE_EVT:
-        BTC_GAP_BLE_CB_TO_APP(ESP_GAP_BLE_ADV_DATA_SET_COMPLETE_EVT, param);
+        btc_gap_ble_cb_to_app(ESP_GAP_BLE_ADV_DATA_SET_COMPLETE_EVT, param);
         break;
     case ESP_GAP_BLE_SCAN_RSP_DATA_SET_COMPLETE_EVT :
-        BTC_GAP_BLE_CB_TO_APP(ESP_GAP_BLE_SCAN_RSP_DATA_SET_COMPLETE_EVT, param);
+        btc_gap_ble_cb_to_app(ESP_GAP_BLE_SCAN_RSP_DATA_SET_COMPLETE_EVT, param);
         break;
     case ESP_GAP_BLE_SCAN_PARAM_SET_COMPLETE_EVT:
-        BTC_GAP_BLE_CB_TO_APP(ESP_GAP_BLE_SCAN_PARAM_SET_COMPLETE_EVT, param);
+        btc_gap_ble_cb_to_app(ESP_GAP_BLE_SCAN_PARAM_SET_COMPLETE_EVT, param);
         break;
     case ESP_GAP_BLE_SCAN_RESULT_EVT:
-        BTC_GAP_BLE_CB_TO_APP(ESP_GAP_BLE_SCAN_RESULT_EVT, param);
+        btc_gap_ble_cb_to_app(ESP_GAP_BLE_SCAN_RESULT_EVT, param);
         break;
     default:
         break;

diff --git a/components/bt/bluedroid/btc/profile/std/gatt/btc_gattc.c b/components/bt/bluedroid/btc/profile/std/gatt/btc_gattc.c
index 4b6947940f71ca6e084b3970c0e09feb13b718cb..537be9092ced72030aaa3e8c9dafa5e65e219d1d 100644 (file)
--- a/components/bt/bluedroid/btc/profile/std/gatt/btc_gattc.c
+++ b/components/bt/bluedroid/btc/profile/std/gatt/btc_gattc.c
@@ -22,13 +22,13 @@
 #include "bt_trace.h"
 #include "esp_gattc_api.h"
 
-#define BTC_GATTC_CB_TO_APP(event, gattc_if, param)    do { \
-        esp_gattc_cb_t btc_gattc_cb = (esp_gattc_cb_t )btc_profile_cb_get(BTC_PID_GATTC); \
-        if (btc_gattc_cb) { \
-            btc_gattc_cb(event, gattc_if, param); \
-        } \
-    } while (0)
-
+static inline void btc_gattc_cb_to_app(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t *param)
+{
+    esp_gattc_cb_t btc_gattc_cb = (esp_gattc_cb_t )btc_profile_cb_get(BTC_PID_GATTC);
+    if (btc_gattc_cb) {
+       btc_gattc_cb(event, gattc_if, param);
+    }                                                                  
+}
 
 void btc_gattc_arg_deep_copy(btc_msg_t *msg, void *p_dest, void *p_src)
 {
@@ -203,7 +203,7 @@ static void btc_gattc_get_first_char(btc_ble_gattc_args_t *arg)
     memcpy(&param.get_char.srvc_id, &arg->get_first_char.service_id, sizeof(esp_gatt_srvc_id_t));
     memcpy(&param.get_char.char_id, &char_id, sizeof(esp_gatt_id_t));
     param.get_char.char_prop = out_char_prop;
-    BTC_GATTC_CB_TO_APP(ESP_GATTC_GET_CHAR_EVT, gattc_if, &param);
+    btc_gattc_cb_to_app(ESP_GATTC_GET_CHAR_EVT, gattc_if, &param);
 }
 
 static void btc_gattc_get_next_char(btc_ble_gattc_args_t *arg)
@@ -233,7 +233,7 @@ static void btc_gattc_get_next_char(btc_ble_gattc_args_t *arg)
     memcpy(&param.get_char.srvc_id, &arg->get_next_char.service_id, sizeof(esp_gatt_srvc_id_t));
     memcpy(&param.get_char.char_id, &char_id, sizeof(esp_gatt_id_t));
     param.get_char.char_prop = out_char_prop;
-    BTC_GATTC_CB_TO_APP(ESP_GATTC_GET_CHAR_EVT, gattc_if, &param);
+    btc_gattc_cb_to_app(ESP_GATTC_GET_CHAR_EVT, gattc_if, &param);
 }
 
 static void btc_gattc_get_first_descr(btc_ble_gattc_args_t *arg)
@@ -262,7 +262,7 @@ static void btc_gattc_get_first_descr(btc_ble_gattc_args_t *arg)
     memcpy(&param.get_descr.srvc_id, &arg->get_first_descr.service_id, sizeof(esp_gatt_srvc_id_t));
     memcpy(&param.get_descr.char_id, &arg->get_first_descr.char_id, sizeof(esp_gatt_id_t));
     memcpy(&param.get_descr.descr_id, &descr_id, sizeof(esp_gatt_id_t));
-    BTC_GATTC_CB_TO_APP(ESP_GATTC_GET_DESCR_EVT, gattc_if, &param);
+    btc_gattc_cb_to_app(ESP_GATTC_GET_DESCR_EVT, gattc_if, &param);
 }
 
 static void btc_gattc_get_next_descr(btc_ble_gattc_args_t *arg)
@@ -291,7 +291,7 @@ static void btc_gattc_get_next_descr(btc_ble_gattc_args_t *arg)
     memcpy(&param.get_descr.srvc_id, &arg->get_next_descr.service_id, sizeof(esp_gatt_srvc_id_t));
     memcpy(&param.get_descr.char_id, &arg->get_next_descr.char_id, sizeof(esp_gatt_id_t));
     memcpy(&param.get_descr.descr_id, &descr_id, sizeof(esp_gatt_id_t));
-    BTC_GATTC_CB_TO_APP(ESP_GATTC_GET_DESCR_EVT, gattc_if, &param);
+    btc_gattc_cb_to_app(ESP_GATTC_GET_DESCR_EVT, gattc_if, &param);
 }
 
 static void btc_gattc_get_first_incl_service(btc_ble_gattc_args_t *arg)
@@ -316,7 +316,7 @@ static void btc_gattc_get_first_incl_service(btc_ble_gattc_args_t *arg)
     param.get_incl_srvc.status = status;
     memcpy(&param.get_incl_srvc.srvc_id, &arg->get_first_incl_srvc.service_id, sizeof(esp_gatt_srvc_id_t));
     memcpy(&param.get_incl_srvc.incl_srvc_id, &incl_srvc_id, sizeof(esp_gatt_srvc_id_t));
-    BTC_GATTC_CB_TO_APP(ESP_GATTC_GET_INCL_SRVC_EVT, gattc_if, &param);
+    btc_gattc_cb_to_app(ESP_GATTC_GET_INCL_SRVC_EVT, gattc_if, &param);
 }
 
 static void btc_gattc_get_next_incl_service(btc_ble_gattc_args_t *arg)
@@ -342,7 +342,7 @@ static void btc_gattc_get_next_incl_service(btc_ble_gattc_args_t *arg)
     param.get_incl_srvc.status = status;
     memcpy(&param.get_incl_srvc.srvc_id, &arg->get_next_incl_srvc.service_id, sizeof(esp_gatt_srvc_id_t));
     memcpy(&param.get_incl_srvc.incl_srvc_id, &incl_srvc_id, sizeof(esp_gatt_srvc_id_t));
-    BTC_GATTC_CB_TO_APP(ESP_GATTC_GET_INCL_SRVC_EVT, gattc_if, &param);
+    btc_gattc_cb_to_app(ESP_GATTC_GET_INCL_SRVC_EVT, gattc_if, &param);
 }
 
 static void btc_gattc_read_char(btc_ble_gattc_args_t *arg)
@@ -429,7 +429,7 @@ static void btc_gattc_reg_for_notify(btc_ble_gattc_args_t *arg)
     param.reg_for_notify.status = status;
     memcpy(&param.reg_for_notify.srvc_id, &arg->reg_for_notify.service_id, sizeof(esp_gatt_srvc_id_t));
     memcpy(&param.reg_for_notify.char_id, &arg->reg_for_notify.char_id, sizeof(esp_gatt_id_t));
-    BTC_GATTC_CB_TO_APP(ESP_GATTC_REG_FOR_NOTIFY_EVT, arg->reg_for_notify.gattc_if, &param);
+    btc_gattc_cb_to_app(ESP_GATTC_REG_FOR_NOTIFY_EVT, arg->reg_for_notify.gattc_if, &param);
 }
 
 static void btc_gattc_unreg_for_notify(btc_ble_gattc_args_t *arg)
@@ -449,7 +449,7 @@ static void btc_gattc_unreg_for_notify(btc_ble_gattc_args_t *arg)
     param.unreg_for_notify.status = status;
     memcpy(&param.unreg_for_notify.srvc_id, &arg->unreg_for_notify.service_id, sizeof(esp_gatt_srvc_id_t));
     memcpy(&param.unreg_for_notify.char_id, &arg->unreg_for_notify.service_id, sizeof(esp_gatt_id_t));
-    BTC_GATTC_CB_TO_APP(ESP_GATTC_UNREG_FOR_NOTIFY_EVT, arg->unreg_for_notify.gattc_if, &param);
+    btc_gattc_cb_to_app(ESP_GATTC_UNREG_FOR_NOTIFY_EVT, arg->unreg_for_notify.gattc_if, &param);
 }
 
 void btc_gattc_call_handler(btc_msg_t *msg)
@@ -539,19 +539,19 @@ void btc_gattc_cb_handler(btc_msg_t *msg)
         gattc_if = reg_oper->client_if;
         param.reg.status = reg_oper->status;
         param.reg.app_id = reg_oper->app_uuid.uu.uuid16;
-        BTC_GATTC_CB_TO_APP(ESP_GATTC_REG_EVT, gattc_if, &param);
+        btc_gattc_cb_to_app(ESP_GATTC_REG_EVT, gattc_if, &param);
         break;
     }
     case BTA_GATTC_DEREG_EVT: {
         tBTA_GATTC_REG *reg_oper = &arg->reg_oper;
 
         gattc_if = reg_oper->client_if;
-        BTC_GATTC_CB_TO_APP(ESP_GATTC_UNREG_EVT, gattc_if, NULL);
+        btc_gattc_cb_to_app(ESP_GATTC_UNREG_EVT, gattc_if, NULL);
         break;
     }
     case BTA_GATTC_READ_CHAR_EVT: {
         set_read_value(&gattc_if, &param, &arg->read);
-        BTC_GATTC_CB_TO_APP(ESP_GATTC_READ_CHAR_EVT, gattc_if, &param);
+        btc_gattc_cb_to_app(ESP_GATTC_READ_CHAR_EVT, gattc_if, &param);
         break;
     }
     case BTA_GATTC_WRITE_CHAR_EVT:
@@ -565,7 +565,7 @@ void btc_gattc_cb_handler(btc_msg_t *msg)
         param.write.status = write->status;
         bta_to_btc_srvc_id(&param.write.srvc_id, &write->srvc_id);
         bta_to_btc_gatt_id(&param.write.char_id, &write->char_id);
-        BTC_GATTC_CB_TO_APP(ret_evt, gattc_if, &param);
+        btc_gattc_cb_to_app(ret_evt, gattc_if, &param);
         break;
     }
 
@@ -575,7 +575,7 @@ void btc_gattc_cb_handler(btc_msg_t *msg)
         gattc_if = BTC_GATT_GET_GATT_IF(exec_cmpl->conn_id);
         param.exec_cmpl.conn_id = BTC_GATT_GET_CONN_ID(exec_cmpl->conn_id);
         param.exec_cmpl.status = exec_cmpl->status;
-        BTC_GATTC_CB_TO_APP(ESP_GATTC_EXEC_EVT, gattc_if, &param);
+        btc_gattc_cb_to_app(ESP_GATTC_EXEC_EVT, gattc_if, &param);
         break;
     }
 
@@ -585,7 +585,7 @@ void btc_gattc_cb_handler(btc_msg_t *msg)
         gattc_if = BTC_GATT_GET_GATT_IF(search_cmpl->conn_id);
         param.search_cmpl.conn_id = BTC_GATT_GET_CONN_ID(search_cmpl->conn_id);
         param.search_cmpl.status = search_cmpl->status;
-        BTC_GATTC_CB_TO_APP(ESP_GATTC_SEARCH_CMPL_EVT, gattc_if, &param);
+        btc_gattc_cb_to_app(ESP_GATTC_SEARCH_CMPL_EVT, gattc_if, &param);
         break;
     }
     case BTA_GATTC_SEARCH_RES_EVT: {
@@ -594,12 +594,12 @@ void btc_gattc_cb_handler(btc_msg_t *msg)
         gattc_if = BTC_GATT_GET_GATT_IF(srvc_res->conn_id);
         param.search_res.conn_id = BTC_GATT_GET_CONN_ID(srvc_res->conn_id);
         bta_to_btc_srvc_id(&param.search_res.srvc_id, &srvc_res->service_uuid);
-        BTC_GATTC_CB_TO_APP(ESP_GATTC_SEARCH_RES_EVT, gattc_if, &param);
+        btc_gattc_cb_to_app(ESP_GATTC_SEARCH_RES_EVT, gattc_if, &param);
         break;
     }
     case BTA_GATTC_READ_DESCR_EVT: {
         set_read_value(&gattc_if, &param, &arg->read);
-        BTC_GATTC_CB_TO_APP(ESP_GATTC_READ_DESCR_EVT, gattc_if, &param);
+        btc_gattc_cb_to_app(ESP_GATTC_READ_DESCR_EVT, gattc_if, &param);
         break;
     }
     case BTA_GATTC_WRITE_DESCR_EVT: {
@@ -611,7 +611,7 @@ void btc_gattc_cb_handler(btc_msg_t *msg)
         bta_to_btc_srvc_id(&param.write.srvc_id, &write->srvc_id);
         bta_to_btc_gatt_id(&param.write.char_id, &write->char_id);
         bta_to_btc_gatt_id(&param.write.descr_id, &write->descr_type);
-        BTC_GATTC_CB_TO_APP(ESP_GATTC_WRITE_DESCR_EVT, gattc_if, &param);
+        btc_gattc_cb_to_app(ESP_GATTC_WRITE_DESCR_EVT, gattc_if, &param);
         break;
     }
     case BTA_GATTC_NOTIF_EVT: {
@@ -632,7 +632,7 @@ void btc_gattc_cb_handler(btc_msg_t *msg)
             BTA_GATTC_SendIndConfirm(notify->conn_id, &notify->char_id);
         }
 
-        BTC_GATTC_CB_TO_APP(ESP_GATTC_NOTIFY_EVT, gattc_if, &param);
+        btc_gattc_cb_to_app(ESP_GATTC_NOTIFY_EVT, gattc_if, &param);
         break;
     }
     case BTA_GATTC_OPEN_EVT: {
@@ -643,7 +643,7 @@ void btc_gattc_cb_handler(btc_msg_t *msg)
         param.open.conn_id = BTC_GATT_GET_CONN_ID(open->conn_id);
         memcpy(param.open.remote_bda, open->remote_bda, sizeof(esp_bd_addr_t));
         param.open.mtu = open->mtu;
-        BTC_GATTC_CB_TO_APP(ESP_GATTC_OPEN_EVT, gattc_if, &param);
+        btc_gattc_cb_to_app(ESP_GATTC_OPEN_EVT, gattc_if, &param);
         break;
     }
     case BTA_GATTC_CLOSE_EVT: {
@@ -654,7 +654,7 @@ void btc_gattc_cb_handler(btc_msg_t *msg)
         param.close.conn_id = BTC_GATT_GET_CONN_ID(close->conn_id);
         memcpy(param.close.remote_bda, close->remote_bda, sizeof(esp_bd_addr_t));
         param.close.reason = close->reason;
-        BTC_GATTC_CB_TO_APP(ESP_GATTC_CLOSE_EVT, gattc_if, &param);
+        btc_gattc_cb_to_app(ESP_GATTC_CLOSE_EVT, gattc_if, &param);
         break;
     }
 
@@ -665,7 +665,7 @@ void btc_gattc_cb_handler(btc_msg_t *msg)
         param.cfg_mtu.conn_id = BTC_GATT_GET_CONN_ID(cfg_mtu->conn_id);
         param.cfg_mtu.status = cfg_mtu->status;
         param.cfg_mtu.mtu = cfg_mtu->mtu;
-        BTC_GATTC_CB_TO_APP(ESP_GATTC_CFG_MTU_EVT, gattc_if, &param);
+        btc_gattc_cb_to_app(ESP_GATTC_CFG_MTU_EVT, gattc_if, &param);
         break;
     }
 
@@ -683,12 +683,12 @@ void btc_gattc_cb_handler(btc_msg_t *msg)
         gattc_if = BTC_GATT_GET_GATT_IF(congest->conn_id);
         param.congest.conn_id = BTC_GATT_GET_CONN_ID(congest->conn_id);
         param.congest.congested = (congest->congested == TRUE) ? true : false;
-        BTC_GATTC_CB_TO_APP(ESP_GATTC_CONGEST_EVT, gattc_if, &param);
+        btc_gattc_cb_to_app(ESP_GATTC_CONGEST_EVT, gattc_if, &param);
         break;
     }
     case BTA_GATTC_SRVC_CHG_EVT: {
         memcpy(param.srvc_chg.remote_bda, arg->remote_bda, sizeof(esp_bd_addr_t));
-        BTC_GATTC_CB_TO_APP(ESP_GATTC_SRVC_CHG_EVT, ESP_GATT_IF_NONE, &param);
+        btc_gattc_cb_to_app(ESP_GATTC_SRVC_CHG_EVT, ESP_GATT_IF_NONE, &param);
         break;
     }
     default:

diff --git a/components/bt/bluedroid/btc/profile/std/gatt/btc_gatts.c b/components/bt/bluedroid/btc/profile/std/gatt/btc_gatts.c
index 3a988fc3b118eb0681aacacda0c7992bcf6a2e4a..9bc41d2ab1db6af0e8a33141dd09a87def29c8f9 100644 (file)
--- a/components/bt/bluedroid/btc/profile/std/gatt/btc_gatts.c
+++ b/components/bt/bluedroid/btc/profile/std/gatt/btc_gatts.c
@@ -23,16 +23,17 @@
 
 #include "esp_gatts_api.h"
 
-#define BTC_GATTS_CB_TO_APP(event, gatts_if, param)     do { \
-        esp_gatts_cb_t btc_gatts_cb = (esp_gatts_cb_t)btc_profile_cb_get(BTC_PID_GATTS); \
-        if (btc_gatts_cb) { \
-            btc_gatts_cb(event, gatts_if, param); \
-        } \
-    } while (0)
-
 #define A2C_GATTS_EVT(_bta_event) (_bta_event) //BTA TO BTC EVT
 #define C2A_GATTS_EVT(_btc_event) (_btc_event) //BTC TO BTA EVT
 
+static inline void btc_gatts_cb_to_app(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if, esp_ble_gatts_cb_param_t *param)
+{
+    esp_gatts_cb_t btc_gatts_cb = (esp_gatts_cb_t)btc_profile_cb_get(BTC_PID_GATTS);
+    if (btc_gatts_cb) {
+       btc_gatts_cb(event, gatts_if, param);
+    }
+}
+
 void btc_gatts_arg_deep_copy(btc_msg_t *msg, void *p_dest, void *p_src)
 {
     btc_ble_gatts_args_t *dst = (btc_ble_gatts_args_t *) p_dest;
@@ -232,7 +233,7 @@ void btc_gatts_call_handler(btc_msg_t *msg)
         }
 
         param.rsp.status = 0;
-        BTC_GATTS_CB_TO_APP(ESP_GATTS_RESPONSE_EVT, BTC_GATT_GET_GATT_IF(arg->send_rsp.conn_id), &param);
+        btc_gatts_cb_to_app(ESP_GATTS_RESPONSE_EVT, BTC_GATT_GET_GATT_IF(arg->send_rsp.conn_id), &param);
         break;
     }
     case BTC_GATTS_ACT_OPEN: {
@@ -291,12 +292,12 @@ void btc_gatts_cb_handler(btc_msg_t *msg)
         param.reg.status = p_data->reg_oper.status;
         param.reg.app_id = p_data->reg_oper.uuid.uu.uuid16;
 
-        BTC_GATTS_CB_TO_APP(ESP_GATTS_REG_EVT, gatts_if, &param);
+        btc_gatts_cb_to_app(ESP_GATTS_REG_EVT, gatts_if, &param);
         break;
     }
     case BTA_GATTS_DEREG_EVT: {
         gatts_if = p_data->reg_oper.server_if;
-        BTC_GATTS_CB_TO_APP(ESP_GATTS_UNREG_EVT, gatts_if, NULL);
+        btc_gatts_cb_to_app(ESP_GATTS_UNREG_EVT, gatts_if, NULL);
         break;
     }
     case BTA_GATTS_READ_EVT: {
@@ -308,7 +309,7 @@ void btc_gatts_cb_handler(btc_msg_t *msg)
         param.read.offset = p_data->req_data.p_data->read_req.offset;
         param.read.is_long = p_data->req_data.p_data->read_req.is_long;
 
-        BTC_GATTS_CB_TO_APP(ESP_GATTS_READ_EVT, gatts_if, &param);
+        btc_gatts_cb_to_app(ESP_GATTS_READ_EVT, gatts_if, &param);
         break;
     }
     case BTA_GATTS_WRITE_EVT: {
@@ -323,7 +324,7 @@ void btc_gatts_cb_handler(btc_msg_t *msg)
         param.write.len = p_data->req_data.p_data->write_req.len;
         param.write.value = p_data->req_data.p_data->write_req.value;
 
-        BTC_GATTS_CB_TO_APP(ESP_GATTS_WRITE_EVT, gatts_if, &param);
+        btc_gatts_cb_to_app(ESP_GATTS_WRITE_EVT, gatts_if, &param);
 
         break;
     }
@@ -334,7 +335,7 @@ void btc_gatts_cb_handler(btc_msg_t *msg)
         memcpy(param.exec_write.bda, p_data->req_data.remote_bda, ESP_BD_ADDR_LEN);
         param.exec_write.exec_write_flag = p_data->req_data.p_data->exec_write;
 
-        BTC_GATTS_CB_TO_APP(ESP_GATTS_EXEC_WRITE_EVT, gatts_if, &param);
+        btc_gatts_cb_to_app(ESP_GATTS_EXEC_WRITE_EVT, gatts_if, &param);
         break;
     }
     case BTA_GATTS_MTU_EVT:
@@ -342,14 +343,14 @@ void btc_gatts_cb_handler(btc_msg_t *msg)
         param.mtu.conn_id = BTC_GATT_GET_CONN_ID(p_data->req_data.conn_id);
         param.mtu.mtu = p_data->req_data.p_data->mtu;
 
-        BTC_GATTS_CB_TO_APP(ESP_GATTS_MTU_EVT, gatts_if, &param);
+        btc_gatts_cb_to_app(ESP_GATTS_MTU_EVT, gatts_if, &param);
         break;
     case BTA_GATTS_CONF_EVT:
         gatts_if = BTC_GATT_GET_GATT_IF(p_data->req_data.conn_id);
         param.conf.conn_id = BTC_GATT_GET_CONN_ID(p_data->req_data.conn_id);
         param.conf.status = p_data->req_data.status;
 
-        BTC_GATTS_CB_TO_APP(ESP_GATTS_CONF_EVT, gatts_if, &param);
+        btc_gatts_cb_to_app(ESP_GATTS_CONF_EVT, gatts_if, &param);
         break;
     case BTA_GATTS_CREATE_EVT:
         gatts_if = p_data->create.server_if;
@@ -358,7 +359,7 @@ void btc_gatts_cb_handler(btc_msg_t *msg)
         param.create.service_id.is_primary = p_data->create.is_primary;
         param.create.service_id.id.inst_id = p_data->create.svc_instance;
         bta_to_btc_uuid(&param.create.service_id.id.uuid, &p_data->create.uuid);
-        BTC_GATTS_CB_TO_APP(ESP_GATTS_CREATE_EVT, gatts_if, &param);
+        btc_gatts_cb_to_app(ESP_GATTS_CREATE_EVT, gatts_if, &param);
         break;
     case BTA_GATTS_ADD_INCL_SRVC_EVT:
         gatts_if = p_data->add_result.server_if;
@@ -366,7 +367,7 @@ void btc_gatts_cb_handler(btc_msg_t *msg)
         param.add_incl_srvc.attr_handle = p_data->add_result.attr_id;
         param.add_incl_srvc.service_handle = p_data->add_result.service_id;
 
-        BTC_GATTS_CB_TO_APP(ESP_GATTS_ADD_INCL_SRVC_EVT, gatts_if, &param);
+        btc_gatts_cb_to_app(ESP_GATTS_ADD_INCL_SRVC_EVT, gatts_if, &param);
         break;
     case BTA_GATTS_ADD_CHAR_EVT:
         gatts_if = p_data->add_result.server_if;
@@ -375,7 +376,7 @@ void btc_gatts_cb_handler(btc_msg_t *msg)
         param.add_char.service_handle = p_data->add_result.service_id;
         bta_to_btc_uuid(&param.add_char.char_uuid, &p_data->add_result.char_uuid);
 
-        BTC_GATTS_CB_TO_APP(ESP_GATTS_ADD_CHAR_EVT, gatts_if, &param);
+        btc_gatts_cb_to_app(ESP_GATTS_ADD_CHAR_EVT, gatts_if, &param);
         break;
     case BTA_GATTS_ADD_CHAR_DESCR_EVT:
         gatts_if = p_data->add_result.server_if;
@@ -384,27 +385,27 @@ void btc_gatts_cb_handler(btc_msg_t *msg)
         param.add_char_descr.service_handle = p_data->add_result.service_id;
         bta_to_btc_uuid(&param.add_char_descr.char_uuid, &p_data->add_result.char_uuid);
 
-        BTC_GATTS_CB_TO_APP(ESP_GATTS_ADD_CHAR_DESCR_EVT, gatts_if, &param);
+        btc_gatts_cb_to_app(ESP_GATTS_ADD_CHAR_DESCR_EVT, gatts_if, &param);
         break;
     case BTA_GATTS_DELELTE_EVT:
         gatts_if = p_data->srvc_oper.server_if;
         param.del.status = p_data->srvc_oper.status;
         param.del.service_handle = p_data->srvc_oper.service_id;
-        BTC_GATTS_CB_TO_APP(ESP_GATTS_DELETE_EVT, gatts_if, &param);
+        btc_gatts_cb_to_app(ESP_GATTS_DELETE_EVT, gatts_if, &param);
         break;
     case BTA_GATTS_START_EVT:
         gatts_if = p_data->srvc_oper.server_if;
         param.start.status = p_data->srvc_oper.status;
         param.start.service_handle = p_data->srvc_oper.service_id;
 
-        BTC_GATTS_CB_TO_APP(ESP_GATTS_START_EVT, gatts_if, &param);
+        btc_gatts_cb_to_app(ESP_GATTS_START_EVT, gatts_if, &param);
         break;
     case BTA_GATTS_STOP_EVT:
         gatts_if = p_data->srvc_oper.server_if;
         param.stop.status = p_data->srvc_oper.status;
         param.stop.service_handle = p_data->srvc_oper.service_id;
 
-        BTC_GATTS_CB_TO_APP(ESP_GATTS_STOP_EVT, gatts_if, &param);
+        btc_gatts_cb_to_app(ESP_GATTS_STOP_EVT, gatts_if, &param);
         break;
     case BTA_GATTS_CONNECT_EVT:
         gatts_if = p_data->conn.server_if;
@@ -412,7 +413,7 @@ void btc_gatts_cb_handler(btc_msg_t *msg)
         param.connect.is_connected = true;
         memcpy(param.connect.remote_bda, p_data->conn.remote_bda, ESP_BD_ADDR_LEN);
 
-        BTC_GATTS_CB_TO_APP(ESP_GATTS_CONNECT_EVT, gatts_if, &param);
+        btc_gatts_cb_to_app(ESP_GATTS_CONNECT_EVT, gatts_if, &param);
         break;
     case BTA_GATTS_DISCONNECT_EVT:
         gatts_if = p_data->conn.server_if;
@@ -420,7 +421,7 @@ void btc_gatts_cb_handler(btc_msg_t *msg)
         param.disconnect.is_connected = false;
         memcpy(param.disconnect.remote_bda, p_data->conn.remote_bda, ESP_BD_ADDR_LEN);
 
-        BTC_GATTS_CB_TO_APP(ESP_GATTS_DISCONNECT_EVT, gatts_if, &param);
+        btc_gatts_cb_to_app(ESP_GATTS_DISCONNECT_EVT, gatts_if, &param);
         break;
     case BTA_GATTS_OPEN_EVT:
     // do nothing
@@ -435,7 +436,7 @@ void btc_gatts_cb_handler(btc_msg_t *msg)
         gatts_if = BTC_GATT_GET_GATT_IF(p_data->congest.conn_id);
         param.congest.conn_id = BTC_GATT_GET_CONN_ID(p_data->congest.conn_id);
         param.congest.congested = p_data->congest.congested;
-        BTC_GATTS_CB_TO_APP(ESP_GATTS_CONGEST_EVT, gatts_if, &param);
+        btc_gatts_cb_to_app(ESP_GATTS_CONGEST_EVT, gatts_if, &param);
         break;
     default:
         // do nothing